@m5kdev/backend 0.1.0 → 0.1.2

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

@@ -0,0 +1,191 @@
+import type { TagService } from "#modules/tag/tag.service";
+export declare function createTagTRPC(tagService: TagService): 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<{
+    list: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            page?: number | undefined;
+            limit?: number | undefined;
+            sort?: string | undefined;
+            order?: "asc" | "desc" | undefined;
+            filters?: {
+                columnId: string;
+                type: "string" | "number" | "boolean" | "date" | "enum";
+                method: "contains" | "equals" | "starts_with" | "ends_with" | "greater_than" | "less_than" | "on" | "between" | "before" | "after" | "oneOf" | "intersect" | "isEmpty" | "isNotEmpty" | "is_null" | "is_not_null";
+                value: string | number | boolean | string[];
+                valueTo?: string | undefined;
+                endColumnId?: string | undefined;
+            }[] | undefined;
+            assignableTo?: string | undefined;
+        };
+        output: {
+            rows: {
+                id: string;
+                createdAt: Date;
+                userId: string;
+                name: string;
+                isEnabled: boolean;
+                assignableTo: string[] | null;
+                organizationId?: string | null | undefined;
+                teamId?: string | null | undefined;
+                updatedAt?: Date | null | undefined;
+                deletedAt?: Date | null | undefined;
+                color?: string | null | undefined;
+                type?: string | null | undefined;
+                parentId?: string | null | undefined;
+            }[];
+            total: number;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    listTaggings: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            resourceType: string;
+            resourceIds?: {
+                columnId: string;
+                type: "string" | "number" | "boolean" | "date" | "enum";
+                method: "contains" | "equals" | "starts_with" | "ends_with" | "greater_than" | "less_than" | "on" | "between" | "before" | "after" | "oneOf" | "intersect" | "isEmpty" | "isNotEmpty" | "is_null" | "is_not_null";
+                value: string | number | boolean | string[];
+                valueTo?: string | undefined;
+                endColumnId?: string | undefined;
+            }[] | undefined;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            tagId: string;
+            resourceType: string;
+            resourceId: string;
+        }[];
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    create: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            name: string;
+            color: string;
+            organizationId?: string | undefined;
+            teamId?: string | undefined;
+            assignableTo?: string[] | undefined;
+            resourceType?: string | undefined;
+            resourceId?: string | undefined;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date | null;
+            deletedAt: Date | null;
+            userId: string;
+            organizationId: string | null;
+            teamId: string | null;
+            name: string;
+            color: string | null;
+            type: string | null;
+            isEnabled: boolean;
+            parentId: string | null;
+            assignableTo: string[];
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    update: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+            name?: string | undefined;
+            color?: string | undefined;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date | null;
+            deletedAt: Date | null;
+            userId: string;
+            organizationId: string | null;
+            teamId: string | null;
+            name: string;
+            color: string | null;
+            type: string | null;
+            isEnabled: boolean;
+            parentId: string | null;
+            assignableTo: string[];
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    link: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            tagId: string;
+            resourceType: string;
+            resourceId: string;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            tagId: string;
+            resourceType: string;
+            resourceId: string;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    unlink: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            tagId: string;
+            resourceType: string;
+            resourceId: string;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date | null;
+            deletedAt: Date | null;
+            userId: string;
+            organizationId: string | null;
+            teamId: string | null;
+            name: string;
+            color: string | null;
+            type: string | null;
+            isEnabled: boolean;
+            parentId: string | null;
+            assignableTo: string[];
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+}>>;
+//# sourceMappingURL=tag.trpc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tag.trpc.d.ts","sourceRoot":"","sources":["../../../../src/modules/tag/tag.trpc.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAG3D,wBAAgB,aAAa,CAAC,UAAU,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgDnD"}

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTagTRPC = createTagTRPC;
+const tag_schema_1 = require("@m5kdev/commons/modules/tag/tag.schema");
+const tag_dto_1 = require("#modules/tag/tag.dto");
+const _trpc_1 = require("#trpc");
+function createTagTRPC(tagService) {
+    const tagListInput = tag_schema_1.tagListInputSchema.extend({
+        assignableTo: tag_schema_1.tagListSchema.shape.assignableTo,
+    });
+    return (0, _trpc_1.router)({
+        list: _trpc_1.procedure
+            .input(tagListInput)
+            .output(tag_schema_1.tagListOutputSchema)
+            .query(async ({ input }) => (0, _trpc_1.handleTRPCResult)(await tagService.list(input))),
+        listTaggings: _trpc_1.procedure
+            .input(tag_schema_1.taggingSchema
+            .pick({ resourceType: true })
+            .extend({ resourceIds: tag_schema_1.tagListInputSchema.shape.filters.optional() }))
+            .output(tag_dto_1.taggingsSelectOutput.array())
+            .query(async ({ input }) => (0, _trpc_1.handleTRPCResult)(await tagService.listTaggings(input))),
+        create: _trpc_1.procedure
+            .input(tag_schema_1.tagCreateSchema)
+            .output(tag_dto_1.tagsSelectOutput)
+            .mutation(async ({ ctx, input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await tagService.create(input, ctx));
+        }),
+        update: _trpc_1.procedure
+            .input(tag_schema_1.tagUpdateSchema)
+            .output(tag_dto_1.tagsSelectOutput)
+            .mutation(async ({ ctx, input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await tagService.update(input, ctx));
+        }),
+        link: _trpc_1.procedure
+            .input(tag_schema_1.tagLinkSchema)
+            .output(tag_dto_1.taggingsSelectOutput)
+            .mutation(async ({ ctx, input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await tagService.link(input, ctx));
+        }),
+        unlink: _trpc_1.procedure
+            .input(tag_schema_1.tagLinkSchema)
+            .output(tag_dto_1.tagsSelectOutput)
+            .mutation(async ({ ctx, input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await tagService.unlink(input, ctx));
+        }),
+    });
+}

package/dist/src/modules/utils/applyPagination.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Applies pagination (limit and offset) to a drizzle query builder.
+ * Returns the query builder with pagination applied, or the original query if no limit is specified.
+ * Page is 1-based and only applied if limit is also provided.
+ */
+export declare const applyPagination: <TQuery>(query: TQuery, limit?: number, page?: number) => TQuery;
+//# sourceMappingURL=applyPagination.d.ts.map

package/dist/src/modules/utils/applyPagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyPagination.d.ts","sourceRoot":"","sources":["../../../../src/modules/utils/applyPagination.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,eAAe,GAAI,MAAM,EAAE,OAAO,MAAM,EAAE,QAAQ,MAAM,EAAE,OAAO,MAAM,KAAG,MAMtF,CAAC"}

package/dist/src/modules/utils/applyPagination.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Applies pagination (limit and offset) to a drizzle query builder.
+ * Returns the query builder with pagination applied, or the original query if no limit is specified.
+ * Page is 1-based and only applied if limit is also provided.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPagination = void 0;
+const applyPagination = (query, limit, page) => {
+    if (limit)
+        query.limit(limit);
+    if (page && page > 1 && limit)
+        query.offset((page - 1) * limit);
+    return query;
+};
+exports.applyPagination = applyPagination;

package/dist/src/modules/utils/applySorting.d.ts

@@ -0,0 +1,9 @@
+import type { SQLiteTableWithColumns } from "drizzle-orm/sqlite-core";
+/**
+ * Applies sorting to a drizzle query builder.
+ * Returns the query builder with sorting applied.
+ * If no sort or order is specified, defaults to createdAt descending.
+ * If createdAt column doesn't exist, returns the query unchanged.
+ */
+export declare const applySorting: <TQuery, TTable extends SQLiteTableWithColumns<any>>(query: TQuery, table: TTable, sort?: string, order?: "asc" | "desc") => TQuery;
+//# sourceMappingURL=applySorting.d.ts.map

package/dist/src/modules/utils/applySorting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applySorting.d.ts","sourceRoot":"","sources":["../../../../src/modules/utils/applySorting.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAEtE;;;;;GAKG;AAEH,eAAO,MAAM,YAAY,GAAI,MAAM,EAAE,MAAM,SAAS,sBAAsB,CAAC,GAAG,CAAC,EAC7E,OAAO,MAAM,EACb,OAAO,MAAM,EACb,OAAO,MAAM,EACb,QAAQ,KAAK,GAAG,MAAM,KACrB,MAKF,CAAC"}

package/dist/src/modules/utils/applySorting.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applySorting = void 0;
+const drizzle_orm_1 = require("drizzle-orm");
+/**
+ * Applies sorting to a drizzle query builder.
+ * Returns the query builder with sorting applied.
+ * If no sort or order is specified, defaults to createdAt descending.
+ * If createdAt column doesn't exist, returns the query unchanged.
+ */
+const applySorting = (query, table, sort, order) => {
+    const column = sort ? table[sort] : table.createdAt || table.id;
+    if (!column)
+        throw new Error(`Column ${sort} not found in table ${table.name}`);
+    query.orderBy(order === "asc" ? (0, drizzle_orm_1.asc)(column) : (0, drizzle_orm_1.desc)(column));
+    return query;
+};
+exports.applySorting = applySorting;

package/dist/src/modules/utils/getConditionsFromFilters.d.ts

@@ -0,0 +1,5 @@
+import type { QueryFilters } from "@m5kdev/commons/modules/schemas/query.schema";
+import type { SQLiteTableWithColumns } from "drizzle-orm/sqlite-core";
+import type { ConditionBuilder } from "#modules/base/base.repository";
+export declare const getConditionsFromFilters: <T extends SQLiteTableWithColumns<any>>(conditions: ConditionBuilder, filters: QueryFilters | undefined, table: T) => ConditionBuilder;
+//# sourceMappingURL=getConditionsFromFilters.d.ts.map

package/dist/src/modules/utils/getConditionsFromFilters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getConditionsFromFilters.d.ts","sourceRoot":"","sources":["../../../../src/modules/utils/getConditionsFromFilters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8CAA8C,CAAC;AAEjF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAEtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAatE,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,sBAAsB,CAAC,GAAG,CAAC,EAC5E,YAAY,gBAAgB,EAC5B,SAAS,YAAY,GAAG,SAAS,EACjC,OAAO,CAAC,KACP,gBAkMF,CAAC"}

package/dist/src/modules/utils/getConditionsFromFilters.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConditionsFromFilters = void 0;
+const drizzle_orm_1 = require("drizzle-orm");
+const luxon_1 = require("luxon");
+// Helper: Create UTC date boundaries from ISO string
+const getUTCDateBoundaries = (isoString) => {
+    const dateTime = luxon_1.DateTime.fromISO(isoString, { zone: "utc" });
+    return {
+        start: dateTime.startOf("day").toJSDate(),
+        end: dateTime.endOf("day").toJSDate(),
+    };
+};
+const getConditionsFromFilters = (conditions, filters, table) => {
+    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[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) {
+                case "string":
+                case "enum":
+                    // isEmpty: IS NULL OR = ''
+                    // isNotEmpty: IS NOT NULL AND != ''
+                    if (method === "isEmpty") {
+                        conditions.push((0, drizzle_orm_1.or)((0, drizzle_orm_1.isNull)(column), (0, drizzle_orm_1.eq)(column, "")));
+                    }
+                    else {
+                        conditions.push((0, drizzle_orm_1.and)((0, drizzle_orm_1.isNotNull)(column), (0, drizzle_orm_1.ne)(column, "")));
+                    }
+                    continue;
+                case "number":
+                    // isEmpty: IS NULL OR = 0
+                    // isNotEmpty: IS NOT NULL AND != 0
+                    if (method === "isEmpty") {
+                        conditions.push((0, drizzle_orm_1.or)((0, drizzle_orm_1.isNull)(column), (0, drizzle_orm_1.eq)(column, 0)));
+                    }
+                    else {
+                        conditions.push((0, drizzle_orm_1.and)((0, drizzle_orm_1.isNotNull)(column), (0, drizzle_orm_1.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) {
+            case "string":
+                switch (method) {
+                    case "contains":
+                        if (typeof value === "string") {
+                            conditions.push((0, drizzle_orm_1.like)(column, `%${value}%`));
+                        }
+                        break;
+                    case "equals":
+                        if (typeof value === "string") {
+                            conditions.push((0, drizzle_orm_1.eq)(column, value));
+                        }
+                        break;
+                    case "starts_with":
+                        if (typeof value === "string") {
+                            conditions.push((0, drizzle_orm_1.like)(column, `${value}%`));
+                        }
+                        break;
+                    case "ends_with":
+                        if (typeof value === "string") {
+                            conditions.push((0, drizzle_orm_1.like)(column, `%${value}`));
+                        }
+                        break;
+                    case "is_null":
+                        conditions.push((0, drizzle_orm_1.isNull)(column));
+                        break;
+                    case "is_not_null":
+                        conditions.push((0, drizzle_orm_1.isNotNull)(column));
+                        break;
+                }
+                break;
+            case "number":
+                switch (method) {
+                    case "equals":
+                        if (typeof value === "number") {
+                            conditions.push((0, drizzle_orm_1.eq)(column, value));
+                        }
+                        break;
+                    case "greater_than":
+                        if (typeof value === "number") {
+                            conditions.push((0, drizzle_orm_1.gte)(column, value));
+                        }
+                        break;
+                    case "less_than":
+                        if (typeof value === "number") {
+                            conditions.push((0, drizzle_orm_1.lte)(column, value));
+                        }
+                        break;
+                    case "is_null":
+                        conditions.push((0, drizzle_orm_1.isNull)(column));
+                        break;
+                    case "is_not_null":
+                        conditions.push((0, drizzle_orm_1.isNotNull)(column));
+                        break;
+                }
+                break;
+            case "date":
+                if (typeof value !== "string")
+                    break;
+                switch (method) {
+                    case "on": {
+                        const { start, end } = getUTCDateBoundaries(value);
+                        conditions.push((0, drizzle_orm_1.and)((0, drizzle_orm_1.gte)(column, start), (0, drizzle_orm_1.lte)(column, end)));
+                        break;
+                    }
+                    case "between":
+                        if (valueTo) {
+                            const { start } = getUTCDateBoundaries(value);
+                            const { end } = getUTCDateBoundaries(valueTo);
+                            conditions.push((0, drizzle_orm_1.between)(column, start, end));
+                        }
+                        break;
+                    case "before": {
+                        const { end } = getUTCDateBoundaries(value);
+                        conditions.push((0, drizzle_orm_1.lte)(column, end));
+                        break;
+                    }
+                    case "after": {
+                        const { start } = getUTCDateBoundaries(value);
+                        conditions.push((0, drizzle_orm_1.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[filter.endColumnId];
+                        if (!endColumn)
+                            break;
+                        const { start } = getUTCDateBoundaries(value);
+                        const { end } = getUTCDateBoundaries(valueTo);
+                        conditions.push((0, drizzle_orm_1.and)((0, drizzle_orm_1.lte)(column, end), (0, drizzle_orm_1.or)((0, drizzle_orm_1.isNull)(endColumn), (0, drizzle_orm_1.gte)(endColumn, start))));
+                        break;
+                    }
+                    case "is_null":
+                        conditions.push((0, drizzle_orm_1.isNull)(column));
+                        break;
+                    case "is_not_null":
+                        conditions.push((0, drizzle_orm_1.isNotNull)(column));
+                        break;
+                }
+                break;
+            case "boolean":
+                switch (method) {
+                    case "equals":
+                        if (typeof value === "boolean") {
+                            conditions.push((0, drizzle_orm_1.eq)(column, value));
+                        }
+                        break;
+                    case "is_null":
+                        conditions.push((0, drizzle_orm_1.isNull)(column));
+                        break;
+                    case "is_not_null":
+                        conditions.push((0, drizzle_orm_1.isNotNull)(column));
+                        break;
+                }
+                break;
+            case "enum":
+                switch (method) {
+                    case "oneOf":
+                        if (Array.isArray(value) && value.length > 0) {
+                            conditions.push((0, drizzle_orm_1.inArray)(column, value));
+                        }
+                        break;
+                    case "equals":
+                        if (typeof value === "string") {
+                            conditions.push((0, drizzle_orm_1.eq)(column, value));
+                        }
+                        break;
+                    case "is_null":
+                        conditions.push((0, drizzle_orm_1.isNull)(column));
+                        break;
+                    case "is_not_null":
+                        conditions.push((0, drizzle_orm_1.isNotNull)(column));
+                        break;
+                }
+                break;
+        }
+    }
+    return conditions;
+};
+exports.getConditionsFromFilters = getConditionsFromFilters;

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

@@ -0,0 +1,8 @@
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseService } from "#modules/base/base.service";
+export declare class VideoService extends BaseService<never, never> {
+    cut(file: string, start: number, end: number): ServerResultAsync<string>;
+    webmToWav(input: string, hz?: number): ServerResultAsync<string>;
+    extractAudioMp3(input: string, kbps?: number, streamIndex?: number): ServerResultAsync<string>;
+}
+//# sourceMappingURL=video.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"video.service.d.ts","sourceRoot":"","sources":["../../../../src/modules/video/video.service.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAczD,qBAAa,YAAa,SAAQ,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC;IACnD,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAAC,MAAM,CAAC;IAwBxE,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAQ,GAAG,iBAAiB,CAAC,MAAM,CAAC;IAsB/D,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,SAAM,EAAE,WAAW,SAAI,GAAG,iBAAiB,CAAC,MAAM,CAAC;CAmB7F"}

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

@@ -0,0 +1,9 @@
+export declare const WEBHOOK_STATUS_ENUM: {
+    readonly WAITING: "WAITING";
+    readonly COMPLETED: "COMPLETED";
+    readonly TIMEOUT: "TIMEOUT";
+    readonly ERROR_CALLBACK: "ERROR_CALLBACK";
+    readonly ERROR_DATA: "ERROR_DATA";
+};
+export type WebhookStatus = (typeof WEBHOOK_STATUS_ENUM)[keyof typeof WEBHOOK_STATUS_ENUM];
+//# sourceMappingURL=webhook.constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webhook.constants.d.ts","sourceRoot":"","sources":["../../../../src/modules/webhook/webhook.constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB;;;;;;CAMtB,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAC"}

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",
+};