@m5kdev/backend 0.1.0 → 0.1.2

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

@@ -0,0 +1,243 @@
+import type { RecurrenceService } from "#modules/recurrence/recurrence.service";
+export declare function createRecurrenceTRPC(recurrenceService: RecurrenceService): 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;
+        } | undefined;
+        output: {
+            rows: {
+                id: string;
+                enabled: boolean;
+                createdAt: Date;
+                updatedAt: Date;
+                userId?: string | null | undefined;
+                organizationId?: string | null | undefined;
+                teamId?: string | null | undefined;
+                name?: string | null | undefined;
+                kind?: string | null | undefined;
+                metadata?: Record<string, unknown> | null | undefined;
+            }[];
+            total: number;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    create: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            name: string;
+            kind: string;
+            enabled: boolean;
+            recurrenceRules: {
+                interval: number;
+                freq: number;
+                bysetpos?: number | number[] | null | undefined;
+                bymonth?: number | number[] | null | undefined;
+                bymonthday?: number | number[] | null | undefined;
+                byyearday?: number | number[] | null | undefined;
+                byweekno?: number | number[] | null | undefined;
+                byweekday?: number | number[] | null | undefined;
+                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;
+        };
+        output: {
+            recurrence: {
+                id: string;
+                enabled: boolean;
+                createdAt: Date;
+                updatedAt: Date;
+                userId?: string | null | undefined;
+                organizationId?: string | null | undefined;
+                teamId?: string | null | undefined;
+                name?: string | null | undefined;
+                kind?: string | null | undefined;
+                metadata?: Record<string, unknown> | null | undefined;
+            };
+            rules: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                freq: number;
+                interval: number;
+                recurrenceId?: string | null | undefined;
+                dtstart?: Date | null | undefined;
+                wkst?: number | null | undefined;
+                count?: 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;
+                byyearday?: number | number[] | null | undefined;
+                byweekno?: number | number[] | null | undefined;
+                byweekday?: number | number[] | null | undefined;
+                byhour?: number | number[] | null | undefined;
+                byminute?: number | number[] | null | undefined;
+                bysecond?: number | number[] | null | undefined;
+            }[];
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    findById: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            id: string;
+        };
+        output: {
+            id: string;
+            enabled: boolean;
+            createdAt: Date;
+            updatedAt: Date;
+            userId?: string | null | undefined;
+            organizationId?: string | null | undefined;
+            teamId?: string | null | undefined;
+            name?: string | null | undefined;
+            kind?: string | null | undefined;
+            metadata?: Record<string, unknown> | null | undefined;
+        } | null;
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    update: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+            name?: string | undefined;
+            kind?: string | undefined;
+            enabled?: boolean | undefined;
+            metadata?: Record<string, unknown> | null | undefined;
+        };
+        output: {
+            id: string;
+            enabled: boolean;
+            createdAt: Date;
+            updatedAt: Date;
+            userId?: string | null | undefined;
+            organizationId?: string | null | undefined;
+            teamId?: string | null | undefined;
+            name?: string | null | undefined;
+            kind?: string | null | undefined;
+            metadata?: Record<string, unknown> | null | undefined;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    updateRule: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+            interval: number;
+            freq: number;
+            bysetpos?: number | number[] | null | undefined;
+            bymonth?: number | number[] | null | undefined;
+            bymonthday?: number | number[] | null | undefined;
+            byyearday?: number | number[] | null | undefined;
+            byweekno?: number | number[] | null | undefined;
+            byweekday?: number | number[] | null | undefined;
+            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;
+            createdAt: Date;
+            updatedAt: Date;
+            freq: number;
+            interval: number;
+            recurrenceId?: string | null | undefined;
+            dtstart?: Date | null | undefined;
+            wkst?: number | null | undefined;
+            count?: 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;
+            byyearday?: number | number[] | null | undefined;
+            byweekno?: number | number[] | null | undefined;
+            byweekday?: number | number[] | null | undefined;
+            byhour?: number | number[] | null | undefined;
+            byminute?: number | number[] | null | undefined;
+            bysecond?: number | number[] | null | undefined;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    delete: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+        };
+        output: {
+            id: string;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    deleteRule: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+        };
+        output: {
+            id: string;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+}>>;
+//# sourceMappingURL=recurrence.trpc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recurrence.trpc.d.ts","sourceRoot":"","sources":["../../../../src/modules/recurrence/recurrence.trpc.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAC;AAmBhF,wBAAgB,oBAAoB,CAAC,iBAAiB,EAAE,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmDxE"}

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

@@ -0,0 +1,35 @@
+import { z } from "zod";
+export declare const socialMediaInputSchema: z.ZodObject<{
+    s3Path: z.ZodString;
+    mediaType: z.ZodOptional<z.ZodEnum<{
+        image: "image";
+        video: "video";
+        document: "document";
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const socialPostInputSchema: z.ZodObject<{
+    text: z.ZodString;
+    media: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        s3Path: z.ZodString;
+        mediaType: z.ZodOptional<z.ZodEnum<{
+            image: "image";
+            video: "video";
+            document: "document";
+        }>>;
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    visibility: z.ZodDefault<z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        CONNECTIONS: "CONNECTIONS";
+    }>>;
+}, z.core.$strip>;
+export declare const socialPostOutputSchema: z.ZodObject<{
+    shareUrn: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SocialPostInput = z.infer<typeof socialPostInputSchema>;
+export type SocialMediaInput = z.infer<typeof socialMediaInputSchema>;
+export type SocialPostOutput = z.infer<typeof socialPostOutputSchema>;
+//# sourceMappingURL=social.dto.d.ts.map

package/dist/src/modules/social/social.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"social.dto.d.ts","sourceRoot":"","sources":["../../../../src/modules/social/social.dto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,sBAAsB;;;;;;;;;iBAKjC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;iBAIhC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;iBAEjC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

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

package/dist/src/modules/social/social.linkedin.d.ts

@@ -0,0 +1,11 @@
+import type { SocialProvider } from "./social.types";
+export declare function createLinkedInSocialProvider(): SocialProvider;
+/**
+ * Escapes special characters in text for LinkedIn's post commentary field.
+ * LinkedIn requires certain characters to be backslash-escaped.
+ * Preserves mentions (@[Name](urn:li:...)) and hashtag templates ({hashtag|#|tag}).
+ * Converts simple hashtags (#tag) to the template format.
+ * @see https://learn.microsoft.com/en-us/linkedin/marketing/community-management/shares/little-text-format
+ */
+export declare function escapeLinkedInText(text: string): string;
+//# sourceMappingURL=social.linkedin.d.ts.map

package/dist/src/modules/social/social.linkedin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"social.linkedin.d.ts","sourceRoot":"","sources":["../../../../src/modules/social/social.linkedin.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAA4C,cAAc,EAAE,MAAM,gBAAgB,CAAC;AA6D/F,wBAAgB,4BAA4B,IAAI,cAAc,CA8B7D;AA2XD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAqDvD"}