Skip to main content
backend-patterns Backend architecture patterns, API design, database optimization, and server-side best practices for Node.js, Express, and Next.js API routes.
Ir para a instalação Skills Marketplace Descubra e explore skills de IA criadas pela comunidade.
Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Mostrar detalhes do prompt Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.
npx skills add https://github.com/linnefromice/claude-code-workspace --skill backend-patternsO comando permanece em uma só linha. Role horizontalmente para revisá-lo antes de copiar.
Prefere uma cópia local? Baixe os arquivos disponíveis atualmente no SkillsMP.
Baixar Zip Baixando... Ocupações relacionadas SOC
Baseado na classificação ocupacional SOC
name backend-patterns description Backend architecture patterns, API design, database optimization, and server-side best practices for Node.js, Express, and Next.js API routes. origin ECC
バックエンド開発パターン
スケーラブルなサーバーサイドアプリケーションのためのバックエンドアーキテクチャパターンとベストプラクティス。
起動条件
REST または GraphQL API エンドポイントの設計
Repository、Service、Controller レイヤーの実装
データベースクエリの最適化（N+1、インデックス、コネクションプーリング）
キャッシュの追加（Redis、インメモリ、HTTP キャッシュヘッダー）
バックグラウンドジョブや非同期処理のセットアップ
API のエラーハンドリングとバリデーションの構築
ミドルウェアの構築（認証、ロギング、レート制限）
API設計パターン
RESTful API構造
GET /api/markets # リソース一覧取得
GET /api/markets/:id # 単一リソース取得
POST /api/markets # リソース作成
PUT /api/markets/:id # リソース置換
PATCH /api/markets/:id # リソース更新
DELETE /api/markets/:id # リソース削除
GET /api/markets?status=active&sort=volume&limit=20 &offset=0
Repositoryパターン
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
from
'markets'
select
'*'
if
status
eq
'status'
status
if
limit
limit
limit
const
await
if
throw
new
Error
message
return
Serviceレイヤーパターン
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パターン
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) => {
})
データベースパターン
クエリ最適化
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クエリ問題の防止
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 )
})
トランザクションパターン 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
-- トランザクションは自動的に開始
INSERT INTO markets VALUES (market_data);
INSERT INTO positions VALUES (position_data);
RETURN jsonb_build_object ('success' , true );
EXCEPTION
WHEN OTHERS THEN
-- ロールバックは自動的に発生
RETURN jsonb_build_object ('success' , false , 'error' , SQLERRM );
END ;
$$;
キャッシュ戦略
Redisキャッシュレイヤー 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パターン 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
}
エラーハンドリングパターン
集中エラーハンドラー 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)
}
}
指数バックオフ付きリトライ 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 ())
認証と認可
JWTトークン検証 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 })
}
ロールベースアクセス制御 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 })
}
)
レート制限
シンプルなインメモリレートリミッター 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 })
}
}
バックグラウンドジョブとキュー
シンプルなキューパターン 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' })
}
ロギングとモニタリング
構造化ロギング 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 })
}
}
覚えておくこと : バックエンドパターンはスケーラブルで保守性の高いサーバーサイドアプリケーションを実現する。複雑さのレベルに合ったパターンを選択すること。
