@m5kdev/backend 0.1.0

package/src/modules/social/social.types.ts

@@ -0,0 +1,43 @@
+import type { ConnectRow } from "#modules/connect/connect.repository";
+import type { FileService } from "#modules/file/file.service";
+
+export type SocialMediaType = "image" | "video" | "document";
+
+export interface SocialMediaDescriptor {
+  readonly s3Path: string;
+  readonly mediaType?: SocialMediaType;
+  readonly title?: string;
+  readonly description?: string;
+}
+
+export type SocialVisibility = "PUBLIC" | "CONNECTIONS";
+
+export interface SocialPostPayload {
+  readonly text: string;
+  readonly media?: readonly SocialMediaDescriptor[];
+  readonly visibility: SocialVisibility;
+}
+
+export interface SocialProviderContext {
+  readonly userId: string;
+  readonly connection: ConnectRow;
+  readonly accessToken: string;
+}
+
+export interface SocialProviderDeps {
+  readonly fileService: FileService;
+}
+
+export interface SocialPostResult {
+  readonly shareUrn?: string;
+  readonly rawResponse?: unknown;
+}
+
+export interface SocialProvider {
+  readonly id: string;
+  post(options: {
+    deps: SocialProviderDeps;
+    context: SocialProviderContext;
+    payload: SocialPostPayload;
+  }): Promise<SocialPostResult>;
+}

package/src/modules/tag/tag.db.ts

@@ -0,0 +1,41 @@
+import { type AnySQLiteColumn, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { v4 as uuidv4 } from "uuid";
+import { organizations, teams, users } from "#modules/auth/auth.db";
+
+export const tags = sqliteTable("tags", {
+  id: text("id").primaryKey().$default(uuidv4),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .notNull()
+    .$default(() => new Date()),
+  updatedAt: integer("updated_at", { mode: "timestamp" }),
+  deletedAt: integer("deleted_at", { mode: "timestamp" }),
+  userId: text("user_id")
+    .notNull()
+    .references(() => users.id, { onDelete: "cascade" }),
+  organizationId: text("organization_id").references(() => organizations.id, {
+    onDelete: "cascade",
+  }),
+  teamId: text("team_id").references(() => teams.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+  color: text("color"),
+  type: text("type"),
+  isEnabled: integer("is_enabled", { mode: "boolean" }).notNull().default(true),
+  parentId: text("parent_id").references((): AnySQLiteColumn => tags.id, { onDelete: "set null" }),
+  assignableTo: text("assignable_to", {
+    mode: "json",
+  })
+    .notNull()
+    .$type<string[]>(),
+});
+
+export const taggings = sqliteTable("taggings", {
+  id: text("id").primaryKey().$default(uuidv4),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .notNull()
+    .$default(() => new Date()),
+  tagId: text("tag_id")
+    .notNull()
+    .references(() => tags.id),
+  resourceType: text("resource_type").notNull(), // e.g., "post", "image"
+  resourceId: text("resource_id").notNull(), // id in the resource table
+});

package/src/modules/tag/tag.dto.ts

@@ -0,0 +1,18 @@
+import type { Result } from "neverthrow";
+import type { z } from "zod";
+import { createSelectDTO } from "#modules/base/base.dto";
+import { taggings, tags } from "#modules/tag/tag.db";
+import type { ServerError } from "#utils/errors";
+
+export const tagsSelectDTO = createSelectDTO(tags);
+export const taggingsSelectDTO = createSelectDTO(taggings);
+
+export const tagsSelectOutput = tagsSelectDTO.schema;
+export const taggingsSelectOutput = taggingsSelectDTO.schema;
+
+export type TagSelectOutputResult = Result<z.infer<typeof tagsSelectOutput>, ServerError>;
+export type TaggingSelectOutputResult = Result<z.infer<typeof taggingsSelectOutput>, ServerError>;
+export type TaggingSelectOutputResults = Result<
+  z.infer<typeof taggingsSelectOutput>[],
+  ServerError
+>;

package/src/modules/tag/tag.repository.ts

@@ -0,0 +1,222 @@
+import type {
+  TaggingSchema,
+  TagLinkSchema,
+  TagListInputSchema,
+  TagListSchema,
+  TagSchema,
+} from "@m5kdev/commons/modules/tag/tag.schema";
+import { and, count, eq, inArray } from "drizzle-orm";
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import { err, ok } from "neverthrow";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseTableRepository } from "#modules/base/base.repository";
+import * as tag from "#modules/tag/tag.db";
+import type { TaggingSelectOutputResult, TagSelectOutputResult } from "#modules/tag/tag.dto";
+
+const schema = { ...tag };
+type Schema = typeof schema;
+type Orm = LibSQLDatabase<Schema>;
+
+export class TagRepository extends BaseTableRepository<
+  Orm,
+  Schema,
+  Record<string, never>,
+  Schema["tags"]
+> {
+  async link(
+    { userId, ...data }: TagLinkSchema & { userId: string },
+    tx?: Orm
+  ): Promise<TaggingSelectOutputResult> {
+    return this.throwableAsync(async () => {
+      const db = tx ?? this.orm;
+      const [foundTag] = await db
+        .select({ id: this.schema.tags.id })
+        .from(this.schema.tags)
+        .where(and(eq(this.schema.tags.id, data.tagId), eq(this.schema.tags.userId, userId)))
+        .limit(1);
+      if (!foundTag) return this.error("FORBIDDEN");
+
+      const [tagging] = await db
+        .insert(this.schema.taggings)
+        .values({ ...data, tagId: foundTag.id })
+        .returning();
+      if (!tagging) return this.error("NOT_FOUND");
+      return ok(tagging);
+    });
+  }
+
+  async linkBulk(data: TagLinkSchema[], tx?: Orm): ServerResultAsync<TagSchema[]> {
+    return this.throwableAsync(async () => {
+      const db = tx ?? this.orm;
+      await db.insert(this.schema.taggings).values(data);
+      const tags = await db
+        .select()
+        .from(this.schema.tags)
+        .where(
+          inArray(
+            this.schema.tags.id,
+            data.map((tag) => tag.tagId)
+          )
+        );
+      return ok(tags);
+    });
+  }
+
+  async set(data: TagLinkSchema[], tx?: Orm): ServerResultAsync<TagSchema[]> {
+    return this.throwableAsync(async () => {
+      const db = tx ?? this.orm;
+      const result = await db.transaction(async (trx) => {
+        // FIXME: We are assuming that all resourceIds are the same, this is not a good assumption.
+        await trx
+          .delete(this.schema.taggings)
+          .where(eq(this.schema.taggings.resourceId, data[0].resourceId));
+        await db.insert(this.schema.taggings).values(data);
+        const tags = await db
+          .select()
+          .from(this.schema.tags)
+          .where(
+            inArray(
+              this.schema.tags.id,
+              data.map((tag) => tag.tagId)
+            )
+          );
+        return tags;
+      });
+      return ok(result);
+    });
+  }
+
+  async unlink(
+    { userId, ...data }: TagLinkSchema & { userId: string },
+    tx?: Orm
+  ): Promise<TagSelectOutputResult> {
+    return this.throwableAsync(async () => {
+      const db = tx ?? this.orm;
+      const [foundTag] = await db
+        .select()
+        .from(this.schema.tags)
+        .where(and(eq(this.schema.tags.id, data.tagId), eq(this.schema.tags.userId, userId)))
+        .limit(1);
+      if (!foundTag) return this.error("FORBIDDEN");
+
+      await db
+        .delete(this.schema.taggings)
+        .where(
+          and(
+            eq(this.schema.taggings.tagId, data.tagId),
+            eq(this.schema.taggings.resourceId, data.resourceId),
+            eq(this.schema.taggings.resourceType, data.resourceType)
+          )
+        );
+
+      return ok(foundTag);
+    });
+  }
+
+  async findTagsForResources(
+    data: { resourceType: string; resourceIds: readonly string[] },
+    tx?: Orm
+  ): ServerResultAsync<Record<string, TagSchema[]>> {
+    return this.throwableAsync(async () => {
+      const db = tx ?? this.orm;
+      if (data.resourceIds.length === 0) return ok({});
+
+      const taggings = await db
+        .select({
+          resourceId: this.schema.taggings.resourceId,
+          tagId: this.schema.taggings.tagId,
+        })
+        .from(this.schema.taggings)
+        .where(
+          and(
+            eq(this.schema.taggings.resourceType, data.resourceType),
+            inArray(this.schema.taggings.resourceId, data.resourceIds as string[])
+          )
+        );
+
+      if (taggings.length === 0) return ok({});
+
+      const tagIds = Array.from(new Set(taggings.map((tagging) => tagging.tagId)));
+      const tags = await db
+        .select()
+        .from(this.schema.tags)
+        .where(inArray(this.schema.tags.id, tagIds));
+
+      const tagById = tags.reduce<Record<string, TagSchema>>((acc, tagRow) => {
+        acc[tagRow.id] = tagRow;
+        return acc;
+      }, {});
+
+      const grouped = taggings.reduce<Record<string, TagSchema[]>>((acc, tagging) => {
+        const tagRow = tagById[tagging.tagId];
+        if (!tagRow) return acc;
+        const existing = acc[tagging.resourceId] ?? [];
+        acc[tagging.resourceId] = [...existing, tagRow];
+        return acc;
+      }, {});
+
+      return ok(grouped);
+    });
+  }
+
+  async attachTagsToResources<TRow extends { id: string }>(
+    resourceType: string,
+    rows: readonly TRow[],
+    tx?: Orm
+  ): ServerResultAsync<Array<TRow & { tags: TagSchema[] }>> {
+    return this.throwableAsync(async () => {
+      if (rows.length === 0) return ok([]);
+      const tagsResult = await this.findTagsForResources(
+        { resourceType, resourceIds: rows.map((row) => row.id) },
+        tx
+      );
+      if (tagsResult.isErr()) return err(tagsResult.error);
+      const tagsByResource = tagsResult.value;
+      const withTags = rows.map((row) => ({
+        ...row,
+        tags: tagsByResource[row.id] ?? [],
+      }));
+      return ok(withTags);
+    });
+  }
+
+  async listTaggings(
+    input: { resourceType: string; resourceIds?: readonly string[] },
+    tx?: Orm
+  ): ServerResultAsync<TaggingSchema[]> {
+    return this.throwableAsync(async () => {
+      const db = tx ?? this.orm;
+      const filters = [eq(this.schema.taggings.resourceType, input.resourceType)];
+      if (input.resourceIds?.length) {
+        filters.push(inArray(this.schema.taggings.resourceId, input.resourceIds as string[]));
+      }
+      const rows = await db
+        .select()
+        .from(this.schema.taggings)
+        .where(and(...filters));
+      return ok(rows);
+    });
+  }
+
+  async list(
+    input: (TagListInputSchema & TagListSchema) | undefined,
+    tx?: Orm
+  ): ServerResultAsync<{ rows: TagSchema[]; total: number }> {
+    return this.throwableAsync(async () => {
+      const db = tx ?? this.orm;
+      const conditions = this.getConditionBuilder(this.table);
+      conditions.applyFilters(input);
+      if (input?.assignableTo) {
+        conditions.push(this.helpers.arrayContains(this.table.assignableTo, [input.assignableTo]));
+      }
+      const whereClause = conditions.join();
+      const rowsQuery = this.withSortingAndPagination(
+        db.select().from(this.table).where(whereClause),
+        input || {}
+      );
+      const countQuery = db.select({ count: count() }).from(this.table).where(whereClause);
+      const [rows, [totalResult]] = await Promise.all([rowsQuery, countQuery]);
+      return ok({ rows, total: totalResult?.count ?? 0 });
+    });
+  }
+}

package/src/modules/tag/tag.service.ts

@@ -0,0 +1,48 @@
+import type {
+  TagCreateSchema,
+  TagLinkSchema,
+  TagListInputSchema,
+  TagListOutputSchema,
+  TagListSchema,
+  TagSchema,
+  TagUpdateSchema,
+} from "@m5kdev/commons/modules/tag/tag.schema";
+import type { User } from "#modules/auth/auth.lib";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseService } from "#modules/base/base.service";
+import type { TaggingSelectOutputResult, TagSelectOutputResult } from "#modules/tag/tag.dto";
+import type { TagRepository } from "#modules/tag/tag.repository";
+
+export class TagService extends BaseService<{ tag: TagRepository }, Record<string, never>> {
+  async list(input: TagListInputSchema & TagListSchema): ServerResultAsync<TagListOutputSchema> {
+    return this.repository.tag.list(input);
+  }
+
+  async listTaggings(input: { resourceType: string; resourceIds?: readonly string[] }) {
+    return this.repository.tag.listTaggings(input);
+  }
+
+  async create(data: TagCreateSchema, { user }: { user: User }): Promise<TagSelectOutputResult> {
+    return this.repository.tag.create({ ...data, userId: user.id });
+  }
+
+  async update(data: TagUpdateSchema, { user }: { user: User }): Promise<TagSelectOutputResult> {
+    return this.repository.tag.update({ ...data, userId: user.id });
+  }
+
+  async link(data: TagLinkSchema, { user }: { user: User }): Promise<TaggingSelectOutputResult> {
+    return this.repository.tag.link({ ...data, userId: user.id });
+  }
+
+  async linkBulk(data: TagLinkSchema[]): ServerResultAsync<TagSchema[]> {
+    return this.repository.tag.linkBulk(data);
+  }
+
+  async set(data: TagLinkSchema[]): ServerResultAsync<TagSchema[]> {
+    return this.repository.tag.set(data);
+  }
+
+  async unlink(data: TagLinkSchema, { user }: { user: User }): Promise<TagSelectOutputResult> {
+    return this.repository.tag.unlink({ ...data, userId: user.id });
+  }
+}

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

@@ -0,0 +1,62 @@
+import {
+  tagCreateSchema,
+  taggingSchema,
+  tagLinkSchema,
+  tagListInputSchema,
+  tagListOutputSchema,
+  tagListSchema,
+  tagUpdateSchema,
+} from "@m5kdev/commons/modules/tag/tag.schema";
+import { taggingsSelectOutput, tagsSelectOutput } from "#modules/tag/tag.dto";
+import type { TagService } from "#modules/tag/tag.service";
+import { handleTRPCResult, procedure, router } from "#trpc";
+
+export function createTagTRPC(tagService: TagService) {
+  const tagListInput = tagListInputSchema.extend({
+    assignableTo: tagListSchema.shape.assignableTo,
+  });
+
+  return router({
+    list: procedure
+      .input(tagListInput)
+      .output(tagListOutputSchema)
+      .query(async ({ input }) => handleTRPCResult(await tagService.list(input))),
+
+    listTaggings: procedure
+      .input(
+        taggingSchema
+          .pick({ resourceType: true })
+          .extend({ resourceIds: tagListInputSchema.shape.filters.optional() })
+      )
+      .output(taggingsSelectOutput.array())
+      .query(async ({ input }) => handleTRPCResult(await tagService.listTaggings(input as any))),
+
+    create: procedure
+      .input(tagCreateSchema)
+      .output(tagsSelectOutput)
+      .mutation(async ({ ctx, input }) => {
+        return handleTRPCResult(await tagService.create(input, ctx));
+      }),
+
+    update: procedure
+      .input(tagUpdateSchema)
+      .output(tagsSelectOutput)
+      .mutation(async ({ ctx, input }) => {
+        return handleTRPCResult(await tagService.update(input, ctx));
+      }),
+
+    link: procedure
+      .input(tagLinkSchema)
+      .output(taggingsSelectOutput)
+      .mutation(async ({ ctx, input }) => {
+        return handleTRPCResult(await tagService.link(input, ctx));
+      }),
+
+    unlink: procedure
+      .input(tagLinkSchema)
+      .output(tagsSelectOutput)
+      .mutation(async ({ ctx, input }) => {
+        return handleTRPCResult(await tagService.unlink(input, ctx));
+      }),
+  });
+}

package/src/modules/utils/applyPagination.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 const applyPagination = <TQuery>(query: TQuery, limit?: number, page?: number): TQuery => {
+  if (limit) (query as any).limit(limit);
+
+  if (page && page > 1 && limit) (query as any).offset((page - 1) * limit);
+
+  return query;
+};

package/src/modules/utils/applySorting.ts

@@ -0,0 +1,21 @@
+import { asc, desc } from "drizzle-orm";
+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 const applySorting = <TQuery, TTable extends SQLiteTableWithColumns<any>>(
+  query: TQuery,
+  table: TTable,
+  sort?: string,
+  order?: "asc" | "desc"
+): TQuery => {
+  const column = sort ? table[sort] : table.createdAt || table.id;
+  if (!column) throw new Error(`Column ${sort} not found in table ${table.name}`);
+  (query as any).orderBy(order === "asc" ? asc(column) : desc(column));
+  return query;
+};