@m5kdev/backend 0.1.4 → 0.2.0

package/src/modules/utils/getConditionsFromFilters.ts

@@ -1,216 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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()),
-});