@m5kdev/backend 0.1.1 → 0.1.2

package/dist/src/modules/file/file.router.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadRouter = void 0;
+const tslib_1 = require("tslib");
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const file_constants_1 = require("@m5kdev/commons/modules/file/file.constants");
+const body_parser_1 = tslib_1.__importDefault(require("body-parser"));
+const express_1 = tslib_1.__importDefault(require("express"));
+const multer_1 = tslib_1.__importDefault(require("multer"));
+const uuid_1 = require("uuid");
+const file_repository_1 = require("#modules/file/file.repository");
+const file_service_1 = require("#modules/file/file.service");
+const fileRepository = new file_repository_1.FileRepository();
+const fileService = new file_service_1.FileService({ file: fileRepository });
+function validateMimeType(type, file) {
+    return file_constants_1.fileTypes[type]?.mimetypes.includes(file.mimetype);
+}
+function getFileExtension(file) {
+    return file.originalname.split(".").pop();
+}
+const storage = multer_1.default.diskStorage({
+    destination: (_req, _file, cb) => {
+        cb(null, node_path_1.default.join(__dirname, "..", "uploads"));
+    },
+    filename: (_req, file, cb) => {
+        cb(null, `${(0, uuid_1.v4)()}.${getFileExtension(file)}`);
+    },
+});
+const fileFilter = (req, file, cb) => {
+    const { type } = req.params;
+    if (type && validateMimeType(type, file)) {
+        cb(null, true);
+    }
+    else {
+        cb(new Error("Invalid file type"));
+    }
+};
+const upload = (0, multer_1.default)({ storage, fileFilter });
+const uploadRouter = express_1.default.Router();
+exports.uploadRouter = uploadRouter;
+uploadRouter.post("/file/:type", upload.single("file"), (req, res) => {
+    const { file } = req;
+    if (!file) {
+        return res.status(400).json({ error: "No file uploaded" });
+    }
+    return res.json({
+        url: `${process.env.VITE_SERVER_URL}/upload/file/${file.filename}`,
+        mimetype: file.mimetype,
+        size: file.size,
+    });
+});
+uploadRouter.get("/file/:filename", (req, res) => {
+    res.sendFile(node_path_1.default.join(__dirname, "..", "uploads", req.params.filename));
+});
+uploadRouter.get("/files/:path", async (req, res) => {
+    try {
+        const url = await fileService.getS3DownloadUrl(req.params.path);
+        if (url.isErr()) {
+            console.error(url.error);
+            return res.status(500).json({ error: url.error.message });
+        }
+        return res.json({ url: url.value });
+    }
+    catch (err) {
+        console.error(err);
+        return res.status(500).json({ error: err.message || "Failed to generate presigned URL" });
+    }
+});
+uploadRouter.post("/s3-presigned-url", body_parser_1.default.json(), async (req, res) => {
+    const { filename, filetype } = req.body;
+    if (!filename || !filetype) {
+        return res.status(400).json({ error: "Missing filename or filetype" });
+    }
+    try {
+        const url = await fileService.getS3UploadUrl(filename, filetype);
+        if (url.isErr()) {
+            return res.status(500).json({ error: url.error.message });
+        }
+        return res.json({ url: url.value });
+    }
+    catch (err) {
+        console.error(err);
+        return res.status(500).json({ error: err.message || "Failed to generate presigned URL" });
+    }
+});
+uploadRouter.delete("/files/:path(*)", async (req, res) => {
+    try {
+        const result = await fileService.deleteS3Object(req.params.path);
+        if (result.isErr()) {
+            console.error(result.error);
+            return res.status(500).json({ error: result.error.message });
+        }
+        return res.json({ success: true });
+    }
+    catch (err) {
+        console.error(err);
+        return res.status(500).json({ error: err.message || "Failed to delete S3 object" });
+    }
+});

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

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileService = void 0;
+const tslib_1 = require("tslib");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = tslib_1.__importStar(require("node:path"));
+const node_stream_1 = require("node:stream");
+const promises_2 = require("node:stream/promises");
+const file_constants_1 = require("@m5kdev/commons/modules/file/file.constants");
+const neverthrow_1 = require("neverthrow");
+const uuid_1 = require("uuid");
+const base_service_1 = require("#modules/base/base.service");
+class FileService extends base_service_1.BaseService {
+    isS3Path(path) {
+        return path.startsWith("s3::");
+    }
+    parseS3Path(S3Path) {
+        if (!this.isS3Path(S3Path)) {
+            return this.error("BAD_REQUEST", "Invalid S3 path");
+        }
+        const [bucket, path] = S3Path.split("s3::")[1].split("//");
+        return (0, neverthrow_1.ok)({ bucket, path });
+    }
+    wrapS3Path(path, bucket) {
+        return `s3::${bucket}//${path}`;
+    }
+    getS3UploadUrl(filename, filetype, expiresIn = 60 * 5) {
+        return this.repository.file.getS3UploadUrl(filename, filetype, expiresIn);
+    }
+    getS3DownloadUrl(path, expiresIn = 60 * 5) {
+        return this.repository.file.getS3DownloadUrl(path, expiresIn);
+    }
+    getS3Object(path) {
+        return this.repository.file.getS3Object(path);
+    }
+    deleteS3Object(path) {
+        return this.repository.file.deleteS3Object(path);
+    }
+    async uploadFileToS3(localPath, returnDownloadUrl = false) {
+        return this.throwableAsync(async () => {
+            const extension = localPath.split(".").pop()?.toLowerCase();
+            const filename = `${(0, uuid_1.v4)()}${extension ? `.${extension}` : ""}`;
+            const mimeByExt = {
+                jpg: "image/jpeg",
+                jpeg: "image/jpeg",
+                png: "image/png",
+                webp: "image/webp",
+                mp4: "video/mp4",
+                mov: "video/mov",
+                avi: "video/avi",
+                mkv: "video/mkv",
+                webm: "video/webm",
+                mp3: "audio/mp3",
+                wav: "audio/wav",
+                m4a: "audio/m4a",
+            };
+            const filetype = (extension && mimeByExt[extension]) || "application/octet-stream";
+            const presigned = await this.getS3UploadUrl(filename, filetype);
+            if (presigned.isErr())
+                return (0, neverthrow_1.err)(presigned.error);
+            const file = await (0, promises_1.readFile)(localPath);
+            const res = await fetch(presigned.value, {
+                method: "PUT",
+                body: file,
+                headers: { "Content-Type": filetype },
+            });
+            if (!res.ok) {
+                return this.error("INTERNAL_SERVER_ERROR", `Failed to upload to S3: ${res.status}`);
+            }
+            if (returnDownloadUrl) {
+                const downloadUrl = await this.getS3DownloadUrl(filename);
+                if (downloadUrl.isErr())
+                    return (0, neverthrow_1.err)(downloadUrl.error);
+                return (0, neverthrow_1.ok)(downloadUrl.value);
+            }
+            return (0, neverthrow_1.ok)(filename);
+        });
+    }
+    async downloadS3ToFile(s3Path) {
+        return this.throwableAsync(async () => {
+            const extension = s3Path.split(".").pop();
+            const destinationPath = node_path_1.default.join((0, node_os_1.tmpdir)(), "s3-downloads", `${(0, uuid_1.v4)()}${extension ? `.${extension}` : ""}`);
+            const result = await this.repository.file.getS3Object(s3Path);
+            if (result.isErr())
+                return (0, neverthrow_1.err)(result.error);
+            const body = result.value.Body;
+            if (!body)
+                return this.error("NOT_FOUND", "S3 object body is empty");
+            await (0, promises_1.mkdir)((0, node_path_1.dirname)(destinationPath), { recursive: true });
+            // AWS SDK v3 SdkStream has transformToByteArray method - use it for reliable handling
+            if (typeof body === "object" &&
+                "transformToByteArray" in body &&
+                typeof body.transformToByteArray === "function") {
+                const bytes = await body.transformToByteArray();
+                await (0, promises_1.writeFile)(destinationPath, bytes);
+                return (0, neverthrow_1.ok)(destinationPath);
+            }
+            // Fallback: try streaming approaches
+            const writeStream = (0, node_fs_1.createWriteStream)(destinationPath);
+            let input = null;
+            const unknownBody = body;
+            if (typeof unknownBody === "object" &&
+                unknownBody !== null &&
+                "pipe" in unknownBody &&
+                typeof unknownBody.pipe === "function") {
+                input = unknownBody;
+            }
+            else if (typeof unknownBody === "object" &&
+                unknownBody !== null &&
+                "getReader" in unknownBody &&
+                typeof unknownBody.getReader === "function") {
+                input = node_stream_1.Readable.fromWeb(unknownBody);
+            }
+            else if (typeof unknownBody === "object" &&
+                unknownBody !== null &&
+                "stream" in unknownBody &&
+                typeof unknownBody.stream === "function") {
+                input = node_stream_1.Readable.fromWeb(unknownBody.stream());
+            }
+            if (input) {
+                await (0, promises_2.pipeline)(input, writeStream);
+                return (0, neverthrow_1.ok)(destinationPath);
+            }
+            if (typeof unknownBody === "object" &&
+                unknownBody !== null &&
+                "arrayBuffer" in unknownBody &&
+                typeof unknownBody.arrayBuffer === "function") {
+                const buffer = Buffer.from(await unknownBody.arrayBuffer());
+                await (0, promises_2.pipeline)(node_stream_1.Readable.from(buffer), writeStream);
+                return (0, neverthrow_1.ok)(destinationPath);
+            }
+            return this.error("INTERNAL_SERVER_ERROR", "Unsupported S3 body type");
+        });
+    }
+    getFileType(path) {
+        // determine the type of the file
+        const extension = path.split(".").pop();
+        if (!extension)
+            return undefined;
+        for (const [key, value] of Object.entries(file_constants_1.fileTypes)) {
+            if (value.extensions.includes(extension)) {
+                return { fileType: key, extension };
+            }
+        }
+        return undefined;
+    }
+}
+exports.FileService = FileService;

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recurrenceRules = exports.recurrence = 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.recurrence = (0, sqlite_core_1.sqliteTable)("recurrence", {
+    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" }),
+    organizationId: (0, sqlite_core_1.text)("organization_id").references(() => auth_db_1.organizations.id, {
+        onDelete: "cascade",
+    }),
+    teamId: (0, sqlite_core_1.text)("team_id").references(() => auth_db_1.teams.id, { onDelete: "cascade" }),
+    name: (0, sqlite_core_1.text)("name"),
+    kind: (0, sqlite_core_1.text)("kind"),
+    enabled: (0, sqlite_core_1.integer)("enabled", { mode: "boolean" }).notNull().default(true),
+    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()),
+    metadata: (0, sqlite_core_1.text)("metadata", { mode: "json" }).$type(),
+});
+exports.recurrenceRules = (0, sqlite_core_1.sqliteTable)("recurrence_rules", {
+    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" })
+        .notNull()
+        .$default(() => new Date()),
+    recurrenceId: (0, sqlite_core_1.text)("recurrence_id").references(() => exports.recurrence.id, {
+        onDelete: "cascade",
+    }),
+    // Required: frequency
+    freq: (0, sqlite_core_1.integer)("freq").notNull(),
+    // Start date; base for recurrence and source for missing instance params
+    dtstart: (0, sqlite_core_1.integer)("dtstart", { mode: "timestamp" }),
+    // Interval between each freq iteration (default 1)
+    interval: (0, sqlite_core_1.integer)("interval").notNull().default(1),
+    // Week start: MO, TU, WE, ... or integer 0–6
+    wkst: (0, sqlite_core_1.integer)("wkst"),
+    // How many occurrences to generate
+    count: (0, sqlite_core_1.integer)("count"),
+    // Last occurrence date (inclusive)
+    until: (0, sqlite_core_1.integer)("until", { mode: "timestamp" }),
+    // IANA timezone string (Intl API)
+    tzid: (0, sqlite_core_1.text)("tzid"),
+    // BYSETPOS: occurrence number(s) in the frequency period (e.g. -1 = last)
+    bysetpos: (0, sqlite_core_1.text)("bysetpos", { mode: "json" }).$type(),
+    // BYMONTH: month(s) 1–12
+    bymonth: (0, sqlite_core_1.text)("bymonth", { mode: "json" }).$type(),
+    // BYMONTHDAY: day(s) of month
+    bymonthday: (0, sqlite_core_1.text)("bymonthday", { mode: "json" }).$type(),
+    // BYYEARDAY: day(s) of year
+    byyearday: (0, sqlite_core_1.text)("byyearday", { mode: "json" }).$type(),
+    // BYWEEKNO: week number(s) (ISO8601)
+    byweekno: (0, sqlite_core_1.text)("byweekno", { mode: "json" }).$type(),
+    // BYWEEKDAY: weekday(s) 0–6, or nth e.g. { weekday: 4, n: 1 } for first Friday
+    byweekday: (0, sqlite_core_1.text)("byweekday", { mode: "json" }).$type(),
+    // BYHOUR, BYMINUTE, BYSECOND
+    byhour: (0, sqlite_core_1.text)("byhour", { mode: "json" }).$type(),
+    byminute: (0, sqlite_core_1.text)("byminute", { mode: "json" }).$type(),
+    bysecond: (0, sqlite_core_1.text)("bysecond", { mode: "json" }).$type(),
+});

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecurrenceRulesRepository = exports.RecurrenceRepository = void 0;
+const tslib_1 = require("tslib");
+const neverthrow_1 = require("neverthrow");
+const base_repository_1 = require("#modules/base/base.repository");
+const recurrence = tslib_1.__importStar(require("#modules/recurrence/recurrence.db"));
+const schema = { ...recurrence };
+class RecurrenceRepository extends base_repository_1.BaseTableRepository {
+    async createWithRules(recurrenceData, rulesData, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            const result = await db.transaction(async (trx) => {
+                const [createdRecurrence] = await trx
+                    .insert(this.table)
+                    .values(recurrenceData)
+                    .returning();
+                if (!createdRecurrence)
+                    throw new Error("Failed to create recurrence");
+                const rulesWithRecurrenceId = rulesData.map((rule) => ({
+                    ...rule,
+                    recurrenceId: createdRecurrence.id,
+                }));
+                const insertedRules = rulesWithRecurrenceId.length > 0
+                    ? await trx
+                        .insert(this.schema.recurrenceRules)
+                        .values(rulesWithRecurrenceId)
+                        .returning()
+                    : [];
+                return (0, neverthrow_1.ok)({ recurrence: createdRecurrence, rules: insertedRules });
+            });
+            return result;
+        });
+    }
+}
+exports.RecurrenceRepository = RecurrenceRepository;
+class RecurrenceRulesRepository extends base_repository_1.BaseTableRepository {
+}
+exports.RecurrenceRulesRepository = RecurrenceRulesRepository;

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecurrenceService = void 0;
+const neverthrow_1 = require("neverthrow");
+const base_service_1 = require("#modules/base/base.service");
+const RECURRENCE_RULE_INSERT_KEYS = [
+    "freq",
+    "dtstart",
+    "interval",
+    "wkst",
+    "count",
+    "until",
+    "tzid",
+    "bysetpos",
+    "bymonth",
+    "bymonthday",
+    "byyearday",
+    "byweekno",
+    "byweekday",
+    "byhour",
+    "byminute",
+    "bysecond",
+];
+function mapRuleToInsert(rule) {
+    const out = {};
+    for (const key of RECURRENCE_RULE_INSERT_KEYS) {
+        if (key in rule && rule[key] !== undefined) {
+            out[key] = rule[key];
+        }
+    }
+    return out;
+}
+class RecurrenceService extends base_service_1.BaseService {
+    async create(data, ctx) {
+        const recurrenceData = {
+            name: data.name,
+            kind: data.kind,
+            enabled: data.enabled,
+            metadata: data.metadata ?? null,
+            userId: ctx.user?.id ?? null,
+            organizationId: ctx.session.activeOrganizationId ?? null,
+            teamId: ctx.session.activeTeamId ?? null,
+        };
+        const rulesData = data.recurrenceRules.map(mapRuleToInsert);
+        return this.repository.recurrence.createWithRules(recurrenceData, rulesData);
+    }
+    async list(query, ctx) {
+        const queryWithUser = ctx?.user ? this.addUserFilter(ctx.user.id, query, "userId") : query;
+        return this.repository.recurrence.queryList(queryWithUser);
+    }
+    async findById(id) {
+        const result = await this.repository.recurrence.findById(id);
+        if (result.isErr())
+            return (0, neverthrow_1.err)(result.error);
+        return (0, neverthrow_1.ok)(result.value ?? null);
+    }
+    async update(data) {
+        return this.repository.recurrence.update(data);
+    }
+    async updateRule(data) {
+        return this.repository.recurrenceRules.update(data);
+    }
+    async delete(data) {
+        return this.repository.recurrence.deleteById(data.id);
+    }
+    async deleteRule(data) {
+        return this.repository.recurrenceRules.deleteById(data.id);
+    }
+}
+exports.RecurrenceService = RecurrenceService;

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

@@ -4,9 +4,9 @@ export declare function createRecurrenceTRPC(recurrenceService: RecurrenceServic
         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 createRecurrenceTRPC(recurrenceService: RecurrenceServic
         };
         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 createRecurrenceTRPC(recurrenceService: RecurrenceServic
             paymentPlanTier: string | null;
             paymentPlanExpiresAt: Date | null;
             preferences: string | null;
+            metadata: Record<string, unknown>;
             onboarding: number | null;
             flags: string | null;
         };
@@ -82,11 +82,6 @@ export declare function createRecurrenceTRPC(recurrenceService: RecurrenceServic
             recurrenceRules: {
                 interval: number;
                 freq: number;
-                count?: number | null | undefined;
-                dtstart?: Date | null | undefined;
-                wkst?: number | null | undefined;
-                until?: Date | null | undefined;
-                tzid?: string | null | undefined;
                 bysetpos?: number | number[] | null | undefined;
                 bymonth?: number | number[] | null | undefined;
                 bymonthday?: number | number[] | null | undefined;
@@ -96,6 +91,11 @@ export declare function createRecurrenceTRPC(recurrenceService: RecurrenceServic
                 byhour?: number | number[] | null | undefined;
                 byminute?: number | number[] | null | undefined;
                 bysecond?: number | number[] | null | undefined;
+                dtstart?: Date | null | undefined;
+                wkst?: number | null | undefined;
+                count?: number | null | undefined;
+                until?: Date | null | undefined;
+                tzid?: string | null | undefined;
             }[];
             metadata?: Record<string, unknown> | null | undefined;
         };
@@ -182,11 +182,6 @@ export declare function createRecurrenceTRPC(recurrenceService: RecurrenceServic
             id: string;
             interval: number;
             freq: number;
-            count?: number | null | undefined;
-            dtstart?: Date | null | undefined;
-            wkst?: number | null | undefined;
-            until?: Date | null | undefined;
-            tzid?: string | null | undefined;
             bysetpos?: number | number[] | null | undefined;
             bymonth?: number | number[] | null | undefined;
             bymonthday?: number | number[] | null | undefined;
@@ -196,6 +191,11 @@ export declare function createRecurrenceTRPC(recurrenceService: RecurrenceServic
             byhour?: number | number[] | null | undefined;
             byminute?: number | number[] | null | undefined;
             bysecond?: number | number[] | null | undefined;
+            dtstart?: Date | null | undefined;
+            wkst?: number | null | undefined;
+            count?: number | null | undefined;
+            until?: Date | null | undefined;
+            tzid?: string | null | undefined;
         };
         output: {
             id: string;

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRecurrenceTRPC = createRecurrenceTRPC;
+const recurrence_schema_1 = require("@m5kdev/commons/modules/recurrence/recurrence.schema");
+const query_schema_1 = require("@m5kdev/commons/modules/schemas/query.schema");
+const zod_1 = require("zod");
+const _trpc_1 = require("#trpc");
+const createRecurrenceOutputSchema = zod_1.z.object({
+    recurrence: recurrence_schema_1.recurrenceSchema,
+    rules: zod_1.z.array(recurrence_schema_1.recurrenceRulesSchema),
+});
+const listRecurrenceOutputSchema = zod_1.z.object({
+    rows: zod_1.z.array(recurrence_schema_1.recurrenceSchema),
+    total: zod_1.z.number(),
+});
+const updateRecurrenceInputSchema = recurrence_schema_1.updateRecurrenceSchema.extend({
+    id: zod_1.z.string(),
+});
+const deleteRecurrenceOutputSchema = zod_1.z.object({ id: zod_1.z.string() });
+function createRecurrenceTRPC(recurrenceService) {
+    return (0, _trpc_1.router)({
+        list: _trpc_1.procedure
+            .input(query_schema_1.querySchema.optional())
+            .output(listRecurrenceOutputSchema)
+            .query(async ({ ctx, input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await recurrenceService.list(input, ctx));
+        }),
+        create: _trpc_1.procedure
+            .input(recurrence_schema_1.createRecurrenceSchema)
+            .output(createRecurrenceOutputSchema)
+            .mutation(async ({ ctx, input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await recurrenceService.create(input, ctx));
+        }),
+        findById: _trpc_1.procedure
+            .input(zod_1.z.object({ id: zod_1.z.string() }))
+            .output(recurrence_schema_1.recurrenceSchema.nullable())
+            .query(async ({ input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await recurrenceService.findById(input.id));
+        }),
+        update: _trpc_1.procedure
+            .input(updateRecurrenceInputSchema)
+            .output(recurrence_schema_1.recurrenceSchema)
+            .mutation(async ({ input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await recurrenceService.update(input));
+        }),
+        updateRule: _trpc_1.procedure
+            .input(recurrence_schema_1.updateRecurrenceRulesSchema)
+            .output(recurrence_schema_1.recurrenceRulesSchema)
+            .mutation(async ({ input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await recurrenceService.updateRule(input));
+        }),
+        delete: _trpc_1.procedure
+            .input(recurrence_schema_1.deleteRecurrenceSchema)
+            .output(deleteRecurrenceOutputSchema)
+            .mutation(async ({ input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await recurrenceService.delete(input));
+        }),
+        deleteRule: _trpc_1.procedure
+            .input(recurrence_schema_1.deleteRecurrenceRulesSchema)
+            .output(deleteRecurrenceOutputSchema)
+            .mutation(async ({ input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await recurrenceService.deleteRule(input));
+        }),
+    });
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.socialPostOutputSchema = exports.socialPostInputSchema = exports.socialMediaInputSchema = void 0;
+const zod_1 = require("zod");
+exports.socialMediaInputSchema = zod_1.z.object({
+    s3Path: zod_1.z.string().min(1, "Media S3 path is required"),
+    mediaType: zod_1.z.enum(["image", "video", "document"]).optional(),
+    title: zod_1.z.string().max(300).optional(),
+    description: zod_1.z.string().max(2000).optional(),
+});
+exports.socialPostInputSchema = zod_1.z.object({
+    text: zod_1.z.string().min(1, "Post text is required"),
+    media: zod_1.z.array(exports.socialMediaInputSchema).max(4).optional(),
+    visibility: zod_1.z.enum(["PUBLIC", "CONNECTIONS"]).default("PUBLIC"),
+});
+exports.socialPostOutputSchema = zod_1.z.object({
+    shareUrn: zod_1.z.string().optional(),
+});