@workflow/world-postgres 4.0.1-beta.2 → 4.1.0-beta.4

package/dist/drizzle/schema.d.ts

@@ -0,0 +1,594 @@
+export declare const workflowRunStatus: import("drizzle-orm/pg-core").PgEnum<["pending" | "running" | "completed" | "failed" | "paused" | "cancelled", ...("pending" | "running" | "completed" | "failed" | "paused" | "cancelled")[]]>;
+export declare const stepStatus: import("drizzle-orm/pg-core").PgEnum<["pending" | "running" | "completed" | "failed" | "cancelled", ...("pending" | "running" | "completed" | "failed" | "cancelled")[]]>;
+/**
+ * Sadly we do `any[]` right now
+ */
+export type SerializedContent = any[];
+export declare const runs: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "workflow_runs";
+    schema: undefined;
+    columns: {
+        runId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "workflow_runs";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        output: import("drizzle-orm/pg-core").PgColumn<{
+            name: "output";
+            tableName: "workflow_runs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: SerializedContent;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+        deploymentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "deployment_id";
+            tableName: "workflow_runs";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "workflow_runs";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "pending" | "running" | "completed" | "failed" | "paused" | "cancelled";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: ["pending" | "running" | "completed" | "failed" | "paused" | "cancelled", ...("pending" | "running" | "completed" | "failed" | "paused" | "cancelled")[]];
+            baseColumn: never;
+        }, {}, {}>;
+        workflowName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "workflow_runs";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        executionContext: import("drizzle-orm/pg-core").PgColumn<{
+            name: "execution_context";
+            tableName: "workflow_runs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, any>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+        input: import("drizzle-orm/pg-core").PgColumn<{
+            name: "input";
+            tableName: "workflow_runs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: SerializedContent;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+        error: import("drizzle-orm/pg-core").PgColumn<{
+            name: "error";
+            tableName: "workflow_runs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        errorCode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "error_code";
+            tableName: "workflow_runs";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "workflow_runs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "workflow_runs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+        completedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "completed_at";
+            tableName: "workflow_runs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+        startedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "started_at";
+            tableName: "workflow_runs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const events: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "workflow_events";
+    schema: undefined;
+    columns: {
+        eventId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "workflow_events";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        eventType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "type";
+            tableName: "workflow_events";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: "step_completed" | "step_failed" | "step_retrying" | "step_started" | "hook_created" | "hook_received" | "hook_disposed" | "wait_created" | "wait_completed" | "workflow_completed" | "workflow_failed" | "workflow_started";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        correlationId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "correlation_id";
+            tableName: "workflow_events";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "workflow_events";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+        runId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "run_id";
+            tableName: "workflow_events";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        eventData: import("drizzle-orm/pg-core").PgColumn<{
+            name: "payload";
+            tableName: "workflow_events";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const steps: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "workflow_steps";
+    schema: undefined;
+    columns: {
+        runId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "run_id";
+            tableName: "workflow_steps";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        stepId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "step_id";
+            tableName: "workflow_steps";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        stepName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "step_name";
+            tableName: "workflow_steps";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "workflow_steps";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "pending" | "running" | "completed" | "failed" | "cancelled";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: ["pending" | "running" | "completed" | "failed" | "cancelled", ...("pending" | "running" | "completed" | "failed" | "cancelled")[]];
+            baseColumn: never;
+        }, {}, {}>;
+        input: import("drizzle-orm/pg-core").PgColumn<{
+            name: "input";
+            tableName: "workflow_steps";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: SerializedContent;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+        output: import("drizzle-orm/pg-core").PgColumn<{
+            name: "output";
+            tableName: "workflow_steps";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: SerializedContent;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+        error: import("drizzle-orm/pg-core").PgColumn<{
+            name: "error";
+            tableName: "workflow_steps";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        errorCode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "error_code";
+            tableName: "workflow_steps";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        attempt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempt";
+            tableName: "workflow_steps";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+        startedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "started_at";
+            tableName: "workflow_steps";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+        completedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "completed_at";
+            tableName: "workflow_steps";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "workflow_steps";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "workflow_steps";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+        retryAfter: import("drizzle-orm/pg-core").PgColumn<{
+            name: "retry_after";
+            tableName: "workflow_steps";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const hooks: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "workflow_hooks";
+    schema: undefined;
+    columns: {
+        runId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "run_id";
+            tableName: "workflow_hooks";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        hookId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "hook_id";
+            tableName: "workflow_hooks";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        token: import("drizzle-orm/pg-core").PgColumn<{
+            name: "token";
+            tableName: "workflow_hooks";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        ownerId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "owner_id";
+            tableName: "workflow_hooks";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        projectId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "project_id";
+            tableName: "workflow_hooks";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        environment: import("drizzle-orm/pg-core").PgColumn<{
+            name: "environment";
+            tableName: "workflow_hooks";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "workflow_hooks";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "workflow_hooks";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: SerializedContent;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const streams: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "workflow_stream_chunks";
+    schema: undefined;
+    columns: {
+        chunkId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "workflow_stream_chunks";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: `chnk_${string}`;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        streamId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "stream_id";
+            tableName: "workflow_stream_chunks";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+        }, {}, {}>;
+        chunkData: import("drizzle-orm/pg-core").PgColumn<{
+            name: "data";
+            tableName: "workflow_stream_chunks";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: Buffer<ArrayBufferLike>;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "workflow_stream_chunks";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+        eof: import("drizzle-orm/pg-core").PgColumn<{
+            name: "eof";
+            tableName: "workflow_stream_chunks";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/drizzle/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/drizzle/schema.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,iBAAiB,iMAG7B,CAAC;AAEF,eAAO,MAAM,UAAU,2KAGtB,CAAC;AAYF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,GAAG,EAAE,CAAC;AAEtC,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBhB,CAAC;AAEF,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAclB,CAAC;AAEF,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBjB,CAAC;AAEF,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBjB,CAAC;AAQF,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYnB,CAAC"}

package/dist/drizzle/schema.js

@@ -0,0 +1,89 @@
+import { StepStatusSchema, WorkflowRunStatusSchema, } from '@workflow/world';
+import { boolean, customType, index, integer, jsonb, pgEnum, pgTable, primaryKey, text, timestamp, varchar, } from 'drizzle-orm/pg-core';
+function mustBeMoreThanOne(t) {
+    return t;
+}
+export const workflowRunStatus = pgEnum('status', mustBeMoreThanOne(WorkflowRunStatusSchema.options));
+export const stepStatus = pgEnum('step_status', mustBeMoreThanOne(StepStatusSchema.options));
+export const runs = pgTable('workflow_runs', {
+    runId: varchar('id').primaryKey(),
+    output: jsonb('output').$type(),
+    deploymentId: varchar('deployment_id').notNull(),
+    status: workflowRunStatus('status').notNull(),
+    workflowName: varchar('name').notNull(),
+    executionContext: jsonb('execution_context').$type(),
+    input: jsonb('input').$type().notNull(),
+    error: text('error'),
+    errorCode: varchar('error_code'),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+    updatedAt: timestamp('updated_at')
+        .defaultNow()
+        .$onUpdateFn(() => new Date())
+        .notNull(),
+    completedAt: timestamp('completed_at'),
+    startedAt: timestamp('started_at'),
+}, (tb) => ({
+    workflowNameIdx: index().on(tb.workflowName),
+    statusIdx: index().on(tb.status),
+}));
+export const events = pgTable('workflow_events', {
+    eventId: varchar('id').primaryKey(),
+    eventType: varchar('type').$type().notNull(),
+    correlationId: varchar('correlation_id'),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+    runId: varchar('run_id').notNull(),
+    eventData: jsonb('payload'),
+}, (tb) => ({
+    runFk: index().on(tb.runId),
+    correlationIdFk: index().on(tb.correlationId),
+}));
+export const steps = pgTable('workflow_steps', {
+    runId: varchar('run_id').notNull(),
+    stepId: varchar('step_id').primaryKey(),
+    stepName: varchar('step_name').notNull(),
+    status: stepStatus('status').notNull(),
+    input: jsonb('input').$type().notNull(),
+    output: jsonb('output').$type(),
+    error: text('error'),
+    errorCode: varchar('error_code'),
+    attempt: integer('attempt').notNull(),
+    startedAt: timestamp('started_at'),
+    completedAt: timestamp('completed_at'),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+    updatedAt: timestamp('updated_at')
+        .defaultNow()
+        .$onUpdateFn(() => new Date())
+        .notNull(),
+    retryAfter: timestamp('retry_after'),
+}, (tb) => ({
+    runFk: index().on(tb.runId),
+    statusIdx: index().on(tb.status),
+}));
+export const hooks = pgTable('workflow_hooks', {
+    runId: varchar('run_id').notNull(),
+    hookId: varchar('hook_id').primaryKey(),
+    token: varchar('token').notNull(),
+    ownerId: varchar('owner_id').notNull(),
+    projectId: varchar('project_id').notNull(),
+    environment: varchar('environment').notNull(),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+    metadata: jsonb('metadata').$type(),
+}, (tb) => ({
+    runFk: index().on(tb.runId),
+    tokenIdx: index().on(tb.token),
+}));
+const bytea = customType({
+    dataType() {
+        return 'bytea';
+    },
+});
+export const streams = pgTable('workflow_stream_chunks', {
+    chunkId: varchar('id').$type().notNull(),
+    streamId: varchar('stream_id').notNull(),
+    chunkData: bytea('data').notNull(),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+    eof: boolean('eof').notNull(),
+}, (tb) => ({
+    primaryKey: primaryKey({ columns: [tb.streamId, tb.chunkId] }),
+}));
+//# sourceMappingURL=schema.js.map