@gencow/core 0.1.23 → 0.1.25

package/dist/workflows-api.js

@@ -0,0 +1,321 @@
+import { sql } from "drizzle-orm";
+import { mutation, query } from "./reactive.js";
+import { createWorkflowRealtimeToken, deserializeWorkflowValue, getWorkflowResumeActionName, getWorkflowRealtimeKey, serializeWorkflowValue, } from "./workflow.js";
+import { GencowValidationError, v } from "./v.js";
+import { deriveWorkflowStatus } from "./workflow-types.js";
+const WORKFLOW_STATUSES = new Set(["pending", "running", "completed", "failed"]);
+const WORKFLOW_DERIVED_PENDING_STATUSES = new Set(["queued", "waiting", "sleeping"]);
+function rowsFromResult(result) {
+    if (Array.isArray(result))
+        return result;
+    if (result && typeof result === "object" && Array.isArray(result.rows)) {
+        return result.rows;
+    }
+    return [];
+}
+function parseJsonField(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function toIsoString(value) {
+    if (value instanceof Date)
+        return value.toISOString();
+    const parsed = new Date(value);
+    return Number.isFinite(parsed.getTime()) ? parsed.toISOString() : String(value);
+}
+function toOptionalIsoString(value) {
+    return value ? toIsoString(value) : null;
+}
+function mapWorkflowSummary(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        status: row.status,
+        derivedStatus: deriveWorkflowStatus(row.status, row.current_step),
+        currentStep: row.current_step,
+        error: row.error,
+        retryCount: row.retry_count,
+        maxRetries: row.max_retries,
+        maxDurationMs: Number(row.max_duration_ms),
+        startedAt: toIsoString(row.started_at),
+        updatedAt: toIsoString(row.updated_at),
+        completedAt: toOptionalIsoString(row.completed_at),
+    };
+}
+function mapWorkflowStep(row) {
+    return {
+        name: row.step_name,
+        status: row.status,
+        output: deserializeWorkflowValue(parseJsonField(row.output)),
+        error: row.error,
+        startedAt: toOptionalIsoString(row.started_at),
+        updatedAt: toIsoString(row.updated_at),
+        completedAt: toOptionalIsoString(row.completed_at),
+    };
+}
+function normalizeListLimit(limit) {
+    if (limit == null)
+        return 20;
+    if (!Number.isFinite(limit)) {
+        throw new GencowValidationError(`Argument "limit": expected a finite number, got ${limit}`);
+    }
+    return Math.max(1, Math.min(100, Math.floor(limit)));
+}
+function normalizeStatus(status) {
+    if (status == null)
+        return undefined;
+    if (!WORKFLOW_STATUSES.has(status)) {
+        throw new GencowValidationError(`Argument "status": expected one of pending, running, completed, failed`);
+    }
+    return status;
+}
+function normalizeDerivedStatus(status) {
+    if (status == null)
+        return undefined;
+    if (WORKFLOW_DERIVED_PENDING_STATUSES.has(status)) {
+        return status;
+    }
+    return normalizeStatus(status);
+}
+function toWorkflowStatusFilter(status) {
+    if (status == null)
+        return undefined;
+    if (WORKFLOW_DERIVED_PENDING_STATUSES.has(status)) {
+        return "pending";
+    }
+    return status;
+}
+async function ensureWorkflowRealtimeToken(db, workflowId, currentToken) {
+    if (currentToken && currentToken.trim() !== "")
+        return currentToken;
+    const nextToken = createWorkflowRealtimeToken();
+    const updateResult = await db.execute(sql `
+        UPDATE _gencow_workflows
+        SET realtime_token = ${nextToken}
+        WHERE id = ${workflowId}
+          AND (realtime_token IS NULL OR realtime_token = '')
+        RETURNING realtime_token
+    `);
+    const updatedToken = rowsFromResult(updateResult)[0]?.realtime_token ?? null;
+    if (updatedToken && updatedToken.trim() !== "")
+        return updatedToken;
+    const rereadResult = await db.execute(sql `
+        SELECT realtime_token
+        FROM _gencow_workflows
+        WHERE id = ${workflowId}
+        LIMIT 1
+    `);
+    const rereadToken = rowsFromResult(rereadResult)[0]?.realtime_token ?? null;
+    return rereadToken && rereadToken.trim() !== "" ? rereadToken : null;
+}
+async function loadWorkflowSignalTarget(db, workflowId) {
+    const result = await db.execute(sql `
+        SELECT
+            id,
+            name,
+            status,
+            current_step,
+            user_id
+        FROM _gencow_workflows
+        WHERE id = ${workflowId}
+        LIMIT 1
+    `);
+    return rowsFromResult(result)[0] ?? null;
+}
+export async function loadWorkflowSnapshot(db, workflowId, options) {
+    const workflowResult = await db.execute(sql `
+        SELECT
+            id,
+            name,
+            args,
+            status,
+            current_step,
+            result,
+            error,
+            retry_count,
+            max_retries,
+            max_duration_ms,
+            started_at,
+            updated_at,
+            completed_at,
+            realtime_token,
+            user_id
+        FROM _gencow_workflows
+        WHERE id = ${workflowId}
+        LIMIT 1
+    `);
+    const row = rowsFromResult(workflowResult)[0] ?? null;
+    if (!row)
+        return null;
+    const viewerUserId = options?.viewerUserId ?? null;
+    if (options?.requireViewerMatch && row.user_id && row.user_id !== viewerUserId) {
+        return null;
+    }
+    const realtimeToken = await ensureWorkflowRealtimeToken(db, workflowId, row.realtime_token);
+    if (!realtimeToken)
+        return null;
+    const stepsResult = await db.execute(sql `
+        SELECT
+            step_name,
+            status,
+            output,
+            error,
+            started_at,
+            updated_at,
+            completed_at
+        FROM _gencow_workflow_steps
+        WHERE workflow_id = ${workflowId}
+        ORDER BY COALESCE(started_at, updated_at) ASC, step_name ASC
+    `);
+    return {
+        ...mapWorkflowSummary(row),
+        args: deserializeWorkflowValue(parseJsonField(row.args)),
+        result: deserializeWorkflowValue(parseJsonField(row.result)),
+        steps: rowsFromResult(stepsResult).map(mapWorkflowStep),
+        realtimeKey: getWorkflowRealtimeKey(row.id, realtimeToken),
+    };
+}
+export function registerWorkflowsApi() {
+    if (globalThis.__gencow_workflowsApiRegistered)
+        return;
+    globalThis.__gencow_workflowsApiRegistered = true;
+    query("workflows.get", {
+        args: { id: v.string() },
+        public: true,
+        handler: async (ctx, args) => {
+            return loadWorkflowSnapshot(ctx.unsafeDb, args.id, {
+                viewerUserId: ctx.auth.getUserIdentity()?.id ?? null,
+                requireViewerMatch: true,
+            });
+        },
+    });
+    mutation("workflows.signal", {
+        args: {
+            id: v.string(),
+            event: v.string(),
+            payload: v.optional(v.any()),
+        },
+        public: true,
+        handler: async (ctx, args) => {
+            const normalizedEvent = args.event.trim();
+            if (!normalizedEvent) {
+                throw new GencowValidationError(`Argument "event": expected a non-empty string`);
+            }
+            const workflow = await loadWorkflowSignalTarget(ctx.unsafeDb, args.id);
+            const viewerUserId = ctx.auth.getUserIdentity()?.id ?? null;
+            if (!workflow || (workflow.user_id && workflow.user_id !== viewerUserId)) {
+                return {
+                    ok: false,
+                    workflowId: args.id,
+                    event: normalizedEvent,
+                    scheduledJobId: null,
+                };
+            }
+            if (workflow.status === "completed" || workflow.status === "failed") {
+                return {
+                    ok: false,
+                    workflowId: workflow.id,
+                    event: normalizedEvent,
+                    scheduledJobId: null,
+                };
+            }
+            const persistedPayload = serializeWorkflowValue(args.payload);
+            await ctx.unsafeDb.execute(sql `
+                INSERT INTO _gencow_workflow_events (
+                    id,
+                    workflow_id,
+                    event_name,
+                    payload
+                )
+                VALUES (
+                    ${crypto.randomUUID()},
+                    ${workflow.id},
+                    ${normalizedEvent},
+                    ${JSON.stringify(persistedPayload)}::jsonb
+                )
+            `);
+            let scheduledJobId = null;
+            if (workflow.status === "pending" && workflow.current_step?.startsWith("wait:")) {
+                try {
+                    scheduledJobId = ctx.scheduler.runAfter(0, getWorkflowResumeActionName(workflow.name), {
+                        workflowId: workflow.id,
+                    });
+                }
+                catch {
+                    scheduledJobId = null;
+                }
+            }
+            return {
+                ok: true,
+                workflowId: workflow.id,
+                event: normalizedEvent,
+                scheduledJobId,
+            };
+        },
+    });
+    query("workflows.list", {
+        args: {
+            limit: v.optional(v.number()),
+            status: v.optional(v.string()),
+        },
+        handler: async (ctx, args) => {
+            const userId = ctx.auth.requireAuth().id;
+            const limit = normalizeListLimit(args.limit);
+            const requestedStatus = normalizeDerivedStatus(args.status);
+            const status = toWorkflowStatusFilter(requestedStatus);
+            const result = status == null
+                ? await ctx.unsafeDb.execute(sql `
+                    SELECT
+                        id,
+                        name,
+                        args,
+                        status,
+                        current_step,
+                        result,
+                        error,
+                        retry_count,
+                        max_retries,
+                        max_duration_ms,
+                        started_at,
+                        updated_at,
+                        completed_at,
+                        user_id
+                    FROM _gencow_workflows
+                    WHERE user_id = ${userId}
+                    ORDER BY started_at DESC
+                    LIMIT ${limit}
+                `)
+                : await ctx.unsafeDb.execute(sql `
+                    SELECT
+                        id,
+                        name,
+                        args,
+                        status,
+                        current_step,
+                        result,
+                        error,
+                        retry_count,
+                        max_retries,
+                        max_duration_ms,
+                        started_at,
+                        updated_at,
+                        completed_at,
+                        user_id
+                    FROM _gencow_workflows
+                    WHERE user_id = ${userId}
+                      AND status = ${status}
+                    ORDER BY started_at DESC
+                    LIMIT ${limit}
+                `);
+            return rowsFromResult(result)
+                .map(mapWorkflowSummary)
+                .filter((row) => requestedStatus == null || row.derivedStatus === requestedStatus);
+        },
+    });
+}

package/package.json

@@ -1,46 +1,50 @@
 {
-    "name": "@gencow/core",
-    "version": "0.1.23",
-    "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"
-        },
-        "./server": {
-            "import": "./dist/server.js",
-            "require": "./dist/server.js",
-            "types": "./dist/server.d.ts"
-        }
+  "name": "@gencow/core",
+  "version": "0.1.25",
+  "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": {
-        "db:generate:fixture-basic": "drizzle-kit generate --config ./src/__tests__/fixtures/basic/drizzle.config.ts",
-        "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",
-        "drizzle-kit": "^0.31.10",
-        "drizzle-seed": "^0.3.1",
-        "typescript": "^5.9.3",
-        "uuid": "^13.0.0"
+    "./server": {
+      "import": "./dist/server.js",
+      "require": "./dist/server.js",
+      "types": "./dist/server.d.ts"
     }
+  },
+  "files": [
+    "dist/",
+    "src/"
+  ],
+  "scripts": {
+    "db:generate:fixture-basic": "drizzle-kit generate --config ./src/__tests__/fixtures/basic/drizzle.config.ts",
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build",
+    "postinstall": "tsc"
+  },
+  "dependencies": {
+    "node-cron": "^4.2.1"
+  },
+  "peerDependencies": {
+    "drizzle-orm": "^1.0.0-beta || ^1.0.0",
+    "hono": "^4.12.0"
+  },
+  "devDependencies": {
+    "@electric-sql/pglite": "^0.3.15",
+    "@types/bun": "^1.3.9",
+    "@types/node": "^25.3.0",
+    "@types/node-cron": "^3.0.11",
+    "drizzle-kit": "^1.0.0-beta || ^1.0.0",
+    "drizzle-orm": "^1.0.0-beta || ^1.0.0",
+    "drizzle-seed": "^1.0.0-beta",
+    "hono": "^4.12.0",
+    "typescript": "^5.9.3",
+    "uuid": "^13.0.0"
+  }
 }

package/src/__tests__/auth.test.ts

@@ -7,108 +7,112 @@
  */
 
 import { describe, it, expect } from "bun:test";
-import { defineAuth } from "../auth-config";
-import type { GencowAuthConfig } from "../auth-config";
+import { defineAuth } from "../auth-config.js";
+import type { GencowAuthConfig } from "../auth-config.js";
 
 // ─── defineAuth() ───────────────────────────────────────
 
 describe("defineAuth()", () => {
-    it("빈 설정 객체 반환", () => {
-        const config = defineAuth({});
-        expect(config).toEqual({});
+  it("빈 설정 객체 반환", () => {
+    const config = defineAuth({});
+    expect(config).toEqual({});
+  });
+
+  it("emailVerification 설정이 그대로 반환된다", () => {
+    const sendFn = async () => {};
+    const config = defineAuth({
+      emailVerification: {
+        sendOnSignUp: true,
+        requireEmailVerification: true,
+        autoSignInAfterVerification: true,
+        sendVerificationEmail: sendFn,
+      },
     });
 
-    it("emailVerification 설정이 그대로 반환된다", () => {
-        const sendFn = async () => {};
-        const config = defineAuth({
-            emailVerification: {
-                sendOnSignUp: true,
-                requireEmailVerification: true,
-                autoSignInAfterVerification: true,
-                sendVerificationEmail: sendFn,
-            },
-        });
-
-        expect(config.emailVerification?.sendOnSignUp).toBe(true);
-        expect(config.emailVerification?.requireEmailVerification).toBe(true);
-        expect(config.emailVerification?.autoSignInAfterVerification).toBe(true);
-        expect(config.emailVerification?.sendVerificationEmail).toBe(sendFn);
+    expect(config.emailVerification?.sendOnSignUp).toBe(true);
+    expect(config.emailVerification?.requireEmailVerification).toBe(true);
+    expect(config.emailVerification?.autoSignInAfterVerification).toBe(true);
+    expect(config.emailVerification?.sendVerificationEmail).toBe(sendFn);
+  });
+
+  it("부분 설정도 허용된다", () => {
+    const config = defineAuth({
+      emailVerification: {
+        sendVerificationEmail: async () => {},
+      },
     });
 
-    it("부분 설정도 허용된다", () => {
-        const config = defineAuth({
-            emailVerification: {
-                sendVerificationEmail: async () => {},
-            },
-        });
-
-        expect(config.emailVerification?.sendOnSignUp).toBeUndefined();
-        expect(config.emailVerification?.sendVerificationEmail).toBeDefined();
-    });
+    expect(config.emailVerification?.sendOnSignUp).toBeUndefined();
+    expect(config.emailVerification?.sendVerificationEmail).toBeDefined();
+  });
 });
 
 // ─── AuthCtx interface 패턴 ─────────────────────────────
 
 describe("AuthCtx 패턴 (mock)", () => {
-    // AuthCtx는 런타임에서 생성되므로, 인터페이스 수준에서 패턴 검증
-
-    it("getUserIdentity — 비로그인 시 null", () => {
-        const authCtx = {
-            getUserIdentity: () => null,
-            requireAuth: () => { throw new Error("Authentication required"); },
-        };
-
-        expect(authCtx.getUserIdentity()).toBeNull();
-    });
-
-    it("getUserIdentity — 로그인 시 유저 반환", () => {
-        const user = { id: "u1", email: "test@test.com", name: "Test" };
-        const authCtx = {
-            getUserIdentity: () => user,
-            requireAuth: () => user,
-        };
-
-        expect(authCtx.getUserIdentity()).toEqual(user);
-        expect(authCtx.getUserIdentity()!.id).toBe("u1");
-        expect(authCtx.getUserIdentity()!.email).toBe("test@test.com");
-    });
-
-    it("requireAuth — 비로그인 시 에러 throw", () => {
-        const authCtx = {
-            getUserIdentity: () => null,
-            requireAuth: () => { throw new Error("Authentication required"); },
-        };
-
-        expect(() => authCtx.requireAuth()).toThrow("Authentication required");
-    });
-
-    it("requireAuth — 로그인 시 유저 반환 (throw 안 함)", () => {
-        const user = { id: "u2", email: "auth@test.com" };
-        const authCtx = {
-            getUserIdentity: () => user,
-            requireAuth: () => user,
-        };
-
-        expect(() => authCtx.requireAuth()).not.toThrow();
-        expect(authCtx.requireAuth()).toEqual(user);
-    });
+  // AuthCtx는 런타임에서 생성되므로, 인터페이스 수준에서 패턴 검증
+
+  it("getUserIdentity — 비로그인 시 null", () => {
+    const authCtx = {
+      getUserIdentity: () => null,
+      requireAuth: () => {
+        throw new Error("Authentication required");
+      },
+    };
+
+    expect(authCtx.getUserIdentity()).toBeNull();
+  });
+
+  it("getUserIdentity — 로그인 시 유저 반환", () => {
+    const user = { id: "u1", email: "test@test.com", name: "Test" };
+    const authCtx = {
+      getUserIdentity: () => user,
+      requireAuth: () => user,
+    };
+
+    expect(authCtx.getUserIdentity()).toEqual(user);
+    expect(authCtx.getUserIdentity()!.id).toBe("u1");
+    expect(authCtx.getUserIdentity()!.email).toBe("test@test.com");
+  });
+
+  it("requireAuth — 비로그인 시 에러 throw", () => {
+    const authCtx = {
+      getUserIdentity: () => null,
+      requireAuth: () => {
+        throw new Error("Authentication required");
+      },
+    };
+
+    expect(() => authCtx.requireAuth()).toThrow("Authentication required");
+  });
+
+  it("requireAuth — 로그인 시 유저 반환 (throw 안 함)", () => {
+    const user = { id: "u2", email: "auth@test.com" };
+    const authCtx = {
+      getUserIdentity: () => user,
+      requireAuth: () => user,
+    };
+
+    expect(() => authCtx.requireAuth()).not.toThrow();
+    expect(authCtx.requireAuth()).toEqual(user);
+  });
 });
 
 // ─── Secure by Default 검증 ─────────────────────────────
 
 describe("Secure by Default — 기본 인증 필수", () => {
-    // query/mutation의 isPublic 기본값은 reactive.test.ts에서 검증됨.
-    // 여기서는 auth 엔드포인트 레벨 패턴만 확인.
-
-    it("공개(public) 쿼리는 auth 없이 실행 가능해야 함", () => {
-        // 이 테스트는 query({ public: true })의 isPublic 플래그 확인
-        // reactive.test.ts의 "Secure by Default" 섹션과 연계
-        const mockQueryDef = { isPublic: true, handler: async () => [] };
-        expect(mockQueryDef.isPublic).toBe(true);
-    });
-
-    it("비공개 쿼리는 기본적으로 auth 필수", () => {
-        const mockQueryDef = { isPublic: false, handler: async () => [] };
-        expect(mockQueryDef.isPublic).toBe(false);
-    });
+  // query/mutation의 isPublic 기본값은 reactive.test.ts에서 검증됨.
+  // 여기서는 auth 엔드포인트 레벨 패턴만 확인.
+
+  it("공개(public) 쿼리는 auth 없이 실행 가능해야 함", () => {
+    // 이 테스트는 query({ public: true })의 isPublic 플래그 확인
+    // reactive.test.ts의 "Secure by Default" 섹션과 연계
+    const mockQueryDef = { isPublic: true, handler: async () => [] };
+    expect(mockQueryDef.isPublic).toBe(true);
+  });
+
+  it("비공개 쿼리는 기본적으로 auth 필수", () => {
+    const mockQueryDef = { isPublic: false, handler: async () => [] };
+    expect(mockQueryDef.isPublic).toBe(false);
+  });
 });