@m5kdev/backend 0.1.0 → 0.1.2

package/dist/src/modules/webhook/webhook.repository.d.ts

@@ -0,0 +1,149 @@
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseTableRepository } from "#modules/base/base.repository";
+declare const schema: {
+    webhook: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        name: "webhook";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "id";
+                tableName: "webhook";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: true;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "created_at";
+                tableName: "webhook";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: true;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "updated_at";
+                tableName: "webhook";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            timeoutSec: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "timeout_sec";
+                tableName: "webhook";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "status";
+                tableName: "webhook";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: import("./webhook.constants").WebhookStatus;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+                $type: import("./webhook.constants").WebhookStatus;
+            }>;
+            error: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "error";
+                tableName: "webhook";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            payload: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "payload";
+                tableName: "webhook";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+        };
+        dialect: "sqlite";
+    }>;
+};
+type Schema = typeof schema;
+type Orm = LibSQLDatabase<Schema>;
+export declare class WebhookRepository extends BaseTableRepository<Orm, Schema, Record<string, never>, Schema["webhook"]> {
+    completed(id: string, payload: unknown, tx?: Orm): ServerResultAsync<void>;
+    timeout(id: string, tx?: Orm): ServerResultAsync<void>;
+    registerError(id: string, status: "ERROR_CALLBACK" | "ERROR_DATA", error: string, tx?: Orm): ServerResultAsync<void>;
+}
+export {};
+//# sourceMappingURL=webhook.repository.d.ts.map

package/dist/src/modules/webhook/webhook.repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook.repository.d.ts","sourceRoot":"","sources":["../../../../src/modules/webhook/webhook.repository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAIpE,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAc,CAAC;AAC3B,KAAK,MAAM,GAAG,OAAO,MAAM,CAAC;AAC5B,KAAK,GAAG,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;AAElC,qBAAa,iBAAkB,SAAQ,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC;IACzG,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,GAAG,GAAG,iBAAiB,CAAC,IAAI,CAAC;IAiB1E,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,GAAG,GAAG,iBAAiB,CAAC,IAAI,CAAC;IAiBtD,aAAa,CACjB,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,gBAAgB,GAAG,YAAY,EACvC,KAAK,EAAE,MAAM,EACb,EAAE,CAAC,EAAE,GAAG,GACP,iBAAiB,CAAC,IAAI,CAAC;CAgB3B"}

package/dist/src/modules/webhook/webhook.repository.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookRepository = void 0;
+const neverthrow_1 = require("neverthrow");
+const base_repository_1 = require("#modules/base/base.repository");
+const webhook_constants_1 = require("./webhook.constants");
+const webhook_db_1 = require("./webhook.db");
+const schema = { webhook: webhook_db_1.webhook };
+class WebhookRepository extends base_repository_1.BaseTableRepository {
+    async completed(id, payload, tx) {
+        return this.throwableAsync(async () => {
+            const webhook = await this.findById(id, tx);
+            if (webhook.isErr())
+                return (0, neverthrow_1.err)(webhook.error);
+            if (!webhook.value)
+                return this.error("NOT_FOUND");
+            await this.update({
+                id,
+                status: webhook_constants_1.WEBHOOK_STATUS_ENUM.COMPLETED,
+                payload: JSON.stringify(payload),
+            }, tx);
+            return (0, neverthrow_1.ok)();
+        });
+    }
+    async timeout(id, tx) {
+        return this.throwableAsync(async () => {
+            const webhook = await this.findById(id, tx);
+            if (webhook.isErr())
+                return (0, neverthrow_1.err)(webhook.error);
+            if (!webhook.value)
+                return this.error("NOT_FOUND");
+            await this.update({
+                id,
+                status: webhook_constants_1.WEBHOOK_STATUS_ENUM.TIMEOUT,
+                error: `Timeout of ${webhook.value.timeoutSec} seconds reached`,
+            }, tx);
+            return (0, neverthrow_1.ok)();
+        });
+    }
+    async registerError(id, status, error, tx) {
+        return this.throwableAsync(async () => {
+            const webhook = await this.findById(id, tx);
+            if (webhook.isErr())
+                return (0, neverthrow_1.err)(webhook.error);
+            if (!webhook.value)
+                return this.error("NOT_FOUND");
+            await this.update({
+                id,
+                status,
+                error,
+            }, tx);
+            return (0, neverthrow_1.ok)();
+        });
+    }
+}
+exports.WebhookRepository = WebhookRepository;

package/dist/src/modules/webhook/webhook.router.d.ts

@@ -0,0 +1,4 @@
+import { Router } from "express";
+import type { WebhookService } from "./webhook.service";
+export declare function createWebhookRouter(webhookService: WebhookService): Router;
+//# sourceMappingURL=webhook.router.d.ts.map

package/dist/src/modules/webhook/webhook.router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook.router.d.ts","sourceRoot":"","sources":["../../../../src/modules/webhook/webhook.router.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,wBAAgB,mBAAmB,CAAC,cAAc,EAAE,cAAc,GAAG,MAAM,CAwB1E"}

package/dist/src/modules/webhook/webhook.router.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebhookRouter = createWebhookRouter;
+const tslib_1 = require("tslib");
+const body_parser_1 = tslib_1.__importDefault(require("body-parser"));
+const express_1 = require("express");
+function createWebhookRouter(webhookService) {
+    const webhookRouter = (0, express_1.Router)();
+    webhookRouter.post("/:id", body_parser_1.default.json(), async (req, res) => {
+        const { authorization } = req.headers;
+        if (!authorization)
+            return res.status(401).json({ message: "Missing authorization header" });
+        if (typeof authorization !== "string")
+            return res.status(401).json({ message: "Authorization header is not a string" });
+        if (!authorization.startsWith("Bearer "))
+            return res.status(401).json({ message: "Invalid authorization header" });
+        const token = authorization.split(" ")[1];
+        if (!token)
+            return res.status(401).json({ message: "Missing token" });
+        if (token !== process.env.WEBHOOK_SECRET)
+            return res.status(401).json({ message: "Invalid token" });
+        const result = await webhookService.completed(req.params.id, req.body);
+        if (result.isErr())
+            return res
+                .status(result.error.getHTTPStatusCode() || 500)
+                .json({ message: result.error.message });
+        return res.status(200).json({ message: "Webhook completed" });
+    });
+    return webhookRouter;
+}

package/dist/src/modules/webhook/webhook.service.d.ts

@@ -0,0 +1,10 @@
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseService } from "#modules/base/base.service";
+import type { WebhookRepository } from "./webhook.repository";
+export declare class WebhookService extends BaseService<{
+    webhook: WebhookRepository;
+}, never> {
+    completed(id: string, payload: unknown): ServerResultAsync<void>;
+    waitForRequest<T>(callback: (url: string) => any, timeoutSec?: number): ServerResultAsync<T>;
+}
+//# sourceMappingURL=webhook.service.d.ts.map

package/dist/src/modules/webhook/webhook.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook.service.d.ts","sourceRoot":"","sources":["../../../../src/modules/webhook/webhook.service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAgB,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,qBAAa,cAAe,SAAQ,WAAW,CAAC;IAAE,OAAO,EAAE,iBAAiB,CAAA;CAAE,EAAE,KAAK,CAAC;IAC9E,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,iBAAiB,CAAC,IAAI,CAAC;IAehE,cAAc,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,GAAG,EAAE,UAAU,SAAK,GAAG,iBAAiB,CAAC,CAAC,CAAC;CAsD/F"}

package/dist/src/modules/webhook/webhook.service.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookService = void 0;
+const json_1 = require("@m5kdev/commons/utils/json");
+const neverthrow_1 = require("neverthrow");
+const base_service_1 = require("#modules/base/base.service");
+const webhook_constants_1 = require("./webhook.constants");
+class WebhookService extends base_service_1.BaseService {
+    async completed(id, payload) {
+        const result = await this.repository.webhook.completed(id, payload);
+        if (result.isErr()) {
+            await this.repository.webhook.registerError(id, webhook_constants_1.WEBHOOK_STATUS_ENUM.ERROR_DATA, JSON.stringify(result.error));
+            return this.error("INTERNAL_SERVER_ERROR", "Webhook completed failed", {
+                cause: result.error,
+            });
+        }
+        return (0, neverthrow_1.ok)();
+    }
+    async waitForRequest(callback, timeoutSec = 60) {
+        const webhook = await this.repository.webhook.create({
+            timeoutSec,
+        });
+        if (webhook.isErr())
+            return Promise.reject(webhook.error);
+        const url = `${process.env.NGROK_LOCALHOST_TUNNEL || process.env.VITE_SERVER_URL}/webhook/${webhook.value.id}`;
+        try {
+            await callback(url);
+        }
+        catch (error) {
+            await this.repository.webhook.registerError(webhook.value.id, webhook_constants_1.WEBHOOK_STATUS_ENUM.ERROR_CALLBACK, JSON.stringify(error));
+            return this.error("INTERNAL_SERVER_ERROR", "Error callback failed", { cause: error });
+        }
+        const startTime = new Date(webhook.value.createdAt).getTime();
+        const endTime = startTime + timeoutSec * 1000;
+        const promise = await new Promise((resolve, reject) => {
+            const intervalId = setInterval(async () => {
+                const currentTime = Date.now();
+                // Check if the timeout is reached
+                if (currentTime > endTime) {
+                    await this.repository.webhook.timeout(webhook.value.id);
+                    clearInterval(intervalId);
+                    return reject(this.error("TIMEOUT", "Wait for request timeout"));
+                }
+                const result = await this.repository.webhook.findById(webhook.value.id);
+                if (result.isErr()) {
+                    clearInterval(intervalId);
+                    return reject((0, neverthrow_1.err)(result.error));
+                }
+                if (!result.value) {
+                    clearInterval(intervalId);
+                    return reject(this.error("NOT_FOUND", "Wait for request failed: cannot find webhook"));
+                }
+                const { status, payload } = result.value;
+                if (status === "COMPLETED") {
+                    const data = payload ? (0, json_1.safeParseJson)(payload, payload) : payload;
+                    clearInterval(intervalId);
+                    return resolve((0, neverthrow_1.ok)(data));
+                }
+                if (status !== "WAITING") {
+                    clearInterval(intervalId);
+                    return reject(this.error("BAD_REQUEST", "Wait for request failed"));
+                }
+            }, 1000);
+        });
+        return promise;
+    }
+}
+exports.WebhookService = WebhookService;

package/dist/src/modules/workflow/workflow.db.d.ts

@@ -0,0 +1,297 @@
+export declare const workflows: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "workflows";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "workflows";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        userId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "user_id";
+            tableName: "workflows";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        jobId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "job_id";
+            tableName: "workflows";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        jobName: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "job_name";
+            tableName: "workflows";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        queueName: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "queue_name";
+            tableName: "workflows";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        timeout: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "timeout";
+            tableName: "workflows";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tags: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "tags";
+            tableName: "workflows";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: string[];
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        input: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "input";
+            tableName: "workflows";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: unknown;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        output: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "output";
+            tableName: "workflows";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: unknown;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "status";
+            tableName: "workflows";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: "queued" | "running" | "completed" | "failed";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+            $type: "queued" | "running" | "completed" | "failed";
+        }>;
+        error: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "error";
+            tableName: "workflows";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        retries: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "retries";
+            tableName: "workflows";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        finishedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "finished_at";
+            tableName: "workflows";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        processedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "processed_at";
+            tableName: "workflows";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "workflows";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "workflows";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+//# sourceMappingURL=workflow.db.d.ts.map

package/dist/src/modules/workflow/workflow.db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.db.d.ts","sourceRoot":"","sources":["../../../../src/modules/workflow/workflow.db.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBpB,CAAC"}

package/dist/src/modules/workflow/workflow.db.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflows = void 0;
+const sqlite_core_1 = require("drizzle-orm/sqlite-core");
+const uuid_1 = require("uuid");
+const auth_db_1 = require("#modules/auth/auth.db");
+exports.workflows = (0, sqlite_core_1.sqliteTable)("workflows", {
+    id: (0, sqlite_core_1.text)("id").primaryKey().$default(uuid_1.v4),
+    userId: (0, sqlite_core_1.text)("user_id").references(() => auth_db_1.users.id, { onDelete: "cascade" }),
+    jobId: (0, sqlite_core_1.text)("job_id").unique().notNull(),
+    jobName: (0, sqlite_core_1.text)("job_name").notNull(),
+    queueName: (0, sqlite_core_1.text)("queue_name").notNull(),
+    timeout: (0, sqlite_core_1.integer)("timeout"),
+    tags: (0, sqlite_core_1.text)("tags", { mode: "json" })
+        .$default(() => [])
+        .$type(),
+    input: (0, sqlite_core_1.text)("input", { mode: "json" }),
+    output: (0, sqlite_core_1.text)("output", { mode: "json" }),
+    status: (0, sqlite_core_1.text)("status").notNull().$type(),
+    error: (0, sqlite_core_1.text)("error"),
+    retries: (0, sqlite_core_1.integer)("retries").notNull().default(0),
+    finishedAt: (0, sqlite_core_1.integer)("finished_at", { mode: "timestamp" }),
+    processedAt: (0, sqlite_core_1.integer)("processed_at", { mode: "timestamp" }),
+    createdAt: (0, sqlite_core_1.integer)("created_at", { mode: "timestamp" })
+        .notNull()
+        .$default(() => new Date()),
+    updatedAt: (0, sqlite_core_1.integer)("updated_at", { mode: "timestamp" })
+        .notNull()
+        .$default(() => new Date()),
+});