@m5kdev/backend 0.1.0 → 0.1.2

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

@@ -0,0 +1,344 @@
+import type { WorkflowListInputSchema, WorkflowListOutputSchema, WorkflowReadOutputSchema } from "@m5kdev/commons/modules/workflow/workflow.schema";
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseRepository } from "#modules/base/base.repository";
+declare const schema: {
+    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";
+    }>;
+};
+type Schema = typeof schema;
+type Orm = LibSQLDatabase<Schema>;
+export declare class WorkflowRepository extends BaseRepository<Orm, Schema, Record<string, never>> {
+    read({ jobId, userId, }: {
+        jobId: string;
+        userId: string;
+    }): ServerResultAsync<WorkflowReadOutputSchema>;
+    list({ userId, status, jobName, }: WorkflowListInputSchema & {
+        userId: string;
+    }): ServerResultAsync<WorkflowListOutputSchema>;
+    added({ userId, jobId, jobName, queueName, timeout, tags, input, }: {
+        userId?: string;
+        jobId: string;
+        jobName: string;
+        queueName: string;
+        timeout?: number;
+        tags?: string[];
+        input: unknown;
+    }): ServerResultAsync<WorkflowReadOutputSchema>;
+    addedMany(data: {
+        userId?: string;
+        jobId: string;
+        jobName: string;
+        queueName: string;
+        timeout?: number;
+        tags?: string[];
+        input: unknown;
+    }[]): ServerResultAsync<WorkflowReadOutputSchema[]>;
+    started({ jobId }: {
+        jobId: string;
+    }): ServerResultAsync<WorkflowReadOutputSchema>;
+    failed({ jobId, error, }: {
+        jobId: string;
+        error: string;
+    }): ServerResultAsync<WorkflowReadOutputSchema>;
+    completed({ jobId, output, }: {
+        jobId: string;
+        output: unknown;
+    }): ServerResultAsync<WorkflowReadOutputSchema>;
+}
+export {};
+//# sourceMappingURL=workflow.repository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.repository.d.ts","sourceRoot":"","sources":["../../../../src/modules/workflow/workflow.repository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EACvB,wBAAwB,EACxB,wBAAwB,EACzB,MAAM,kDAAkD,CAAC;AAE1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAG/D,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAkB,CAAC;AAE/B,KAAK,MAAM,GAAG,OAAO,MAAM,CAAC;AAC5B,KAAK,GAAG,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;AAElC,qBAAa,kBAAmB,SAAQ,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAClF,IAAI,CAAC,EACT,KAAK,EACL,MAAM,GACP,EAAE;QACD,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;KAChB,GAAG,iBAAiB,CAAC,wBAAwB,CAAC;IAazC,IAAI,CAAC,EACT,MAAM,EACN,MAAM,EACN,OAAO,GACR,EAAE,uBAAuB,GAAG;QAC3B,MAAM,EAAE,MAAM,CAAC;KAChB,GAAG,iBAAiB,CAAC,wBAAwB,CAAC;IAazC,KAAK,CAAC,EACV,MAAM,EACN,KAAK,EACL,OAAO,EACP,SAAS,EACT,OAAO,EACP,IAAI,EACJ,KAAK,GACN,EAAE;QACD,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAChB,KAAK,EAAE,OAAO,CAAC;KAChB,GAAG,iBAAiB,CAAC,wBAAwB,CAAC;IAqBzC,SAAS,CACb,IAAI,EAAE;QACJ,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAChB,KAAK,EAAE,OAAO,CAAC;KAChB,EAAE,GACF,iBAAiB,CAAC,wBAAwB,EAAE,CAAC;IAuB1C,OAAO,CAAC,EAAE,KAAK,EAAE,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,iBAAiB,CAAC,wBAAwB,CAAC;IAWlF,MAAM,CAAC,EACX,KAAK,EACL,KAAK,GACN,EAAE;QACD,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;KACf,GAAG,iBAAiB,CAAC,wBAAwB,CAAC;IAWzC,SAAS,CAAC,EACd,KAAK,EACL,MAAM,GACP,EAAE;QACD,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,OAAO,CAAC;KACjB,GAAG,iBAAiB,CAAC,wBAAwB,CAAC;CAUhD"}

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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowRepository = void 0;
+const tslib_1 = require("tslib");
+const drizzle_orm_1 = require("drizzle-orm");
+const neverthrow_1 = require("neverthrow");
+const base_repository_1 = require("#modules/base/base.repository");
+const workflow = tslib_1.__importStar(require("#modules/workflow/workflow.db"));
+const schema = { ...workflow };
+class WorkflowRepository extends base_repository_1.BaseRepository {
+    async read({ jobId, userId, }) {
+        return this.throwableAsync(async () => {
+            const [wf] = await this.orm
+                .select()
+                .from(this.schema.workflows)
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(this.schema.workflows.jobId, jobId), (0, drizzle_orm_1.eq)(this.schema.workflows.userId, userId)));
+            if (!wf)
+                return this.error("NOT_FOUND");
+            return (0, neverthrow_1.ok)(wf);
+        });
+    }
+    async list({ userId, status, jobName, }) {
+        return this.throwableAsync(async () => {
+            const { ConditionBuilder } = this.helpers;
+            const condition = new ConditionBuilder([(0, drizzle_orm_1.eq)(this.schema.workflows.userId, userId)]);
+            if (status)
+                condition.push((0, drizzle_orm_1.inArray)(this.schema.workflows.status, status));
+            if (jobName)
+                condition.push((0, drizzle_orm_1.eq)(this.schema.workflows.jobName, jobName));
+            const workflows = await this.orm.select().from(this.schema.workflows).where(condition.join());
+            return (0, neverthrow_1.ok)(workflows);
+        });
+    }
+    async added({ userId, jobId, jobName, queueName, timeout, tags, input, }) {
+        return this.throwableAsync(async () => {
+            const [wf] = await this.orm
+                .insert(this.schema.workflows)
+                .values({
+                userId,
+                jobId,
+                jobName,
+                input,
+                status: "queued",
+                queueName,
+                timeout,
+                tags,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            })
+                .returning();
+            return (0, neverthrow_1.ok)(wf);
+        });
+    }
+    async addedMany(data) {
+        return this.throwableAsync(async () => {
+            const wfs = await this.orm
+                .insert(this.schema.workflows)
+                .values(data.map((d) => ({
+                userId: d.userId,
+                jobId: d.jobId,
+                jobName: d.jobName,
+                queueName: d.queueName,
+                timeout: d.timeout,
+                tags: d.tags,
+                input: d.input,
+                status: "queued",
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            })))
+                .returning();
+            return (0, neverthrow_1.ok)(wfs);
+        });
+    }
+    async started({ jobId }) {
+        return this.throwableAsync(async () => {
+            const [wf] = await this.orm
+                .update(this.schema.workflows)
+                .set({ status: "running", updatedAt: new Date(), processedAt: new Date() })
+                .where((0, drizzle_orm_1.eq)(this.schema.workflows.jobId, jobId))
+                .returning();
+            return (0, neverthrow_1.ok)(wf);
+        });
+    }
+    async failed({ jobId, error, }) {
+        return this.throwableAsync(async () => {
+            const [wf] = await this.orm
+                .update(this.schema.workflows)
+                .set({ status: "failed", error, updatedAt: new Date(), finishedAt: new Date() })
+                .where((0, drizzle_orm_1.eq)(this.schema.workflows.jobId, jobId))
+                .returning();
+            return (0, neverthrow_1.ok)(wf);
+        });
+    }
+    async completed({ jobId, output, }) {
+        return this.throwableAsync(async () => {
+            const [wf] = await this.orm
+                .update(this.schema.workflows)
+                .set({ status: "completed", updatedAt: new Date(), finishedAt: new Date(), output })
+                .where((0, drizzle_orm_1.eq)(this.schema.workflows.jobId, jobId))
+                .returning();
+            return (0, neverthrow_1.ok)(wf);
+        });
+    }
+}
+exports.WorkflowRepository = WorkflowRepository;

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

@@ -0,0 +1,22 @@
+import type { WorkflowListInputSchema, WorkflowListOutputSchema, WorkflowReadInputSchema, WorkflowReadOutputSchema } from "@m5kdev/commons/modules/workflow/workflow.schema";
+import type { Job } from "bullmq";
+import type { User } from "#modules/auth/auth.lib";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseService } from "#modules/base/base.service";
+import type { WorkflowRepository } from "#modules/workflow/workflow.repository";
+export declare class WorkflowService extends BaseService<{
+    workflow: WorkflowRepository;
+}, never> {
+    read(input: WorkflowReadInputSchema, { user }: {
+        user: User;
+    }): ServerResultAsync<WorkflowReadOutputSchema>;
+    list(input: WorkflowListInputSchema, { user }: {
+        user: User;
+    }): ServerResultAsync<WorkflowListOutputSchema>;
+    added(params: Parameters<WorkflowRepository["added"]>[0]): ServerResultAsync<WorkflowReadOutputSchema>;
+    addedMany(params: Parameters<WorkflowRepository["addedMany"]>[0]): ServerResultAsync<WorkflowReadOutputSchema[]>;
+    started(job: Job): ServerResultAsync<WorkflowReadOutputSchema>;
+    failed(job?: Job, error?: Error): ServerResultAsync<WorkflowReadOutputSchema>;
+    completed(job: Job): ServerResultAsync<WorkflowReadOutputSchema>;
+}
+//# sourceMappingURL=workflow.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.service.d.ts","sourceRoot":"","sources":["../../../../src/modules/workflow/workflow.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EACvB,wBAAwB,EACxB,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,kDAAkD,CAAC;AAC1D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAClC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAChF,qBAAa,eAAgB,SAAQ,WAAW,CAAC;IAAE,QAAQ,EAAE,kBAAkB,CAAA;CAAE,EAAE,KAAK,CAAC;IACjF,IAAI,CACR,KAAK,EAAE,uBAAuB,EAC9B,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,GACvB,iBAAiB,CAAC,wBAAwB,CAAC;IAIxC,IAAI,CACR,KAAK,EAAE,uBAAuB,EAC9B,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,GACvB,iBAAiB,CAAC,wBAAwB,CAAC;IAIxC,KAAK,CACT,MAAM,EAAE,UAAU,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,GACjD,iBAAiB,CAAC,wBAAwB,CAAC;IAIxC,SAAS,CACb,MAAM,EAAE,UAAU,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,GACrD,iBAAiB,CAAC,wBAAwB,EAAE,CAAC;IAI1C,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,iBAAiB,CAAC,wBAAwB,CAAC;IAK9D,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,iBAAiB,CAAC,wBAAwB,CAAC;IAQ7E,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,iBAAiB,CAAC,wBAAwB,CAAC;CAIvE"}

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowService = void 0;
+const base_service_1 = require("#modules/base/base.service");
+class WorkflowService extends base_service_1.BaseService {
+    async read(input, { user }) {
+        return await this.repository.workflow.read({ ...input, userId: user.id });
+    }
+    async list(input, { user }) {
+        return await this.repository.workflow.list({ ...input, userId: user.id });
+    }
+    async added(params) {
+        return this.repository.workflow.added(params);
+    }
+    async addedMany(params) {
+        return this.repository.workflow.addedMany(params);
+    }
+    async started(job) {
+        if (!job.id)
+            return this.error("INTERNAL_SERVER_ERROR");
+        return this.repository.workflow.started({ jobId: job.id });
+    }
+    async failed(job, error) {
+        if (!job?.id)
+            return this.error("INTERNAL_SERVER_ERROR");
+        return this.repository.workflow.failed({
+            jobId: job.id,
+            error: error?.message || "Unknown error",
+        });
+    }
+    async completed(job) {
+        if (!job.id)
+            return this.error("INTERNAL_SERVER_ERROR");
+        return this.repository.workflow.completed({ jobId: job.id, output: job.returnvalue });
+    }
+}
+exports.WorkflowService = WorkflowService;

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

@@ -0,0 +1,93 @@
+import type { WorkflowService } from "#modules/workflow/workflow.service";
+export declare function createWorkflowTRPC(workflowService: WorkflowService): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        session: {
+            id: string;
+            userId: string;
+            updatedAt: Date;
+            createdAt: Date;
+            expiresAt: Date;
+            token: string;
+            ipAddress: string | null;
+            userAgent: string | null;
+            impersonatedBy: string | null;
+            activeOrganizationId: string | null;
+            activeOrganizationRole: string | null;
+            activeTeamId: string | null;
+            activeTeamRole: string | null;
+        };
+        user: {
+            name: string;
+            id: string;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            image: string | null;
+            createdAt: Date;
+            role: string | null;
+            banned: boolean | null;
+            banReason: string | null;
+            banExpires: Date | null;
+            stripeCustomerId: string | null;
+            paymentCustomerId: string | null;
+            paymentPlanTier: string | null;
+            paymentPlanExpiresAt: Date | null;
+            preferences: string | null;
+            metadata: Record<string, unknown>;
+            onboarding: number | null;
+            flags: string | null;
+        };
+    };
+    meta: import("trpc-to-openapi").OpenApiMeta;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    read: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            jobId: string;
+        };
+        output: {
+            id: string;
+            userId: string | null;
+            jobId: string;
+            jobName: string;
+            queueName: string;
+            tags: string[] | null;
+            input: unknown;
+            output: unknown;
+            status: "queued" | "running" | "completed" | "failed";
+            error: string | null;
+            retries: number;
+            finishedAt: Date | null;
+            processedAt: Date | null;
+            createdAt: Date;
+            updatedAt: Date;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    list: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            status?: ("queued" | "running" | "completed" | "failed")[] | undefined;
+            jobName?: string | undefined;
+        };
+        output: {
+            id: string;
+            userId: string | null;
+            jobId: string;
+            jobName: string;
+            queueName: string;
+            tags: string[] | null;
+            input: unknown;
+            output: unknown;
+            status: "queued" | "running" | "completed" | "failed";
+            error: string | null;
+            retries: number;
+            finishedAt: Date | null;
+            processedAt: Date | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+}>>;
+//# sourceMappingURL=workflow.trpc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.trpc.d.ts","sourceRoot":"","sources":["../../../../src/modules/workflow/workflow.trpc.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAG1E,wBAAgB,kBAAkB,CAAC,eAAe,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgBlE"}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkflowTRPC = createWorkflowTRPC;
+const workflow_schema_1 = require("@m5kdev/commons/modules/workflow/workflow.schema");
+const _trpc_1 = require("#trpc");
+function createWorkflowTRPC(workflowService) {
+    return (0, _trpc_1.router)({
+        read: _trpc_1.procedure
+            .input(workflow_schema_1.workflowReadInputSchema)
+            .output(workflow_schema_1.workflowReadOutputSchema)
+            .query(async ({ ctx, input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await workflowService.read(input, ctx));
+        }),
+        list: _trpc_1.procedure
+            .input(workflow_schema_1.workflowListInputSchema)
+            .output(workflow_schema_1.workflowListOutputSchema)
+            .query(async ({ ctx, input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await workflowService.list(input, ctx));
+        }),
+    });
+}

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

@@ -0,0 +1,21 @@
+import type { Job, JobsOptions } from "bullmq";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import type { ServerError } from "#utils/errors";
+export type WorkflowMeta = {
+    queue?: string;
+    userId?: string;
+    tags?: string[];
+    timeout?: number;
+    disablePosthogCapture?: boolean;
+};
+export type WorkflowDataType<Payload> = {
+    payload: Payload;
+    meta: WorkflowMeta;
+};
+export type WorkflowJob<DataType extends WorkflowDataType<any>, ReturnType extends ServerResultAsync<any>, Name extends string> = JobsOptions & {
+    run: (job: Job<DataType, ReturnType, Name>) => ReturnType;
+    onComplete?: (job: Job<DataType, ReturnType, Name>) => ReturnType;
+    onSuccess?: (job: Job<DataType, ReturnType, Name>) => ServerResultAsync<any>;
+    onFailure?: (job: Job<DataType, ReturnType, Name>, error?: ServerError | unknown) => ServerResultAsync<any>;
+};
+//# sourceMappingURL=workflow.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.types.d.ts","sourceRoot":"","sources":["../../../../src/modules/workflow/workflow.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAC/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,gBAAgB,CAAC,OAAO,IAAI;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,YAAY,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,WAAW,CACrB,QAAQ,SAAS,gBAAgB,CAAC,GAAG,CAAC,EACtC,UAAU,SAAS,iBAAiB,CAAC,GAAG,CAAC,EACzC,IAAI,SAAS,MAAM,IACjB,WAAW,GAAG;IAChB,GAAG,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,QAAQ,EAAE,UAAU,EAAE,IAAI,CAAC,KAAK,UAAU,CAAC;IAC1D,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,QAAQ,EAAE,UAAU,EAAE,IAAI,CAAC,KAAK,UAAU,CAAC;IAClE,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,QAAQ,EAAE,UAAU,EAAE,IAAI,CAAC,KAAK,iBAAiB,CAAC,GAAG,CAAC,CAAC;IAC7E,SAAS,CAAC,EAAE,CACV,GAAG,EAAE,GAAG,CAAC,QAAQ,EAAE,UAAU,EAAE,IAAI,CAAC,EACpC,KAAK,CAAC,EAAE,WAAW,GAAG,OAAO,KAC1B,iBAAiB,CAAC,GAAG,CAAC,CAAC;CAC7B,CAAC"}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });