@gencow/core 0.1.8 → 0.1.10

package/src/__tests__/table.test.ts

@@ -0,0 +1,324 @@
+/**
+ * packages/core/src/__tests__/table.test.ts
+ *
+ * Tests for gencowTable(), ownerFilter(), and table access registry.
+ *
+ * Run: bun test packages/core/src/__tests__/table.test.ts
+ */
+
+import { describe, it, expect, beforeEach } from "bun:test";
+import {
+    gencowTable,
+    ownerFilter,
+    getTableAccessMeta,
+    isGencowTable,
+    getAllGencowTables,
+    _resetTableRegistry,
+} from "../table";
+import type { GencowCtx } from "../reactive";
+import { pgTable, serial, text, integer } from "drizzle-orm/pg-core";
+import { eq } from "drizzle-orm";
+
+// ─── Test Helpers ────────────────────────────────────────
+
+function makeCtx(userId: string, role = "user"): GencowCtx {
+    return {
+        auth: {
+            getUserIdentity: () => ({ id: userId, email: `${userId}@test.com`, name: "Test" }),
+            requireAuth: () => ({ id: userId, email: `${userId}@test.com`, name: "Test", role }),
+        },
+        db: {},
+        unsafeDb: {},
+        storage: {} as any,
+        scheduler: {} as any,
+        realtime: {} as any,
+        retry: {} as any,
+    };
+}
+
+function makeAnonCtx(): GencowCtx {
+    return {
+        auth: {
+            getUserIdentity: () => null,
+            requireAuth: () => { throw new Error("Authentication required"); },
+        },
+        db: {},
+        unsafeDb: {},
+        storage: {} as any,
+        scheduler: {} as any,
+        realtime: {} as any,
+        retry: {} as any,
+    };
+}
+
+// ─── Tests ───────────────────────────────────────────────
+
+describe("gencowTable()", () => {
+    beforeEach(() => {
+        _resetTableRegistry();
+    });
+
+    it("유효한 Drizzle 테이블을 반환한다", () => {
+        const table = gencowTable("test_tasks", {
+            id: serial("id").primaryKey(),
+            title: text("title").notNull(),
+        }, {
+            filter: () => true,
+        });
+
+        // Drizzle 테이블은 Symbol 기반 내부 속성을 가짐
+        expect(table).toBeDefined();
+        expect(typeof table).toBe("object");
+    });
+
+    it("filter 메타데이터를 레지스트리에 저장한다", () => {
+        const filterFn = (ctx: GencowCtx) => true;
+        const table = gencowTable("meta_test", {
+            id: serial("id").primaryKey(),
+        }, {
+            filter: filterFn,
+        });
+
+        const meta = getTableAccessMeta(table);
+        expect(meta).toBeDefined();
+        expect(meta!.tableName).toBe("meta_test");
+        expect(meta!.filter).toBe(filterFn);
+    });
+
+    it("filter 옵션이 없으면 에러를 던진다", () => {
+        expect(() => {
+            gencowTable("no_filter", {
+                id: serial("id").primaryKey(),
+            }, {} as any);
+        }).toThrow("requires a filter option");
+    });
+
+    it("filter가 함수가 아니면 에러를 던진다", () => {
+        expect(() => {
+            gencowTable("bad_filter", {
+                id: serial("id").primaryKey(),
+            }, {
+                filter: "not a function" as any,
+            });
+        }).toThrow("requires a filter option");
+    });
+
+    it("options 자체가 없으면 에러를 던진다", () => {
+        expect(() => {
+            (gencowTable as any)("no_opts", {
+                id: serial("id").primaryKey(),
+            });
+        }).toThrow();
+    });
+
+    it("fieldAccess 메타데이터도 저장한다", () => {
+        const readCheck = (ctx: GencowCtx) => true;
+        const table = gencowTable("field_test", {
+            id: serial("id").primaryKey(),
+            salary: integer("salary"),
+        }, {
+            filter: () => true,
+            fieldAccess: {
+                salary: { read: readCheck },
+            },
+        });
+
+        const meta = getTableAccessMeta(table);
+        expect(meta!.fieldAccess).toBeDefined();
+        expect(meta!.fieldAccess!.salary.read).toBe(readCheck);
+    });
+
+    it("filter 함수가 ctx를 받아 SQL 조건을 반환할 수 있다", () => {
+        const table = gencowTable("sql_filter", {
+            id: serial("id").primaryKey(),
+            userId: text("user_id").notNull(),
+        }, {
+            filter: (ctx) => {
+                const user = ctx.auth.requireAuth();
+                return eq((table as any).userId, user.id);
+            },
+        });
+
+        const meta = getTableAccessMeta(table);
+        const ctx = makeCtx("user-123");
+        const result = meta!.filter(ctx);
+        // Should return a SQL condition, not a boolean
+        expect(result).not.toBe(true);
+        expect(result).not.toBe(false);
+        expect(typeof result).toBe("object"); // Drizzle SQL object
+    });
+
+    it("filter가 true를 반환하면 전체 접근", () => {
+        const table = gencowTable("public_table", {
+            id: serial("id").primaryKey(),
+        }, {
+            filter: () => true,
+        });
+
+        const meta = getTableAccessMeta(table);
+        expect(meta!.filter({} as GencowCtx)).toBe(true);
+    });
+
+    it("filter가 false를 반환하면 전체 차단", () => {
+        const table = gencowTable("blocked_table", {
+            id: serial("id").primaryKey(),
+        }, {
+            filter: () => false,
+        });
+
+        const meta = getTableAccessMeta(table);
+        expect(meta!.filter({} as GencowCtx)).toBe(false);
+    });
+
+    it("RBAC filter — admin은 true, 일반은 SQL 조건", () => {
+        const table = gencowTable("rbac_test", {
+            id: serial("id").primaryKey(),
+            userId: text("user_id").notNull(),
+        }, {
+            filter: (ctx) => {
+                const user = ctx.auth.requireAuth() as any;
+                if (user.role === "admin") return true;
+                return eq((table as any).userId, user.id);
+            },
+        });
+
+        const meta = getTableAccessMeta(table);
+
+        // admin → true
+        const adminCtx = makeCtx("admin-1", "admin");
+        expect(meta!.filter(adminCtx)).toBe(true);
+
+        // user → SQL condition
+        const userCtx = makeCtx("user-1", "user");
+        const result = meta!.filter(userCtx);
+        expect(result).not.toBe(true);
+        expect(typeof result).toBe("object");
+    });
+
+    it("requireAuth 포함 filter — 비인증 시 에러", () => {
+        const table = gencowTable("auth_required", {
+            id: serial("id").primaryKey(),
+            userId: text("user_id").notNull(),
+        }, {
+            filter: (ctx) => {
+                ctx.auth.requireAuth(); // throws if not authenticated
+                return true;
+            },
+        });
+
+        const meta = getTableAccessMeta(table);
+        const anonCtx = makeAnonCtx();
+        expect(() => meta!.filter(anonCtx)).toThrow("Authentication required");
+    });
+});
+
+// ─── ownerFilter() ──────────────────────────────────────
+
+describe("ownerFilter()", () => {
+    beforeEach(() => {
+        _resetTableRegistry();
+    });
+
+    it("기본 컬럼명 userId로 필터를 생성한다", () => {
+        const table = gencowTable("owner_default", {
+            id: serial("id").primaryKey(),
+            userId: text("user_id").notNull(),
+        }, ownerFilter("userId"));
+
+        const meta = getTableAccessMeta(table);
+        expect(meta).toBeDefined();
+        expect(meta!.tableName).toBe("owner_default");
+
+        // Filter should work with auth ctx
+        const ctx = makeCtx("user-abc");
+        const result = meta!.filter(ctx);
+        expect(result).not.toBe(true); // Returns SQL condition, not boolean
+        expect(typeof result).toBe("object");
+    });
+
+    it("커스텀 컬럼명을 지원한다 (ownerId)", () => {
+        const table = gencowTable("owner_custom", {
+            id: serial("id").primaryKey(),
+            ownerId: text("owner_id").notNull(),
+        }, ownerFilter("ownerId"));
+
+        const meta = getTableAccessMeta(table);
+        expect(meta).toBeDefined();
+
+        const ctx = makeCtx("user-xyz");
+        const result = meta!.filter(ctx);
+        expect(typeof result).toBe("object"); // SQL condition
+    });
+
+    it("존재하지 않는 컬럼명이면 에러", () => {
+        expect(() => {
+            gencowTable("owner_bad", {
+                id: serial("id").primaryKey(),
+                title: text("title"),
+            }, ownerFilter("nonExistentColumn"));
+        }).toThrow("not found on table");
+    });
+
+    it("비인증 사용자 시 requireAuth에서 에러", () => {
+        const table = gencowTable("owner_auth", {
+            id: serial("id").primaryKey(),
+            userId: text("user_id").notNull(),
+        }, ownerFilter("userId"));
+
+        const meta = getTableAccessMeta(table);
+        const anonCtx = makeAnonCtx();
+        expect(() => meta!.filter(anonCtx)).toThrow("Authentication required");
+    });
+});
+
+// ─── isGencowTable / getAllGencowTables ──────────────────
+
+describe("isGencowTable() / getAllGencowTables()", () => {
+    beforeEach(() => {
+        _resetTableRegistry();
+    });
+
+    it("gencowTable로 생성한 테이블은 true", () => {
+        const table = gencowTable("is_test", {
+            id: serial("id").primaryKey(),
+        }, { filter: () => true });
+
+        expect(isGencowTable(table)).toBe(true);
+    });
+
+    it("pgTable로 생성한 테이블은 false", () => {
+        const table = pgTable("plain_pg", {
+            id: serial("id").primaryKey(),
+        });
+
+        expect(isGencowTable(table)).toBe(false);
+    });
+
+    it("getTableAccessMeta — pgTable은 undefined 반환", () => {
+        const table = pgTable("no_meta", {
+            id: serial("id").primaryKey(),
+        });
+
+        expect(getTableAccessMeta(table)).toBeUndefined();
+    });
+
+    it("getAllGencowTables — 등록된 모든 테이블 반환", () => {
+        gencowTable("all_a", { id: serial("id").primaryKey() }, { filter: () => true });
+        gencowTable("all_b", { id: serial("id").primaryKey() }, { filter: () => true });
+
+        const all = getAllGencowTables();
+        expect(all.size).toBe(2);
+
+        const names = Array.from(all.values()).map(m => m.tableName);
+        expect(names).toContain("all_a");
+        expect(names).toContain("all_b");
+    });
+
+    it("_resetTableRegistry — 레지스트리 초기화", () => {
+        gencowTable("reset_test", { id: serial("id").primaryKey() }, { filter: () => true });
+        expect(getAllGencowTables().size).toBe(1);
+
+        _resetTableRegistry();
+        expect(getAllGencowTables().size).toBe(0);
+    });
+});

package/src/__tests__/validator.test.ts

@@ -0,0 +1,284 @@
+/**
+ * packages/core/src/__tests__/validator.test.ts
+ *
+ * Tests for the `v` validator module — runtime argument validation.
+ *
+ * Run: bun test packages/core/src/__tests__/validator.test.ts
+ */
+
+import { describe, it, expect } from "bun:test";
+import { v, parseArgs, GencowValidationError } from "../v";
+
+// ─── v.string() ─────────────────────────────────────────
+
+describe("v.string()", () => {
+    const validator = v.string();
+
+    it("문자열 통과", () => {
+        expect(validator.parse("hello")).toBe("hello");
+    });
+
+    it("빈 문자열 통과", () => {
+        expect(validator.parse("")).toBe("");
+    });
+
+    it("숫자 → 에러", () => {
+        expect(() => validator.parse(42)).toThrow("Expected string");
+    });
+
+    it("불리언 → 에러", () => {
+        expect(() => validator.parse(true)).toThrow("Expected string");
+    });
+
+    it("null → 에러", () => {
+        expect(() => validator.parse(null)).toThrow("Expected string");
+    });
+
+    it("undefined → 에러", () => {
+        expect(() => validator.parse(undefined)).toThrow("Expected string");
+    });
+});
+
+// ─── v.number() ─────────────────────────────────────────
+
+describe("v.number()", () => {
+    const validator = v.number();
+
+    it("정수 통과", () => {
+        expect(validator.parse(42)).toBe(42);
+    });
+
+    it("실수 통과", () => {
+        expect(validator.parse(3.14)).toBe(3.14);
+    });
+
+    it("0 통과", () => {
+        expect(validator.parse(0)).toBe(0);
+    });
+
+    it("음수 통과", () => {
+        expect(validator.parse(-10)).toBe(-10);
+    });
+
+    it("숫자 문자열 → 자동 변환", () => {
+        expect(validator.parse("42")).toBe(42);
+    });
+
+    it("비숫자 문자열 → 에러", () => {
+        expect(() => validator.parse("abc")).toThrow("Expected number");
+    });
+
+    it("불리언 → 에러", () => {
+        expect(() => validator.parse(true)).toThrow("Expected number");
+    });
+
+    it("NaN 입력 → 에러", () => {
+        expect(() => validator.parse(NaN)).toThrow("Expected number");
+    });
+});
+
+// ─── v.boolean() ────────────────────────────────────────
+
+describe("v.boolean()", () => {
+    const validator = v.boolean();
+
+    it("true 통과", () => {
+        expect(validator.parse(true)).toBe(true);
+    });
+
+    it("false 통과", () => {
+        expect(validator.parse(false)).toBe(false);
+    });
+
+    it("문자열 → 에러", () => {
+        expect(() => validator.parse("true")).toThrow("Expected boolean");
+    });
+
+    it("숫자 → 에러", () => {
+        expect(() => validator.parse(1)).toThrow("Expected boolean");
+    });
+});
+
+// ─── v.any() ────────────────────────────────────────────
+
+describe("v.any()", () => {
+    const validator = v.any();
+
+    it("모든 값 통과 — 문자열", () => {
+        expect(validator.parse("hello")).toBe("hello");
+    });
+
+    it("모든 값 통과 — 숫자", () => {
+        expect(validator.parse(42)).toBe(42);
+    });
+
+    it("모든 값 통과 — null", () => {
+        expect(validator.parse(null)).toBe(null);
+    });
+
+    it("모든 값 통과 — undefined", () => {
+        expect(validator.parse(undefined)).toBe(undefined);
+    });
+
+    it("모든 값 통과 — 객체", () => {
+        const obj = { key: "value" };
+        expect(validator.parse(obj)).toBe(obj);
+    });
+});
+
+// ─── v.optional() ───────────────────────────────────────
+
+describe("v.optional()", () => {
+    const validator = v.optional(v.string());
+
+    it("문자열 통과", () => {
+        expect(validator.parse("hello")).toBe("hello");
+    });
+
+    it("undefined → undefined 반환", () => {
+        expect(validator.parse(undefined)).toBe(undefined);
+    });
+
+    it("null → undefined 반환", () => {
+        expect(validator.parse(null)).toBe(undefined);
+    });
+
+    it("숫자 → 에러 (내부 validator 적용)", () => {
+        expect(() => validator.parse(42)).toThrow("Expected string");
+    });
+});
+
+// ─── v.array() ──────────────────────────────────────────
+
+describe("v.array()", () => {
+    const validator = v.array(v.string());
+
+    it("문자열 배열 통과", () => {
+        expect(validator.parse(["a", "b", "c"])).toEqual(["a", "b", "c"]);
+    });
+
+    it("빈 배열 통과", () => {
+        expect(validator.parse([])).toEqual([]);
+    });
+
+    it("비배열 → 에러", () => {
+        expect(() => validator.parse("not array")).toThrow("Expected array");
+    });
+
+    it("원소 타입 불일치 → 에러", () => {
+        expect(() => validator.parse([1, 2, 3])).toThrow("Expected string");
+    });
+
+    it("혼합 배열 → 에러", () => {
+        expect(() => validator.parse(["ok", 42])).toThrow("Expected string");
+    });
+});
+
+// ─── v.object() ─────────────────────────────────────────
+
+describe("v.object()", () => {
+    const validator = v.object({
+        name: v.string(),
+        age: v.number(),
+    });
+
+    it("유효한 객체 통과", () => {
+        expect(validator.parse({ name: "Alice", age: 30 })).toEqual({ name: "Alice", age: 30 });
+    });
+
+    it("비객체 → 에러", () => {
+        expect(() => validator.parse("string")).toThrow("Expected object");
+    });
+
+    it("null → 에러", () => {
+        expect(() => validator.parse(null)).toThrow("Expected object");
+    });
+
+    it("필드 타입 불일치 → 에러", () => {
+        expect(() => validator.parse({ name: 42, age: 30 })).toThrow("Expected string");
+    });
+
+    it("필드 누락 → inner validator 에러", () => {
+        expect(() => validator.parse({ name: "Alice" })).toThrow("Expected number");
+    });
+});
+
+// ─── 복합 중첩 검증 ────────────────────────────────────
+
+describe("복합 중첩 검증", () => {
+    it("v.optional(v.array(v.string()))", () => {
+        const validator = v.optional(v.array(v.string()));
+        expect(validator.parse(undefined)).toBe(undefined);
+        expect(validator.parse(["a", "b"])).toEqual(["a", "b"]);
+        expect(() => validator.parse([1])).toThrow("Expected string");
+    });
+
+    it("v.array(v.object(...))", () => {
+        const validator = v.array(v.object({
+            id: v.number(),
+            label: v.string(),
+        }));
+        expect(validator.parse([
+            { id: 1, label: "A" },
+            { id: 2, label: "B" },
+        ])).toEqual([
+            { id: 1, label: "A" },
+            { id: 2, label: "B" },
+        ]);
+    });
+
+    it("v.object({ tags: v.array(v.string()), meta: v.optional(v.object(...)) })", () => {
+        const validator = v.object({
+            tags: v.array(v.string()),
+            meta: v.optional(v.object({ key: v.string() })),
+        });
+        expect(validator.parse({ tags: ["a"], meta: undefined })).toEqual({ tags: ["a"], meta: undefined });
+        expect(validator.parse({ tags: [], meta: { key: "val" } })).toEqual({ tags: [], meta: { key: "val" } });
+    });
+});
+
+// ─── parseArgs() ────────────────────────────────────────
+
+describe("parseArgs()", () => {
+    it("schema 없으면 args 그대로 반환", () => {
+        expect(parseArgs(null, { foo: 1 })).toEqual({ foo: 1 });
+        expect(parseArgs(undefined, "hello")).toBe("hello");
+    });
+
+    it("Validator 스키마로 직접 파싱", () => {
+        const schema = v.string();
+        expect(parseArgs(schema, "hello")).toBe("hello");
+    });
+
+    it("Validator 스키마 검증 실패 → GencowValidationError", () => {
+        const schema = v.string();
+        expect(() => parseArgs(schema, 42)).toThrow(GencowValidationError);
+    });
+
+    it("Shorthand record 스키마 (Convex 스타일)", () => {
+        const schema = { title: v.string(), count: v.number() };
+        expect(parseArgs(schema, { title: "Hello", count: 5 })).toEqual({ title: "Hello", count: 5 });
+    });
+
+    it("Shorthand record 검증 실패 → GencowValidationError + 필드명 포함", () => {
+        const schema = { title: v.string(), count: v.number() };
+        try {
+            parseArgs(schema, { title: 42, count: 5 });
+            expect(true).toBe(false); // 여기 도달하면 안 됨
+        } catch (e) {
+            expect(e).toBeInstanceOf(GencowValidationError);
+            expect((e as Error).message).toContain("title");
+        }
+    });
+
+    it("Shorthand record에 비객체 전달 → GencowValidationError", () => {
+        const schema = { title: v.string() };
+        expect(() => parseArgs(schema, "not an object")).toThrow(GencowValidationError);
+    });
+
+    it("GencowValidationError.statusCode === 400", () => {
+        const err = new GencowValidationError("test");
+        expect(err.statusCode).toBe(400);
+        expect(err.name).toBe("GencowValidationError");
+    });
+});

package/src/index.ts

@@ -19,4 +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";
+
+
 

package/src/reactive.ts

@@ -58,8 +58,12 @@ export interface AIContext {
     chat: (opts: {
         model?: string;
         messages: AIMessage[];
+        /** System prompt — shorthand for adding a system message */
+        system?: string;
         temperature?: number;
         maxTokens?: number;
+        /** Response format — e.g. { type: "json_object" } for JSON mode */
+        responseFormat?: { type: string };
     }) => Promise<AIResult>;
     /** 텍스트 임베딩 (단일) — ctx.ai.embed("검색 텍스트") */
     embed: (text: string) => Promise<number[]>;
@@ -68,8 +72,10 @@ export interface AIContext {
 }
 
 export interface GencowCtx {
-    /** Drizzle DB 인스턴스 — ctx.db.select().from(table) */
+    /** Drizzle DB 인스턴스 (scoped) — 스키마 filter 자동 적용, execute 차단 */
     db: any; // typed per-app via generic
+    /** Raw Drizzle DB — 필터 없음, execute 허용. ⚠️ 이름이 곧 경고. */
+    unsafeDb: any;
     /** 인증 컨텍스트 — ctx.auth.getUserIdentity() */
     auth: AuthCtx;
     /** 파일 스토리지 — ctx.storage.store(), ctx.storage.getUrl() */

package/src/scheduler.ts

@@ -15,6 +15,8 @@ export interface Scheduler {
     cron(name: string, pattern: string, handler: () => Promise<void>): void;
     /** Register an action handler */
     registerAction(name: string, handler: ActionHandler): void;
+    /** Execute a registered action by name — 선언적 crons.ts 문자열 액션 실행용 */
+    executeAction(name: string, args?: any): Promise<void>;
 }
 
 // ─── Implementation ─────────────────────────────────────
@@ -34,9 +36,17 @@ export interface Scheduler {
  * // Cron (Convex-style)
  * scheduler.cron('daily-cleanup', '0 2 * * *', async () => { ... });
  */
-// Module-level state for dashboard introspection
-const _cronInfo: { name: string; pattern: string; registeredAt: string }[] = [];
-const _pendingJobs: { id: string; action: string; scheduledAt: string }[] = [];
+// ─── globalThis 기반 레지스트리 (모듈 중복 방지) ─────────
+// query/mutation 레지스트리(globalThis.__gencow_*)와 동일 패턴.
+// @gencow/core가 다중 resolve되어도 단일 배열 공유.
+
+interface CronInfoEntry { name: string; pattern: string; registeredAt: string }
+interface PendingJobEntry { id: string; action: string; scheduledAt: string }
+
+const _cronInfo: CronInfoEntry[] =
+    (globalThis as any).__gencow_cronInfo ??= [];
+const _pendingJobs: PendingJobEntry[] =
+    (globalThis as any).__gencow_pendingJobs ??= [];
 
 export function getSchedulerInfo() {
     return {
@@ -125,5 +135,9 @@ export function createScheduler(): Scheduler {
         registerAction(name: string, handler: ActionHandler): void {
             actions.set(name, handler);
         },
+
+        async executeAction(name: string, args?: any): Promise<void> {
+            await executeAction(name, args);
+        },
     };
 }