@m5kdev/backend 0.1.4 → 0.2.0

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

@@ -1,43 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,222 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,13 +0,0 @@
-/**
- * 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

@@ -1,21 +0,0 @@
-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;
-};