@gencow/core 0.1.10 → 0.1.11

package/src/crud.ts

@@ -0,0 +1,174 @@
+import { eq, or, and, ilike, desc, asc, inArray, count, sql, type SQL } from "drizzle-orm";
+import type { PgDatabase, PgTable, AnyPgColumn } from "drizzle-orm/pg-core";
+
+type CrudOptions<T extends PgTable> = {
+    searchFields?: (keyof T["_"]["columns"])[];
+    softDelete?: { field: keyof T["_"]["columns"] };
+    allowedFilters?: (keyof T["_"]["columns"])[];
+    defaultLimit?: number;
+    maxLimit?: number;
+    hooks?: {
+        beforeCreate?: (data: any) => any | Promise<any>;
+        beforeUpdate?: (data: any) => any | Promise<any>;
+    };
+};
+
+export function gencowCrud(db: PgDatabase<any, any, any>) {
+    return function createCrud<T extends PgTable>(table: T, options?: CrudOptions<T>) {
+        const anyTable = table as any;
+        const pk = anyTable["id"] as AnyPgColumn;
+        
+        if (!pk) {
+            throw new Error(`[gencowCrud] Table ${anyTable["_"]["name"]} must have an 'id' column.`);
+        }
+        
+        async function create(data: any): Promise<any> {
+            let insertData = { ...data };
+            if (options?.hooks?.beforeCreate) {
+                insertData = await options.hooks.beforeCreate(insertData);
+            }
+            const [result] = await db.insert(anyTable).values(insertData).returning();
+            return result;
+        }
+
+        async function findById(id: any): Promise<any | null> {
+            let whereCond: SQL | undefined = eq(pk, id);
+            
+            if (options?.softDelete) {
+                const sdField = anyTable[options.softDelete.field as string] as AnyPgColumn;
+                whereCond = and(whereCond, sql`${sdField} IS NULL`);
+            }
+            
+            const [result] = await db.select().from(anyTable).where(whereCond).limit(1);
+            return result || null;
+        }
+
+        async function list(params?: {
+            page?: number;
+            limit?: number;
+            search?: string;
+            filters?: Record<string, any>;
+            orderBy?: { field: string; direction: 'asc' | 'desc' }[];
+            includeDeleted?: boolean;
+        }) {
+            const page = Math.max(1, params?.page || 1);
+            const limit = Math.min(
+                Math.max(1, params?.limit || options?.defaultLimit || 20),
+                options?.maxLimit || 100
+            );
+            const offset = (page - 1) * limit;
+
+            const conditions: SQL[] = [];
+
+            // Soft delete
+            if (options?.softDelete && !params?.includeDeleted) {
+               conditions.push(sql`${anyTable[options.softDelete.field as string]} IS NULL`);
+            }
+
+            // Search
+            if (params?.search && options?.searchFields?.length) {
+                const searchConds = options.searchFields.map(
+                    (f) => ilike(anyTable[f as string] as AnyPgColumn, `%${params!.search}%`)
+                );
+                conditions.push(or(...searchConds)!);
+            }
+
+            // Filters
+            if (params?.filters && options?.allowedFilters) {
+                for (const [k, v] of Object.entries(params.filters)) {
+                    if (options.allowedFilters.includes(k as keyof T["_"]["columns"])) {
+                        conditions.push(eq(anyTable[k] as AnyPgColumn, v));
+                    }
+                }
+            }
+
+            const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
+
+            // Order By
+            const orderByArgs = (params?.orderBy || []).map((o) => {
+                const col = anyTable[o.field] as AnyPgColumn;
+                return o.direction === 'desc' ? desc(col) : asc(col);
+            });
+            
+            // Base count 
+            const [{ count: total }] = await db.select({ count: count() }).from(anyTable).where(whereClause);
+            
+            const results = await db.select()
+                .from(anyTable)
+                .where(whereClause)
+                .orderBy(...orderByArgs)
+                .limit(limit)
+                .offset(offset);
+
+            return {
+                results,
+                page,
+                limit,
+                total: Number(total),
+            };
+        }
+
+        async function update(id: any, data: any): Promise<any> {
+            let updateData = { ...data };
+            if (options?.hooks?.beforeUpdate) {
+                updateData = await options.hooks.beforeUpdate(updateData);
+            }
+            const [result] = await db.update(anyTable)
+                .set(updateData)
+                .where(eq(pk, id))
+                .returning();
+            return result;
+        }
+
+        async function deleteOne(id: any): Promise<void> {
+            if (options?.softDelete) {
+                const sdField = options.softDelete.field as string;
+                await db.update(anyTable)
+                    .set({ [sdField]: new Date() } as any)
+                    .where(eq(pk, id));
+            } else {
+                await db.delete(anyTable).where(eq(pk, id));
+            }
+        }
+
+        async function restore(id: any): Promise<void> {
+            if (options?.softDelete) {
+                const sdField = options.softDelete.field as string;
+                await db.update(anyTable)
+                    .set({ [sdField]: null } as any)
+                    .where(eq(pk, id));
+            }
+        }
+
+        async function bulkCreate(dataArray: any[]): Promise<any[]> {
+            let insertData = [...dataArray];
+            if (options?.hooks?.beforeCreate) {
+                insertData = await Promise.all(insertData.map((d) => options.hooks!.beforeCreate!(d)));
+            }
+            return await db.insert(anyTable).values(insertData).returning();
+        }
+
+        async function bulkDelete(ids: any[]): Promise<void> {
+            if (ids.length === 0) return;
+            if (options?.softDelete) {
+                const sdField = options.softDelete.field as string;
+                await db.update(anyTable)
+                    .set({ [sdField]: new Date() } as any)
+                    .where(inArray(pk, ids));
+            } else {
+                await db.delete(anyTable).where(inArray(pk, ids));
+            }
+        }
+
+        return {
+            create,
+            findById,
+            list,
+            update,
+            deleteOne,
+            restore,
+            bulkCreate,
+            bulkDelete,
+        };
+    };
+}

package/src/index.ts

@@ -9,7 +9,7 @@ export type { GencowCtx, AuthCtx, UserIdentity, QueryDef, MutationDef, RealtimeC
 export { query, mutation, httpAction, invalidateQueries, buildRealtimeCtx, subscribe, unsubscribe, registerClient, deregisterClient, handleWsMessage, getQueryHandler, getQueryDef, getRegisteredQueries, getRegisteredMutations, getRegisteredHttpActions } from "./reactive";
 export type { Storage } from "./storage";
 export { createScheduler, getSchedulerInfo } from "./scheduler";
-export type { Scheduler } from "./scheduler";
+export type { Scheduler, ScheduleOptions, FailedJob } from "./scheduler";
 export { v, parseArgs, GencowValidationError } from "./v";
 export type { Validator, Infer, InferArgs } from "./v";
 export { withRetry } from "./retry";
@@ -19,10 +19,10 @@ export type { CronJobsBuilder, CronJobDef, IntervalOptions, DailyOptions, Weekly
 export { defineAuth } from "./auth-config";
 export type { GencowAuthConfig, AuthEmailVerification } from "./auth-config";
 
-// ─── Data Isolation (gencowTable + scoped DB) ───────────
-export { gencowTable, ownerFilter, getTableAccessMeta, isGencowTable, getAllGencowTables } from "./table";
-export type { GencowTableOptions, AccessFilter, FieldAccessRule, TableAccessMeta } from "./table";
-export { createScopedDb, applyFieldAccess } from "./scoped-db";
+// ─── RLS + CRUD Factory ───────────
+export { ownerRls } from "./rls";
+export { createRlsDb } from "./rls-db";
+export { gencowCrud } from "./crud";
 
 
 

package/src/rls-db.ts

@@ -0,0 +1,24 @@
+import { sql } from "drizzle-orm";
+import type { PgDatabase } from "drizzle-orm/pg-core";
+
+/**
+ * JWT payload.sub(userId)로 RLS 세션 변수를 주입하는 DB 래퍼.
+ * Supabase createDrizzle 패턴 참고.
+ *
+ * set_config(name, value, is_local=true)
+ *   → is_local=true: 현재 트랜잭션에서만 유효
+ *   → PgBouncer transaction 모드에서 안전
+ */
+export function createRlsDb(db: PgDatabase<any, any, any>, userId: string) {
+    return {
+        ...db,
+        transaction: (async (callback: any, ...rest: any[]) => {
+            return await db.transaction(async (tx) => {
+                await tx.execute(
+                    sql`SELECT set_config('app.current_user_id', ${userId}, true)`
+                );
+                return await callback(tx);
+            }, ...rest as any);
+        }) as typeof db.transaction,
+    };
+}

package/src/rls.ts

@@ -0,0 +1,15 @@
+import { sql, type SQL } from "drizzle-orm";
+import { pgPolicy, type AnyPgColumn } from "drizzle-orm/pg-core";
+
+export function ownerRls(
+    userIdColumn: AnyPgColumn,
+    options?: { read?: "public" },
+) {
+    const isOwner = sql`${userIdColumn} = current_setting('app.current_user_id')`;
+    return [
+        pgPolicy("rls-select", { for: "select", using: options?.read === "public" ? sql`true` : isOwner }),
+        pgPolicy("rls-insert", { for: "insert", withCheck: isOwner }),
+        pgPolicy("rls-update", { for: "update", using: isOwner, withCheck: isOwner }),
+        pgPolicy("rls-delete", { for: "delete", using: isOwner }),
+    ];
+}

package/src/scheduler.ts

@@ -4,11 +4,26 @@ import * as cron from "node-cron";
 
 type ActionHandler = (args: any) => Promise<any>;
 
+/** runAfter/runAt 옵션 — onError dead-letter 콜백 지원 */
+export interface ScheduleOptions {
+    /** 실패 시 호출할 action 이름 (dead-letter 패턴) */
+    onError?: string;
+}
+
+/** 실패한 작업의 기록 */
+export interface FailedJob {
+    id: string;
+    action: string;
+    args: any;
+    error: string;
+    failedAt: string;
+}
+
 export interface Scheduler {
     /** Schedule a function to run after a delay — Convex의 ctx.scheduler.runAfter() */
-    runAfter(ms: number, action: string, args?: any): string;
+    runAfter(ms: number, action: string, args?: any, options?: ScheduleOptions): string;
     /** Schedule a function at a specific time — Convex의 ctx.scheduler.runAt() */
-    runAt(timestamp: number | Date, action: string, args?: any): string;
+    runAt(timestamp: number | Date, action: string, args?: any, options?: ScheduleOptions): string;
     /** Cancel a scheduled function */
     cancel(jobId: string): boolean;
     /** Register a cron job — Convex의 cronJobs() */
@@ -33,6 +48,9 @@ export interface Scheduler {
  * // Schedule (Convex-style)
  * scheduler.runAfter(5 * 60 * 1000, 'emails.send', { to: 'user@test.com' });
  *
+ * // Schedule with error callback (dead-letter 패턴)
+ * scheduler.runAfter(0, 'pipeline.step2', args, { onError: 'pipeline.onStepError' });
+ *
  * // Cron (Convex-style)
  * scheduler.cron('daily-cleanup', '0 2 * * *', async () => { ... });
  */
@@ -41,17 +59,28 @@ export interface Scheduler {
 // @gencow/core가 다중 resolve되어도 단일 배열 공유.
 
 interface CronInfoEntry { name: string; pattern: string; registeredAt: string }
-interface PendingJobEntry { id: string; action: string; scheduledAt: string }
+interface PendingJobEntry {
+    id: string;
+    action: string;
+    scheduledAt: string;
+    status?: "pending" | "running" | "completed" | "failed";
+}
 
 const _cronInfo: CronInfoEntry[] =
     (globalThis as any).__gencow_cronInfo ??= [];
 const _pendingJobs: PendingJobEntry[] =
     (globalThis as any).__gencow_pendingJobs ??= [];
+const _failedJobs: FailedJob[] =
+    (globalThis as any).__gencow_failedJobs ??= [];
+
+/** 최대 보관할 실패 작업 수 (메모리 보호) */
+const MAX_FAILED_JOBS = 100;
 
 export function getSchedulerInfo() {
     return {
         crons: _cronInfo,
         pendingJobs: _pendingJobs,
+        failedJobs: _failedJobs,
     };
 }
 
@@ -66,42 +95,85 @@ export function createScheduler(): Scheduler {
         return `job_${++jobCounter}_${Date.now()}`;
     }
 
-    async function executeAction(action: string, args: any) {
+    /** 실패 기록 추가 (dead-letter 레지스트리) */
+    function recordFailure(id: string, action: string, args: any, error: Error): void {
+        _failedJobs.push({
+            id,
+            action,
+            args,
+            error: error.message,
+            failedAt: new Date().toISOString(),
+        });
+        // 메모리 보호: 오래된 실패 기록 정리
+        while (_failedJobs.length > MAX_FAILED_JOBS) {
+            _failedJobs.shift();
+        }
+    }
+
+    async function executeAction(action: string, args: any): Promise<void> {
         const handler = actions.get(action);
         if (!handler) {
             console.error(`[scheduler] Action "${action}" not registered`);
-            return;
-        }
-        try {
-            await handler(args);
-            console.log(`[scheduler] Action "${action}" completed`);
-        } catch (error) {
-            console.error(`[scheduler] Action "${action}" failed:`, error);
+            throw new Error(`Action "${action}" not registered`);
         }
+        await handler(args);
+        console.log(`[scheduler] Action "${action}" completed`);
     }
 
     return {
-        runAfter(ms: number, action: string, args?: any): string {
+        runAfter(ms: number, action: string, args?: any, options?: ScheduleOptions): string {
             const id = generateId();
-            _pendingJobs.push({ id, action, scheduledAt: new Date().toISOString() });
+            const jobEntry: PendingJobEntry = { id, action, scheduledAt: new Date().toISOString(), status: "pending" };
+            _pendingJobs.push(jobEntry);
+
             const timer = setTimeout(async () => {
-                await executeAction(action, args);
-                timers.delete(id);
-                const idx = _pendingJobs.findIndex((j) => j.id === id);
-                if (idx >= 0) _pendingJobs.splice(idx, 1);
+                jobEntry.status = "running";
+                try {
+                    await executeAction(action, args);
+                    jobEntry.status = "completed";
+                } catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    jobEntry.status = "failed";
+                    console.error(`[scheduler] Action "${action}" failed (job: ${id}):`, err.message);
+
+                    // 실패 기록 보관 (dead-letter)
+                    recordFailure(id, action, args, err);
+
+                    // onError 콜백 실행 — 다른 action에 에러 정보 전달
+                    if (options?.onError) {
+                        try {
+                            await executeAction(options.onError, {
+                                failedAction: action,
+                                failedJobId: id,
+                                error: err.message,
+                                originalArgs: args,
+                            });
+                            console.log(`[scheduler] onError handler "${options.onError}" completed for "${action}"`);
+                        } catch (onErrorErr) {
+                            console.error(`[scheduler] onError handler "${options.onError}" also failed:`, onErrorErr);
+                        }
+                    }
+                } finally {
+                    timers.delete(id);
+                    // completed/failed 기록은 잠시 유지 후 정리 (status 조회 가능하도록)
+                    setTimeout(() => {
+                        const idx = _pendingJobs.findIndex((j) => j.id === id);
+                        if (idx >= 0) _pendingJobs.splice(idx, 1);
+                    }, 60_000); // 1분 후 정리
+                }
             }, ms);
             timers.set(id, timer);
             console.log(
-                `[scheduler] Scheduled "${action}" to run after ${ms}ms (id: ${id})`
+                `[scheduler] Scheduled "${action}" to run after ${ms}ms (id: ${id})${options?.onError ? ` [onError: ${options.onError}]` : ""}`
             );
             return id;
         },
 
-        runAt(timestamp: number | Date, action: string, args?: any): string {
+        runAt(timestamp: number | Date, action: string, args?: any, options?: ScheduleOptions): string {
             const target =
                 timestamp instanceof Date ? timestamp.getTime() : timestamp;
             const ms = Math.max(0, target - Date.now());
-            return this.runAfter(ms, action, args);
+            return this.runAfter(ms, action, args, options);
         },
 
         cancel(jobId: string): boolean {
@@ -109,6 +181,8 @@ export function createScheduler(): Scheduler {
             if (timer) {
                 clearTimeout(timer);
                 timers.delete(jobId);
+                const idx = _pendingJobs.findIndex((j) => j.id === jobId);
+                if (idx >= 0) _pendingJobs.splice(idx, 1);
                 console.log(`[scheduler] Cancelled job ${jobId}`);
                 return true;
             }
@@ -124,7 +198,10 @@ export function createScheduler(): Scheduler {
                 try {
                     await handler();
                 } catch (error) {
-                    console.error(`[scheduler] Cron "${name}" failed:`, error);
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    console.error(`[scheduler] Cron "${name}" failed:`, err.message);
+                    // cron 실패도 dead-letter에 기록
+                    recordFailure(`cron_${name}_${Date.now()}`, `cron:${name}`, {}, err);
                 }
             });
             cronJobs.set(name, task);