Skip to main content Startseite Ersteller skyyrosellc devskyy backend-patterns
backend-patterns Node.js / TypeScript backend patterns: REST API design, repository pattern, middleware, caching, and error handling for Express and Next.js API routes. (Python/FastAPI service layers live in the fastapi-patterns skill.)
Zur Installation springen Skills Marktplatz Entdecken und erkunden Sie KI-Skills, die von der Community erstellt wurden.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Prompt-Details anzeigen Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.
npx skills add https://github.com/SkyyRoseLLC/DevSkyy --skill backend-patternsDer Befehl bleibt in einer Zeile. Scrollen Sie horizontal, um ihn vor dem Kopieren vollständig zu prüfen.
Sie bevorzugen eine lokale Kopie? Laden Sie die Dateien herunter, die SkillsMP derzeit vorliegen.
ZIP herunterladen Herunterladen... Mehr aus diesem Repository
Verwandte Berufe SOC
Basierend auf der SOC-Berufsklassifikation
name backend-patterns description Node.js / TypeScript backend patterns: REST API design, repository pattern, middleware, caching, and error handling for Express and Next.js API routes. (Python/FastAPI service layers live in the fastapi-patterns skill.) origin ECC
Backend Development Patterns
Scope: Node/TypeScript backends. For Python/FastAPI service layers, see the fastapi-patterns skill.
Backend architecture patterns and best practices for scalable server-side applications.
When to Activate
Designing REST or GraphQL API endpoints
Implementing repository, service, or controller layers
Optimizing database queries (N+1, indexing, connection pooling)
Adding caching (Redis, in-memory, HTTP cache headers)
Setting up background jobs or async processing
Structuring error handling and validation for APIs
Building middleware (auth, logging, rate limiting)
API Design Patterns
RESTful API Structure
GET /api/markets # List resources
GET /api/markets/:id # Get single resource
POST /api/markets # Create resource
PUT /api/markets/:id # Replace resource
PATCH
Update
DELETE
Delete
GET
20
0
Repository Pattern
interface MarketRepository {
findAll (filters ?: MarketFilters ): Promise <Market []>
findById (id : string ): Promise <Market | null >
create (data : CreateMarketDto ): Promise <Market >
update (id : string , data : UpdateMarketDto ): Promise <Market >
delete (id : string ): Promise <void >
}
class SupabaseMarketRepository implements MarketRepository {
async findAll (filters ?: MarketFilters ): Promise <Market []> {
let query = supabase.from ('markets' ).select ('*' )
if (filters?.status ) {
query = query.eq ('status' , filters.status )
}
if (filters?.limit ) {
query = query.limit (filters.limit )
}
const { data, error } = await query
if (error) throw new Error (error.message )
return data
}
}
Service Layer Pattern
class MarketService {
constructor (private marketRepo : MarketRepository async searchMarkets (query : string , limit : number = 10 ): Promise <Market []> {
const embedding = await generateEmbedding (query)
const results = await this .vectorSearch (embedding, limit)
const markets = await this .marketRepo .findByIds (results.map (r =>id ))
return markets.sort ((a, b ) => {
const scoreA = results.find (r =>id === a.id )?.score || 0
const scoreB = results.find (r =>id === b.id )?.score || 0
return scoreA - scoreB
})
}
private async vectorSearch (embedding : number [], limit : number
Middleware Pattern
export function withAuth (handler : NextApiHandler NextApiHandler {
return async (req, res) => {
const token = req.headers .authorization ?.replace ('Bearer ' , '' )
if (!token) {
return res.status (401 ).json ({ error : 'Unauthorized' })
}
try {
const user = await verifyToken (token)
req.user = user
return handler (req, res)
} catch (error) {
return res.status (401 ).json ({ error : 'Invalid token' })
}
}
}
export default withAuth (async (req, res) => {
})
Database Patterns
Query Optimization
const { data } = await supabase
.from ('markets' )
.select ('id, name, status, volume' )
.eq ('status' , 'active' )
.order ('volume' , { ascending : false })
.limit (10 )
const { data } = await supabase
.from ('markets' )
.select ('*' )
N+1 Query Prevention
const markets = await getMarkets ()
for (const market of markets) {
market.creator = await getUser (market.creator_id )
}
const markets = await getMarkets ()
const creatorIds = markets.map (m =>creator_id )
const creators = await getUsers (creatorIds)
const creatorMap = new Map (creators.map (c =>id , c]))
markets.forEach (market =>creator = creatorMap.get (market.creator_id )
})
Transaction Pattern async function createMarketWithPosition (
marketData : CreateMarketDto ,
positionData : CreatePositionDto
) {
const { data, error } = await supabase.rpc ('create_market_with_position' , {
market_data : marketData,
position_data : positionData
})
if (error) throw new Error ('Transaction failed' )
return data
}
CREATE OR REPLACE FUNCTION create_market_with_position (
market_data jsonb,
position_data jsonb
)
RETURNS jsonb
LANGUAGE plpgsql
AS $$
BEGIN
-- Start transaction automatically
INSERT INTO markets VALUES (market_data);
INSERT INTO positions VALUES (position_data);
RETURN jsonb_build_object ('success' , true );
EXCEPTION
WHEN OTHERS THEN
-- Rollback happens automatically
RETURN jsonb_build_object ('success' , false , 'error' , SQLERRM );
END ;
$$;
Caching Strategies
Redis Caching Layer class CachedMarketRepository implements MarketRepository {
constructor (
private baseRepo : MarketRepository ,
private redis : RedisClient
) {}
async findById (id : string ): Promise <Market | null > {
const cached = await this .redis .get (`market:${id} ` )
if (cached) {
return JSON .parse (cached)
}
const market = await this .baseRepo .findById (id)
if (market) {
await this .redis .setex (`market:${id} ` , 300 , JSON .stringify (market))
}
return market
}
async invalidateCache (id : string ): Promise <void > {
await this .redis .del (`market:${id} ` )
}
}
Cache-Aside Pattern async function getMarketWithCache (id : string Promise <Market > {
const cacheKey = `market:${id} `
const cached = await redis.get (cacheKey)
if (cached) return JSON .parse (cached)
const market = await db.markets .findUnique ({ where : { id } })
if (!market) throw new Error ('Market not found' )
await redis.setex (cacheKey, 300 , JSON .stringify (market))
return market
}
Error Handling Patterns
Centralized Error Handler class ApiError extends Error {
constructor (
public statusCode : number ,
public message : string ,
public isOperational = true
) {
super (message)
Object .setPrototypeOf (this , ApiError .prototype export function errorHandler (error : unknown , req : Request Response {
if (error instanceof ApiError ) {
return NextResponse .json ({
success : false ,
error : error.message
}, { status : error.statusCode })
}
if (error instanceof z.ZodError ) {
return NextResponse .json ({
success : false ,
error : 'Validation failed' ,
details : error.errors
}, { status : 400 })
}
console .error ('Unexpected error:' , error)
return NextResponse .json ({
success : false ,
error : 'Internal server error'
}, { status : 500 })
}
export async function GET (request : Request try {
const data = await fetchData ()
return NextResponse .json ({ success : true , data })
} catch (error) {
return errorHandler (error, request)
}
}
Retry with Exponential Backoff async function fetchWithRetry<T>(
fn : () => Promise <T>,
maxRetries = 3
): Promise <T> {
let lastError : Error
for (let i = 0 ; i < maxRetries; i++) {
try {
return await fn ()
} catch (error) {
lastError = error as Error
if (i < maxRetries - 1 ) {
const delay = Math .pow (2 , i) * 1000
await new Promise (resolve =>setTimeout (resolve, delay))
}
}
}
throw lastError!
}
const data = await fetchWithRetry (() => fetchFromAPI ())
Authentication & Authorization
JWT Token Validation import jwt from 'jsonwebtoken'
interface JWTPayload {
userId : string
email : string
role : 'admin' | 'user'
}
export function verifyToken (token : string JWTPayload {
try {
const payload = jwt.verify (token, process.env .JWT_SECRET !) as JWTPayload
return payload
} catch (error) {
throw new ApiError (401 , 'Invalid token' )
}
}
export async function requireAuth (request : Request const token = request.headers .get ('authorization' )?.replace ('Bearer ' , '' )
if (!token) {
throw new ApiError (401 , 'Missing authorization token' )
}
return verifyToken (token)
}
export async function GET (request : Request const user = await requireAuth (request)
const data = await getDataForUser (user.userId )
return NextResponse .json ({ success : true , data })
}
Role-Based Access Control type Permission = 'read' | 'write' | 'delete' | 'admin'
interface User {
id : string
role : 'admin' | 'moderator' | 'user'
}
const rolePermissions : Record <User ['role' ], Permission []> = {
admin : ['read' , 'write' , 'delete' , 'admin' ],
moderator : ['read' , 'write' , 'delete' ],
user : ['read' , 'write' ]
}
export function hasPermission (user : User , permission : Permission boolean {
return rolePermissions[user.role ].includes (permission)
}
export function requirePermission (permission : Permission return (handler : (request: Request, user: User) => Promise <Response > {
return async (request : Request ) => {
const user = await requireAuth (request)
if (!hasPermission (user, permission)) {
throw new ApiError (403 , 'Insufficient permissions' )
}
return handler (request, user)
}
}
}
export const DELETE = requirePermission ('delete' )(
async (request : Request , user : User ) => {
return new Response ('Deleted' , { status : 200 })
}
)
Rate Limiting
Simple In-Memory Rate Limiter class RateLimiter {
private requests = new Map <string , number []>()
async checkLimit (
identifier : string ,
maxRequests : number ,
windowMs : number
): Promise <boolean > {
const now = Date .now ()
const requests = this .requests .get (identifier) || []
const recentRequests = requests.filter (time =>if (recentRequests.length >= maxRequests) {
return false
}
recentRequests.push (now)
this .requests .set (identifier, recentRequests)
return true
}
}
const limiter = new RateLimiter ()
export async function GET (request : Request const ip = request.headers .get ('x-forwarded-for' ) || 'unknown'
const allowed = await limiter.checkLimit (ip, 100 , 60000 )
if (!allowed) {
return NextResponse .json ({
error : 'Rate limit exceeded'
}, { status : 429 })
}
}
Background Jobs & Queues
Simple Queue Pattern class JobQueue <T> {
private queue : T[] = []
private processing = false
async add (job : T): Promise <void > {
this .queue .push (job)
if (!this .processing ) {
this .process ()
}
}
private async process (): Promise <void > {
this .processing = true
while (this .queue .length > 0 ) {
const job = this .queue .shift ()!
try {
await this .execute (job)
} catch (error) {
console .error ('Job failed:' , error)
}
}
this .processing = false
}
private async execute (job : T): Promise <void > {
}
}
interface IndexJob {
marketId : string
}
const indexQueue = new JobQueue <IndexJob >()
export async function POST (request : Request const { marketId } = await request.json ()
await indexQueue.add ({ marketId })
return NextResponse .json ({ success : true , message : 'Job queued' })
}
Logging & Monitoring
Structured Logging interface LogContext {
userId ?: string
requestId ?: string
method ?: string
path ?: string
[key : string ]: unknown
}
class Logger {
log (level : 'info' | 'warn' | 'error' , message : string , context ?: LogContext const entry = {
timestamp : new Date ().toISOString (),
level,
message,
...context
}
console .log (JSON .stringify (entry))
}
info (message : string , context ?: LogContext this .log ('info' , message, context)
}
warn (message : string , context ?: LogContext this .log ('warn' , message, context)
}
error (message : string , error : Error , context ?: LogContext this .log ('error' , message, {
...context,
error : error.message ,
stack : error.stack
})
}
}
const logger = new Logger ()
export async function GET (request : Request const requestId = crypto.randomUUID ()
logger.info ('Fetching markets' , {
requestId,
method : 'GET' ,
path : '/api/markets'
})
try {
const markets = await fetchMarkets ()
return NextResponse .json ({ success : true , data : markets })
} catch (error) {
logger.error ('Failed to fetch markets' , error as Error , { requestId })
return NextResponse .json ({ error : 'Internal error' }, { status : 500 })
}
}
Remember : Backend patterns enable scalable, maintainable server-side applications. Choose patterns that fit your complexity level.
