@gencow/core 0.1.27 → 0.1.29

package/src/workflow.ts

@@ -1,6 +1,6 @@
 import { sql } from "drizzle-orm";
-import { mutation } from "./reactive.js";
-import type { MutationDef } from "./reactive.js";
+import { mutation } from "./reactive-mutation.js";
+import type { MutationDef } from "./reactive-mutation-types.js";
 import type {
   WorkflowDef,
   WorkflowDuration,
@@ -82,9 +82,137 @@ export function parseWorkflowDurationMs(raw: WorkflowDuration, label = "workflow
   return parseDurationString(raw, label);
 }
 
-function normalizeMaxDurationMs(maxDuration: WorkflowDuration | undefined): number {
+function normalizeMaxDurationMs(maxDuration: WorkflowDuration | undefined, label = "workflow() maxDuration"): number {
   if (maxDuration == null) return DEFAULT_WORKFLOW_MAX_DURATION_MS;
-  return parseWorkflowDurationMs(maxDuration, "workflow() maxDuration");
+  return parseWorkflowDurationMs(maxDuration, label);
+}
+
+function normalizeOptionalDurationMs(
+  duration: WorkflowDuration | undefined,
+  label: string,
+): number | null {
+  return duration == null ? null : parseWorkflowDurationMs(duration, label);
+}
+
+function normalizeConcurrency(concurrency: number | undefined): number | null {
+  if (concurrency == null) return null;
+  if (!Number.isFinite(concurrency) || concurrency <= 0) {
+    throw new Error(`workflow() concurrency must be a positive finite number, got "${concurrency}"`);
+  }
+  return Math.floor(concurrency);
+}
+
+function isMissingWorkflowV2SchemaError(error: unknown): boolean {
+  const code =
+    error && typeof error === "object" && "code" in error ? String((error as { code?: unknown }).code) : "";
+  const cause =
+    error && typeof error === "object" && "cause" in error ? (error as { cause?: unknown }).cause : null;
+  const causeCode =
+    cause && typeof cause === "object" && "code" in cause ? String((cause as { code?: unknown }).code) : "";
+  const message = error instanceof Error ? error.message : String(error);
+  return (
+    code === "42P01" ||
+    code === "42703" ||
+    causeCode === "42P01" ||
+    causeCode === "42703" ||
+    message.includes('relation "_gencow_workflow_runs_v2" does not exist') ||
+    message.includes("relation _gencow_workflow_runs_v2 does not exist") ||
+    message.includes('relation "_gencow_workflow_outbox_v2" does not exist') ||
+    message.includes("relation _gencow_workflow_outbox_v2 does not exist") ||
+    message.includes('column "max_active_duration_ms"') ||
+    message.includes('column "retry_count"') ||
+    message.includes('column "user_id"')
+  );
+}
+
+async function tryInsertWorkflowV2WakeOutbox(
+  db: { execute: (query: ReturnType<typeof sql>) => Promise<unknown> },
+  workflowId: string,
+): Promise<void> {
+  try {
+    await db.execute(sql`
+      INSERT INTO _gencow_workflow_outbox_v2 (
+        id,
+        run_id,
+        kind,
+        available_at,
+        status
+      )
+      VALUES (
+        ${`start:${workflowId}`},
+        ${workflowId},
+        'wake_run',
+        NOW(),
+        'pending'
+      )
+      ON CONFLICT (id) DO NOTHING
+    `);
+  } catch (error) {
+    if (!isMissingWorkflowV2SchemaError(error)) throw error;
+  }
+}
+
+async function tryInsertWorkflowV2Run(options: {
+  db: { execute: (query: ReturnType<typeof sql>) => Promise<unknown> };
+  workflowId: string;
+  workflowName: string;
+  workflowVersion?: string | null;
+  args: unknown;
+  userId: string | null;
+  maxActiveDurationMs: number;
+  lifecycleTimeoutMs: number | null;
+  maxRetries: number;
+}): Promise<boolean> {
+  try {
+    await options.db.execute(sql`
+      INSERT INTO _gencow_workflow_runs_v2 (
+        id,
+        workflow_name,
+        workflow_version,
+        args_json,
+        user_id,
+        max_active_duration_ms,
+        lifecycle_deadline_at,
+        retry_count,
+        max_retries,
+        max_attempts
+      )
+      VALUES (
+        ${options.workflowId},
+        ${options.workflowName},
+        ${options.workflowVersion ?? null},
+        ${JSON.stringify(options.args)}::jsonb,
+        ${options.userId},
+        ${options.maxActiveDurationMs},
+        CASE
+          WHEN ${options.lifecycleTimeoutMs}::bigint IS NULL THEN NULL
+          ELSE NOW() + (${options.lifecycleTimeoutMs}::bigint * INTERVAL '1 millisecond')
+        END,
+        0,
+        ${options.maxRetries},
+        ${options.maxRetries + 1}
+      )
+    `);
+    await tryInsertWorkflowV2WakeOutbox(options.db, options.workflowId);
+    return true;
+  } catch (error) {
+    if (isMissingWorkflowV2SchemaError(error)) return false;
+    throw error;
+  }
+}
+
+async function tryDeleteWorkflowV2Run(
+  db: { execute: (query: ReturnType<typeof sql>) => Promise<unknown> },
+  workflowId: string,
+): Promise<void> {
+  try {
+    await db.execute(sql`
+      DELETE FROM _gencow_workflow_runs_v2
+      WHERE id = ${workflowId}
+    `);
+  } catch (error) {
+    if (!isMissingWorkflowV2SchemaError(error)) throw error;
+  }
 }
 
 export function getWorkflowResumeActionName(name: string): string {
@@ -119,14 +247,25 @@ export function workflow<TSchema = any, TReturn = any>(
 ): MutationDef<TSchema, WorkflowStartResult> {
   registerWorkflowsApi();
 
-  const maxDurationMs = normalizeMaxDurationMs(options.maxDuration);
+  const maxActiveDurationMs = normalizeMaxDurationMs(
+    options.maxActiveDuration ?? options.maxDuration,
+    options.maxActiveDuration == null ? "workflow() maxDuration" : "workflow() maxActiveDuration",
+  );
+  const lifecycleTimeoutMs = normalizeOptionalDurationMs(
+    options.lifecycleTimeout,
+    "workflow() lifecycleTimeout",
+  );
   const maxRetries = clampRetries(options.retries);
 
   const def: WorkflowDef<TSchema, TReturn> = {
     name,
     argsSchema: options.args,
     isPublic: options.public === true,
-    maxDurationMs,
+    version: options.version,
+    maxDurationMs: maxActiveDurationMs,
+    maxActiveDurationMs,
+    lifecycleTimeoutMs,
+    concurrency: normalizeConcurrency(options.concurrency),
     maxRetries,
     handler: options.handler,
   };
@@ -159,16 +298,28 @@ export function workflow<TSchema = any, TReturn = any>(
                     ${workflowId},
                     ${name},
                     ${JSON.stringify(persistedArgs)}::jsonb,
-                    ${realtimeToken},
-                    'pending',
-                    0,
-                    ${maxRetries},
-                    ${maxDurationMs},
-                    ${ownerId}
+                  ${realtimeToken},
+                  'pending',
+                  0,
+                  ${maxRetries},
+                  ${maxActiveDurationMs},
+                  ${ownerId}
                 )
             `);
+      let insertedWorkflowV2 = false;
 
       try {
+        insertedWorkflowV2 = await tryInsertWorkflowV2Run({
+          db: ctx.unsafeDb,
+          workflowId,
+          workflowName: name,
+          workflowVersion: options.version ?? null,
+          args: persistedArgs,
+          userId: ownerId,
+          maxActiveDurationMs,
+          lifecycleTimeoutMs,
+          maxRetries,
+        });
         const scheduledJobId = ctx.scheduler.runAfter(0, resumeAction, { workflowId });
         return {
           id: workflowId,
@@ -181,6 +332,9 @@ export function workflow<TSchema = any, TReturn = any>(
                     DELETE FROM _gencow_workflows
                     WHERE id = ${workflowId}
                 `);
+        if (insertedWorkflowV2) {
+          await tryDeleteWorkflowV2Run(ctx.unsafeDb, workflowId);
+        }
         throw error;
       }
     },

package/src/workflows-api.ts

@@ -1,5 +1,6 @@
 import { sql } from "drizzle-orm";
-import { mutation, query } from "./reactive.js";
+import { query } from "./reactive-query.js";
+import { mutation } from "./reactive-mutation.js";
 import {
   createWorkflowRealtimeToken,
   deserializeWorkflowValue,
@@ -31,6 +32,7 @@ type WorkflowRow = {
   current_step: string | null;
   result: unknown;
   error: string | null;
+  error_code: string | null;
   retry_count: number;
   max_retries: number;
   max_duration_ms: number;
@@ -101,6 +103,7 @@ function mapWorkflowSummary(row: WorkflowRow): WorkflowSummary {
     derivedStatus: deriveWorkflowStatus(row.status, row.current_step),
     currentStep: row.current_step,
     error: row.error,
+    errorCode: row.error_code,
     retryCount: row.retry_count,
     maxRetries: row.max_retries,
     maxDurationMs: Number(row.max_duration_ms),
@@ -198,10 +201,77 @@ async function loadWorkflowSignalTarget(
         FROM _gencow_workflows
         WHERE id = ${workflowId}
         LIMIT 1
-    `);
+  `);
   return rowsFromResult<WorkflowSignalTargetRow>(result)[0] ?? null;
 }
 
+function isMissingWorkflowV2SignalSchemaError(error: unknown): boolean {
+  const code =
+    error && typeof error === "object" && "code" in error ? String((error as { code?: unknown }).code) : "";
+  const cause =
+    error && typeof error === "object" && "cause" in error ? (error as { cause?: unknown }).cause : null;
+  const causeCode =
+    cause && typeof cause === "object" && "code" in cause ? String((cause as { code?: unknown }).code) : "";
+  const message = error instanceof Error ? error.message : String(error);
+  return (
+    code === "42P01" ||
+    code === "42703" ||
+    causeCode === "42P01" ||
+    causeCode === "42703" ||
+    ((code === "23503" || causeCode === "23503") && message.includes("_gencow_workflow_signals_v2")) ||
+    message.includes('relation "_gencow_workflow_signals_v2" does not exist') ||
+    message.includes("relation _gencow_workflow_signals_v2 does not exist") ||
+    message.includes('relation "_gencow_workflow_runs_v2" does not exist') ||
+    message.includes("relation _gencow_workflow_runs_v2 does not exist")
+  );
+}
+
+async function tryRecordWorkflowV2Signal(options: {
+  db: WorkflowDbLike;
+  workflowId: string;
+  event: string;
+  payload: unknown;
+}): Promise<boolean> {
+  try {
+    await options.db.execute(sql`
+      WITH inserted AS (
+        INSERT INTO _gencow_workflow_signals_v2 (
+          id,
+          run_id,
+          event_name,
+          payload_json,
+          idempotency_key
+        )
+        VALUES (
+          ${crypto.randomUUID()},
+          ${options.workflowId},
+          ${options.event},
+          ${JSON.stringify(options.payload)}::jsonb,
+          ${crypto.randomUUID()}
+        )
+        RETURNING run_id
+      )
+      UPDATE _gencow_workflow_runs_v2 run
+      SET
+        status = 'queued',
+        runnable_at = NOW(),
+        lease_owner = NULL,
+        lease_expires_at = NULL,
+        heartbeat_at = NULL,
+        updated_at = NOW()
+      FROM inserted
+      WHERE run.id = inserted.run_id
+        AND run.status = 'waiting'
+        AND run.completed_at IS NULL
+        AND run.cancel_requested_at IS NULL
+    `);
+    return true;
+  } catch (error) {
+    if (isMissingWorkflowV2SignalSchemaError(error)) return false;
+    throw error;
+  }
+}
+
 export async function loadWorkflowSnapshot(
   db: WorkflowDbLike,
   workflowId: string,
@@ -219,6 +289,7 @@ export async function loadWorkflowSnapshot(
             current_step,
             result,
             error,
+            error_code,
             retry_count,
             max_retries,
             max_duration_ms,
@@ -326,9 +397,15 @@ export function registerWorkflowsApi(): void {
                     ${crypto.randomUUID()},
                     ${workflow.id},
                     ${normalizedEvent},
-                    ${JSON.stringify(persistedPayload)}::jsonb
+                  ${JSON.stringify(persistedPayload)}::jsonb
                 )
             `);
+      await tryRecordWorkflowV2Signal({
+        db: ctx.unsafeDb,
+        workflowId: workflow.id,
+        event: normalizedEvent,
+        payload: persistedPayload,
+      });
 
       let scheduledJobId: string | null = null;
       if (workflow.status === "pending" && workflow.current_step?.startsWith("wait:")) {
@@ -372,6 +449,7 @@ export function registerWorkflowsApi(): void {
                         current_step,
                         result,
                         error,
+                        error_code,
                         retry_count,
                         max_retries,
                         max_duration_ms,
@@ -393,6 +471,7 @@ export function registerWorkflowsApi(): void {
                         current_step,
                         result,
                         error,
+                        error_code,
                         retry_count,
                         max_retries,
                         max_duration_ms,

package/src/__tests__/auth.test.ts

@@ -1,118 +0,0 @@
-/**
- * packages/core/src/__tests__/auth.test.ts
- *
- * Tests for auth module — AuthCtx, defineAuth, auth-config.
- *
- * Run: bun test packages/core/src/__tests__/auth.test.ts
- */
-
-import { describe, it, expect } from "bun:test";
-import { defineAuth } from "../auth-config.js";
-import type { GencowAuthConfig } from "../auth-config.js";
-
-// ─── defineAuth() ───────────────────────────────────────
-
-describe("defineAuth()", () => {
-  it("빈 설정 객체 반환", () => {
-    const config = defineAuth({});
-    expect(config).toEqual({});
-  });
-
-  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);
-  });
-
-  it("부분 설정도 허용된다", () => {
-    const config = defineAuth({
-      emailVerification: {
-        sendVerificationEmail: async () => {},
-      },
-    });
-
-    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);
-  });
-});
-
-// ─── 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);
-  });
-});

package/src/__tests__/crons.test.ts

@@ -1,83 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { cronJobs } from "../crons.js";
-
-describe("cronJobs 빌더", () => {
-  test("interval — minutes → cron 패턴 변환", () => {
-    const crons = cronJobs();
-    crons.interval("test", { minutes: 15 }, "test.action");
-    const jobs = crons.getJobs();
-    expect(jobs).toHaveLength(1);
-    expect(jobs[0].name).toBe("test");
-    expect(jobs[0].pattern).toBe("*/15 * * * *");
-    expect(jobs[0].action).toBe("test.action");
-  });
-
-  test("interval — hours → cron 패턴 변환", () => {
-    const crons = cronJobs();
-    crons.interval("hourly", { hours: 6 }, "cleanup");
-    expect(crons.getJobs()[0].pattern).toBe("0 */6 * * *");
-  });
-
-  test("interval — seconds → 6자리 cron 패턴", () => {
-    const crons = cronJobs();
-    crons.interval("fast", { seconds: 30 }, "tick");
-    expect(crons.getJobs()[0].pattern).toBe("*/30 * * * * *");
-  });
-
-  test("daily — 특정 시각", () => {
-    const crons = cronJobs();
-    crons.daily("report", { hour: 9, minute: 30 }, "reports.gen");
-    const job = crons.getJobs()[0];
-    expect(job.pattern).toBe("30 9 * * *");
-  });
-
-  test("daily — minute 기본값 0", () => {
-    const crons = cronJobs();
-    crons.daily("cleanup", { hour: 2 }, "admin.cleanup");
-    expect(crons.getJobs()[0].pattern).toBe("0 2 * * *");
-  });
-
-  test("weekly — 요일 + 시각", () => {
-    const crons = cronJobs();
-    crons.weekly("monday-report", { dayOfWeek: 1, hour: 9 }, "reports.weekly");
-    expect(crons.getJobs()[0].pattern).toBe("0 9 * * 1");
-  });
-
-  test("cron — 직접 패턴 지정", () => {
-    const crons = cronJobs();
-    crons.cron("custom", "0 */2 * * *", "custom.handler");
-    expect(crons.getJobs()[0].pattern).toBe("0 */2 * * *");
-  });
-
-  test("체이닝 지원", () => {
-    const crons = cronJobs();
-    crons
-      .interval("a", { minutes: 5 }, "a.action")
-      .daily("b", { hour: 3 }, "b.action")
-      .cron("c", "0 * * * *", "c.action");
-    expect(crons.getJobs()).toHaveLength(3);
-  });
-
-  test("인라인 핸들러 지원", () => {
-    const crons = cronJobs();
-    const fn = async () => {
-      /* noop */
-    };
-    crons.interval("inline", { minutes: 1 }, fn);
-    expect(typeof crons.getJobs()[0].action).toBe("function");
-  });
-
-  test("getJobs는 복사본 반환 (원본 보호)", () => {
-    const crons = cronJobs();
-    crons.interval("test", { minutes: 1 }, "test");
-    const jobs1 = crons.getJobs();
-    const jobs2 = crons.getJobs();
-    expect(jobs1).not.toBe(jobs2); // 서로 다른 참조
-    expect(jobs1).toEqual(jobs2); // 내용은 동일
-  });
-
-  test("interval — 옵션 없으면 에러", () => {
-    const crons = cronJobs();
-    expect(() => crons.interval("bad", {}, "bad")).toThrow("minutes, hours, 또는 seconds");
-  });
-});