@unifiedcommerce/core 0.0.1

package/src/modules/media/repository/index.ts

@@ -0,0 +1,274 @@
+import { eq, and, inArray } from "drizzle-orm";
+import type { TxContext } from "../../../kernel/database/tx-context";
+import type {
+  DrizzleDatabase,
+  DbOrTx,
+} from "../../../kernel/database/drizzle-db";
+import { mediaAssets, entityMedia } from "../schema";
+
+// Infer types from Drizzle schema
+export type MediaAsset = typeof mediaAssets.$inferSelect;
+export type MediaAssetInsert = typeof mediaAssets.$inferInsert;
+export type EntityMedia = typeof entityMedia.$inferSelect;
+export type EntityMediaInsert = typeof entityMedia.$inferInsert;
+
+/**
+ * MediaRepository provides type-safe database operations for media assets.
+ *
+ * This repository manages media assets and their associations with entities.
+ * All methods support an optional TxContext parameter for transaction participation.
+ */
+export class MediaRepository {
+  constructor(private readonly db: DrizzleDatabase) {}
+
+  private getDb(ctx?: TxContext): DbOrTx {
+    return (ctx?.tx as DbOrTx | undefined) ?? this.db;
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Media Assets
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  async findAssetById(
+    id: string,
+    ctx?: TxContext,
+    orgId?: string,
+  ): Promise<MediaAsset | undefined> {
+    const db = this.getDb(ctx);
+    const conditions = [eq(mediaAssets.id, id)];
+    if (orgId) {
+      conditions.push(eq(mediaAssets.organizationId, orgId));
+    }
+    const rows = await db
+      .select()
+      .from(mediaAssets)
+      .where(and(...conditions));
+    return rows[0];
+  }
+
+  async findAssetByStorageKey(
+    storageKey: string,
+    ctx?: TxContext,
+  ): Promise<MediaAsset | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .select()
+      .from(mediaAssets)
+      .where(eq(mediaAssets.storageKey, storageKey));
+    return rows[0];
+  }
+
+  async findAssetsByIds(ids: string[], ctx?: TxContext): Promise<MediaAsset[]> {
+    if (ids.length === 0) return [];
+    const db = this.getDb(ctx);
+    return db.select().from(mediaAssets).where(inArray(mediaAssets.id, ids));
+  }
+
+  async createAsset(
+    data: MediaAssetInsert,
+    ctx?: TxContext,
+  ): Promise<MediaAsset> {
+    const db = this.getDb(ctx);
+    const rows = await db.insert(mediaAssets).values(data).returning();
+    return rows[0]!;
+  }
+
+  async updateAsset(
+    id: string,
+    data: Partial<Omit<MediaAssetInsert, "id">>,
+    ctx?: TxContext,
+  ): Promise<MediaAsset | undefined> {
+    const db = this.getDb(ctx);
+    const rows = await db
+      .update(mediaAssets)
+      .set(data)
+      .where(eq(mediaAssets.id, id))
+      .returning();
+    return rows[0];
+  }
+
+  async deleteAsset(id: string, ctx?: TxContext): Promise<boolean> {
+    const db = this.getDb(ctx);
+    const result = await db
+      .delete(mediaAssets)
+      .where(eq(mediaAssets.id, id))
+      .returning();
+    return result.length > 0;
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Entity Media (Associations)
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  async findEntityMedia(
+    entityId: string,
+    variantId?: string,
+    ctx?: TxContext,
+  ): Promise<EntityMedia[]> {
+    const db = this.getDb(ctx);
+
+    if (variantId === undefined) {
+      // Find media for entity only (not variant-specific)
+      const rows = await db
+        .select()
+        .from(entityMedia)
+        .where(eq(entityMedia.entityId, entityId));
+      return rows.filter((r) => r.variantId === null);
+    }
+
+    return db
+      .select()
+      .from(entityMedia)
+      .where(
+        and(
+          eq(entityMedia.entityId, entityId),
+          eq(entityMedia.variantId, variantId),
+        ),
+      );
+  }
+
+  async findEntityMediaByRole(
+    entityId: string,
+    role: EntityMedia["role"],
+    variantId?: string,
+    ctx?: TxContext,
+  ): Promise<EntityMedia[]> {
+    const db = this.getDb(ctx);
+    const conditions = [
+      eq(entityMedia.entityId, entityId),
+      eq(entityMedia.role, role),
+    ];
+
+    if (variantId !== undefined) {
+      conditions.push(eq(entityMedia.variantId, variantId));
+    }
+
+    const rows = await db
+      .select()
+      .from(entityMedia)
+      .where(and(...conditions));
+
+    if (variantId === undefined) {
+      return rows.filter((r) => r.variantId === null);
+    }
+    return rows;
+  }
+
+  async findPrimaryMedia(
+    entityId: string,
+    variantId?: string,
+    ctx?: TxContext,
+  ): Promise<EntityMedia | undefined> {
+    const media = await this.findEntityMediaByRole(
+      entityId,
+      "primary",
+      variantId,
+      ctx,
+    );
+    return media[0];
+  }
+
+  async createEntityMedia(
+    data: EntityMediaInsert,
+    ctx?: TxContext,
+  ): Promise<EntityMedia> {
+    const db = this.getDb(ctx);
+    const rows = await db.insert(entityMedia).values(data).returning();
+    return rows[0]!;
+  }
+
+  async createEntityMediaBatch(
+    data: EntityMediaInsert[],
+    ctx?: TxContext,
+  ): Promise<EntityMedia[]> {
+    if (data.length === 0) return [];
+    const db = this.getDb(ctx);
+    return db.insert(entityMedia).values(data).returning();
+  }
+
+  async updateEntityMediaSortOrder(
+    entityId: string,
+    mediaAssetId: string,
+    sortOrder: number,
+    variantId?: string,
+    ctx?: TxContext,
+  ): Promise<EntityMedia | undefined> {
+    const db = this.getDb(ctx);
+    const conditions = [
+      eq(entityMedia.entityId, entityId),
+      eq(entityMedia.mediaAssetId, mediaAssetId),
+    ];
+
+    if (variantId !== undefined) {
+      conditions.push(eq(entityMedia.variantId, variantId));
+    }
+
+    const rows = await db
+      .update(entityMedia)
+      .set({ sortOrder })
+      .where(and(...conditions))
+      .returning();
+
+    if (variantId === undefined) {
+      return rows.find((r) => r.variantId === null);
+    }
+    return rows[0];
+  }
+
+  async removeEntityMedia(
+    entityId: string,
+    mediaAssetId: string,
+    variantId?: string,
+    ctx?: TxContext,
+  ): Promise<boolean> {
+    const db = this.getDb(ctx);
+    const conditions = [
+      eq(entityMedia.entityId, entityId),
+      eq(entityMedia.mediaAssetId, mediaAssetId),
+    ];
+
+    if (variantId !== undefined) {
+      conditions.push(eq(entityMedia.variantId, variantId));
+    }
+
+    const result = await db
+      .delete(entityMedia)
+      .where(and(...conditions))
+      .returning();
+
+    if (variantId === undefined) {
+      return result.some((r) => r.variantId === null);
+    }
+    return result.length > 0;
+  }
+
+  async removeAllEntityMedia(entityId: string, ctx?: TxContext): Promise<void> {
+    const db = this.getDb(ctx);
+    await db.delete(entityMedia).where(eq(entityMedia.entityId, entityId));
+  }
+
+  async removeAllMediaByAssetId(
+    mediaAssetId: string,
+    ctx?: TxContext,
+  ): Promise<void> {
+    const db = this.getDb(ctx);
+    await db
+      .delete(entityMedia)
+      .where(eq(entityMedia.mediaAssetId, mediaAssetId));
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Aggregates
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  async findAssetsForEntity(
+    entityId: string,
+    variantId?: string,
+    ctx?: TxContext,
+  ): Promise<MediaAsset[]> {
+    const associations = await this.findEntityMedia(entityId, variantId, ctx);
+    const assetIds = associations.map((a) => a.mediaAssetId);
+    if (assetIds.length === 0) return [];
+    return this.findAssetsByIds(assetIds, ctx);
+  }
+}

package/src/modules/media/schema.ts

@@ -0,0 +1,41 @@
+import { index, integer, jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { organization } from "../../auth/auth-schema";
+import { sellableEntities, variants } from "../catalog/schema";
+
+export const mediaAssets = pgTable(
+  "media_assets",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id")
+      .notNull()
+      .references(() => organization.id, { onDelete: "cascade" }),
+    storageKey: text("storage_key").notNull(),
+    filename: text("filename").notNull(),
+    contentType: text("content_type").notNull(),
+    size: integer("size").notNull(),
+    width: integer("width"),
+    height: integer("height"),
+    alt: text("alt"),
+    metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+    uploadedAt: timestamp("uploaded_at", { withTimezone: true }).defaultNow().notNull(),
+  },
+  (table) => ({
+    orgIdx: index("idx_media_assets_org").on(table.organizationId),
+  }),
+);
+
+export const entityMedia = pgTable("entity_media", {
+  entityId: uuid("entity_id")
+    .references(() => sellableEntities.id, { onDelete: "cascade" })
+    .notNull(),
+  variantId: uuid("variant_id").references(() => variants.id, {
+    onDelete: "cascade",
+  }),
+  mediaAssetId: uuid("media_asset_id")
+    .references(() => mediaAssets.id, { onDelete: "cascade" })
+    .notNull(),
+  role: text("role", {
+    enum: ["primary", "gallery", "thumbnail", "video", "document"],
+  }).notNull(),
+  sortOrder: integer("sort_order").notNull().default(0),
+});

package/src/modules/media/service.ts

@@ -0,0 +1,151 @@
+import { resolveOrgId } from "../../auth/org";
+import type { Actor } from "../../auth/types";
+import type { StorageAdapter, StoredFile } from "./adapter";
+import { Err, Ok, type Result } from "../../kernel/result";
+import {
+  CommerceNotFoundError,
+  CommerceValidationError,
+} from "../../kernel/errors";
+import type { MediaRepository } from "./repository";
+import type { CatalogRepository } from "../catalog/repository";
+import type { TxContext } from "../../kernel/database/tx-context";
+import { makeId } from "../../utils/id";
+
+export interface UploadMediaInput {
+  filename: string;
+  contentType: string;
+  data: ArrayBuffer;
+  alt?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface AttachMediaInput {
+  entityId: string;
+  mediaAssetId: string;
+  role: "primary" | "gallery" | "thumbnail" | "video" | "document";
+  variantId?: string;
+  sortOrder?: number;
+}
+
+interface MediaServiceDeps {
+  repository: MediaRepository;
+  catalogRepository: CatalogRepository;
+  storage: StorageAdapter;
+}
+
+export class MediaService {
+  private readonly repo: MediaRepository;
+  private readonly catalogRepo: CatalogRepository;
+
+  constructor(private deps: MediaServiceDeps) {
+    this.repo = deps.repository;
+    this.catalogRepo = deps.catalogRepository;
+  }
+
+  async upload(
+    input: UploadMediaInput,
+    actor?: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<{ id: string; url: string }>> {
+    if (!input.filename || !input.contentType) {
+      return Err(
+        new CommerceValidationError("filename and contentType are required."),
+      );
+    }
+
+    const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+
+    const id = makeId();
+    const key = `${new Date().getFullYear()}/${id}-${input.filename}`;
+    const uploaded = await this.deps.storage.upload(
+      key,
+      input.data,
+      input.contentType,
+    );
+    if (!uploaded.ok) return uploaded as Result<never>;
+
+    await this.repo.createAsset(
+      {
+        organizationId: orgId,
+        id,
+        storageKey: key,
+        filename: input.filename,
+        contentType: input.contentType,
+        size: input.data.byteLength,
+        metadata: input.metadata ?? {},
+        uploadedAt: new Date(),
+        ...(input.alt !== undefined ? { alt: input.alt } : {}),
+      },
+      ctx,
+    );
+
+    const url = await this.deps.storage.getUrl(key);
+    if (!url.ok) return url as Result<never>;
+
+    return Ok({ id, url: url.value });
+  }
+
+  async getUrl(id: string, ctx?: TxContext): Promise<Result<string>> {
+    const asset = await this.repo.findAssetById(id, ctx);
+    if (!asset) return Err(new CommerceNotFoundError("Media asset not found."));
+    return this.deps.storage.getUrl(asset.storageKey);
+  }
+
+  async getSignedUrl(
+    id: string,
+    expiresIn = 60 * 15,
+    ctx?: TxContext,
+  ): Promise<Result<string>> {
+    const asset = await this.repo.findAssetById(id, ctx);
+    if (!asset) return Err(new CommerceNotFoundError("Media asset not found."));
+    return this.deps.storage.getSignedUrl(asset.storageKey, expiresIn);
+  }
+
+  async delete(id: string, ctx?: TxContext): Promise<Result<void>> {
+    const asset = await this.repo.findAssetById(id, ctx);
+    if (!asset) return Err(new CommerceNotFoundError("Media asset not found."));
+
+    const deleted = await this.deps.storage.delete(asset.storageKey);
+    if (!deleted.ok) return deleted;
+
+    await this.repo.removeAllMediaByAssetId(id, ctx);
+    await this.repo.deleteAsset(id, ctx);
+    return Ok(undefined);
+  }
+
+  async list(prefix = ""): Promise<Result<StoredFile[]>> {
+    const listed = await this.deps.storage.list(prefix);
+    if (!listed.ok) return listed;
+    return Ok(listed.value);
+  }
+
+  async attachToEntity(
+    input: AttachMediaInput,
+    ctx?: TxContext,
+  ): Promise<Result<void>> {
+    const entity = await this.catalogRepo.findEntityById(input.entityId, ctx);
+    if (!entity) {
+      return Err(new CommerceNotFoundError("Entity not found."));
+    }
+
+    const asset = await this.repo.findAssetById(input.mediaAssetId, ctx);
+    if (!asset) {
+      return Err(new CommerceNotFoundError("Media asset not found."));
+    }
+
+    await this.repo.createEntityMedia(
+      {
+        entityId: input.entityId,
+        mediaAssetId: input.mediaAssetId,
+        role: input.role,
+        sortOrder: input.sortOrder ?? 0,
+        ...(input.variantId !== undefined
+          ? { variantId: input.variantId }
+          : {}),
+      },
+      ctx,
+    );
+
+    return Ok(undefined);
+  }
+}