@workflow/world-postgres 4.0.1-beta.2 → 4.0.1-beta.3

package/dist/boss.d.ts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+/**
+/* pgboss is using JSON under the hood, so we need to base64 encode
+/* the body to ensure binary safety
+/* maybe later we can have a `blobs` table for larger payloads
+ **/
+export declare const MessageData: z.ZodObject<{
+    attempt: z.ZodNumber;
+    messageId: z.core.$ZodBranded<z.ZodString, "MessageId">;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    data: z.ZodCodec<z.ZodBase64, z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>>;
+}, z.core.$strip>;
+export type MessageData = z.infer<typeof MessageData>;
+//# sourceMappingURL=boss.d.ts.map

package/dist/boss.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boss.d.ts","sourceRoot":"","sources":["../src/boss.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAGzB;;;;IAII;AACJ,eAAO,MAAM,WAAW;;;;;;iBAUtB,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC"}

package/dist/boss.js

@@ -0,0 +1,18 @@
+import { MessageId } from '@workflow/world';
+import * as z from 'zod';
+import { Base64Buffer } from './zod.js';
+/**
+/* pgboss is using JSON under the hood, so we need to base64 encode
+/* the body to ensure binary safety
+/* maybe later we can have a `blobs` table for larger payloads
+ **/
+export const MessageData = z.object({
+    attempt: z.number().describe('The attempt number of the message'),
+    messageId: MessageId.describe('The unique ID of the message'),
+    idempotencyKey: z.string().optional(),
+    id: z
+        .string()
+        .describe("The ID of the sub-queue. For workflows, it's the workflow name. For steps, it's the step name."),
+    data: Base64Buffer.describe('The message that was sent'),
+});
+//# sourceMappingURL=boss.js.map

package/dist/boss.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boss.js","sourceRoot":"","sources":["../src/boss.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAExC;;;;IAII;AACJ,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAClC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,mCAAmC,CAAC;IACjE,SAAS,EAAE,SAAS,CAAC,QAAQ,CAAC,8BAA8B,CAAC;IAC7D,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACrC,EAAE,EAAE,CAAC;SACF,MAAM,EAAE;SACR,QAAQ,CACP,gGAAgG,CACjG;IACH,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC,2BAA2B,CAAC;CACzD,CAAC,CAAC"}

package/dist/config.d.ts

@@ -0,0 +1,6 @@
+export interface PostgresWorldConfig {
+    connectionString: string;
+    jobPrefix?: string;
+    queueConcurrency?: number;
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B"}

package/dist/config.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":""}

package/dist/drizzle/index.d.ts

@@ -0,0 +1,6 @@
+import type Postgres from 'postgres';
+import * as Schema from './schema.js';
+export { Schema };
+export type Drizzle = ReturnType<typeof createClient>;
+export declare function createClient(postgres: Postgres.Sql): import("drizzle-orm/postgres-js").PostgresJsDatabase<typeof Schema>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/drizzle/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AACrC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAEtC,OAAO,EAAE,MAAM,EAAE,CAAC;AAElB,MAAM,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;AACtD,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAAC,GAAG,uEAElD"}

package/dist/drizzle/index.js

@@ -0,0 +1,7 @@
+import { drizzle } from 'drizzle-orm/postgres-js';
+import * as Schema from './schema.js';
+export { Schema };
+export function createClient(postgres) {
+    return drizzle(postgres, { schema: Schema });
+}
+//# sourceMappingURL=index.js.map

package/dist/drizzle/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/drizzle/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAElD,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAEtC,OAAO,EAAE,MAAM,EAAE,CAAC;AAGlB,MAAM,UAAU,YAAY,CAAC,QAAsB;IACjD,OAAO,OAAO,CAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;AAC/C,CAAC"}

package/dist/drizzle/schema.d.ts

@@ -0,0 +1,582 @@
+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" | "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;
+        }, {}, {}>;
+    };
+    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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBjB,CAAC;AAEF,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBjB,CAAC;AAQF,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYnB,CAAC"}