@gencow/core 0.1.23 → 0.1.25

package/dist/rls-db.d.ts

@@ -1,4 +1,4 @@
-import type { PgDatabase } from "drizzle-orm/pg-core";
+import type { PgAsyncDatabase } from "drizzle-orm/pg-core";
 /**
  * RLS DB wrapper — execution paths for `withRlsConnection`:
  * 1. **Reuse outer Drizzle transaction** (`reuseOuterConnection`): same connection, apply GUCs then run `fn`.
@@ -44,4 +44,4 @@ export declare function withRlsLeasedConnection<T>(leased: {
  *
  * `db.transaction()` still injects the same variables at the start of the callback transaction.
  */
-export declare function createRlsDb(db: PgDatabase<any, any, any>, rls: RlsSessionContext): PgDatabase<any, any, any>;
+export declare function createRlsDb(db: PgAsyncDatabase<any, any, any, any>, rls: RlsSessionContext): PgAsyncDatabase<any, any, any, any>;

package/dist/rls-db.js

@@ -1,11 +1,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { sql } from "drizzle-orm";
 const gucNameRe = /^app\.[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)*$/;
-const RESERVED_VARS_KEYS = new Set([
-    "app.current_user_id",
-    "app.current_user_role",
-    "app.tenant_id",
-]);
+const RESERVED_VARS_KEYS = new Set(["app.current_user_id", "app.current_user_role", "app.tenant_id"]);
 function assertSafeGucName(key) {
     if (!gucNameRe.test(key)) {
         throw new Error(`createRlsDb: GUC name "${key}" is invalid — use lowercase app.* names (e.g. app.org_id)`);

package/dist/scheduler.d.ts

@@ -45,6 +45,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 and propagate errors to the caller */
+    executeActionStrict(name: string, args?: any): Promise<void>;
     /** Execute a registered action by name — 선언적 crons.ts 문자열 액션 실행용 */
     executeAction(name: string, args?: any): Promise<void>;
 }

package/dist/scheduler.js

@@ -1,7 +1,7 @@
 import * as cron from "node-cron";
-const _cronInfo = globalThis.__gencow_cronInfo ??= [];
-const _pendingJobs = globalThis.__gencow_pendingJobs ??= [];
-const _failedJobs = globalThis.__gencow_failedJobs ??= [];
+const _cronInfo = (globalThis.__gencow_cronInfo ??= []);
+const _pendingJobs = (globalThis.__gencow_pendingJobs ??= []);
+const _failedJobs = (globalThis.__gencow_failedJobs ??= []);
 /** 최대 보관할 실패 작업 수 (메모리 보호) */
 const MAX_FAILED_JOBS = 100;
 export function getSchedulerInfo() {
@@ -89,7 +89,12 @@ export function createScheduler(options) {
     return {
         runAfter(ms, action, args, scheduleOpts) {
             const id = generateId();
-            const jobEntry = { id, action, scheduledAt: new Date().toISOString(), status: "pending" };
+            const jobEntry = {
+                id,
+                action,
+                scheduledAt: new Date().toISOString(),
+                status: "pending",
+            };
             _pendingJobs.push(jobEntry);
             // ── Durable mode: DB에 영속화, 실행은 외부 폴러에 위임 ──
             if (isDurable) {
@@ -100,10 +105,12 @@ export function createScheduler(options) {
                     args: args ?? {},
                     runAt,
                     onErrorAction: scheduleOpts?.onError,
-                }).then(() => {
+                })
+                    .then(() => {
                     console.log(`[scheduler] Persisted "${action}" to run at ${runAt.toISOString()} (id: ${id}, durable)` +
                         `${scheduleOpts?.onError ? ` [onError: ${scheduleOpts.onError}]` : ""}`);
-                }).catch((err) => {
+                })
+                    .catch((err) => {
                     console.error(`[scheduler] Failed to persist job ${id}:`, err instanceof Error ? err.message : err);
                     // DB persist 실패 → 인메모리 fallback
                     scheduleInMemory(id, ms, action, args, scheduleOpts, jobEntry);
@@ -171,6 +178,9 @@ export function createScheduler(options) {
         registerAction(name, handler) {
             actions.set(name, handler);
         },
+        async executeActionStrict(name, args) {
+            await executeAction(name, args);
+        },
         async executeAction(name, args) {
             try {
                 await executeAction(name, args);

package/dist/server.d.ts

@@ -5,7 +5,6 @@
  * executing server. Excluded from client-side core (`index.ts`) so they aren't
  * bundled into user functions which run in Firecracker.
  */
-export { createDb } from "./db.js";
 export { createStorage, storageRoutes } from "./storage.js";
 export type { StorageImageTierConfig } from "./storage.js";
 export { createScheduler, getSchedulerInfo } from "./scheduler.js";

package/dist/server.js

@@ -5,7 +5,6 @@
  * executing server. Excluded from client-side core (`index.ts`) so they aren't
  * bundled into user functions which run in Firecracker.
  */
-export { createDb } from "./db.js";
 export { createStorage, storageRoutes } from "./storage.js";
 export { createScheduler, getSchedulerInfo } from "./scheduler.js";
 export { authMiddleware, authRoutes, getUsers } from "./auth.js";

package/dist/storage.js

@@ -141,7 +141,9 @@ export function createStorage(dir = "./uploads", options) {
             const filePath = path.join(dir, id);
             await fs.writeFile(filePath, buffer);
             // .meta JSON 기록 — Platform 레벨 직접 서빙용
-            await fs.writeFile(`${filePath}.meta`, JSON.stringify({ name: filename, type, size: buffer.length })).catch(() => { });
+            await fs
+                .writeFile(`${filePath}.meta`, JSON.stringify({ name: filename, type, size: buffer.length }))
+                .catch(() => { });
             metaStore.set(id, {
                 id,
                 name: filename,
@@ -187,25 +189,27 @@ export function createStorage(dir = "./uploads", options) {
                 const entries = await fs.readdir(cacheDir);
                 const prefix = `${storageId}_`;
                 await Promise.all(entries
-                    .filter(e => e.startsWith(prefix))
-                    .map(e => fs.unlink(path.join(cacheDir, e)).catch(() => { })));
+                    .filter((e) => e.startsWith(prefix))
+                    .map((e) => fs.unlink(path.join(cacheDir, e)).catch(() => { })));
+            }
+            catch {
+                /* .cache 디렉토리 미존재 시 무시 */
             }
-            catch { /* .cache 디렉토리 미존재 시 무시 */ }
             // DB에서도 삭제 (rawSql 있을 때만)
             if (rawSql) {
                 try {
                     await rawSql(`DELETE FROM _system_files WHERE storage_id = $1`, [storageId]);
                 }
-                catch { /* 삭제 실패 무시 — 파일은 이미 제거됨 */ }
+                catch {
+                    /* 삭제 실패 무시 — 파일은 이미 제거됨 */
+                }
             }
         },
     };
 }
 // ─── Image Optimization Constants ───────────────────────
 /** 변환 가능한 원본 MIME 타입 */
-const TRANSFORMABLE_TYPES = new Set([
-    "image/png", "image/jpeg", "image/jpg", "image/webp",
-]);
+const TRANSFORMABLE_TYPES = new Set(["image/png", "image/jpeg", "image/jpg", "image/webp"]);
 /** 허용 출력 포맷 */
 const ALLOWED_FORMATS = new Set(["webp", "avif", "jpeg", "png"]);
 /** 허용 맞춤 모드 */
@@ -363,9 +367,10 @@ export function storageRoutes(storage, rawSql, storageDir, tierConfig) {
             const appConfig = JSON.parse(raw);
             // Tier ceiling 적용: min(앱 설정, Tier 최대값)
             if (appConfig.autoMaxWidth > 0) {
-                config.autoMaxWidth = config.autoMaxWidth > 0
-                    ? Math.min(appConfig.autoMaxWidth, config.autoMaxWidth)
-                    : appConfig.autoMaxWidth;
+                config.autoMaxWidth =
+                    config.autoMaxWidth > 0
+                        ? Math.min(appConfig.autoMaxWidth, config.autoMaxWidth)
+                        : appConfig.autoMaxWidth;
             }
             if (appConfig.autoQuality > 0 && appConfig.autoQuality <= 100) {
                 config.autoQuality = appConfig.autoQuality;
@@ -374,7 +379,9 @@ export function storageRoutes(storage, rawSql, storageDir, tierConfig) {
                 config.autoWebp = false;
             }
         }
-        catch { /* 파일 없음 or 파싱 실패 → Tier 기본값 유지 */ }
+        catch {
+            /* 파일 없음 or 파싱 실패 → Tier 기본값 유지 */
+        }
         return config;
     }
     // sharp 모듈 캐시 (동적 import 1회만)
@@ -417,7 +424,9 @@ export function storageRoutes(storage, rawSql, storageDir, tierConfig) {
                     };
                 }
             }
-            catch { /* fallthrough to 404 */ }
+            catch {
+                /* fallthrough to 404 */
+            }
         }
         if (!meta) {
             return c.json({ error: "Not found" }, 404);
@@ -432,11 +441,11 @@ export function storageRoutes(storage, rawSql, storageDir, tierConfig) {
         const acceptHeader = c.req.header("accept") || "";
         const clientAcceptsWebp = acceptHeader.includes("image/webp");
         // Auto WebP: 파라미터 없지만 브라우저가 webp 지원 + 원본이 PNG/JPEG
-        const isAutoWebp = !transformParams
-            && isTransformable
-            && clientAcceptsWebp
-            && config.autoWebp
-            && (meta.type === "image/png" || meta.type === "image/jpeg" || meta.type === "image/jpg");
+        const isAutoWebp = !transformParams &&
+            isTransformable &&
+            clientAcceptsWebp &&
+            config.autoWebp &&
+            (meta.type === "image/png" || meta.type === "image/jpeg" || meta.type === "image/jpg");
         // 이미지 변환이 필요 없는 경우 → 원본 서빙 (기존 동작 100% 유지)
         if (!transformParams && !isAutoWebp) {
             return serveOriginal(c, meta);
@@ -595,16 +604,14 @@ export function storageRoutes(storage, rawSql, storageDir, tierConfig) {
         // 변환된 파일명: original.png → original.webp (또는 original_300x200.webp)
         const baseName = originalMeta.name.replace(/\.[^.]+$/, "");
         const ext = outputFormat || originalMeta.name.split(".").pop() || "bin";
-        const suffix = params?.w || params?.h
-            ? `_${params.w || "auto"}x${params.h || "auto"}`
-            : "";
+        const suffix = params?.w || params?.h ? `_${params.w || "auto"}x${params.h || "auto"}` : "";
         const fileName = `${baseName}${suffix}.${ext}`;
         const headers = {
             "Content-Type": contentType,
             "Content-Disposition": `inline; filename="${encodeURIComponent(fileName)}"; filename*=UTF-8''${encodeURIComponent(fileName)}`,
             "Cache-Control": "public, max-age=31536000, immutable",
             // Vary: Accept — Auto WebP 시 CDN/브라우저 캐시 분리
-            ...(isAutoWebp ? { "Vary": "Accept" } : {}),
+            ...(isAutoWebp ? { Vary: "Accept" } : {}),
         };
         if (typeof globalThis.Bun !== "undefined") {
             const bunFile = Bun.file(cachePath);

package/dist/v.d.ts

@@ -32,9 +32,9 @@ export declare const v: {
  * Correctly handles optional properties (Validator<T | undefined> → optional key).
  */
 export type InferArgs<T> = T extends Validator<infer U> ? U : T extends Record<string, Validator> ? {
-    [K in keyof T as T[K] extends Validator<infer U> ? (undefined extends U ? never : K) : K]: T[K] extends Validator<infer U> ? U : any;
+    [K in keyof T as T[K] extends Validator<infer U> ? undefined extends U ? never : K : K]: T[K] extends Validator<infer U> ? U : any;
 } & {
-    [K in keyof T as T[K] extends Validator<infer U> ? (undefined extends U ? K : never) : never]?: T[K] extends Validator<infer U> ? U : any;
+    [K in keyof T as T[K] extends Validator<infer U> ? undefined extends U ? K : never : never]?: T[K] extends Validator<infer U> ? U : any;
 } : T;
 /**
  * Validates and parses arguments against a schema at runtime.

package/dist/workflow-types.d.ts

@@ -0,0 +1,81 @@
+import type { GencowCtx } from "./reactive.js";
+import type { InferArgs } from "./v.js";
+export type WorkflowStatus = "pending" | "running" | "completed" | "failed";
+export type WorkflowDuration = number | string;
+export type WorkflowDerivedStatus = WorkflowStatus | "queued" | "waiting" | "sleeping";
+export declare function deriveWorkflowStatus(status: WorkflowStatus, currentStep: string | null | undefined): WorkflowDerivedStatus;
+export interface WorkflowSummary {
+    id: string;
+    name: string;
+    status: WorkflowStatus;
+    derivedStatus: WorkflowDerivedStatus;
+    currentStep: string | null;
+    error: string | null;
+    retryCount: number;
+    maxRetries: number;
+    maxDurationMs: number;
+    startedAt: string;
+    updatedAt: string;
+    completedAt: string | null;
+}
+export interface WorkflowStepSnapshot {
+    name: string;
+    status: WorkflowStatus;
+    output: unknown;
+    error: string | null;
+    startedAt: string | null;
+    updatedAt: string;
+    completedAt: string | null;
+}
+export interface WorkflowSnapshot extends WorkflowSummary {
+    args: unknown;
+    result: unknown;
+    steps: WorkflowStepSnapshot[];
+    /** Opaque realtime channel for exact-id workflow updates. */
+    realtimeKey: string;
+}
+export interface WorkflowListArgs {
+    limit?: number;
+    status?: WorkflowDerivedStatus;
+}
+export interface WorkflowStartResult {
+    id: string;
+    name: string;
+    status: "pending";
+    scheduledJobId: string;
+}
+export interface WorkflowSignalResult {
+    ok: boolean;
+    workflowId: string;
+    event: string;
+    scheduledJobId: string | null;
+}
+export interface WorkflowResumePayload {
+    workflowId: string;
+}
+export interface WorkflowCtx extends GencowCtx {
+    workflowId: string;
+    workflowName: string;
+    step<TResult>(name: string, run: () => Promise<TResult>): Promise<TResult>;
+    sleep(duration: WorkflowDuration): Promise<void>;
+    waitForEvent<TPayload = unknown>(name: string, timeout?: WorkflowDuration): Promise<TPayload>;
+    parallel<TTasks extends ReadonlyArray<() => Promise<any>>>(tasks: TTasks): Promise<{
+        [K in keyof TTasks]: Awaited<ReturnType<TTasks[K]>>;
+    }>;
+}
+export type WorkflowHandler<TArgs, TReturn> = (wf: WorkflowCtx, args: TArgs) => Promise<TReturn>;
+export interface WorkflowOptions<TSchema = any, TReturn = any> {
+    args?: TSchema;
+    public?: boolean;
+    maxDuration?: WorkflowDuration;
+    retries?: number;
+    handler: WorkflowHandler<InferArgs<TSchema>, TReturn>;
+}
+export interface WorkflowDef<TSchema = any, TReturn = any> {
+    name: string;
+    argsSchema?: TSchema;
+    isPublic: boolean;
+    maxDurationMs: number;
+    maxRetries: number;
+    handler: WorkflowHandler<InferArgs<TSchema>, TReturn>;
+}

package/dist/workflow-types.js

@@ -0,0 +1,12 @@
+export function deriveWorkflowStatus(status, currentStep) {
+    if (status !== "pending") {
+        return status;
+    }
+    if (currentStep?.startsWith("sleep#")) {
+        return "sleeping";
+    }
+    if (currentStep?.startsWith("wait:")) {
+        return "waiting";
+    }
+    return "queued";
+}

package/dist/workflow.d.ts

@@ -0,0 +1,30 @@
+import type { MutationDef } from "./reactive.js";
+import type { WorkflowDef, WorkflowDuration, WorkflowOptions, WorkflowStartResult } from "./workflow-types.js";
+declare global {
+    var __gencow_workflowRegistry: Map<string, WorkflowDef<any, any>>;
+}
+export declare const DEFAULT_WORKFLOW_MAX_DURATION_MS: number;
+export declare const DEFAULT_WORKFLOW_MAX_RETRIES = 3;
+export declare const WORKFLOW_RESUME_ACTION_PREFIX = "__gencow.workflow.resume";
+export declare const WORKFLOW_REALTIME_KEY_PREFIX = "__gencow.workflow.state";
+type SerializedWorkflowValue = {
+    __gencowUndefined: true;
+} | {
+    value: unknown;
+};
+export declare function serializeWorkflowValue(value: unknown): SerializedWorkflowValue;
+export declare function deserializeWorkflowValue(value: unknown): unknown;
+export declare function parseWorkflowDurationMs(raw: WorkflowDuration, label?: string): number;
+export declare function getWorkflowResumeActionName(name: string): string;
+export declare function createWorkflowRealtimeToken(): string;
+export declare function getWorkflowRealtimeKey(workflowId: string, realtimeToken: string): string;
+export declare function getWorkflowDef(name: string): WorkflowDef | undefined;
+export declare function getRegisteredWorkflows(): WorkflowDef[];
+/**
+ * workflow() — durable multi-step execution with step memoization.
+ *
+ * The returned value is still a mutation definition, so existing API codegen and
+ * frontend hooks keep working without extra workflow-specific tooling.
+ */
+export declare function workflow<TSchema = any, TReturn = any>(name: string, options: WorkflowOptions<TSchema, TReturn>): MutationDef<TSchema, WorkflowStartResult>;
+export {};

package/dist/workflow.js

@@ -0,0 +1,150 @@
+import { sql } from "drizzle-orm";
+import { mutation } from "./reactive.js";
+import { registerWorkflowsApi } from "./workflows-api.js";
+const workflowRegistry = (globalThis.__gencow_workflowRegistry ??= new Map());
+export const DEFAULT_WORKFLOW_MAX_DURATION_MS = 30 * 60 * 1000;
+export const DEFAULT_WORKFLOW_MAX_RETRIES = 3;
+export const WORKFLOW_RESUME_ACTION_PREFIX = "__gencow.workflow.resume";
+export const WORKFLOW_REALTIME_KEY_PREFIX = "__gencow.workflow.state";
+function isSerializedWorkflowValue(value) {
+    return !!value && typeof value === "object" && ("__gencowUndefined" in value || "value" in value);
+}
+export function serializeWorkflowValue(value) {
+    const payload = value === undefined ? { __gencowUndefined: true } : { value };
+    try {
+        return JSON.parse(JSON.stringify(payload));
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`workflow() only persists JSON-serializable values. Failed to serialize workflow payload: ${reason}`);
+    }
+}
+export function deserializeWorkflowValue(value) {
+    if (!isSerializedWorkflowValue(value))
+        return value;
+    if ("__gencowUndefined" in value)
+        return undefined;
+    return value.value;
+}
+function clampRetries(retries) {
+    if (retries == null)
+        return DEFAULT_WORKFLOW_MAX_RETRIES;
+    if (!Number.isFinite(retries) || retries < 0) {
+        throw new Error(`workflow() retries must be a non-negative finite number, got "${retries}"`);
+    }
+    return Math.floor(retries);
+}
+function parseDurationString(raw, label) {
+    const normalized = raw.trim().toLowerCase();
+    const match = normalized.match(/^(\d+)(ms|s|m|h|d)$/);
+    if (!match) {
+        throw new Error(`${label} must be a number of ms or a string like "30m", "90s", "1h" — got "${raw}"`);
+    }
+    const value = Number(match[1]);
+    const unit = match[2];
+    const unitMs = unit === "ms" ? 1 : unit === "s" ? 1_000 : unit === "m" ? 60_000 : unit === "h" ? 3_600_000 : 86_400_000;
+    return value * unitMs;
+}
+export function parseWorkflowDurationMs(raw, label = "workflow duration") {
+    if (typeof raw === "number") {
+        if (!Number.isFinite(raw) || raw <= 0) {
+            throw new Error(`${label} must be a positive finite number, got "${raw}"`);
+        }
+        return Math.floor(raw);
+    }
+    if (typeof raw !== "string") {
+        throw new Error(`${label} must be a positive finite number or a string like "30m", "90s", "1h" — got "${String(raw)}"`);
+    }
+    return parseDurationString(raw, label);
+}
+function normalizeMaxDurationMs(maxDuration) {
+    if (maxDuration == null)
+        return DEFAULT_WORKFLOW_MAX_DURATION_MS;
+    return parseWorkflowDurationMs(maxDuration, "workflow() maxDuration");
+}
+export function getWorkflowResumeActionName(name) {
+    return `${WORKFLOW_RESUME_ACTION_PREFIX}.${name}`;
+}
+export function createWorkflowRealtimeToken() {
+    return crypto.randomUUID().replace(/-/g, "");
+}
+export function getWorkflowRealtimeKey(workflowId, realtimeToken) {
+    return `${WORKFLOW_REALTIME_KEY_PREFIX}.${workflowId}.${realtimeToken}`;
+}
+export function getWorkflowDef(name) {
+    return workflowRegistry.get(name);
+}
+export function getRegisteredWorkflows() {
+    return Array.from(workflowRegistry.values());
+}
+/**
+ * workflow() — durable multi-step execution with step memoization.
+ *
+ * The returned value is still a mutation definition, so existing API codegen and
+ * frontend hooks keep working without extra workflow-specific tooling.
+ */
+export function workflow(name, options) {
+    registerWorkflowsApi();
+    const maxDurationMs = normalizeMaxDurationMs(options.maxDuration);
+    const maxRetries = clampRetries(options.retries);
+    const def = {
+        name,
+        argsSchema: options.args,
+        isPublic: options.public === true,
+        maxDurationMs,
+        maxRetries,
+        handler: options.handler,
+    };
+    workflowRegistry.set(name, def);
+    return mutation(name, {
+        args: options.args,
+        public: options.public,
+        handler: async (ctx, args) => {
+            const workflowId = crypto.randomUUID();
+            const resumeAction = getWorkflowResumeActionName(name);
+            const ownerId = ctx.auth.getUserIdentity()?.id ?? null;
+            const persistedArgs = serializeWorkflowValue(args ?? {});
+            const realtimeToken = createWorkflowRealtimeToken();
+            await ctx.unsafeDb.execute(sql `
+                INSERT INTO _gencow_workflows (
+                    id,
+                    name,
+                    args,
+                    realtime_token,
+                    status,
+                    retry_count,
+                    max_retries,
+                    max_duration_ms,
+                    user_id
+                )
+                VALUES (
+                    ${workflowId},
+                    ${name},
+                    ${JSON.stringify(persistedArgs)}::jsonb,
+                    ${realtimeToken},
+                    'pending',
+                    0,
+                    ${maxRetries},
+                    ${maxDurationMs},
+                    ${ownerId}
+                )
+            `);
+            try {
+                const scheduledJobId = ctx.scheduler.runAfter(0, resumeAction, { workflowId });
+                return {
+                    id: workflowId,
+                    name,
+                    status: "pending",
+                    scheduledJobId,
+                };
+            }
+            catch (error) {
+                await ctx.unsafeDb.execute(sql `
+                    DELETE FROM _gencow_workflows
+                    WHERE id = ${workflowId}
+                `);
+                throw error;
+            }
+        },
+    });
+}

package/dist/workflows-api.d.ts

@@ -0,0 +1,13 @@
+import type { WorkflowSnapshot } from "./workflow-types.js";
+declare global {
+    var __gencow_workflowsApiRegistered: boolean | undefined;
+}
+type WorkflowDbLike = {
+    execute: (query: unknown) => Promise<unknown>;
+};
+export declare function loadWorkflowSnapshot(db: WorkflowDbLike, workflowId: string, options?: {
+    viewerUserId?: string | null;
+    requireViewerMatch?: boolean;
+}): Promise<WorkflowSnapshot | null>;
+export declare function registerWorkflowsApi(): void;
+export {};