@m5kdev/backend 0.1.1 → 0.1.3

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VideoService = void 0;
+const tslib_1 = require("tslib");
+const node_fs_1 = require("node:fs");
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+//
+const ffmpeg_ffprobe_static_1 = tslib_1.__importDefault(require("ffmpeg-ffprobe-static"));
+const fluent_ffmpeg_1 = tslib_1.__importDefault(require("fluent-ffmpeg"));
+const neverthrow_1 = require("neverthrow");
+const uuid_1 = require("uuid");
+const base_service_1 = require("#modules/base/base.service");
+if (!ffmpeg_ffprobe_static_1.default.ffmpegPath || !ffmpeg_ffprobe_static_1.default.ffprobePath) {
+    throw new Error("FFmpeg or FFprobe not found");
+}
+fluent_ffmpeg_1.default.setFfmpegPath(ffmpeg_ffprobe_static_1.default.ffmpegPath);
+fluent_ffmpeg_1.default.setFfprobePath(ffmpeg_ffprobe_static_1.default.ffprobePath);
+const uploadsDir = node_path_1.default.join(__dirname, "..", "uploads");
+if (!(0, node_fs_1.existsSync)(uploadsDir)) {
+    (0, node_fs_1.mkdirSync)(uploadsDir, { recursive: true });
+}
+class VideoService extends base_service_1.BaseService {
+    async cut(file, start, end) {
+        return this.throwableAsync(async () => {
+            const duration = end - start;
+            const output = node_path_1.default.join(uploadsDir, `${(0, uuid_1.v4)()}.mp4`);
+            if (!(0, node_fs_1.existsSync)(output)) {
+                (0, node_fs_1.closeSync)((0, node_fs_1.openSync)(output, "w"));
+            }
+            await new Promise((resolve, reject) => {
+                (0, fluent_ffmpeg_1.default)(file)
+                    .seekOutput(start)
+                    .videoCodec("libx264")
+                    .audioCodec("copy")
+                    .outputOptions(["-y", "-movflags +faststart"])
+                    .duration(duration)
+                    .on("end", () => resolve())
+                    .on("error", (e, _stdout, _stderr) => reject(e))
+                    .save(output);
+            }).catch((error) => (0, neverthrow_1.err)(this.handleUnknownError(error)));
+            return (0, neverthrow_1.ok)(output);
+        });
+    }
+    async webmToWav(input, hz = 48000) {
+        return this.throwableAsync(async () => {
+            const output = node_path_1.default.join(uploadsDir, `${(0, uuid_1.v4)()}.wav`);
+            if (!(0, node_fs_1.existsSync)(output)) {
+                (0, node_fs_1.closeSync)((0, node_fs_1.openSync)(output, "w"));
+            }
+            await new Promise((resolve, reject) => {
+                (0, fluent_ffmpeg_1.default)(input)
+                    .noVideo()
+                    .audioCodec("pcm_s16le") // WAV PCM 16-bit
+                    .audioFrequency(hz) // 48000 or 44100
+                    .audioChannels(2) // down/up-mix as needed
+                    .format("wav")
+                    .outputOptions(["-y"])
+                    .on("end", () => resolve())
+                    .on("error", reject)
+                    .save(output);
+            }).catch((error) => (0, neverthrow_1.err)(this.handleUnknownError(error)));
+            return (0, neverthrow_1.ok)(output);
+        });
+    }
+    async extractAudioMp3(input, kbps = 192, streamIndex = 0) {
+        return this.throwableAsync(async () => {
+            const output = node_path_1.default.join(uploadsDir, `${(0, uuid_1.v4)()}.mp3`);
+            if (!(0, node_fs_1.existsSync)(output)) {
+                (0, node_fs_1.closeSync)((0, node_fs_1.openSync)(output, "w"));
+            }
+            await new Promise((resolve, reject) => {
+                (0, fluent_ffmpeg_1.default)(input)
+                    .outputOptions(["-y", `-map 0:a:${streamIndex}`])
+                    .audioCodec("libmp3lame")
+                    .audioBitrate(kbps)
+                    .on("end", () => resolve())
+                    .on("error", reject)
+                    .save(output);
+            }).catch((error) => (0, neverthrow_1.err)(this.handleUnknownError(error)));
+            return (0, neverthrow_1.ok)(output);
+        });
+    }
+}
+exports.VideoService = VideoService;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEBHOOK_STATUS_ENUM = void 0;
+exports.WEBHOOK_STATUS_ENUM = {
+    WAITING: "WAITING",
+    COMPLETED: "COMPLETED",
+    TIMEOUT: "TIMEOUT",
+    ERROR_CALLBACK: "ERROR_CALLBACK",
+    ERROR_DATA: "ERROR_DATA",
+};

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webhook = void 0;
+const sqlite_core_1 = require("drizzle-orm/sqlite-core");
+const uuid_1 = require("uuid");
+const webhook_constants_1 = require("./webhook.constants");
+exports.webhook = (0, sqlite_core_1.sqliteTable)("webhook", {
+    id: (0, sqlite_core_1.text)("id").primaryKey().$default(uuid_1.v4),
+    createdAt: (0, sqlite_core_1.integer)("created_at", { mode: "timestamp" })
+        .notNull()
+        .$default(() => new Date()),
+    updatedAt: (0, sqlite_core_1.integer)("updated_at", { mode: "timestamp" }),
+    timeoutSec: (0, sqlite_core_1.integer)("timeout_sec").notNull().default(60),
+    status: (0, sqlite_core_1.text)("status").notNull().default(webhook_constants_1.WEBHOOK_STATUS_ENUM.WAITING).$type(),
+    error: (0, sqlite_core_1.text)("error"),
+    payload: (0, sqlite_core_1.text)("payload"),
+});

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webhookSelectSchema = exports.webhookSelectDTO = void 0;
+const base_dto_1 = require("#modules/base/base.dto");
+const webhook_db_1 = require("./webhook.db");
+exports.webhookSelectDTO = (0, base_dto_1.createSelectDTO)(webhook_db_1.webhook);
+exports.webhookSelectSchema = exports.webhookSelectDTO.schema;

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.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.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.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()),
+});

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.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

@@ -4,9 +4,9 @@ export declare function createWorkflowTRPC(workflowService: WorkflowService): im
         session: {
             id: string;
             userId: string;
-            expiresAt: Date;
-            createdAt: Date;
             updatedAt: Date;
+            createdAt: Date;
+            expiresAt: Date;
             token: string;
             ipAddress: string | null;
             userAgent: string | null;
@@ -18,13 +18,12 @@ export declare function createWorkflowTRPC(workflowService: WorkflowService): im
         };
         user: {
             name: string;
-            image: string | null;
             id: string;
-            createdAt: Date;
             updatedAt: Date;
             email: string;
-            metadata: Record<string, unknown>;
             emailVerified: boolean;
+            image: string | null;
+            createdAt: Date;
             role: string | null;
             banned: boolean | null;
             banReason: string | null;
@@ -34,6 +33,7 @@ export declare function createWorkflowTRPC(workflowService: WorkflowService): im
             paymentPlanTier: string | null;
             paymentPlanExpiresAt: Date | null;
             preferences: string | null;
+            metadata: Record<string, unknown>;
             onboarding: number | null;
             flags: string | null;
         };

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.js

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