@gencow/core 0.1.24 → 0.1.25

package/src/workflows-api.ts

@@ -1,203 +1,194 @@
 import { sql } from "drizzle-orm";
 import { mutation, query } from "./reactive.js";
 import {
-    createWorkflowRealtimeToken,
-    deserializeWorkflowValue,
-    getWorkflowResumeActionName,
-    getWorkflowRealtimeKey,
-    serializeWorkflowValue,
+  createWorkflowRealtimeToken,
+  deserializeWorkflowValue,
+  getWorkflowResumeActionName,
+  getWorkflowRealtimeKey,
+  serializeWorkflowValue,
 } from "./workflow.js";
 import { GencowValidationError, v } from "./v.js";
 import type {
-    WorkflowDerivedStatus,
-    WorkflowSnapshot,
-    WorkflowSignalResult,
-    WorkflowStatus,
-    WorkflowStepSnapshot,
-    WorkflowSummary,
+  WorkflowDerivedStatus,
+  WorkflowSnapshot,
+  WorkflowSignalResult,
+  WorkflowStatus,
+  WorkflowStepSnapshot,
+  WorkflowSummary,
 } from "./workflow-types.js";
 import { deriveWorkflowStatus } from "./workflow-types.js";
 
 declare global {
-    // eslint-disable-next-line no-var
-    var __gencow_workflowsApiRegistered: boolean | undefined;
+  // eslint-disable-next-line no-var
+  var __gencow_workflowsApiRegistered: boolean | undefined;
 }
 
 type WorkflowRow = {
-    id: string;
-    name: string;
-    args: unknown;
-    status: WorkflowStatus;
-    current_step: string | null;
-    result: unknown;
-    error: string | null;
-    retry_count: number;
-    max_retries: number;
-    max_duration_ms: number;
-    started_at: string | Date;
-    updated_at: string | Date;
-    completed_at: string | Date | null;
-    realtime_token: string | null;
-    user_id: string | null;
+  id: string;
+  name: string;
+  args: unknown;
+  status: WorkflowStatus;
+  current_step: string | null;
+  result: unknown;
+  error: string | null;
+  retry_count: number;
+  max_retries: number;
+  max_duration_ms: number;
+  started_at: string | Date;
+  updated_at: string | Date;
+  completed_at: string | Date | null;
+  realtime_token: string | null;
+  user_id: string | null;
 };
 
 type WorkflowStepRow = {
-    step_name: string;
-    status: WorkflowStatus;
-    output: unknown;
-    error: string | null;
-    started_at: string | Date | null;
-    updated_at: string | Date;
-    completed_at: string | Date | null;
+  step_name: string;
+  status: WorkflowStatus;
+  output: unknown;
+  error: string | null;
+  started_at: string | Date | null;
+  updated_at: string | Date;
+  completed_at: string | Date | null;
 };
 
 type WorkflowSignalTargetRow = {
-    id: string;
-    name: string;
-    status: WorkflowStatus;
-    current_step: string | null;
-    user_id: string | null;
+  id: string;
+  name: string;
+  status: WorkflowStatus;
+  current_step: string | null;
+  user_id: string | null;
 };
 
-const WORKFLOW_STATUSES = new Set<WorkflowStatus>([
-    "pending",
-    "running",
-    "completed",
-    "failed",
-]);
-const WORKFLOW_DERIVED_PENDING_STATUSES = new Set<WorkflowDerivedStatus>([
-    "queued",
-    "waiting",
-    "sleeping",
-]);
+const WORKFLOW_STATUSES = new Set<WorkflowStatus>(["pending", "running", "completed", "failed"]);
+const WORKFLOW_DERIVED_PENDING_STATUSES = new Set<WorkflowDerivedStatus>(["queued", "waiting", "sleeping"]);
 
 type WorkflowDbLike = {
-    execute: (query: unknown) => Promise<unknown>;
+  execute: (query: unknown) => Promise<unknown>;
 };
 
 function rowsFromResult<T>(result: unknown): T[] {
-    if (Array.isArray(result)) return result as T[];
-    if (result && typeof result === "object" && Array.isArray((result as { rows?: unknown[] }).rows)) {
-        return (result as { rows: T[] }).rows;
-    }
-    return [];
+  if (Array.isArray(result)) return result as T[];
+  if (result && typeof result === "object" && Array.isArray((result as { rows?: unknown[] }).rows)) {
+    return (result as { rows: T[] }).rows;
+  }
+  return [];
 }
 
 function parseJsonField(value: unknown): unknown {
-    if (typeof value !== "string") return value;
-    try {
-        return JSON.parse(value);
-    } catch {
-        return value;
-    }
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
 }
 
 function toIsoString(value: string | Date): string {
-    if (value instanceof Date) return value.toISOString();
-    const parsed = new Date(value);
-    return Number.isFinite(parsed.getTime()) ? parsed.toISOString() : String(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: string | Date | null): string | null {
-    return value ? toIsoString(value) : null;
+  return value ? toIsoString(value) : null;
 }
 
 function mapWorkflowSummary(row: WorkflowRow): WorkflowSummary {
-    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),
-    };
+  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: WorkflowStepRow): WorkflowStepSnapshot {
-    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),
-    };
+  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: number | undefined): number {
-    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)));
+  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: string | undefined): WorkflowStatus | undefined {
-    if (status == null) return undefined;
-    if (!WORKFLOW_STATUSES.has(status as WorkflowStatus)) {
-        throw new GencowValidationError(
-            `Argument "status": expected one of pending, running, completed, failed`
-        );
-    }
-    return status as WorkflowStatus;
+  if (status == null) return undefined;
+  if (!WORKFLOW_STATUSES.has(status as WorkflowStatus)) {
+    throw new GencowValidationError(`Argument "status": expected one of pending, running, completed, failed`);
+  }
+  return status as WorkflowStatus;
 }
 
 function normalizeDerivedStatus(status: string | undefined): WorkflowDerivedStatus | undefined {
-    if (status == null) return undefined;
-    if (WORKFLOW_DERIVED_PENDING_STATUSES.has(status as WorkflowDerivedStatus)) {
-        return status as WorkflowDerivedStatus;
-    }
-    return normalizeStatus(status) as WorkflowDerivedStatus;
+  if (status == null) return undefined;
+  if (WORKFLOW_DERIVED_PENDING_STATUSES.has(status as WorkflowDerivedStatus)) {
+    return status as WorkflowDerivedStatus;
+  }
+  return normalizeStatus(status) as WorkflowDerivedStatus;
 }
 
 function toWorkflowStatusFilter(status: WorkflowDerivedStatus | undefined): WorkflowStatus | undefined {
-    if (status == null) return undefined;
-    if (WORKFLOW_DERIVED_PENDING_STATUSES.has(status)) {
-        return "pending";
-    }
-    return status as WorkflowStatus;
+  if (status == null) return undefined;
+  if (WORKFLOW_DERIVED_PENDING_STATUSES.has(status)) {
+    return "pending";
+  }
+  return status as WorkflowStatus;
 }
 
 async function ensureWorkflowRealtimeToken(
-    db: WorkflowDbLike,
-    workflowId: string,
-    currentToken: string | null
+  db: WorkflowDbLike,
+  workflowId: string,
+  currentToken: string | null,
 ): Promise<string | null> {
-    if (currentToken && currentToken.trim() !== "") return currentToken;
+  if (currentToken && currentToken.trim() !== "") return currentToken;
 
-    const nextToken = createWorkflowRealtimeToken();
-    const updateResult = await db.execute(sql`
+  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<{ realtime_token: string | null }>(updateResult)[0]?.realtime_token ?? null;
-    if (updatedToken && updatedToken.trim() !== "") return updatedToken;
+  const updatedToken =
+    rowsFromResult<{ realtime_token: string | null }>(updateResult)[0]?.realtime_token ?? null;
+  if (updatedToken && updatedToken.trim() !== "") return updatedToken;
 
-    const rereadResult = await db.execute(sql`
+  const rereadResult = await db.execute(sql`
         SELECT realtime_token
         FROM _gencow_workflows
         WHERE id = ${workflowId}
         LIMIT 1
     `);
-    const rereadToken = rowsFromResult<{ realtime_token: string | null }>(rereadResult)[0]?.realtime_token ?? null;
-    return rereadToken && rereadToken.trim() !== "" ? rereadToken : null;
+  const rereadToken =
+    rowsFromResult<{ realtime_token: string | null }>(rereadResult)[0]?.realtime_token ?? null;
+  return rereadToken && rereadToken.trim() !== "" ? rereadToken : null;
 }
 
 async function loadWorkflowSignalTarget(
-    db: WorkflowDbLike,
-    workflowId: string
+  db: WorkflowDbLike,
+  workflowId: string,
 ): Promise<WorkflowSignalTargetRow | null> {
-    const result = await db.execute(sql`
+  const result = await db.execute(sql`
         SELECT
             id,
             name,
@@ -208,18 +199,18 @@ async function loadWorkflowSignalTarget(
         WHERE id = ${workflowId}
         LIMIT 1
     `);
-    return rowsFromResult<WorkflowSignalTargetRow>(result)[0] ?? null;
+  return rowsFromResult<WorkflowSignalTargetRow>(result)[0] ?? null;
 }
 
 export async function loadWorkflowSnapshot(
-    db: WorkflowDbLike,
-    workflowId: string,
-    options?: {
-        viewerUserId?: string | null;
-        requireViewerMatch?: boolean;
-    }
+  db: WorkflowDbLike,
+  workflowId: string,
+  options?: {
+    viewerUserId?: string | null;
+    requireViewerMatch?: boolean;
+  },
 ): Promise<WorkflowSnapshot | null> {
-    const workflowResult = await db.execute(sql`
+  const workflowResult = await db.execute(sql`
         SELECT
             id,
             name,
@@ -240,18 +231,18 @@ export async function loadWorkflowSnapshot(
         WHERE id = ${workflowId}
         LIMIT 1
     `);
-    const row = rowsFromResult<WorkflowRow>(workflowResult)[0] ?? null;
-    if (!row) return null;
+  const row = rowsFromResult<WorkflowRow>(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 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 realtimeToken = await ensureWorkflowRealtimeToken(db, workflowId, row.realtime_token);
+  if (!realtimeToken) return null;
 
-    const stepsResult = await db.execute(sql`
+  const stepsResult = await db.execute(sql`
         SELECT
             step_name,
             status,
@@ -265,66 +256,66 @@ export async function loadWorkflowSnapshot(
         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<WorkflowStepRow>(stepsResult).map(mapWorkflowStep),
-        realtimeKey: getWorkflowRealtimeKey(row.id, realtimeToken),
-    };
+  return {
+    ...mapWorkflowSummary(row),
+    args: deserializeWorkflowValue(parseJsonField(row.args)),
+    result: deserializeWorkflowValue(parseJsonField(row.result)),
+    steps: rowsFromResult<WorkflowStepRow>(stepsResult).map(mapWorkflowStep),
+    realtimeKey: getWorkflowRealtimeKey(row.id, realtimeToken),
+  };
 }
 
 export function registerWorkflowsApi(): void {
-    if (globalThis.__gencow_workflowsApiRegistered) return;
-    globalThis.__gencow_workflowsApiRegistered = true;
-
-    query("workflows.get", {
-        args: { id: v.string() },
-        public: true,
-        handler: async (ctx, args): Promise<WorkflowSnapshot | null> => {
-            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): Promise<WorkflowSignalResult> => {
-            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`
+  if (globalThis.__gencow_workflowsApiRegistered) return;
+  globalThis.__gencow_workflowsApiRegistered = true;
+
+  query("workflows.get", {
+    args: { id: v.string() },
+    public: true,
+    handler: async (ctx, args): Promise<WorkflowSnapshot | null> => {
+      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): Promise<WorkflowSignalResult> => {
+      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,
@@ -339,41 +330,40 @@ export function registerWorkflowsApi(): void {
                 )
             `);
 
-            let scheduledJobId: string | null = 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): Promise<WorkflowSummary[]> => {
-            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`
+      let scheduledJobId: string | null = 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): Promise<WorkflowSummary[]> => {
+      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,
@@ -394,7 +384,7 @@ export function registerWorkflowsApi(): void {
                     ORDER BY started_at DESC
                     LIMIT ${limit}
                 `)
-                : await ctx.unsafeDb.execute(sql`
+          : await ctx.unsafeDb.execute(sql`
                     SELECT
                         id,
                         name,
@@ -417,9 +407,9 @@ export function registerWorkflowsApi(): void {
                     LIMIT ${limit}
                 `);
 
-            return rowsFromResult<WorkflowRow>(result)
-                .map(mapWorkflowSummary)
-                .filter((row) => requestedStatus == null || row.derivedStatus === requestedStatus);
-        },
-    });
+      return rowsFromResult<WorkflowRow>(result)
+        .map(mapWorkflowSummary)
+        .filter((row) => requestedStatus == null || row.derivedStatus === requestedStatus);
+    },
+  });
 }

package/src/db.ts

@@ -1,18 +0,0 @@
-/**
- * @deprecated — 레거시 싱글톤 DB 인스턴스.
- * 새 코드에서는 ctx.db를 사용하세요.
- * 서버의 createDatabase() (database.ts)가 실제 DB 연결을 관리합니다.
- */
-import { PGlite } from "@electric-sql/pglite";
-import { drizzle } from "drizzle-orm/pglite";
-
-let pgliteInstance: PGlite | null = null;
-
-/** @deprecated Use ctx.db instead */
-export async function createDb(dataDir: string = "./data") {
-    if (!pgliteInstance) {
-        pgliteInstance = new PGlite(dataDir);
-    }
-    const db = drizzle(pgliteInstance);
-    return { db, client: pgliteInstance };
-}