@unifiedcommerce/core 0.0.1

package/dist/modules/media/repository/index.js

@@ -0,0 +1,176 @@
+import { eq, and, inArray } from "drizzle-orm";
+import { mediaAssets, entityMedia } from "../schema";
+/**
+ * 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 {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    getDb(ctx) {
+        return ctx?.tx ?? this.db;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Media Assets
+    // ─────────────────────────────────────────────────────────────────────────────
+    async findAssetById(id, ctx, orgId) {
+        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, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db
+            .select()
+            .from(mediaAssets)
+            .where(eq(mediaAssets.storageKey, storageKey));
+        return rows[0];
+    }
+    async findAssetsByIds(ids, ctx) {
+        if (ids.length === 0)
+            return [];
+        const db = this.getDb(ctx);
+        return db.select().from(mediaAssets).where(inArray(mediaAssets.id, ids));
+    }
+    async createAsset(data, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db.insert(mediaAssets).values(data).returning();
+        return rows[0];
+    }
+    async updateAsset(id, data, ctx) {
+        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, ctx) {
+        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, variantId, ctx) {
+        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, role, variantId, ctx) {
+        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, variantId, ctx) {
+        const media = await this.findEntityMediaByRole(entityId, "primary", variantId, ctx);
+        return media[0];
+    }
+    async createEntityMedia(data, ctx) {
+        const db = this.getDb(ctx);
+        const rows = await db.insert(entityMedia).values(data).returning();
+        return rows[0];
+    }
+    async createEntityMediaBatch(data, ctx) {
+        if (data.length === 0)
+            return [];
+        const db = this.getDb(ctx);
+        return db.insert(entityMedia).values(data).returning();
+    }
+    async updateEntityMediaSortOrder(entityId, mediaAssetId, sortOrder, variantId, ctx) {
+        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, mediaAssetId, variantId, ctx) {
+        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, ctx) {
+        const db = this.getDb(ctx);
+        await db.delete(entityMedia).where(eq(entityMedia.entityId, entityId));
+    }
+    async removeAllMediaByAssetId(mediaAssetId, ctx) {
+        const db = this.getDb(ctx);
+        await db
+            .delete(entityMedia)
+            .where(eq(entityMedia.mediaAssetId, mediaAssetId));
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Aggregates
+    // ─────────────────────────────────────────────────────────────────────────────
+    async findAssetsForEntity(entityId, variantId, ctx) {
+        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/dist/modules/media/schema.d.ts

@@ -0,0 +1,289 @@
+export declare const mediaAssets: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "media_assets";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "media_assets";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        organizationId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "organization_id";
+            tableName: "media_assets";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        storageKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "storage_key";
+            tableName: "media_assets";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        filename: import("drizzle-orm/pg-core").PgColumn<{
+            name: "filename";
+            tableName: "media_assets";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        contentType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "content_type";
+            tableName: "media_assets";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        size: import("drizzle-orm/pg-core").PgColumn<{
+            name: "size";
+            tableName: "media_assets";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        width: import("drizzle-orm/pg-core").PgColumn<{
+            name: "width";
+            tableName: "media_assets";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        height: import("drizzle-orm/pg-core").PgColumn<{
+            name: "height";
+            tableName: "media_assets";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        alt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "alt";
+            tableName: "media_assets";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "media_assets";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        uploadedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "uploaded_at";
+            tableName: "media_assets";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const entityMedia: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "entity_media";
+    schema: undefined;
+    columns: {
+        entityId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_id";
+            tableName: "entity_media";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        variantId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "variant_id";
+            tableName: "entity_media";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        mediaAssetId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "media_asset_id";
+            tableName: "entity_media";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        role: import("drizzle-orm/pg-core").PgColumn<{
+            name: "role";
+            tableName: "entity_media";
+            dataType: "string";
+            columnType: "PgText";
+            data: "primary" | "gallery" | "thumbnail" | "video" | "document";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["primary", "gallery", "thumbnail", "video", "document"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sortOrder: import("drizzle-orm/pg-core").PgColumn<{
+            name: "sort_order";
+            tableName: "entity_media";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/modules/media/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/modules/media/schema.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBvB,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EActB,CAAC"}

package/dist/modules/media/schema.js

@@ -0,0 +1,35 @@
+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().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/dist/modules/media/service.d.ts

@@ -0,0 +1,42 @@
+import type { Actor } from "../../auth/types";
+import type { StorageAdapter, StoredFile } from "./adapter";
+import { type Result } from "../../kernel/result";
+import type { MediaRepository } from "./repository";
+import type { CatalogRepository } from "../catalog/repository";
+import type { TxContext } from "../../kernel/database/tx-context";
+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 declare class MediaService {
+    private deps;
+    private readonly repo;
+    private readonly catalogRepo;
+    constructor(deps: MediaServiceDeps);
+    upload(input: UploadMediaInput, actor?: Actor | null, ctx?: TxContext): Promise<Result<{
+        id: string;
+        url: string;
+    }>>;
+    getUrl(id: string, ctx?: TxContext): Promise<Result<string>>;
+    getSignedUrl(id: string, expiresIn?: number, ctx?: TxContext): Promise<Result<string>>;
+    delete(id: string, ctx?: TxContext): Promise<Result<void>>;
+    list(prefix?: string): Promise<Result<StoredFile[]>>;
+    attachToEntity(input: AttachMediaInput, ctx?: TxContext): Promise<Result<void>>;
+}
+export {};
+//# sourceMappingURL=service.d.ts.map

package/dist/modules/media/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../src/modules/media/service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5D,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAK3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAGlE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,WAAW,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,OAAO,GAAG,UAAU,CAAC;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,gBAAgB;IACxB,UAAU,EAAE,eAAe,CAAC;IAC5B,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,OAAO,EAAE,cAAc,CAAC;CACzB;AAED,qBAAa,YAAY;IAIX,OAAO,CAAC,IAAI;IAHxB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAkB;IACvC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoB;gBAE5B,IAAI,EAAE,gBAAgB;IAKpC,MAAM,CACV,KAAK,EAAE,gBAAgB,EACvB,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,EACpB,GAAG,CAAC,EAAE,SAAS,GACd,OAAO,CAAC,MAAM,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAuCzC,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAM5D,YAAY,CAChB,EAAE,EAAE,MAAM,EACV,SAAS,SAAU,EACnB,GAAG,CAAC,EAAE,SAAS,GACd,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAMpB,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAY1D,IAAI,CAAC,MAAM,SAAK,GAAG,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC;IAMhD,cAAc,CAClB,KAAK,EAAE,gBAAgB,EACvB,GAAG,CAAC,EAAE,SAAS,GACd,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CA0BzB"}

package/dist/modules/media/service.js

@@ -0,0 +1,89 @@
+import { resolveOrgId } from "../../auth/org";
+import { Err, Ok } from "../../kernel/result";
+import { CommerceNotFoundError, CommerceValidationError, } from "../../kernel/errors";
+import { makeId } from "../../utils/id";
+export class MediaService {
+    deps;
+    repo;
+    catalogRepo;
+    constructor(deps) {
+        this.deps = deps;
+        this.repo = deps.repository;
+        this.catalogRepo = deps.catalogRepository;
+    }
+    async upload(input, actor, ctx) {
+        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;
+        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;
+        return Ok({ id, url: url.value });
+    }
+    async getUrl(id, ctx) {
+        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, expiresIn = 60 * 15, ctx) {
+        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, ctx) {
+        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 = "") {
+        const listed = await this.deps.storage.list(prefix);
+        if (!listed.ok)
+            return listed;
+        return Ok(listed.value);
+    }
+    async attachToEntity(input, ctx) {
+        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);
+    }
+}

package/dist/modules/orders/repository/in-memory.d.ts

@@ -0,0 +1,40 @@
+import type { TxContext } from "../../../kernel/database/tx-context";
+import type { Order, OrderInsert, OrderLineItem, OrderLineItemInsert, OrderStatusHistory, OrderStatusHistoryInsert } from "./index";
+/**
+ * In-memory implementation of OrdersRepository for testing.
+ * Provides the same interface as the Drizzle-based repository but stores data in memory.
+ */
+export declare class InMemoryOrdersRepository {
+    private orders;
+    private lineItems;
+    private statusHistory;
+    private orderSequenceByYear;
+    findById(id: string, _ctx?: TxContext): Promise<Order | undefined>;
+    findByOrderNumber(orderNumber: string, _ctx?: TxContext): Promise<Order | undefined>;
+    findByCustomerId(customerId: string, _ctx?: TxContext): Promise<Order[]>;
+    findByStatus(status: string, _ctx?: TxContext): Promise<Order[]>;
+    findAll(options?: {
+        limit?: number;
+        offset?: number;
+    }, _ctx?: TxContext): Promise<Order[]>;
+    create(data: OrderInsert, _ctx?: TxContext): Promise<Order>;
+    update(id: string, data: Partial<Omit<OrderInsert, "id">>, _ctx?: TxContext): Promise<Order | undefined>;
+    updateStatus(id: string, status: string, _ctx?: TxContext): Promise<Order | undefined>;
+    delete(id: string, _ctx?: TxContext): Promise<boolean>;
+    findAllLineItems(_ctx?: TxContext): Promise<OrderLineItem[]>;
+    findLineItemById(id: string, _ctx?: TxContext): Promise<OrderLineItem | undefined>;
+    findLineItemsByOrderId(orderId: string, _ctx?: TxContext): Promise<OrderLineItem[]>;
+    createLineItem(data: OrderLineItemInsert, _ctx?: TxContext): Promise<OrderLineItem>;
+    createLineItems(data: OrderLineItemInsert[], ctx?: TxContext): Promise<OrderLineItem[]>;
+    updateLineItem(id: string, data: Partial<Omit<OrderLineItemInsert, "id">>, _ctx?: TxContext): Promise<OrderLineItem | undefined>;
+    deleteLineItem(id: string, _ctx?: TxContext): Promise<boolean>;
+    deleteLineItemsByOrderId(orderId: string, _ctx?: TxContext): Promise<void>;
+    findStatusHistoryByOrderId(orderId: string, _ctx?: TxContext): Promise<OrderStatusHistory[]>;
+    createStatusHistory(data: OrderStatusHistoryInsert, _ctx?: TxContext): Promise<OrderStatusHistory>;
+    findWithLineItems(id: string, ctx?: TxContext): Promise<{
+        order: Order;
+        lineItems: OrderLineItem[];
+    } | undefined>;
+    getNextOrderNumber(_ctx?: TxContext): Promise<string>;
+}
+//# sourceMappingURL=in-memory.d.ts.map