@gencow/core 0.1.10 → 0.1.12

package/dist/crud.d.ts

@@ -0,0 +1,42 @@
+import type { PgDatabase, PgTable } 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 declare function gencowCrud(db: PgDatabase<any, any, any>): <T extends PgTable>(table: T, options?: CrudOptions<T>) => {
+    create: (data: any) => Promise<any>;
+    findById: (id: any) => Promise<any | null>;
+    list: (params?: {
+        page?: number;
+        limit?: number;
+        search?: string;
+        filters?: Record<string, any>;
+        orderBy?: {
+            field: string;
+            direction: "asc" | "desc";
+        }[];
+        includeDeleted?: boolean;
+    }) => Promise<{
+        results: {
+            [x: string]: any;
+        }[];
+        page: number;
+        limit: number;
+        total: number;
+    }>;
+    update: (id: any, data: any) => Promise<any>;
+    deleteOne: (id: any) => Promise<void>;
+    restore: (id: any) => Promise<void>;
+    bulkCreate: (dataArray: any[]) => Promise<any[]>;
+    bulkDelete: (ids: any[]) => Promise<void>;
+};
+export {};

package/dist/crud.js

@@ -0,0 +1,130 @@
+import { eq, or, and, ilike, desc, asc, inArray, count, sql } from "drizzle-orm";
+export function gencowCrud(db) {
+    return function createCrud(table, options) {
+        const anyTable = table;
+        const pk = anyTable["id"];
+        if (!pk) {
+            throw new Error(`[gencowCrud] Table ${anyTable["_"]["name"]} must have an 'id' column.`);
+        }
+        async function create(data) {
+            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) {
+            let whereCond = eq(pk, id);
+            if (options?.softDelete) {
+                const sdField = anyTable[options.softDelete.field];
+                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) {
+            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 = [];
+            // Soft delete
+            if (options?.softDelete && !params?.includeDeleted) {
+                conditions.push(sql `${anyTable[options.softDelete.field]} IS NULL`);
+            }
+            // Search
+            if (params?.search && options?.searchFields?.length) {
+                const searchConds = options.searchFields.map((f) => ilike(anyTable[f], `%${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)) {
+                        conditions.push(eq(anyTable[k], v));
+                    }
+                }
+            }
+            const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
+            // Order By
+            const orderByArgs = (params?.orderBy || []).map((o) => {
+                const col = anyTable[o.field];
+                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, data) {
+            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) {
+            if (options?.softDelete) {
+                const sdField = options.softDelete.field;
+                await db.update(anyTable)
+                    .set({ [sdField]: new Date() })
+                    .where(eq(pk, id));
+            }
+            else {
+                await db.delete(anyTable).where(eq(pk, id));
+            }
+        }
+        async function restore(id) {
+            if (options?.softDelete) {
+                const sdField = options.softDelete.field;
+                await db.update(anyTable)
+                    .set({ [sdField]: null })
+                    .where(eq(pk, id));
+            }
+        }
+        async function bulkCreate(dataArray) {
+            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) {
+            if (ids.length === 0)
+                return;
+            if (options?.softDelete) {
+                const sdField = options.softDelete.field;
+                await db.update(anyTable)
+                    .set({ [sdField]: new Date() })
+                    .where(inArray(pk, ids));
+            }
+            else {
+                await db.delete(anyTable).where(inArray(pk, ids));
+            }
+        }
+        return {
+            create,
+            findById,
+            list,
+            update,
+            deleteOne,
+            restore,
+            bulkCreate,
+            bulkDelete,
+        };
+    };
+}

package/dist/index.d.ts

@@ -8,7 +8,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";
@@ -17,6 +17,6 @@ export { cronJobs } from "./crons";
 export type { CronJobsBuilder, CronJobDef, IntervalOptions, DailyOptions, WeeklyOptions } from "./crons";
 export { defineAuth } from "./auth-config";
 export type { GencowAuthConfig, AuthEmailVerification } from "./auth-config";
-export { gencowTable, ownerFilter, getTableAccessMeta, isGencowTable, getAllGencowTables } from "./table";
-export type { GencowTableOptions, AccessFilter, FieldAccessRule, TableAccessMeta } from "./table";
-export { createScopedDb, applyFieldAccess } from "./scoped-db";
+export { ownerRls } from "./rls";
+export { createRlsDb } from "./rls-db";
+export { gencowCrud } from "./crud";

package/dist/index.js

@@ -10,6 +10,7 @@ export { v, parseArgs, GencowValidationError } from "./v";
 export { withRetry } from "./retry";
 export { cronJobs } from "./crons";
 export { defineAuth } from "./auth-config";
-// ─── Data Isolation (gencowTable + scoped DB) ───────────
-export { gencowTable, ownerFilter, getTableAccessMeta, isGencowTable, getAllGencowTables } 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/dist/rls-db.d.ts

@@ -0,0 +1,10 @@
+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 declare function createRlsDb(db: PgDatabase<any, any, any>, userId: string): PgDatabase<any, any, any>;

package/dist/rls-db.js

@@ -0,0 +1,25 @@
+import { sql } from "drizzle-orm";
+/**
+ * JWT payload.sub(userId)로 RLS 세션 변수를 주입하는 DB 래퍼.
+ * Supabase createDrizzle 패턴 참고.
+ *
+ * set_config(name, value, is_local=true)
+ *   → is_local=true: 현재 트랜잭션에서만 유효
+ *   → PgBouncer transaction 모드에서 안전
+ */
+export function createRlsDb(db, userId) {
+    return new Proxy(db, {
+        get(target, prop, receiver) {
+            if (prop === "transaction") {
+                return async (callback, ...rest) => {
+                    return await target.transaction(async (tx) => {
+                        await tx.execute(sql `SELECT set_config('app.current_user_id', ${userId}, true)`);
+                        return await callback(tx);
+                    }, ...rest);
+                };
+            }
+            const value = Reflect.get(target, prop, receiver);
+            return typeof value === "function" ? value.bind(target) : value;
+        }
+    });
+}

package/dist/rls.d.ts

@@ -0,0 +1,4 @@
+import { type AnyPgColumn } from "drizzle-orm/pg-core";
+export declare function ownerRls(userIdColumn: AnyPgColumn, options?: {
+    read?: "public";
+}): import("drizzle-orm/pg-core").PgPolicy[];

package/dist/rls.js

@@ -0,0 +1,11 @@
+import { sql } from "drizzle-orm";
+import { pgPolicy } from "drizzle-orm/pg-core";
+export function ownerRls(userIdColumn, options) {
+    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/dist/scheduler.d.ts

@@ -1,9 +1,22 @@
 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() */
@@ -25,6 +38,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 () => { ... });
  */
@@ -37,10 +53,12 @@ interface PendingJobEntry {
     id: string;
     action: string;
     scheduledAt: string;
+    status?: "pending" | "running" | "completed" | "failed";
 }
 export declare function getSchedulerInfo(): {
     crons: CronInfoEntry[];
     pendingJobs: PendingJobEntry[];
+    failedJobs: FailedJob[];
 };
 export declare function createScheduler(): Scheduler;
 export {};

package/dist/scheduler.js

@@ -1,10 +1,14 @@
 import * as cron from "node-cron";
 const _cronInfo = globalThis.__gencow_cronInfo ??= [];
 const _pendingJobs = globalThis.__gencow_pendingJobs ??= [];
+const _failedJobs = globalThis.__gencow_failedJobs ??= [];
+/** 최대 보관할 실패 작업 수 (메모리 보호) */
+const MAX_FAILED_JOBS = 100;
 export function getSchedulerInfo() {
     return {
         crons: _cronInfo,
         pendingJobs: _pendingJobs,
+        failedJobs: _failedJobs,
     };
 }
 export function createScheduler() {
@@ -15,45 +19,89 @@ export function createScheduler() {
     function generateId() {
         return `job_${++jobCounter}_${Date.now()}`;
     }
+    /** 실패 기록 추가 (dead-letter 레지스트리) */
+    function recordFailure(id, action, args, error) {
+        _failedJobs.push({
+            id,
+            action,
+            args,
+            error: error.message,
+            failedAt: new Date().toISOString(),
+        });
+        // 메모리 보호: 오래된 실패 기록 정리
+        while (_failedJobs.length > MAX_FAILED_JOBS) {
+            _failedJobs.shift();
+        }
+    }
     async function executeAction(action, args) {
         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, action, args) {
+        runAfter(ms, action, args, options) {
             const id = generateId();
-            _pendingJobs.push({ id, action, scheduledAt: new Date().toISOString() });
+            const jobEntry = { 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})`);
+            console.log(`[scheduler] Scheduled "${action}" to run after ${ms}ms (id: ${id})${options?.onError ? ` [onError: ${options.onError}]` : ""}`);
             return id;
         },
-        runAt(timestamp, action, args) {
+        runAt(timestamp, action, args, options) {
             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) {
             const timer = timers.get(jobId);
             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;
             }
@@ -69,7 +117,10 @@ export function createScheduler() {
                     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);

package/package.json

@@ -1,40 +1,41 @@
 {
-    "name": "@gencow/core",
-    "version": "0.1.10",
-    "description": "Gencow core library — defineQuery, defineMutation, reactive subscriptions",
-    "type": "module",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "exports": {
-        ".": {
-            "import": "./dist/index.js",
-            "types": "./dist/index.d.ts"
-        },
-        "./server": {
-            "import": "./dist/server.js",
-            "types": "./dist/server.d.ts"
-        }
+  "name": "@gencow/core",
+  "version": "0.1.12",
+  "description": "Gencow core library — defineQuery, defineMutation, reactive subscriptions",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
     },
-    "files": [
-        "dist/",
-        "src/"
-    ],
-    "scripts": {
-        "build": "tsc",
-        "typecheck": "tsc --noEmit",
-        "prepublishOnly": "npm run build",
-        "postinstall": "tsc"
-    },
-    "dependencies": {
-        "@electric-sql/pglite": "^0.3.15",
-        "drizzle-orm": "^0.45.1",
-        "hono": "^4.12.0",
-        "node-cron": "^4.2.1"
-    },
-    "devDependencies": {
-        "@types/bun": "^1.3.9",
-        "@types/node": "^25.3.0",
-        "@types/node-cron": "^3.0.11",
-        "typescript": "^5.9.3"
+    "./server": {
+      "import": "./dist/server.js",
+      "require": "./dist/server.js",
+      "types": "./dist/server.d.ts"
     }
-}
+  },
+  "files": [
+    "dist/",
+    "src/"
+  ],
+  "dependencies": {
+    "@electric-sql/pglite": "^0.3.15",
+    "drizzle-orm": "^0.45.1",
+    "hono": "^4.12.0",
+    "node-cron": "^4.2.1"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.9",
+    "@types/node": "^25.3.0",
+    "@types/node-cron": "^3.0.11",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "postinstall": "tsc"
+  }
+}

package/src/__tests__/scheduler-exec.test.ts

@@ -142,10 +142,17 @@ describe("Scheduler 실행 — registerAction + executeAction", () => {
         expect(result).toBe("Hello World");
     });
 
-    it("미등록 action executeAction → 에러 없이 무시", async () => {
+    it("미등록 action executeAction → 에러를 throw한다", async () => {
         const scheduler = createScheduler();
-        // 에러 없이 조용히 실패해야 함
-        await scheduler.executeAction("nonexistent");
+        // 미등록 action은 에러를 throw해야 함
+        let threw = false;
+        try {
+            await scheduler.executeAction("nonexistent");
+        } catch (e) {
+            threw = true;
+            expect((e as Error).message).toContain("not registered");
+        }
+        expect(threw).toBe(true);
     });
 
     it("action 에러 시 다른 action에 영향 없음", async () => {
@@ -159,8 +166,15 @@ describe("Scheduler 실행 — registerAction + executeAction", () => {
             secondRan = true;
         });
 
-        // 실패하는 action
-        await scheduler.executeAction("failing");
+        // 실패하는 action — 에러를 throw함
+        let threw = false;
+        try {
+            await scheduler.executeAction("failing");
+        } catch {
+            threw = true;
+        }
+        expect(threw).toBe(true);
+
         // 정상 action은 여전히 동작
         await scheduler.executeAction("healthy");
         expect(secondRan).toBe(true);
@@ -244,3 +258,62 @@ describe("Scheduler 실행 — cron", () => {
         expect(count).toBeGreaterThanOrEqual(2);
     });
 });
+
+describe("Scheduler 실행 — onError dead-letter", () => {
+    it("runAfter 실패 시 onError action이 호출된다", async () => {
+        const scheduler = createScheduler();
+        let errorHandlerArgs: any = null;
+
+        scheduler.registerAction("failing.step", async () => {
+            throw new Error("Step failed!");
+        });
+
+        scheduler.registerAction("pipeline.onError", async (args) => {
+            errorHandlerArgs = args;
+        });
+
+        scheduler.runAfter(50, "failing.step", { input: "test" }, {
+            onError: "pipeline.onError",
+        });
+
+        await new Promise((r) => setTimeout(r, 300));
+
+        expect(errorHandlerArgs).not.toBeNull();
+        expect(errorHandlerArgs.failedAction).toBe("failing.step");
+        expect(errorHandlerArgs.error).toBe("Step failed!");
+        expect(errorHandlerArgs.originalArgs).toEqual({ input: "test" });
+    });
+
+    it("실패한 작업이 failedJobs에 기록된다", async () => {
+        const scheduler = createScheduler();
+
+        scheduler.registerAction("record.fail", async () => {
+            throw new Error("Recorded failure");
+        });
+
+        scheduler.runAfter(50, "record.fail", { id: 1 });
+
+        await new Promise((r) => setTimeout(r, 300));
+
+        const info = getSchedulerInfo();
+        const failed = info.failedJobs.find(
+            (j: any) => j.action === "record.fail"
+        );
+        expect(failed).toBeDefined();
+        expect(failed!.error).toBe("Recorded failure");
+    });
+
+    it("pendingJobs에 status 필드가 포함된다", () => {
+        const scheduler = createScheduler();
+        scheduler.registerAction("noop", async () => {});
+        const id = scheduler.runAfter(10000, "noop");
+
+        const info = getSchedulerInfo();
+        const job = info.pendingJobs.find((j: any) => j.id === id);
+        expect(job).toBeDefined();
+        expect(job!.status).toBe("pending");
+
+        // cleanup
+        scheduler.cancel(id);
+    });
+});