@m5kdev/backend 0.6.0 → 0.8.0

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

@@ -0,0 +1,64 @@
+import { BaseService } from "../base/base.service.mjs";
+import { err, ok } from "neverthrow";
+//#region src/modules/recurrence/recurrence.service.ts
+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] !== void 0) out[key] = rule[key];
+	return out;
+}
+var RecurrenceService = class extends BaseService {
+	list = this.procedure("list").addContextFilter(["user"]).handle(({ input }) => this.repository.recurrence.queryList(input));
+	create = this.procedure("create").requireAuth().handle(({ input, ctx }) => {
+		const { actor } = ctx;
+		const recurrenceData = {
+			name: input.name,
+			kind: input.kind,
+			enabled: input.enabled,
+			metadata: input.metadata ?? null,
+			userId: actor.userId,
+			organizationId: actor.organizationId,
+			teamId: actor.teamId
+		};
+		const rulesData = input.recurrenceRules.map(mapRuleToInsert);
+		return this.repository.recurrence.createWithRules(recurrenceData, rulesData);
+	});
+	async findById(id) {
+		const result = await this.repository.recurrence.findById(id);
+		if (result.isErr()) return err(result.error);
+		return 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);
+	}
+};
+//#endregion
+export { RecurrenceService };
+
+//# sourceMappingURL=recurrence.service.mjs.map

package/dist/src/modules/recurrence/recurrence.service.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"recurrence.service.mjs","names":[],"sources":["../../../../src/modules/recurrence/recurrence.service.ts"],"sourcesContent":["import type {\r\n  CreateRecurrenceSchema,\r\n  DeleteRecurrenceRulesSchema,\r\n  DeleteRecurrenceSchema,\r\n  UpdateRecurrenceRulesSchema,\r\n  UpdateRecurrenceSchema,\r\n} from \"@m5kdev/commons/modules/recurrence/recurrence.schema\";\r\nimport type { QueryInput } from \"@m5kdev/commons/modules/schemas/query.schema\";\r\nimport { err, ok } from \"neverthrow\";\r\nimport type { ServerResultAsync } from \"../base/base.dto\";\r\nimport { BaseService } from \"../base/base.service\";\r\nimport type {\r\n  CreateRecurrenceRuleInput,\r\n  CreateWithRulesResult,\r\n  RecurrenceRepository,\r\n  RecurrenceRulesRepository,\r\n} from \"./recurrence.repository\";\r\n\r\nconst RECURRENCE_RULE_INSERT_KEYS = [\r\n  \"freq\",\r\n  \"dtstart\",\r\n  \"interval\",\r\n  \"wkst\",\r\n  \"count\",\r\n  \"until\",\r\n  \"tzid\",\r\n  \"bysetpos\",\r\n  \"bymonth\",\r\n  \"bymonthday\",\r\n  \"byyearday\",\r\n  \"byweekno\",\r\n  \"byweekday\",\r\n  \"byhour\",\r\n  \"byminute\",\r\n  \"bysecond\",\r\n] as const;\r\n\r\nfunction mapRuleToInsert(\r\n  rule: CreateRecurrenceSchema[\"recurrenceRules\"][number]\r\n): CreateRecurrenceRuleInput {\r\n  const out: Record<string, unknown> = {};\r\n  for (const key of RECURRENCE_RULE_INSERT_KEYS) {\r\n    if (key in rule && rule[key as keyof typeof rule] !== undefined) {\r\n      out[key] = rule[key as keyof typeof rule];\r\n    }\r\n  }\r\n  return out as CreateRecurrenceRuleInput;\r\n}\r\n\r\nexport class RecurrenceService extends BaseService<\r\n  { recurrence: RecurrenceRepository; recurrenceRules: RecurrenceRulesRepository },\r\n  Record<string, never>\r\n> {\r\n  readonly list = this.procedure<QueryInput>(\"list\")\r\n    .addContextFilter([\"user\"])\r\n    .handle(({ input }) => this.repository.recurrence.queryList(input));\r\n\r\n  readonly create = this.procedure<CreateRecurrenceSchema>(\"create\")\r\n    .requireAuth()\r\n    .handle(({ input, ctx }): ServerResultAsync<CreateWithRulesResult> => {\r\n      const { actor } = ctx;\r\n      const recurrenceData = {\r\n        name: input.name,\r\n        kind: input.kind,\r\n        enabled: input.enabled,\r\n        metadata: input.metadata ?? null,\r\n        userId: actor.userId,\r\n        organizationId: actor.organizationId,\r\n        teamId: actor.teamId,\r\n      };\r\n      const rulesData = input.recurrenceRules.map(mapRuleToInsert);\r\n      return this.repository.recurrence.createWithRules(recurrenceData, rulesData);\r\n    });\r\n\r\n  async findById(id: string): ServerResultAsync<CreateWithRulesResult[\"recurrence\"] | null> {\r\n    const result = await this.repository.recurrence.findById(id);\r\n    if (result.isErr()) return err(result.error);\r\n    return ok(result.value ?? null);\r\n  }\r\n\r\n  async update(\r\n    data: UpdateRecurrenceSchema & { id: string }\r\n  ): ServerResultAsync<CreateWithRulesResult[\"recurrence\"]> {\r\n    return this.repository.recurrence.update(data);\r\n  }\r\n\r\n  async updateRule(\r\n    data: UpdateRecurrenceRulesSchema\r\n  ): ServerResultAsync<CreateWithRulesResult[\"rules\"][number]> {\r\n    return this.repository.recurrenceRules.update(data);\r\n  }\r\n\r\n  async delete(data: DeleteRecurrenceSchema): ServerResultAsync<{ id: string }> {\r\n    return this.repository.recurrence.deleteById(data.id);\r\n  }\r\n\r\n  async deleteRule(data: DeleteRecurrenceRulesSchema): ServerResultAsync<{ id: string }> {\r\n    return this.repository.recurrenceRules.deleteById(data.id);\r\n  }\r\n}\r\n"],"mappings":";;;AAkBA,MAAM,8BAA8B;CAClC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD;AAED,SAAS,gBACP,MAC2B;CAC3B,MAAM,MAA+B,EAAE;AACvC,MAAK,MAAM,OAAO,4BAChB,KAAI,OAAO,QAAQ,KAAK,SAA8B,KAAA,EACpD,KAAI,OAAO,KAAK;AAGpB,QAAO;;AAGT,IAAa,oBAAb,cAAuC,YAGrC;CACA,OAAgB,KAAK,UAAsB,OAAO,CAC/C,iBAAiB,CAAC,OAAO,CAAC,CAC1B,QAAQ,EAAE,YAAY,KAAK,WAAW,WAAW,UAAU,MAAM,CAAC;CAErE,SAAkB,KAAK,UAAkC,SAAS,CAC/D,aAAa,CACb,QAAQ,EAAE,OAAO,UAAoD;EACpE,MAAM,EAAE,UAAU;EAClB,MAAM,iBAAiB;GACrB,MAAM,MAAM;GACZ,MAAM,MAAM;GACZ,SAAS,MAAM;GACf,UAAU,MAAM,YAAY;GAC5B,QAAQ,MAAM;GACd,gBAAgB,MAAM;GACtB,QAAQ,MAAM;GACf;EACD,MAAM,YAAY,MAAM,gBAAgB,IAAI,gBAAgB;AAC5D,SAAO,KAAK,WAAW,WAAW,gBAAgB,gBAAgB,UAAU;GAC5E;CAEJ,MAAM,SAAS,IAA2E;EACxF,MAAM,SAAS,MAAM,KAAK,WAAW,WAAW,SAAS,GAAG;AAC5D,MAAI,OAAO,OAAO,CAAE,QAAO,IAAI,OAAO,MAAM;AAC5C,SAAO,GAAG,OAAO,SAAS,KAAK;;CAGjC,MAAM,OACJ,MACwD;AACxD,SAAO,KAAK,WAAW,WAAW,OAAO,KAAK;;CAGhD,MAAM,WACJ,MAC2D;AAC3D,SAAO,KAAK,WAAW,gBAAgB,OAAO,KAAK;;CAGrD,MAAM,OAAO,MAAiE;AAC5E,SAAO,KAAK,WAAW,WAAW,WAAW,KAAK,GAAG;;CAGvD,MAAM,WAAW,MAAsE;AACrF,SAAO,KAAK,WAAW,gBAAgB,WAAW,KAAK,GAAG"}

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

@@ -0,0 +1,65 @@
+import { Context, TRPCMethods } from "../../utils/trpc.mjs";
+import { RecurrenceService } from "./recurrence.service.mjs";
+import * as _$_trpc_server0 from "@trpc/server";
+
+//#region src/modules/recurrence/recurrence.trpc.d.ts
+declare function createRecurrenceTRPC({
+  router,
+  privateProcedure: procedure
+}: TRPCMethods, recurrenceService: RecurrenceService): _$_trpc_server0.TRPCBuiltRouter<{
+  ctx: Context;
+  meta: any;
+  errorShape: _$_trpc_server0.TRPCDefaultErrorShape;
+  transformer: any;
+}, _$_trpc_server0.TRPCDecorateCreateRouterOptions<{
+  list: _$_trpc_server0.TRPCQueryProcedure<{
+    input: any;
+    output: {
+      rows: any[];
+      total: number;
+    };
+    meta: any;
+  }>;
+  create: _$_trpc_server0.TRPCMutationProcedure<{
+    input: any;
+    output: {
+      [x: string]: any;
+      rules: any[];
+    };
+    meta: any;
+  }>;
+  findById: _$_trpc_server0.TRPCQueryProcedure<{
+    input: {
+      id: string;
+    };
+    output: any;
+    meta: any;
+  }>;
+  update: _$_trpc_server0.TRPCMutationProcedure<{
+    input: any;
+    output: any;
+    meta: any;
+  }>;
+  updateRule: _$_trpc_server0.TRPCMutationProcedure<{
+    input: any;
+    output: any;
+    meta: any;
+  }>;
+  delete: _$_trpc_server0.TRPCMutationProcedure<{
+    input: any;
+    output: {
+      id: string;
+    };
+    meta: any;
+  }>;
+  deleteRule: _$_trpc_server0.TRPCMutationProcedure<{
+    input: any;
+    output: {
+      id: string;
+    };
+    meta: any;
+  }>;
+}>>;
+//#endregion
+export { createRecurrenceTRPC };
+//# sourceMappingURL=recurrence.trpc.d.mts.map

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

@@ -0,0 +1,44 @@
+import { handleTRPCResult } from "../../utils/trpc.mjs";
+import { z } from "zod";
+import { createRecurrenceSchema, deleteRecurrenceRulesSchema, deleteRecurrenceSchema, recurrenceRulesSchema, recurrenceSchema, updateRecurrenceRulesSchema, updateRecurrenceSchema } from "@m5kdev/commons/modules/recurrence/recurrence.schema";
+import { querySchema } from "@m5kdev/commons/modules/schemas/query.schema";
+//#region src/modules/recurrence/recurrence.trpc.ts
+const createRecurrenceOutputSchema = z.object({
+	recurrence: recurrenceSchema,
+	rules: z.array(recurrenceRulesSchema)
+});
+const listRecurrenceOutputSchema = z.object({
+	rows: z.array(recurrenceSchema),
+	total: z.number()
+});
+const updateRecurrenceInputSchema = updateRecurrenceSchema.extend({ id: z.string() });
+const deleteRecurrenceOutputSchema = z.object({ id: z.string() });
+function createRecurrenceTRPC({ router, privateProcedure: procedure }, recurrenceService) {
+	return router({
+		list: procedure.input(querySchema.default({})).output(listRecurrenceOutputSchema).query(async ({ ctx, input }) => {
+			return handleTRPCResult(await recurrenceService.list(input, ctx));
+		}),
+		create: procedure.input(createRecurrenceSchema).output(createRecurrenceOutputSchema).mutation(async ({ ctx, input }) => {
+			return handleTRPCResult(await recurrenceService.create(input, ctx));
+		}),
+		findById: procedure.input(z.object({ id: z.string() })).output(recurrenceSchema.nullable()).query(async ({ input }) => {
+			return handleTRPCResult(await recurrenceService.findById(input.id));
+		}),
+		update: procedure.input(updateRecurrenceInputSchema).output(recurrenceSchema).mutation(async ({ input }) => {
+			return handleTRPCResult(await recurrenceService.update(input));
+		}),
+		updateRule: procedure.input(updateRecurrenceRulesSchema).output(recurrenceRulesSchema).mutation(async ({ input }) => {
+			return handleTRPCResult(await recurrenceService.updateRule(input));
+		}),
+		delete: procedure.input(deleteRecurrenceSchema).output(deleteRecurrenceOutputSchema).mutation(async ({ input }) => {
+			return handleTRPCResult(await recurrenceService.delete(input));
+		}),
+		deleteRule: procedure.input(deleteRecurrenceRulesSchema).output(deleteRecurrenceOutputSchema).mutation(async ({ input }) => {
+			return handleTRPCResult(await recurrenceService.deleteRule(input));
+		})
+	});
+}
+//#endregion
+export { createRecurrenceTRPC };
+
+//# sourceMappingURL=recurrence.trpc.mjs.map

package/dist/src/modules/recurrence/recurrence.trpc.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"recurrence.trpc.mjs","names":[],"sources":["../../../../src/modules/recurrence/recurrence.trpc.ts"],"sourcesContent":["import {\r\n  createRecurrenceSchema,\r\n  deleteRecurrenceRulesSchema,\r\n  deleteRecurrenceSchema,\r\n  recurrenceRulesSchema,\r\n  recurrenceSchema,\r\n  updateRecurrenceRulesSchema,\r\n  updateRecurrenceSchema,\r\n} from \"@m5kdev/commons/modules/recurrence/recurrence.schema\";\r\nimport { querySchema } from \"@m5kdev/commons/modules/schemas/query.schema\";\r\nimport { z } from \"zod\";\r\nimport { handleTRPCResult, type TRPCMethods } from \"../../utils/trpc\";\r\nimport type { RecurrenceService } from \"./recurrence.service\";\r\n\r\nconst createRecurrenceOutputSchema = z.object({\r\n  recurrence: recurrenceSchema,\r\n  rules: z.array(recurrenceRulesSchema),\r\n});\r\n\r\nconst listRecurrenceOutputSchema = z.object({\r\n  rows: z.array(recurrenceSchema),\r\n  total: z.number(),\r\n});\r\n\r\nconst updateRecurrenceInputSchema = updateRecurrenceSchema.extend({\r\n  id: z.string(),\r\n});\r\n\r\nconst deleteRecurrenceOutputSchema = z.object({ id: z.string() });\r\n\r\nexport function createRecurrenceTRPC(\r\n  { router, privateProcedure: procedure }: TRPCMethods,\r\n  recurrenceService: RecurrenceService\r\n) {\r\n  return router({\r\n    list: procedure\r\n      .input(querySchema.default({}))\r\n      .output(listRecurrenceOutputSchema)\r\n      .query(async ({ ctx, input }) => {\r\n        return handleTRPCResult(await recurrenceService.list(input, ctx));\r\n      }),\r\n\r\n    create: procedure\r\n      .input(createRecurrenceSchema)\r\n      .output(createRecurrenceOutputSchema)\r\n      .mutation(async ({ ctx, input }) => {\r\n        return handleTRPCResult(await recurrenceService.create(input, ctx));\r\n      }),\r\n\r\n    findById: procedure\r\n      .input(z.object({ id: z.string() }))\r\n      .output(recurrenceSchema.nullable())\r\n      .query(async ({ input }) => {\r\n        return handleTRPCResult(await recurrenceService.findById(input.id));\r\n      }),\r\n\r\n    update: procedure\r\n      .input(updateRecurrenceInputSchema)\r\n      .output(recurrenceSchema)\r\n      .mutation(async ({ input }) => {\r\n        return handleTRPCResult(await recurrenceService.update(input));\r\n      }),\r\n\r\n    updateRule: procedure\r\n      .input(updateRecurrenceRulesSchema)\r\n      .output(recurrenceRulesSchema)\r\n      .mutation(async ({ input }) => {\r\n        return handleTRPCResult(await recurrenceService.updateRule(input));\r\n      }),\r\n\r\n    delete: procedure\r\n      .input(deleteRecurrenceSchema)\r\n      .output(deleteRecurrenceOutputSchema)\r\n      .mutation(async ({ input }) => {\r\n        return handleTRPCResult(await recurrenceService.delete(input));\r\n      }),\r\n\r\n    deleteRule: procedure\r\n      .input(deleteRecurrenceRulesSchema)\r\n      .output(deleteRecurrenceOutputSchema)\r\n      .mutation(async ({ input }) => {\r\n        return handleTRPCResult(await recurrenceService.deleteRule(input));\r\n      }),\r\n  });\r\n}\r\n"],"mappings":";;;;;AAcA,MAAM,+BAA+B,EAAE,OAAO;CAC5C,YAAY;CACZ,OAAO,EAAE,MAAM,sBAAsB;CACtC,CAAC;AAEF,MAAM,6BAA6B,EAAE,OAAO;CAC1C,MAAM,EAAE,MAAM,iBAAiB;CAC/B,OAAO,EAAE,QAAQ;CAClB,CAAC;AAEF,MAAM,8BAA8B,uBAAuB,OAAO,EAChE,IAAI,EAAE,QAAQ,EACf,CAAC;AAEF,MAAM,+BAA+B,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AAEjE,SAAgB,qBACd,EAAE,QAAQ,kBAAkB,aAC5B,mBACA;AACA,QAAO,OAAO;EACZ,MAAM,UACH,MAAM,YAAY,QAAQ,EAAE,CAAC,CAAC,CAC9B,OAAO,2BAA2B,CAClC,MAAM,OAAO,EAAE,KAAK,YAAY;AAC/B,UAAO,iBAAiB,MAAM,kBAAkB,KAAK,OAAO,IAAI,CAAC;IACjE;EAEJ,QAAQ,UACL,MAAM,uBAAuB,CAC7B,OAAO,6BAA6B,CACpC,SAAS,OAAO,EAAE,KAAK,YAAY;AAClC,UAAO,iBAAiB,MAAM,kBAAkB,OAAO,OAAO,IAAI,CAAC;IACnE;EAEJ,UAAU,UACP,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC,CACnC,OAAO,iBAAiB,UAAU,CAAC,CACnC,MAAM,OAAO,EAAE,YAAY;AAC1B,UAAO,iBAAiB,MAAM,kBAAkB,SAAS,MAAM,GAAG,CAAC;IACnE;EAEJ,QAAQ,UACL,MAAM,4BAA4B,CAClC,OAAO,iBAAiB,CACxB,SAAS,OAAO,EAAE,YAAY;AAC7B,UAAO,iBAAiB,MAAM,kBAAkB,OAAO,MAAM,CAAC;IAC9D;EAEJ,YAAY,UACT,MAAM,4BAA4B,CAClC,OAAO,sBAAsB,CAC7B,SAAS,OAAO,EAAE,YAAY;AAC7B,UAAO,iBAAiB,MAAM,kBAAkB,WAAW,MAAM,CAAC;IAClE;EAEJ,QAAQ,UACL,MAAM,uBAAuB,CAC7B,OAAO,6BAA6B,CACpC,SAAS,OAAO,EAAE,YAAY;AAC7B,UAAO,iBAAiB,MAAM,kBAAkB,OAAO,MAAM,CAAC;IAC9D;EAEJ,YAAY,UACT,MAAM,4BAA4B,CAClC,OAAO,6BAA6B,CACpC,SAAS,OAAO,EAAE,YAAY;AAC7B,UAAO,iBAAiB,MAAM,kBAAkB,WAAW,MAAM,CAAC;IAClE;EACL,CAAC"}

package/dist/src/modules/social/social.dto.d.mts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+
+//#region src/modules/social/social.dto.d.ts
+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>;
+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>;
+declare const socialPostOutputSchema: z.ZodObject<{
+  shareUrn: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SocialPostInput = z.infer<typeof socialPostInputSchema>;
+type SocialMediaInput = z.infer<typeof socialMediaInputSchema>;
+type SocialPostOutput = z.infer<typeof socialPostOutputSchema>;
+//#endregion
+export { SocialMediaInput, SocialPostInput, SocialPostOutput, socialMediaInputSchema, socialPostInputSchema, socialPostOutputSchema };
+//# sourceMappingURL=social.dto.d.mts.map

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

@@ -0,0 +1,22 @@
+import { z } from "zod";
+//#region src/modules/social/social.dto.ts
+const socialMediaInputSchema = z.object({
+	s3Path: z.string().min(1, "Media S3 path is required"),
+	mediaType: z.enum([
+		"image",
+		"video",
+		"document"
+	]).optional(),
+	title: z.string().max(300).optional(),
+	description: z.string().max(2e3).optional()
+});
+const socialPostInputSchema = z.object({
+	text: z.string().min(1, "Post text is required"),
+	media: z.array(socialMediaInputSchema).max(4).optional(),
+	visibility: z.enum(["PUBLIC", "CONNECTIONS"]).default("PUBLIC")
+});
+const socialPostOutputSchema = z.object({ shareUrn: z.string().optional() });
+//#endregion
+export { socialMediaInputSchema, socialPostInputSchema, socialPostOutputSchema };
+
+//# sourceMappingURL=social.dto.mjs.map

package/dist/src/modules/social/social.dto.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"social.dto.mjs","names":[],"sources":["../../../../src/modules/social/social.dto.ts"],"sourcesContent":["import { z } from \"zod\";\r\n\r\nexport const socialMediaInputSchema = z.object({\r\n  s3Path: z.string().min(1, \"Media S3 path is required\"),\r\n  mediaType: z.enum([\"image\", \"video\", \"document\"]).optional(),\r\n  title: z.string().max(300).optional(),\r\n  description: z.string().max(2000).optional(),\r\n});\r\n\r\nexport const socialPostInputSchema = z.object({\r\n  text: z.string().min(1, \"Post text is required\"),\r\n  media: z.array(socialMediaInputSchema).max(4).optional(),\r\n  visibility: z.enum([\"PUBLIC\", \"CONNECTIONS\"]).default(\"PUBLIC\"),\r\n});\r\n\r\nexport const socialPostOutputSchema = z.object({\r\n  shareUrn: z.string().optional(),\r\n});\r\n\r\nexport type SocialPostInput = z.infer<typeof socialPostInputSchema>;\r\nexport type SocialMediaInput = z.infer<typeof socialMediaInputSchema>;\r\nexport type SocialPostOutput = z.infer<typeof socialPostOutputSchema>;\r\n"],"mappings":";;AAEA,MAAa,yBAAyB,EAAE,OAAO;CAC7C,QAAQ,EAAE,QAAQ,CAAC,IAAI,GAAG,4BAA4B;CACtD,WAAW,EAAE,KAAK;EAAC;EAAS;EAAS;EAAW,CAAC,CAAC,UAAU;CAC5D,OAAO,EAAE,QAAQ,CAAC,IAAI,IAAI,CAAC,UAAU;CACrC,aAAa,EAAE,QAAQ,CAAC,IAAI,IAAK,CAAC,UAAU;CAC7C,CAAC;AAEF,MAAa,wBAAwB,EAAE,OAAO;CAC5C,MAAM,EAAE,QAAQ,CAAC,IAAI,GAAG,wBAAwB;CAChD,OAAO,EAAE,MAAM,uBAAuB,CAAC,IAAI,EAAE,CAAC,UAAU;CACxD,YAAY,EAAE,KAAK,CAAC,UAAU,cAAc,CAAC,CAAC,QAAQ,SAAS;CAChE,CAAC;AAEF,MAAa,yBAAyB,EAAE,OAAO,EAC7C,UAAU,EAAE,QAAQ,CAAC,UAAU,EAChC,CAAC"}

package/dist/src/modules/social/{social.linkedin.d.ts → social.linkedin.d.mts}

@@ -1,5 +1,7 @@
-import type { SocialProvider } from "./social.types";
-export declare function createLinkedInSocialProvider(): SocialProvider;
+import { SocialProvider } from "./social.types.mjs";
+
+//#region src/modules/social/social.linkedin.d.ts
+declare function createLinkedInSocialProvider(): SocialProvider;
 /**
  * Escapes special characters in text for LinkedIn's post commentary field.
  * LinkedIn requires certain characters to be backslash-escaped.
@@ -7,4 +9,7 @@ export declare function createLinkedInSocialProvider(): SocialProvider;
  * 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;
+declare function escapeLinkedInText(text: string): string;
+//#endregion
+export { createLinkedInSocialProvider, escapeLinkedInText };
+//# sourceMappingURL=social.linkedin.d.mts.map

package/dist/src/modules/social/social.linkedin.mjs

@@ -0,0 +1,346 @@
+import { createReadStream } from "node:fs";
+import { stat, unlink } from "node:fs/promises";
+//#region src/modules/social/social.linkedin.ts
+const LINKEDIN_API_BASE = "https://api.linkedin.com/rest";
+const LINKEDIN_VERSION = "202601";
+const IMAGES_URL = `${LINKEDIN_API_BASE}/images?action=initializeUpload`;
+const VIDEOS_URL = `${LINKEDIN_API_BASE}/videos?action=initializeUpload`;
+const VIDEOS_FINALIZE_URL = `${LINKEDIN_API_BASE}/videos?action=finalizeUpload`;
+const DOCUMENTS_URL = `${LINKEDIN_API_BASE}/documents?action=initializeUpload`;
+const POSTS_URL = `${LINKEDIN_API_BASE}/posts`;
+function getApiHeaders(accessToken) {
+	return {
+		Authorization: `Bearer ${accessToken}`,
+		"Content-Type": "application/json",
+		"Linkedin-Version": LINKEDIN_VERSION,
+		"X-Restli-Protocol-Version": "2.0.0"
+	};
+}
+function createLinkedInSocialProvider() {
+	return {
+		id: "linkedin",
+		async post({ deps, context, payload }) {
+			const personUrn = resolveAuthorUrn(context.connection);
+			const mediaDescriptors = payload.media ?? [];
+			let uploadedAssets = [];
+			if (mediaDescriptors.length > 0) uploadedAssets = await uploadMediaAssets({
+				accessToken: context.accessToken,
+				fileService: deps.fileService,
+				mediaDescriptors,
+				personUrn
+			});
+			const response = await publishPost({
+				accessToken: context.accessToken,
+				personUrn,
+				payload,
+				uploadedAssets
+			});
+			return {
+				shareUrn: response.postUrn,
+				rawResponse: response.raw
+			};
+		}
+	};
+}
+function resolveAuthorUrn(connection) {
+	if (connection.metadataJson) try {
+		const metadata = connection.metadataJson;
+		if (metadata.linkedInUrn && typeof metadata.linkedInUrn === "string") return metadata.linkedInUrn;
+	} catch {
+		throw new Error("Failed to parse LinkedIn connection metadata");
+	}
+	if (connection.providerAccountId) return `urn:li:person:${connection.providerAccountId}`;
+	throw new Error("LinkedIn connection is missing a person URN");
+}
+async function uploadMediaAssets(params) {
+	const results = [];
+	for (const descriptor of params.mediaDescriptors) {
+		const download = await params.fileService.downloadS3ToFile(descriptor.s3Path);
+		if (download.isErr()) throw download.error;
+		const localPath = download.value;
+		try {
+			const mediaType = determineMediaType(descriptor.mediaType, localPath);
+			let assetUrn;
+			switch (mediaType) {
+				case "image":
+					assetUrn = await uploadImage({
+						accessToken: params.accessToken,
+						personUrn: params.personUrn,
+						localPath
+					});
+					break;
+				case "video":
+					assetUrn = await uploadVideo({
+						accessToken: params.accessToken,
+						personUrn: params.personUrn,
+						localPath
+					});
+					break;
+				case "document":
+					assetUrn = await uploadDocument({
+						accessToken: params.accessToken,
+						personUrn: params.personUrn,
+						localPath
+					});
+					break;
+			}
+			results.push({
+				assetUrn,
+				mediaType,
+				title: descriptor.title,
+				description: descriptor.description
+			});
+		} finally {
+			await unlink(localPath).catch(() => void 0);
+		}
+	}
+	return results;
+}
+function determineMediaType(explicitType, localPath) {
+	if (explicitType) return explicitType;
+	const extension = localPath.split(".").pop()?.toLowerCase();
+	if (!extension) throw new Error("Unable to determine media type from file extension");
+	const imageExtensions = new Set([
+		"jpg",
+		"jpeg",
+		"png",
+		"gif",
+		"webp"
+	]);
+	const videoExtensions = new Set([
+		"mp4",
+		"mov",
+		"m4v",
+		"avi",
+		"mkv",
+		"webm"
+	]);
+	const documentExtensions = new Set([
+		"pdf",
+		"ppt",
+		"pptx",
+		"doc",
+		"docx"
+	]);
+	if (imageExtensions.has(extension)) return "image";
+	if (videoExtensions.has(extension)) return "video";
+	if (documentExtensions.has(extension)) return "document";
+	throw new Error(`Unsupported media extension: ${extension}`);
+}
+async function uploadImage(params) {
+	const initResponse = await fetch(IMAGES_URL, {
+		method: "POST",
+		headers: getApiHeaders(params.accessToken),
+		body: JSON.stringify({ initializeUploadRequest: { owner: params.personUrn } })
+	});
+	if (!initResponse.ok) {
+		const errorText = await initResponse.text().catch(() => "");
+		throw new Error(`LinkedIn image upload initialization failed: ${initResponse.status} ${errorText}`);
+	}
+	const { uploadUrl, image } = (await initResponse.json()).value;
+	if (!uploadUrl || !image) throw new Error("LinkedIn image initialization response missing required fields");
+	await uploadBinaryToLinkedIn({
+		uploadUrl,
+		localPath: params.localPath,
+		mimeType: inferImageMime(params.localPath)
+	});
+	return image;
+}
+async function uploadVideo(params) {
+	const fileSizeBytes = await getFileSize(params.localPath);
+	const initResponse = await fetch(VIDEOS_URL, {
+		method: "POST",
+		headers: getApiHeaders(params.accessToken),
+		body: JSON.stringify({ initializeUploadRequest: {
+			owner: params.personUrn,
+			fileSizeBytes,
+			uploadCaptions: false,
+			uploadThumbnail: false
+		} })
+	});
+	if (!initResponse.ok) {
+		const errorText = await initResponse.text().catch(() => "");
+		throw new Error(`LinkedIn video upload initialization failed: ${initResponse.status} ${errorText}`);
+	}
+	const { uploadInstructions, video, uploadToken } = (await initResponse.json()).value;
+	if (!uploadInstructions || !video || !uploadToken) throw new Error("LinkedIn video initialization response missing required fields");
+	const uploadedPartIds = await uploadVideoMultipart({
+		localPath: params.localPath,
+		uploadInstructions
+	});
+	await finalizeVideoUpload({
+		accessToken: params.accessToken,
+		video,
+		uploadToken,
+		uploadedPartIds
+	});
+	return video;
+}
+async function uploadVideoMultipart(params) {
+	const uploadedPartIds = [];
+	for (const instruction of params.uploadInstructions) {
+		const chunkStream = createReadStream(params.localPath, {
+			start: instruction.firstByte,
+			end: instruction.lastByte
+		});
+		const uploadResponse = await fetch(instruction.uploadUrl, {
+			method: "PUT",
+			headers: { "Content-Type": "application/octet-stream" },
+			body: chunkStream,
+			duplex: "half"
+		});
+		if (!uploadResponse.ok) {
+			const errorText = await uploadResponse.text().catch(() => "");
+			throw new Error(`LinkedIn video part upload failed: ${uploadResponse.status} ${errorText}`);
+		}
+		const etag = uploadResponse.headers.get("etag");
+		if (!etag) throw new Error("LinkedIn video part upload response missing ETag header");
+		uploadedPartIds.push(etag.replace(/"/g, ""));
+	}
+	return uploadedPartIds;
+}
+async function finalizeVideoUpload(params) {
+	const response = await fetch(VIDEOS_FINALIZE_URL, {
+		method: "POST",
+		headers: getApiHeaders(params.accessToken),
+		body: JSON.stringify({ finalizeUploadRequest: {
+			video: params.video,
+			uploadToken: params.uploadToken,
+			uploadedPartIds: params.uploadedPartIds
+		} })
+	});
+	if (!response.ok) {
+		const errorText = await response.text().catch(() => "");
+		throw new Error(`LinkedIn video finalize failed: ${response.status} ${errorText}`);
+	}
+}
+async function uploadDocument(params) {
+	const initResponse = await fetch(DOCUMENTS_URL, {
+		method: "POST",
+		headers: getApiHeaders(params.accessToken),
+		body: JSON.stringify({ initializeUploadRequest: { owner: params.personUrn } })
+	});
+	if (!initResponse.ok) {
+		const errorText = await initResponse.text().catch(() => "");
+		throw new Error(`LinkedIn document upload initialization failed: ${initResponse.status} ${errorText}`);
+	}
+	const { uploadUrl, document } = (await initResponse.json()).value;
+	if (!uploadUrl || !document) throw new Error("LinkedIn document initialization response missing required fields");
+	await uploadBinaryToLinkedIn({
+		uploadUrl,
+		localPath: params.localPath,
+		mimeType: inferDocumentMime(params.localPath)
+	});
+	return document;
+}
+async function uploadBinaryToLinkedIn(params) {
+	const uploadResponse = await fetch(params.uploadUrl, {
+		method: "PUT",
+		headers: { "Content-Type": params.mimeType },
+		body: createReadStream(params.localPath),
+		duplex: "half"
+	});
+	if (!uploadResponse.ok) {
+		const errorText = await uploadResponse.text().catch(() => "");
+		throw new Error(`LinkedIn media upload failed: ${uploadResponse.status} ${errorText}`);
+	}
+}
+async function getFileSize(filePath) {
+	return (await stat(filePath)).size;
+}
+function inferImageMime(localPath) {
+	switch (localPath.split(".").pop()?.toLowerCase()) {
+		case "png": return "image/png";
+		case "webp": return "image/webp";
+		case "gif": return "image/gif";
+		case "jpg":
+		case "jpeg": return "image/jpeg";
+		default: return "application/octet-stream";
+	}
+}
+function inferDocumentMime(localPath) {
+	switch (localPath.split(".").pop()?.toLowerCase()) {
+		case "pdf": return "application/pdf";
+		case "doc": return "application/msword";
+		case "docx": return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+		case "ppt": return "application/vnd.ms-powerpoint";
+		case "pptx": return "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+		default: return "application/octet-stream";
+	}
+}
+async function publishPost(params) {
+	const body = buildPostBody(params);
+	const response = await fetch(POSTS_URL, {
+		method: "POST",
+		headers: getApiHeaders(params.accessToken),
+		body: JSON.stringify(body)
+	});
+	if (!response.ok) {
+		const errorText = await response.text().catch(() => "");
+		throw new Error(`LinkedIn post failed: ${response.status} ${errorText}`);
+	}
+	return {
+		postUrn: response.headers.get("x-restli-id") ?? void 0,
+		raw: await safeJson(response)
+	};
+}
+/**
+* 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
+*/
+function escapeLinkedInText(text) {
+	const mentionPattern = /@\[[^\]]*\]\(urn:li:[^)]+\)/g;
+	const hashtagTemplatePattern = /\{hashtag\|\\?[#＃]\|[^}]+\}/g;
+	const simpleHashtagPattern = /#([a-zA-Z\u00C0-\u024F\u1E00-\u1EFF][\w\u00C0-\u024F\u1E00-\u1EFF]*)/g;
+	const preserved = [];
+	const createPlaceholder = (content) => {
+		const index = preserved.length;
+		preserved.push(content);
+		return `\x00${index}\x00`;
+	};
+	let result = text.replace(mentionPattern, (match) => createPlaceholder(match));
+	result = result.replace(hashtagTemplatePattern, (match) => createPlaceholder(match));
+	result = result.replace(simpleHashtagPattern, (_match, tag) => createPlaceholder(`{hashtag|\\#|${tag}}`));
+	result = result.replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\{/g, "\\{").replace(/\}/g, "\\}").replace(/@/g, "\\@").replace(/\[/g, "\\[").replace(/\]/g, "\\]").replace(/\(/g, "\\(").replace(/\)/g, "\\)").replace(/</g, "\\<").replace(/>/g, "\\>").replace(/#/g, "\\#").replace(/\*/g, "\\*").replace(/_/g, "\\_").replace(/~/g, "\\~");
+	result = result.replace(/\x00(\d+)\x00/g, (_match, index) => preserved[Number(index)]);
+	return result;
+}
+function buildPostBody(params) {
+	const { personUrn, payload, uploadedAssets } = params;
+	const basePost = {
+		author: personUrn,
+		commentary: escapeLinkedInText(payload.text),
+		visibility: payload.visibility,
+		distribution: {
+			feedDistribution: "MAIN_FEED",
+			targetEntities: [],
+			thirdPartyDistributionChannels: []
+		},
+		lifecycleState: "PUBLISHED",
+		isReshareDisabledByAuthor: false
+	};
+	if (uploadedAssets.length === 0) return basePost;
+	if (uploadedAssets.length > 1) throw new Error("LinkedIn Posts API currently supports only a single media asset per post");
+	const asset = uploadedAssets[0];
+	const mediaContent = { id: asset.assetUrn };
+	if (asset.title) mediaContent.title = asset.title;
+	if (asset.description && asset.mediaType === "image") mediaContent.altText = asset.description;
+	return {
+		...basePost,
+		content: { media: mediaContent }
+	};
+}
+async function safeJson(response) {
+	try {
+		return await response.json();
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { createLinkedInSocialProvider, escapeLinkedInText };
+
+//# sourceMappingURL=social.linkedin.mjs.map