@m5kdev/backend 0.1.0

package/src/modules/utils/getConditionsFromFilters.ts

@@ -0,0 +1,216 @@
+import type { QueryFilters } from "@m5kdev/commons/modules/schemas/query.schema";
+import { and, between, eq, gte, inArray, isNotNull, isNull, like, lte, ne, or } from "drizzle-orm";
+import type { SQLiteTableWithColumns } from "drizzle-orm/sqlite-core";
+import { DateTime } from "luxon";
+import type { ConditionBuilder } from "#modules/base/base.repository";
+
+type ColumnDataType = "string" | "number" | "date" | "boolean" | "enum";
+
+// Helper: Create UTC date boundaries from ISO string
+const getUTCDateBoundaries = (isoString: string) => {
+  const dateTime = DateTime.fromISO(isoString, { zone: "utc" });
+  return {
+    start: dateTime.startOf("day").toJSDate(),
+    end: dateTime.endOf("day").toJSDate(),
+  };
+};
+
+export const getConditionsFromFilters = <T extends SQLiteTableWithColumns<any>>(
+  conditions: ConditionBuilder,
+  filters: QueryFilters | undefined,
+  table: T
+): ConditionBuilder => {
+  if (!filters || filters.length === 0) {
+    return conditions;
+  }
+
+  // Process each filter (maximum one filter per column)
+  for (const filter of filters) {
+    const { columnId, type, method, value, valueTo } = filter;
+
+    // Get the column from the table using columnId
+    const column = (table as any)[columnId];
+    if (!column) {
+      continue; // Skip if column doesn't exist
+    }
+
+    // Handle isEmpty/isNotEmpty methods (work across types, ignore value)
+    if (method === "isEmpty" || method === "isNotEmpty") {
+      switch (type as ColumnDataType) {
+        case "string":
+        case "enum":
+          // isEmpty: IS NULL OR = ''
+          // isNotEmpty: IS NOT NULL AND != ''
+          if (method === "isEmpty") {
+            conditions.push(or(isNull(column), eq(column, "")));
+          } else {
+            conditions.push(and(isNotNull(column), ne(column, "")));
+          }
+          continue;
+        case "number":
+          // isEmpty: IS NULL OR = 0
+          // isNotEmpty: IS NOT NULL AND != 0
+          if (method === "isEmpty") {
+            conditions.push(or(isNull(column), eq(column, 0)));
+          } else {
+            conditions.push(and(isNotNull(column), ne(column, 0)));
+          }
+          continue;
+        case "boolean":
+          // Should not happen per plan, but handle gracefully
+          continue;
+        default:
+          continue;
+      }
+    }
+
+    // Apply filter based on type and method
+    switch (type as ColumnDataType) {
+      case "string":
+        switch (method) {
+          case "contains":
+            if (typeof value === "string") {
+              conditions.push(like(column, `%${value}%`));
+            }
+            break;
+          case "equals":
+            if (typeof value === "string") {
+              conditions.push(eq(column, value));
+            }
+            break;
+          case "starts_with":
+            if (typeof value === "string") {
+              conditions.push(like(column, `${value}%`));
+            }
+            break;
+          case "ends_with":
+            if (typeof value === "string") {
+              conditions.push(like(column, `%${value}`));
+            }
+            break;
+          case "is_null":
+            conditions.push(isNull(column));
+            break;
+          case "is_not_null":
+            conditions.push(isNotNull(column));
+            break;
+        }
+        break;
+
+      case "number":
+        switch (method) {
+          case "equals":
+            if (typeof value === "number") {
+              conditions.push(eq(column, value));
+            }
+            break;
+          case "greater_than":
+            if (typeof value === "number") {
+              conditions.push(gte(column, value));
+            }
+            break;
+          case "less_than":
+            if (typeof value === "number") {
+              conditions.push(lte(column, value));
+            }
+            break;
+          case "is_null":
+            conditions.push(isNull(column));
+            break;
+          case "is_not_null":
+            conditions.push(isNotNull(column));
+            break;
+        }
+        break;
+
+      case "date":
+        if (typeof value !== "string") break;
+
+        switch (method) {
+          case "on": {
+            const { start, end } = getUTCDateBoundaries(value);
+            conditions.push(and(gte(column, start), lte(column, end)));
+            break;
+          }
+          case "between":
+            if (valueTo) {
+              const { start } = getUTCDateBoundaries(value);
+              const { end } = getUTCDateBoundaries(valueTo);
+              conditions.push(between(column, start, end));
+            }
+            break;
+          case "before": {
+            const { end } = getUTCDateBoundaries(value);
+            conditions.push(lte(column, end));
+            break;
+          }
+          case "after": {
+            const { start } = getUTCDateBoundaries(value);
+            conditions.push(gte(column, start));
+            break;
+          }
+          case "intersect": {
+            // Interval overlap: [columnId, endColumnId] intersects with [value, valueTo]
+            // Logic: columnId <= valueTo AND (endColumnId IS NULL OR endColumnId >= value)
+            if (!valueTo || !filter.endColumnId) break;
+
+            const endColumn = (table as any)[filter.endColumnId];
+            if (!endColumn) break;
+
+            const { start } = getUTCDateBoundaries(value);
+            const { end } = getUTCDateBoundaries(valueTo);
+
+            conditions.push(and(lte(column, end), or(isNull(endColumn), gte(endColumn, start))));
+            break;
+          }
+          case "is_null":
+            conditions.push(isNull(column));
+            break;
+          case "is_not_null":
+            conditions.push(isNotNull(column));
+            break;
+        }
+        break;
+
+      case "boolean":
+        switch (method) {
+          case "equals":
+            if (typeof value === "boolean") {
+              conditions.push(eq(column, value));
+            }
+            break;
+          case "is_null":
+            conditions.push(isNull(column));
+            break;
+          case "is_not_null":
+            conditions.push(isNotNull(column));
+            break;
+        }
+
+        break;
+
+      case "enum":
+        switch (method) {
+          case "oneOf":
+            if (Array.isArray(value) && value.length > 0) {
+              conditions.push(inArray(column, value));
+            }
+            break;
+          case "equals":
+            if (typeof value === "string") {
+              conditions.push(eq(column, value));
+            }
+            break;
+          case "is_null":
+            conditions.push(isNull(column));
+            break;
+          case "is_not_null":
+            conditions.push(isNotNull(column));
+            break;
+        }
+        break;
+    }
+  }
+
+  return conditions;
+};

package/src/modules/video/video.service.ts

@@ -0,0 +1,89 @@
+import { closeSync, existsSync, mkdirSync, openSync } from "node:fs";
+import path from "node:path";
+//
+import ffbin from "ffmpeg-ffprobe-static";
+import ffmpeg from "fluent-ffmpeg";
+import { err, ok } from "neverthrow";
+import { v4 as uuidv4 } from "uuid";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseService } from "#modules/base/base.service";
+
+if (!ffbin.ffmpegPath || !ffbin.ffprobePath) {
+  throw new Error("FFmpeg or FFprobe not found");
+}
+
+ffmpeg.setFfmpegPath(ffbin.ffmpegPath);
+ffmpeg.setFfprobePath(ffbin.ffprobePath);
+
+const uploadsDir = path.join(__dirname, "..", "uploads");
+if (!existsSync(uploadsDir)) {
+  mkdirSync(uploadsDir, { recursive: true });
+}
+
+export class VideoService extends BaseService<never, never> {
+  async cut(file: string, start: number, end: number): ServerResultAsync<string> {
+    return this.throwableAsync(async () => {
+      const duration = end - start;
+      const output = path.join(uploadsDir, `${uuidv4()}.mp4`);
+      if (!existsSync(output)) {
+        closeSync(openSync(output, "w"));
+      }
+
+      await new Promise<void>((resolve, reject) => {
+        ffmpeg(file)
+          .seekOutput(start)
+          .videoCodec("libx264")
+          .audioCodec("copy")
+          .outputOptions(["-y", "-movflags +faststart"])
+          .duration(duration)
+          .on("end", () => resolve())
+          .on("error", (e: Error, _stdout: string | null, _stderr: string | null) => reject(e))
+          .save(output);
+      }).catch((error) => err(this.handleUnknownError(error)));
+
+      return ok(output);
+    });
+  }
+
+  async webmToWav(input: string, hz = 48000): ServerResultAsync<string> {
+    return this.throwableAsync(async () => {
+      const output = path.join(uploadsDir, `${uuidv4()}.wav`);
+      if (!existsSync(output)) {
+        closeSync(openSync(output, "w"));
+      }
+      await new Promise<void>((resolve, reject) => {
+        ffmpeg(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) => err(this.handleUnknownError(error)));
+      return ok(output);
+    });
+  }
+
+  async extractAudioMp3(input: string, kbps = 192, streamIndex = 0): ServerResultAsync<string> {
+    return this.throwableAsync(async () => {
+      const output = path.join(uploadsDir, `${uuidv4()}.mp3`);
+      if (!existsSync(output)) {
+        closeSync(openSync(output, "w"));
+      }
+      await new Promise<void>((resolve, reject) => {
+        ffmpeg(input)
+          .outputOptions(["-y", `-map 0:a:${streamIndex}`])
+          .audioCodec("libmp3lame")
+          .audioBitrate(kbps)
+          .on("end", () => resolve())
+          .on("error", reject)
+          .save(output);
+      }).catch((error) => err(this.handleUnknownError(error)));
+
+      return ok(output);
+    });
+  }
+}

package/src/modules/webhook/webhook.constants.ts

@@ -0,0 +1,9 @@
+export const WEBHOOK_STATUS_ENUM = {
+  WAITING: "WAITING",
+  COMPLETED: "COMPLETED",
+  TIMEOUT: "TIMEOUT",
+  ERROR_CALLBACK: "ERROR_CALLBACK",
+  ERROR_DATA: "ERROR_DATA",
+} as const;
+
+export type WebhookStatus = (typeof WEBHOOK_STATUS_ENUM)[keyof typeof WEBHOOK_STATUS_ENUM];

package/src/modules/webhook/webhook.db.ts

@@ -0,0 +1,15 @@
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { v4 as uuidv4 } from "uuid";
+import { WEBHOOK_STATUS_ENUM, type WebhookStatus } from "./webhook.constants";
+
+export const webhook = sqliteTable("webhook", {
+  id: text("id").primaryKey().$default(uuidv4),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .notNull()
+    .$default(() => new Date()),
+  updatedAt: integer("updated_at", { mode: "timestamp" }),
+  timeoutSec: integer("timeout_sec").notNull().default(60),
+  status: text("status").notNull().default(WEBHOOK_STATUS_ENUM.WAITING).$type<WebhookStatus>(),
+  error: text("error"),
+  payload: text("payload"),
+});

package/src/modules/webhook/webhook.dto.ts

@@ -0,0 +1,9 @@
+import type { z } from "zod";
+import { createSelectDTO } from "#modules/base/base.dto";
+import { webhook } from "./webhook.db";
+
+export const webhookSelectDTO = createSelectDTO(webhook);
+
+export const webhookSelectSchema = webhookSelectDTO.schema;
+
+export type WebhookSelectOutput = z.infer<typeof webhookSelectSchema>;

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

@@ -0,0 +1,68 @@
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import { err, ok } from "neverthrow";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseTableRepository } from "#modules/base/base.repository";
+import { WEBHOOK_STATUS_ENUM } from "./webhook.constants";
+import { webhook } from "./webhook.db";
+
+const schema = { webhook };
+type Schema = typeof schema;
+type Orm = LibSQLDatabase<Schema>;
+
+export class WebhookRepository extends BaseTableRepository<Orm, Schema, Record<string, never>, Schema["webhook"]> {
+  async completed(id: string, payload: unknown, tx?: Orm): ServerResultAsync<void> {
+    return this.throwableAsync(async () => {
+      const webhook = await this.findById(id, tx);
+      if (webhook.isErr()) return err(webhook.error);
+      if (!webhook.value) return this.error("NOT_FOUND");
+      await this.update(
+        {
+          id,
+          status: WEBHOOK_STATUS_ENUM.COMPLETED,
+          payload: JSON.stringify(payload),
+        },
+        tx
+      );
+      return ok();
+    });
+  }
+
+  async timeout(id: string, tx?: Orm): ServerResultAsync<void> {
+    return this.throwableAsync(async () => {
+      const webhook = await this.findById(id, tx);
+      if (webhook.isErr()) return err(webhook.error);
+      if (!webhook.value) return this.error("NOT_FOUND");
+      await this.update(
+        {
+          id,
+          status: WEBHOOK_STATUS_ENUM.TIMEOUT,
+          error: `Timeout of ${webhook.value.timeoutSec} seconds reached`,
+        },
+        tx
+      );
+      return ok();
+    });
+  }
+
+  async registerError(
+    id: string,
+    status: "ERROR_CALLBACK" | "ERROR_DATA",
+    error: string,
+    tx?: Orm
+  ): ServerResultAsync<void> {
+    return this.throwableAsync(async () => {
+      const webhook = await this.findById(id, tx);
+      if (webhook.isErr()) return err(webhook.error);
+      if (!webhook.value) return this.error("NOT_FOUND");
+      await this.update(
+        {
+          id,
+          status,
+          error,
+        },
+        tx
+      );
+      return ok();
+    });
+  }
+}

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

@@ -0,0 +1,29 @@
+import bodyParser from "body-parser";
+import { Router } from "express";
+import type { WebhookService } from "./webhook.service";
+
+export function createWebhookRouter(webhookService: WebhookService): Router {
+  const webhookRouter = Router();
+
+  webhookRouter.post("/:id", bodyParser.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/src/modules/webhook/webhook.service.ts

@@ -0,0 +1,78 @@
+import { safeParseJson } from "@m5kdev/commons/utils/json";
+import { err, ok } from "neverthrow";
+import type { ServerResult, ServerResultAsync } from "#modules/base/base.dto";
+import { BaseService } from "#modules/base/base.service";
+import { WEBHOOK_STATUS_ENUM } from "./webhook.constants";
+import type { WebhookRepository } from "./webhook.repository";
+
+export class WebhookService extends BaseService<{ webhook: WebhookRepository }, never> {
+  async completed(id: string, payload: unknown): ServerResultAsync<void> {
+    const result = await this.repository.webhook.completed(id, payload);
+    if (result.isErr()) {
+      await this.repository.webhook.registerError(
+        id,
+        WEBHOOK_STATUS_ENUM.ERROR_DATA,
+        JSON.stringify(result.error)
+      );
+      return this.error("INTERNAL_SERVER_ERROR", "Webhook completed failed", {
+        cause: result.error,
+      });
+    }
+    return ok();
+  }
+
+  async waitForRequest<T>(callback: (url: string) => any, timeoutSec = 60): ServerResultAsync<T> {
+    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_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<ServerResult<T>>((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(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 ? safeParseJson<T>(payload, payload as T) : (payload as T);
+          clearInterval(intervalId);
+          return resolve(ok(data));
+        }
+        if (status !== "WAITING") {
+          clearInterval(intervalId);
+          return reject(this.error("BAD_REQUEST", "Wait for request failed"));
+        }
+      }, 1000);
+    });
+    return promise;
+  }
+}

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

@@ -0,0 +1,29 @@
+import type { WorkflowStatus } from "@m5kdev/commons/modules/workflow/workflow.constants";
+import { integer, sqliteTable as table, text } from "drizzle-orm/sqlite-core";
+import { v4 as uuidv4 } from "uuid";
+import { users } from "#modules/auth/auth.db";
+
+export const workflows = table("workflows", {
+  id: text("id").primaryKey().$default(uuidv4),
+  userId: text("user_id").references(() => users.id, { onDelete: "cascade" }),
+  jobId: text("job_id").unique().notNull(),
+  jobName: text("job_name").notNull(),
+  queueName: text("queue_name").notNull(),
+  timeout: integer("timeout"),
+  tags: text("tags", { mode: "json" })
+    .$default(() => [])
+    .$type<string[]>(),
+  input: text("input", { mode: "json" }),
+  output: text("output", { mode: "json" }),
+  status: text("status").notNull().$type<WorkflowStatus>(),
+  error: text("error"),
+  retries: integer("retries").notNull().default(0),
+  finishedAt: integer("finished_at", { mode: "timestamp" }),
+  processedAt: integer("processed_at", { mode: "timestamp" }),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .notNull()
+    .$default(() => new Date()),
+  updatedAt: integer("updated_at", { mode: "timestamp" })
+    .notNull()
+    .$default(() => new Date()),
+});