@kubun/store-workflow 0.13.0

package/LICENSE.md

@@ -0,0 +1,57 @@
+# The Prosperity Public License 3.0.0
+
+Contributor: Paul Le Cam
+
+Source Code: https://github.com/PaulLeCam/kubun
+
+## Purpose
+
+This license allows you to use and share this software for noncommercial purposes for free and to try this software for commercial purposes for thirty days.
+
+## Agreement
+
+In order to receive this license, you have to agree to its rules.  Those rules are both obligations under that agreement and conditions to your license.  Don't do anything with this software that triggers a rule you can't or won't follow.
+
+## Notices
+
+Make sure everyone who gets a copy of any part of this software from you, with or without changes, also gets the text of this license and the contributor and source code lines above.
+
+## Commercial Trial
+
+Limit your use of this software for commercial purposes to a thirty-day trial period.  If you use this software for work, your company gets one trial period for all personnel, not one trial per person.
+
+## Contributions Back
+
+Developing feedback, changes, or additions that you contribute back to the contributor on the terms of a standardized public software license such as [the Blue Oak Model License 1.0.0](https://blueoakcouncil.org/license/1.0.0), [the Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0.html), [the MIT license](https://spdx.org/licenses/MIT.html), or [the two-clause BSD license](https://spdx.org/licenses/BSD-2-Clause.html) doesn't count as use for a commercial purpose.
+
+## Personal Uses
+
+Personal use for research, experiment, and testing for the benefit of public knowledge, personal study, private entertainment, hobby projects, amateur pursuits, or religious observance, without any anticipated commercial application, doesn't count as use for a commercial purpose.
+
+## Noncommercial Organizations
+
+Use by any charitable organization, educational institution, public research organization, public safety or health organization, environmental protection organization, or government institution doesn't count as use for a commercial purpose regardless of the source of funding or obligations resulting from the funding.
+
+## Defense
+
+Don't make any legal claim against anyone accusing this software, with or without changes, alone or with other technology, of infringing any patent.
+
+## Copyright
+
+The contributor licenses you to do everything with this software that would otherwise infringe their copyright in it.
+
+## Patent
+
+The contributor licenses you to do everything with this software that would otherwise infringe any patents they can license or become able to license.
+
+## Reliability
+
+The contributor can't revoke this license.
+
+## Excuse
+
+You're excused for unknowingly breaking [Notices](#notices) if you take all practical steps to comply within thirty days of learning you broke the rule.
+
+## No Liability
+
+***As far as the law allows, this software comes as is, without any warranty or condition, and the contributor won't be liable to anyone for any damages related to this software or this license, under any kind of legal claim.***

package/lib/api.d.ts

@@ -0,0 +1,87 @@
+import type { Adapter } from '@kubun/db-adapter';
+import type { Kysely } from 'kysely';
+import type { WorkflowInstance, WorkflowSchedule, WorkflowTables } from './tables.js';
+export type WorkflowStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+export type WorkflowNextAction = {
+    name: string;
+    params?: unknown;
+};
+export type WorkflowInstanceRow = Omit<WorkflowInstance, 'state' | 'next_action'> & {
+    state: unknown;
+    next_action: WorkflowNextAction | null;
+};
+export type InsertInstanceInput = {
+    instanceID: string;
+    name: string;
+    queue?: string;
+    idempotencyKey?: string | null;
+    singletonKey?: string | null;
+    priority?: number;
+    state?: unknown;
+    nextAction?: WorkflowNextAction | null;
+    runAfter?: number;
+    createdAt: number;
+    updatedAt?: number;
+};
+export type InsertReason = 'idempotent' | 'singleton';
+export type InsertInstanceResult = {
+    row: WorkflowInstanceRow;
+    created: boolean;
+    reason?: InsertReason;
+};
+export type CheckpointInput = {
+    state: unknown;
+    nextAction: WorkflowNextAction | null;
+    status?: WorkflowStatus;
+};
+export type FailInput = {
+    state: unknown;
+    nextAction: WorkflowNextAction | null;
+    error: string;
+    attempts: number;
+    runAfter: number;
+    status: WorkflowStatus;
+};
+export type FinishInput = {
+    status: 'completed' | 'cancelled';
+    state: unknown;
+};
+export type ListFilter = {
+    name?: string;
+    queue?: string;
+    status?: WorkflowStatus;
+};
+export type WorkflowScheduleRow = Omit<WorkflowSchedule, 'params' | 'enabled'> & {
+    params: unknown;
+    enabled: boolean;
+};
+export type InsertScheduleInput = {
+    id: string;
+    workflowName: string;
+    params: unknown;
+    cron?: string | null;
+    every?: string | null;
+    nextRun: number;
+    enabled: boolean;
+};
+export type WorkflowStoreAPI = {
+    insertInstance(input: InsertInstanceInput): Promise<InsertInstanceResult>;
+    claim(instanceID: string, bootID: string, leaseMs: number, now: number): Promise<WorkflowInstanceRow | null>;
+    claimDue(queue: string, limit: number, bootID: string, leaseMs: number, now: number): Promise<Array<WorkflowInstanceRow>>;
+    renew(instanceID: string, bootID: string, leaseMs: number, now: number): Promise<boolean>;
+    checkpoint(instanceID: string, input: CheckpointInput, now: number): Promise<void>;
+    fail(instanceID: string, input: FailInput, now: number, bootID?: string): Promise<boolean>;
+    finish(instanceID: string, input: FinishInput, now: number, bootID?: string): Promise<boolean>;
+    listRecoverable(now: number): Promise<Array<WorkflowInstanceRow>>;
+    countRunning(queue: string, now: number): Promise<number>;
+    listRunnableQueues(now: number): Promise<Array<string>>;
+    get(instanceID: string): Promise<WorkflowInstanceRow | null>;
+    list(filter?: ListFilter): Promise<Array<WorkflowInstanceRow>>;
+    insertSchedule(input: InsertScheduleInput, now: number): Promise<void>;
+    getSchedule(id: string): Promise<WorkflowScheduleRow | null>;
+    listSchedules(): Promise<Array<WorkflowScheduleRow>>;
+    listDueSchedules(now: number): Promise<Array<WorkflowScheduleRow>>;
+    advanceSchedule(id: string, nextRun: number, now: number): Promise<void>;
+    setScheduleEnabled(id: string, enabled: boolean, now: number): Promise<void>;
+};
+export declare function createWorkflowStore(db: Kysely<WorkflowTables>, adapter: Adapter): WorkflowStoreAPI;

package/lib/api.js

@@ -0,0 +1,253 @@
+// --- Serialization helpers ---
+// ParseJSONResultsPlugin usually parses JSON columns back to objects, but a
+// value can still arrive as a string (adapter/driver dependent). Handle both.
+function decodeJSON(value) {
+    if (value == null) return null;
+    return typeof value === 'string' ? JSON.parse(value) : value;
+}
+function rowToInstance(row) {
+    return {
+        ...row,
+        state: decodeJSON(row.state),
+        next_action: decodeJSON(row.next_action)
+    };
+}
+function rowToSchedule(row) {
+    return {
+        ...row,
+        params: decodeJSON(row.params),
+        // Stored as integer 0/1 across adapters.
+        enabled: Number(row.enabled) === 1
+    };
+}
+export function createWorkflowStore(db, adapter) {
+    // Values common to writing a JSON column across adapters.
+    const encodeJSON = (value)=>adapter.encodeJSON(value);
+    const encodeNextAction = (value)=>value != null ? adapter.encodeJSON(value) : null;
+    const encodeParams = (value)=>adapter.encodeJSON(value);
+    async function readRow(tx, instanceID) {
+        return await tx.selectFrom('kubun_workflow_instances').selectAll().where('instance_id', '=', instanceID).executeTakeFirst();
+    }
+    return {
+        async insertInstance (input) {
+            const queue = input.queue ?? input.name;
+            const runAfter = input.runAfter ?? input.createdAt;
+            const updatedAt = input.updatedAt ?? input.createdAt;
+            // A transaction gives the pre-checks and the insert one snapshot. The
+            // partial unique index is the concurrent-race backstop (a second
+            // in-flight insert for the same active singleton would surface as a
+            // thrown constraint error); the graceful created:false return is the
+            // sequential pre-check path, so no driver error strings are parsed.
+            return await db.transaction().execute(async (tx)=>{
+                if (input.idempotencyKey != null) {
+                    const existing = await tx.selectFrom('kubun_workflow_instances').selectAll().where('idempotency_key', '=', input.idempotencyKey).executeTakeFirst();
+                    if (existing != null) {
+                        return {
+                            row: rowToInstance(existing),
+                            created: false,
+                            reason: 'idempotent'
+                        };
+                    }
+                }
+                if (input.singletonKey != null) {
+                    const active = await tx.selectFrom('kubun_workflow_instances').selectAll().where('name', '=', input.name).where('singleton_key', '=', input.singletonKey).where('status', 'in', [
+                        'pending',
+                        'running'
+                    ]).executeTakeFirst();
+                    if (active != null) {
+                        return {
+                            row: rowToInstance(active),
+                            created: false,
+                            reason: 'singleton'
+                        };
+                    }
+                }
+                await tx.insertInto('kubun_workflow_instances').values({
+                    instance_id: input.instanceID,
+                    name: input.name,
+                    queue,
+                    idempotency_key: input.idempotencyKey ?? null,
+                    singleton_key: input.singletonKey ?? null,
+                    priority: input.priority ?? 0,
+                    state: encodeJSON(input.state ?? {}),
+                    next_action: encodeNextAction(input.nextAction ?? null),
+                    status: 'pending',
+                    attempts: 0,
+                    run_after: runAfter,
+                    lease_owner: null,
+                    lease_expires: null,
+                    last_error: null,
+                    created_at: input.createdAt,
+                    updated_at: updatedAt
+                }).execute();
+                const row = await tx.selectFrom('kubun_workflow_instances').selectAll().where('instance_id', '=', input.instanceID).executeTakeFirstOrThrow();
+                return {
+                    row: rowToInstance(row),
+                    created: true
+                };
+            });
+        },
+        async claim (instanceID, bootID, leaseMs, now) {
+            // One atomic UPDATE. Claimable when pending, or when a running lease has
+            // expired (crash reclaim), and the run gate has opened. A concurrent
+            // caller either loses the row lock and re-reads the now-running row
+            // (WHERE no longer holds) or matches nothing — exactly one winner.
+            const row = await db.updateTable('kubun_workflow_instances').set({
+                status: 'running',
+                lease_owner: bootID,
+                lease_expires: now + leaseMs,
+                updated_at: now
+            }).where('instance_id', '=', instanceID).where('run_after', '<=', now).where((eb)=>eb.or([
+                    eb('status', '=', 'pending'),
+                    eb.and([
+                        eb('status', '=', 'running'),
+                        eb('lease_expires', '<', now)
+                    ])
+                ])).returningAll().executeTakeFirst();
+            return row != null ? rowToInstance(row) : null;
+        },
+        async claimDue (queue, limit, bootID, leaseMs, now) {
+            // A row is claimable on this lane when its run gate has opened and it is
+            // either pending or a running lease that has expired (crash reclaim).
+            const claimable = (eb)=>eb.and([
+                    eb('queue', '=', queue),
+                    eb('run_after', '<=', now),
+                    eb.or([
+                        eb('status', '=', 'pending'),
+                        eb.and([
+                            eb('status', '=', 'running'),
+                            eb('lease_expires', '<', now)
+                        ])
+                    ])
+                ]);
+            // One statement: pick the next `limit` candidates in the inner select, but
+            // repeat `claimable` in the OUTER update's WHERE so IT is the atomic guard.
+            // Under a concurrent claimDue the loser blocks on the row lock, then
+            // re-evaluates the outer WHERE against the now-running row (its own
+            // columns, not the snapshot subquery) and skips it — no double-claim,
+            // without SKIP LOCKED (which SQLite lacks).
+            const rows = await db.updateTable('kubun_workflow_instances').set({
+                status: 'running',
+                lease_owner: bootID,
+                lease_expires: now + leaseMs,
+                updated_at: now
+            }).where('instance_id', 'in', (eb)=>eb.selectFrom('kubun_workflow_instances').select('instance_id').where(claimable)// priority ascending (lower number first), then earliest run_after.
+                .orderBy('priority', 'asc').orderBy('run_after', 'asc').limit(limit)).where(claimable).returningAll().execute();
+            // The inner ORDER BY selects WHICH rows; UPDATE ... RETURNING does not
+            // guarantee the returned order, so re-sort the batch for the caller
+            // (priority ascending, then earliest run_after).
+            rows.sort((a, b)=>a.priority - b.priority || a.run_after - b.run_after);
+            return rows.map(rowToInstance);
+        },
+        async renew (instanceID, bootID, leaseMs, now) {
+            const row = await db.updateTable('kubun_workflow_instances').set({
+                lease_expires: now + leaseMs,
+                updated_at: now
+            }).where('instance_id', '=', instanceID).where('lease_owner', '=', bootID).where('status', '=', 'running').returning('instance_id').executeTakeFirst();
+            return row != null;
+        },
+        async checkpoint (instanceID, input, now) {
+            await db.updateTable('kubun_workflow_instances').set({
+                state: encodeJSON(input.state),
+                next_action: encodeNextAction(input.nextAction),
+                status: input.status ?? 'running',
+                updated_at: now
+            }).where('instance_id', '=', instanceID).execute();
+        },
+        async fail (instanceID, input, now, bootID) {
+            let query = db.updateTable('kubun_workflow_instances').set({
+                state: encodeJSON(input.state),
+                next_action: encodeNextAction(input.nextAction),
+                last_error: input.error,
+                attempts: input.attempts,
+                run_after: input.runAfter,
+                status: input.status,
+                updated_at: now
+            }).where('instance_id', '=', instanceID);
+            if (bootID != null) query = query.where('lease_owner', '=', bootID);
+            const row = await query.returning('instance_id').executeTakeFirst();
+            return row != null;
+        },
+        async finish (instanceID, input, now, bootID) {
+            let query = db.updateTable('kubun_workflow_instances').set({
+                status: input.status,
+                state: encodeJSON(input.state),
+                next_action: null,
+                lease_owner: null,
+                lease_expires: null,
+                updated_at: now
+            }).where('instance_id', '=', instanceID);
+            if (bootID != null) query = query.where('lease_owner', '=', bootID);
+            const row = await query.returning('instance_id').executeTakeFirst();
+            return row != null;
+        },
+        async listRecoverable (now) {
+            const rows = await db.selectFrom('kubun_workflow_instances').selectAll().where('status', '=', 'running').where('lease_expires', '<', now).execute();
+            return rows.map(rowToInstance);
+        },
+        async countRunning (queue, now) {
+            const row = await db.selectFrom('kubun_workflow_instances').select((eb)=>eb.fn.countAll().as('c')).where('queue', '=', queue).where('status', '=', 'running').where('lease_expires', '>=', now).executeTakeFirst();
+            return Number(row?.c ?? 0);
+        },
+        async listRunnableQueues (now) {
+            const rows = await db.selectFrom('kubun_workflow_instances').select('queue').distinct().where('run_after', '<=', now).where((eb)=>eb.or([
+                    eb('status', '=', 'pending'),
+                    eb.and([
+                        eb('status', '=', 'running'),
+                        eb('lease_expires', '<', now)
+                    ])
+                ])).execute();
+            return rows.map((r)=>r.queue);
+        },
+        async get (instanceID) {
+            const row = await readRow(db, instanceID);
+            return row != null ? rowToInstance(row) : null;
+        },
+        async list (filter) {
+            let query = db.selectFrom('kubun_workflow_instances').selectAll();
+            if (filter?.name != null) query = query.where('name', '=', filter.name);
+            if (filter?.queue != null) query = query.where('queue', '=', filter.queue);
+            if (filter?.status != null) query = query.where('status', '=', filter.status);
+            const rows = await query.execute();
+            return rows.map(rowToInstance);
+        },
+        // --- Schedules ---
+        async insertSchedule (input, now) {
+            await db.insertInto('kubun_workflow_schedules').values({
+                id: input.id,
+                workflow_name: input.workflowName,
+                params: encodeParams(input.params),
+                cron: input.cron ?? null,
+                every: input.every ?? null,
+                next_run: input.nextRun,
+                enabled: input.enabled ? 1 : 0,
+                created_at: now,
+                updated_at: now
+            }).execute();
+        },
+        async getSchedule (id) {
+            const row = await db.selectFrom('kubun_workflow_schedules').selectAll().where('id', '=', id).executeTakeFirst();
+            return row != null ? rowToSchedule(row) : null;
+        },
+        async listSchedules () {
+            const rows = await db.selectFrom('kubun_workflow_schedules').selectAll().execute();
+            return rows.map(rowToSchedule);
+        },
+        async listDueSchedules (now) {
+            const rows = await db.selectFrom('kubun_workflow_schedules').selectAll().where('enabled', '=', 1).where('next_run', '<=', now).execute();
+            return rows.map(rowToSchedule);
+        },
+        async advanceSchedule (id, nextRun, now) {
+            await db.updateTable('kubun_workflow_schedules').set({
+                next_run: nextRun,
+                updated_at: now
+            }).where('id', '=', id).execute();
+        },
+        async setScheduleEnabled (id, enabled, now) {
+            await db.updateTable('kubun_workflow_schedules').set({
+                enabled: enabled ? 1 : 0,
+                updated_at: now
+            }).where('id', '=', id).execute();
+        }
+    };
+}

package/lib/definition.d.ts

@@ -0,0 +1,4 @@
+import type { StoreDefinition } from '@kubun/db';
+import type { WorkflowStoreAPI } from './api.js';
+import type { WorkflowTables } from './tables.js';
+export declare const workflowStoreDefinition: StoreDefinition<WorkflowTables, WorkflowStoreAPI>;

package/lib/definition.js

@@ -0,0 +1,7 @@
+import { createWorkflowStore } from './api.js';
+import { getWorkflowMigrations } from './migrations.js';
+export const workflowStoreDefinition = {
+    name: 'workflow',
+    migrations: getWorkflowMigrations,
+    createAPI: createWorkflowStore
+};

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+import type { StoreProvider } from '@kubun/db';
+import type { WorkflowStoreAPI } from './api.js';
+export type { CheckpointInput, FailInput, FinishInput, InsertInstanceInput, InsertInstanceResult, InsertReason, InsertScheduleInput, ListFilter, WorkflowInstanceRow, WorkflowNextAction, WorkflowScheduleRow, WorkflowStatus, WorkflowStoreAPI, } from './api.js';
+export { createWorkflowStore } from './api.js';
+export { workflowStoreDefinition } from './definition.js';
+export { WORKFLOW_SINGLETON_UNIQUE_INDEX } from './migrations.js';
+export declare const WORKFLOW_STORE: "workflow";
+export declare function getWorkflowStore(provider: StoreProvider): Promise<WorkflowStoreAPI>;
+export type { WorkflowInstance, WorkflowInstanceTable, WorkflowSchedule, WorkflowScheduleTable, WorkflowTables, } from './tables.js';

package/lib/index.js

@@ -0,0 +1,7 @@
+export { createWorkflowStore } from './api.js';
+export { workflowStoreDefinition } from './definition.js';
+export { WORKFLOW_SINGLETON_UNIQUE_INDEX } from './migrations.js';
+export const WORKFLOW_STORE = 'workflow';
+export function getWorkflowStore(provider) {
+    return provider.getStore(WORKFLOW_STORE);
+}

package/lib/migrations.d.ts

@@ -0,0 +1,4 @@
+import type { MigrationContext } from '@kubun/db';
+import type { Migration } from 'kysely/migration';
+export declare const WORKFLOW_SINGLETON_UNIQUE_INDEX = "uq_workflow_instances_singleton";
+export declare function getWorkflowMigrations(ctx: MigrationContext): Record<string, Migration>;

package/lib/migrations.js

@@ -0,0 +1,66 @@
+import { sql } from 'kysely';
+// Partial unique index enforcing at most one active instance per
+// (name, singleton_key). Named here because the guarantee is a database
+// constraint, not a convention a writer upholds. Partial unique indexes carry
+// the same meaning on both adapter families (SQLite >= 3.8, Postgres).
+export const WORKFLOW_SINGLETON_UNIQUE_INDEX = 'uq_workflow_instances_singleton';
+export function getWorkflowMigrations(ctx) {
+    const t = ctx.types;
+    const init = {
+        async up (db) {
+            await db.schema.createTable('kubun_workflow_instances').ifNotExists().addColumn('instance_id', t.text, (col)=>col.notNull().primaryKey()).addColumn('name', t.text, (col)=>col.notNull()).addColumn('queue', t.text, (col)=>col.notNull()).addColumn('idempotency_key', t.text).addColumn('singleton_key', t.text).addColumn('priority', 'integer', (col)=>col.notNull().defaultTo(0)).addColumn('state', t.json, (col)=>col.notNull()).addColumn('next_action', t.json).addColumn('status', t.text, (col)=>col.notNull()).addColumn('attempts', 'integer', (col)=>col.notNull().defaultTo(0))// ms-epoch as bigint (not the `timestamp` column type). See tables.ts:
+            // the store compares against an explicit numeric `now`, and `timestamp`
+            // diverges across adapters. bigint holds ms-epoch and the int8 parser
+            // reads it back as a JS number on both.
+            .addColumn('run_after', t.bigint, (col)=>col.notNull()).addColumn('lease_owner', t.text).addColumn('lease_expires', t.bigint).addColumn('last_error', t.text).addColumn('created_at', t.bigint, (col)=>col.notNull()).addColumn('updated_at', t.bigint, (col)=>col.notNull()).execute();
+            // Exactly-once enqueue. A plain unique index treats NULLs as distinct on
+            // both adapters (Postgres default, SQLite always), so many rows may carry
+            // a null idempotency_key while present keys stay unique.
+            await db.schema.createIndex('uq_workflow_instances_idempotency').ifNotExists().unique().on('kubun_workflow_instances').column('idempotency_key').execute();
+            // At most one active instance per (name, singleton_key). Partial: only
+            // pending/running rows and non-null keys participate, so terminal rows
+            // free the key for a fresh singleton.
+            await db.schema.createIndex(WORKFLOW_SINGLETON_UNIQUE_INDEX).ifNotExists().unique().on('kubun_workflow_instances').columns([
+                'name',
+                'singleton_key'
+            ])// Raw predicate: the index builder's expression scope is limited to the
+            // indexed columns, so `status` is referenced via raw sql (the store-p2p
+            // partial-index precedent). Portable across SQLite and Postgres.
+            .where(sql`status in ('pending', 'running') and singleton_key is not null`).execute();
+            // Claim scan: pick the next runnable instance on a lane.
+            await db.schema.createIndex('idx_workflow_instances_claim').ifNotExists().on('kubun_workflow_instances').columns([
+                'queue',
+                'status',
+                'run_after'
+            ]).execute();
+            // Recovery scan: strand-reclaim of running rows past their lease.
+            await db.schema.createIndex('idx_workflow_instances_recovery').ifNotExists().on('kubun_workflow_instances').columns([
+                'status',
+                'lease_expires'
+            ]).execute();
+            await db.schema.createTable('kubun_workflow_schedules').ifNotExists().addColumn('id', t.text, (col)=>col.notNull().primaryKey()).addColumn('workflow_name', t.text, (col)=>col.notNull()).addColumn('params', t.json, (col)=>col.notNull())// Exactly one of cron / every is set; both nullable, the store persists
+            // them without parsing.
+            .addColumn('cron', t.text).addColumn('every', t.text)// ms-epoch as bigint (not the `timestamp` column type), matching the
+            // instance time columns and compared against an explicit numeric `now`.
+            .addColumn('next_run', t.bigint, (col)=>col.notNull())// 0/1: no portable boolean column type across the adapters.
+            .addColumn('enabled', 'integer', (col)=>col.notNull().defaultTo(1)).addColumn('created_at', t.bigint, (col)=>col.notNull()).addColumn('updated_at', t.bigint, (col)=>col.notNull()).execute();
+            // Due-scan: enabled schedules whose next_run has arrived.
+            await db.schema.createIndex('idx_workflow_schedules_due').ifNotExists().on('kubun_workflow_schedules').columns([
+                'enabled',
+                'next_run'
+            ]).execute();
+        },
+        async down (db) {
+            await db.schema.dropIndex('idx_workflow_schedules_due').ifExists().execute();
+            await db.schema.dropTable('kubun_workflow_schedules').ifExists().execute();
+            await db.schema.dropIndex('idx_workflow_instances_recovery').ifExists().execute();
+            await db.schema.dropIndex('idx_workflow_instances_claim').ifExists().execute();
+            await db.schema.dropIndex(WORKFLOW_SINGLETON_UNIQUE_INDEX).ifExists().execute();
+            await db.schema.dropIndex('uq_workflow_instances_idempotency').ifExists().execute();
+            await db.schema.dropTable('kubun_workflow_instances').ifExists().execute();
+        }
+    };
+    return {
+        '0-init': init
+    };
+}

package/lib/tables.d.ts

@@ -0,0 +1,36 @@
+import type { Selectable } from 'kysely';
+export type WorkflowInstanceTable = {
+    instance_id: string;
+    name: string;
+    queue: string;
+    idempotency_key: string | null;
+    singleton_key: string | null;
+    priority: number;
+    state: unknown;
+    next_action: unknown | null;
+    status: string;
+    attempts: number;
+    run_after: number;
+    lease_owner: string | null;
+    lease_expires: number | null;
+    last_error: string | null;
+    created_at: number;
+    updated_at: number;
+};
+export type WorkflowInstance = Selectable<WorkflowInstanceTable>;
+export type WorkflowScheduleTable = {
+    id: string;
+    workflow_name: string;
+    params: unknown;
+    cron: string | null;
+    every: string | null;
+    next_run: number;
+    enabled: number;
+    created_at: number;
+    updated_at: number;
+};
+export type WorkflowSchedule = Selectable<WorkflowScheduleTable>;
+export type WorkflowTables = {
+    kubun_workflow_instances: WorkflowInstanceTable;
+    kubun_workflow_schedules: WorkflowScheduleTable;
+};

package/lib/tables.js

@@ -0,0 +1,2 @@
+// --- Aggregate WorkflowTables type ---
+export { };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@kubun/store-workflow",
+  "version": "0.13.0",
+  "keywords": [],
+  "license": "see LICENSE.md",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib/*",
+    "LICENSE.md"
+  ],
+  "dependencies": {
+    "kysely": "^0.29.5",
+    "@kubun/db": "^0.13.0",
+    "@kubun/db-adapter": "^0.13.0"
+  },
+  "devDependencies": {
+    "@testcontainers/postgresql": "^12.1.0",
+    "@kubun/db-better-sqlite": "^0.13.0",
+    "@kubun/db-postgres": "^0.13.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "build:clean": "del lib",
+    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
+    "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
+    "build:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
+    "test": "pnpm run test:types && pnpm run test:unit",
+    "test:types": "tsc --noEmit -p tsconfig.test.json",
+    "test:unit": "vitest run"
+  }
+}