Nodejs Development

by mindrally97184105b5daNo license269 starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated 5 weeks ago

Node.js development guidelines covering Payload CMS, Vue.js with TypeScript, and general TypeScript best practices

Instructions onlySoftware Development

AI-generated overview

Node.js and TypeScript development guidelines covering Payload CMS, Vue.js components, and Zod validation patterns.

What it does: Provides reference guidance and code examples for Node.js development with TypeScript. It covers Payload CMS collections and API routes in Next.js, Vue.js components, composables and Pinia stores, Zod schema validation and Express middleware, plus general error handling, async and testing practices. It produces explanatory patterns and snippets rather than runnable tooling.
When to use it: Use it when writing or reviewing TypeScript code in Node.js projects, especially with Payload CMS, Next.js, Vue.js or Zod. It suits developers who want established patterns for collections, components, stores and validation.
Requirements: None beyond the agent; it is instructions only and ships no scripts.

Node.js Development Guidelines

You are an expert in Node.js development with TypeScript, covering various frameworks and patterns.

Payload CMS with Next.js

Project Setup

project/├── src/│   ├── app/              # Next.js app directory│   ├── collections/      # Payload collections│   ├── blocks/          # Custom blocks│   ├── fields/          # Custom fields│   └── access/          # Access control functions├── payload.config.ts    # Payload configuration└── next.config.js       # Next.js configuration

project/├── src/│   ├── app/              # Next.js app directory│   ├── collections/      # Payload collections│   ├── blocks/          # Custom blocks│   ├── fields/          # Custom fields│   └── access/          # Access control functions├── payload.config.ts    # Payload configuration└── next.config.js       # Next.js configuration

Collection Definition

typescript

import { CollectionConfig } from 'payload/types';
const Posts: CollectionConfig = {  slug: 'posts',  admin: {    useAsTitle: 'title',  },  access: {    read: () => true,    create: ({ req: { user } }) => Boolean(user),    update: ({ req: { user } }) => Boolean(user),    delete: ({ req: { user } }) => Boolean(user),  },  fields: [    {      name: 'title',      type: 'text',      required: true,    },    {      name: 'content',      type: 'richText',    },    {      name: 'publishedDate',      type: 'date',    },  ],};
export default Posts;

import { CollectionConfig } from 'payload/types';
const Posts: CollectionConfig = {  slug: 'posts',  admin: {    useAsTitle: 'title',  },  access: {    read: () => true,    create: ({ req: { user } }) => Boolean(user),    update: ({ req: { user } }) => Boolean(user),    delete: ({ req: { user } }) => Boolean(user),  },  fields: [    {      name: 'title',      type: 'text',      required: true,    },    {      name: 'content',      type: 'richText',    },    {      name: 'publishedDate',      type: 'date',    },  ],};
export default Posts;

API Routes

typescript

// app/api/posts/route.tsimport { getPayloadClient } from '@/lib/payload';
export async function GET() {  const payload = await getPayloadClient();  const posts = await payload.find({    collection: 'posts',    limit: 10,  });  return Response.json(posts);}

// app/api/posts/route.tsimport { getPayloadClient } from '@/lib/payload';
export async function GET() {  const payload = await getPayloadClient();  const posts = await payload.find({    collection: 'posts',    limit: 10,  });  return Response.json(posts);}

Vue.js with TypeScript

Component Structure

vue

<script setup lang="ts">import { ref, computed, onMounted } from 'vue';
interface User {  id: number;  name: string;  email: string;}
const props = defineProps<{  userId: number;}>();
const emit = defineEmits<{  (e: 'update', user: User): void;}>();
const user = ref<User | null>(null);const isLoading = ref(false);
const displayName = computed(() => user.value?.name ?? 'Unknown');
async function fetchUser() {  isLoading.value = true;  try {    const response = await fetch(`/api/users/${props.userId}`);    user.value = await response.json();  } finally {    isLoading.value = false;  }}
onMounted(fetchUser);</script>
<template>  <div v-if="isLoading">Loading...</div>  <div v-else-if="user">    <h2>{{ displayName }}</h2>    <p>{{ user.email }}</p>  </div></template>

<script setup lang="ts">import { ref, computed, onMounted } from 'vue';
interface User {  id: number;  name: string;  email: string;}
const props = defineProps<{  userId: number;}>();
const emit = defineEmits<{  (e: 'update', user: User): void;}>();
const user = ref<User | null>(null);const isLoading = ref(false);
const displayName = computed(() => user.value?.name ?? 'Unknown');
async function fetchUser() {  isLoading.value = true;  try {    const response = await fetch(`/api/users/${props.userId}`);    user.value = await response.json();  } finally {    isLoading.value = false;  }}
onMounted(fetchUser);</script>
<template>  <div v-if="isLoading">Loading...</div>  <div v-else-if="user">    <h2>{{ displayName }}</h2>    <p>{{ user.email }}</p>  </div></template>

Composables

typescript

// composables/useApi.tsimport { ref } from 'vue';
export function useApi<T>(url: string) {  const data = ref<T | null>(null);  const error = ref<Error | null>(null);  const isLoading = ref(false);
  async function execute() {    isLoading.value = true;    error.value = null;
    try {      const response = await fetch(url);      if (!response.ok) throw new Error('Request failed');      data.value = await response.json();    } catch (e) {      error.value = e as Error;    } finally {      isLoading.value = false;    }  }
  return { data, error, isLoading, execute };}

// composables/useApi.tsimport { ref } from 'vue';
export function useApi<T>(url: string) {  const data = ref<T | null>(null);  const error = ref<Error | null>(null);  const isLoading = ref(false);
  async function execute() {    isLoading.value = true;    error.value = null;
    try {      const response = await fetch(url);      if (!response.ok) throw new Error('Request failed');      data.value = await response.json();    } catch (e) {      error.value = e as Error;    } finally {      isLoading.value = false;    }  }
  return { data, error, isLoading, execute };}

Pinia Store

typescript

// stores/user.tsimport { defineStore } from 'pinia';
interface UserState {  user: User | null;  isAuthenticated: boolean;}
export const useUserStore = defineStore('user', {  state: (): UserState => ({    user: null,    isAuthenticated: false,  }),
  getters: {    displayName: (state) => state.user?.name ?? 'Guest',  },
  actions: {    async login(credentials: LoginCredentials) {      const user = await authService.login(credentials);      this.user = user;      this.isAuthenticated = true;    },
    logout() {      this.user = null;      this.isAuthenticated = false;    },  },});

// stores/user.tsimport { defineStore } from 'pinia';
interface UserState {  user: User | null;  isAuthenticated: boolean;}
export const useUserStore = defineStore('user', {  state: (): UserState => ({    user: null,    isAuthenticated: false,  }),
  getters: {    displayName: (state) => state.user?.name ?? 'Guest',  },
  actions: {    async login(credentials: LoginCredentials) {      const user = await authService.login(credentials);      this.user = user;      this.isAuthenticated = true;    },
    logout() {      this.user = null;      this.isAuthenticated = false;    },  },});

TypeScript with Zod

Schema Definition

typescript

import { z } from 'zod';
const UserSchema = z.object({  id: z.number(),  name: z.string().min(1),  email: z.string().email(),  role: z.enum(['user', 'admin']),  createdAt: z.date(),});
type User = z.infer<typeof UserSchema>;
const CreateUserSchema = UserSchema.omit({ id: true, createdAt: true });type CreateUserInput = z.infer<typeof CreateUserSchema>;

import { z } from 'zod';
const UserSchema = z.object({  id: z.number(),  name: z.string().min(1),  email: z.string().email(),  role: z.enum(['user', 'admin']),  createdAt: z.date(),});
type User = z.infer<typeof UserSchema>;
const CreateUserSchema = UserSchema.omit({ id: true, createdAt: true });type CreateUserInput = z.infer<typeof CreateUserSchema>;

Validation

typescript

function createUser(input: unknown): User {  const validatedInput = CreateUserSchema.parse(input);  // Input is now typed as CreateUserInput  return {    ...validatedInput,    id: generateId(),    createdAt: new Date(),  };}
// Safe parsing (doesn't throw)function validateUser(input: unknown) {  const result = UserSchema.safeParse(input);  if (!result.success) {    console.error(result.error.issues);    return null;  }  return result.data;}

function createUser(input: unknown): User {  const validatedInput = CreateUserSchema.parse(input);  // Input is now typed as CreateUserInput  return {    ...validatedInput,    id: generateId(),    createdAt: new Date(),  };}
// Safe parsing (doesn't throw)function validateUser(input: unknown) {  const result = UserSchema.safeParse(input);  if (!result.success) {    console.error(result.error.issues);    return null;  }  return result.data;}

API Validation Middleware

typescript

import { z } from 'zod';import { Request, Response, NextFunction } from 'express';
function validate<T extends z.ZodSchema>(schema: T) {  return (req: Request, res: Response, next: NextFunction) => {    const result = schema.safeParse(req.body);    if (!result.success) {      return res.status(400).json({ errors: result.error.issues });    }    req.body = result.data;    next();  };}
// Usageapp.post('/users', validate(CreateUserSchema), createUserHandler);

import { z } from 'zod';import { Request, Response, NextFunction } from 'express';
function validate<T extends z.ZodSchema>(schema: T) {  return (req: Request, res: Response, next: NextFunction) => {    const result = schema.safeParse(req.body);    if (!result.success) {      return res.status(400).json({ errors: result.error.issues });    }    req.body = result.data;    next();  };}
// Usageapp.post('/users', validate(CreateUserSchema), createUserHandler);

General Best Practices

Error Handling

Use custom error classes
Implement global error handlers
Log errors with context
Return appropriate status codes

Async Patterns

Use async/await consistently
Handle promise rejections
Implement proper timeouts
Use Promise.all for parallel operations

Testing

Write unit tests for utilities
Integration tests for APIs
Use test fixtures
Mock external dependencies

Source and attribution

Source:mindrally/skillsinnodejs-developmentat commit9718410

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

Nodejs Development

Node.js Development Guidelines

Payload CMS with Next.js

Project Setup

Collection Definition

API Routes

Vue.js with TypeScript

Component Structure

Composables

Pinia Store

TypeScript with Zod

Schema Definition

Validation

API Validation Middleware

General Best Practices

Error Handling

Async Patterns

Testing

Source and attribution

More from mindrally/skills

Zustand State Management

Zod Schema Validation

Woocommerce

Wordpress

Websocket Development

Web Development

More in Software Development

Playground

M5 Onboard

Cardputer Buddy

Web Design Guidelines

Vercel React Native Skills

Vercel React Best Practices