@unifiedcommerce/core 0.4.4 → 0.5.0

package/dist/modules/inventory/schemas.js

@@ -0,0 +1,28 @@
+import { z } from "@hono/zod-openapi";
+// ─── Zod Body Schemas (single source of truth) ─────────────────────────────
+export const InventoryAdjustBodySchema = z.object({
+    entityId: z.string().openapi({ example: "550e8400-e29b-41d4-a716-446655440000" }),
+    variantId: z.string().optional().openapi({ example: "variant-uuid" }),
+    warehouseId: z.string().optional().openapi({ example: "warehouse-uuid" }),
+    adjustment: z.number().int().refine((v) => v !== 0, { message: "Adjustment cannot be zero" }).openapi({ example: 10 }),
+    reason: z.string().openapi({ example: "Restock from supplier" }),
+    performedBy: z.string().optional(),
+    referenceType: z.string().optional(),
+    referenceId: z.string().optional(),
+}).openapi("InventoryAdjustRequest");
+export const InventoryReserveBodySchema = z.object({
+    entityId: z.string().openapi({ example: "550e8400-e29b-41d4-a716-446655440000" }),
+    variantId: z.string().optional(),
+    warehouseId: z.string().optional(),
+    quantity: z.number().int().min(1).openapi({ example: 2 }),
+    orderId: z.string().openapi({ example: "order-uuid" }),
+    performedBy: z.string().optional(),
+}).openapi("InventoryReserveRequest");
+export const InventoryReleaseBodySchema = z.object({
+    entityId: z.string().openapi({ example: "550e8400-e29b-41d4-a716-446655440000" }),
+    variantId: z.string().optional(),
+    warehouseId: z.string().optional(),
+    quantity: z.number().int().min(1).openapi({ example: 2 }),
+    orderId: z.string().openapi({ example: "order-uuid" }),
+    performedBy: z.string().optional(),
+}).openapi("InventoryReleaseRequest");

package/dist/modules/inventory/service.d.ts

@@ -0,0 +1,69 @@
+import type { Actor } from "../../auth/types.js";
+import type { CommerceConfig } from "../../config/types.js";
+import type { HookRegistry } from "../../kernel/hooks/registry.js";
+import { type Result } from "../../kernel/result.js";
+import type { DatabaseAdapter } from "../../kernel/database/adapter.js";
+import { type TxContext } from "../../kernel/database/tx-context.js";
+import { InventoryRepository, type Warehouse, type InventoryLevel } from "./repository/index.js";
+export type { InventoryAdjustInput, InventoryReserveInput, InventoryReleaseInput } from "./schemas.js";
+import type { InventoryAdjustInput, InventoryReserveInput, InventoryReleaseInput } from "./schemas.js";
+export interface InventoryServiceDeps {
+    repository: InventoryRepository;
+    hooks: HookRegistry;
+    config: CommerceConfig;
+    services: Record<string, unknown>;
+    database: DatabaseAdapter;
+}
+export declare class InventoryService {
+    private deps;
+    private readonly repo;
+    constructor(deps: InventoryServiceDeps);
+    private pickWarehouse;
+    createWarehouse(input: Partial<Warehouse>, actor?: Actor | null, ctx?: TxContext): Promise<Result<Warehouse>>;
+    listWarehouses(actor?: Actor | null, ctx?: TxContext): Promise<Result<Warehouse[]>>;
+    getAvailable(entityId: string, variantId?: string, ctx?: TxContext): Promise<Result<number>>;
+    listLevels(params?: {
+        warehouseId?: string;
+        entityId?: string;
+    }, actor?: Actor | null, ctx?: TxContext): Promise<Result<InventoryLevel[]>>;
+    checkMultiple(entityIds: string[], ctx?: TxContext): Promise<Result<Record<string, number>>>;
+    getLevelsByEntityId(entityId: string, ctx?: TxContext): Promise<Result<InventoryLevel[]>>;
+    reserve(input: InventoryReserveInput, actor?: Actor | null, ctx?: TxContext): Promise<Result<void>>;
+    release(input: InventoryReleaseInput, actor?: Actor | null, ctx?: TxContext): Promise<Result<void>>;
+    adjust(input: InventoryAdjustInput, actor?: Actor | null, ctx?: TxContext): Promise<Result<InventoryLevel>>;
+    /**
+     * Set inventory to an absolute quantity (not a delta).
+     *
+     * Used by external store webhooks where the source system reports
+     * the current stock level (e.g., Shopify sends `{ available: 6 }`).
+     * Computes the delta internally so audit movements stay correct.
+     */
+    setAbsolute(input: {
+        entityId: string;
+        quantity: number;
+        warehouseId?: string;
+        variantId?: string;
+        reason?: string;
+    }, actor?: Actor | null, ctx?: TxContext): Promise<Result<InventoryLevel>>;
+    /**
+     * Deduct inventory on fulfillment (system-level, no permission check).
+     *
+     * Decrements quantityOnHand for fulfilled items. This is a system
+     * operation triggered by order status → fulfilled, not a manual
+     * stock adjustment. Creates a "fulfillment" type movement for audit.
+     *
+     * Net effect when paired with release():
+     *   Before: on_hand=100, reserved=5, available=95
+     *   After deduct+release: on_hand=95, reserved=0, available=95
+     */
+    deductForFulfillment(input: {
+        entityId: string;
+        variantId?: string;
+        warehouseId?: string;
+        quantity: number;
+        orderId: string;
+        orgId?: string;
+    }, ctx?: TxContext): Promise<Result<void>>;
+    setUnitCost(entityId: string, warehouseId: string, unitCost: number, variantId?: string, ctx?: TxContext): Promise<Result<InventoryLevel>>;
+}
+//# sourceMappingURL=service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../src/modules/inventory/service.ts"],"names":[],"mappings":"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"}

package/dist/modules/inventory/service.js

@@ -0,0 +1,283 @@
+import { resolveOrgId } from "../../auth/org.js";
+import { assertPermission } from "../../auth/permissions.js";
+import { CommerceNotFoundError, CommerceValidationError, toCommerceError, } from "../../kernel/errors.js";
+import { runAfterHooks } from "../../kernel/hooks/executor.js";
+import { createHookContext } from "../../kernel/hooks/create-context.js";
+import { Err, Ok } from "../../kernel/result.js";
+import { createLogger } from "../../utils/logger.js";
+import { createTxContext } from "../../kernel/database/tx-context.js";
+export class InventoryService {
+    deps;
+    repo;
+    constructor(deps) {
+        this.deps = deps;
+        this.repo = deps.repository;
+    }
+    async pickWarehouse(actor, ctx) {
+        const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+        const warehouses = await this.repo.findAllWarehouses(orgId, ctx);
+        const sorted = warehouses.sort((a, b) => a.priority - b.priority);
+        if (sorted.length > 0) {
+            return sorted[0].id;
+        }
+        // Create default warehouse if none exists
+        const defaultWarehouse = await this.repo.createWarehouse({
+            organizationId: orgId,
+            name: "Default Warehouse",
+            code: "DEFAULT",
+            isActive: true,
+            priority: 0,
+            metadata: {},
+        }, ctx);
+        return defaultWarehouse.id;
+    }
+    async createWarehouse(input, actor, ctx) {
+        if (!input.name || !input.code) {
+            return Err(new CommerceValidationError("Warehouse name and code are required."));
+        }
+        const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+        const warehouse = await this.repo.createWarehouse({
+            organizationId: orgId,
+            name: input.name,
+            code: input.code,
+            isActive: input.isActive ?? true,
+            priority: input.priority ?? 0,
+            metadata: input.metadata ?? {},
+            ...(input.address !== undefined ? { address: input.address } : {}),
+        }, ctx);
+        return Ok(warehouse);
+    }
+    async listWarehouses(actor, ctx) {
+        const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+        const warehouses = await this.repo.findAllWarehouses(orgId, ctx);
+        return Ok(warehouses.sort((a, b) => a.priority - b.priority));
+    }
+    async getAvailable(entityId, variantId, ctx) {
+        const available = await this.repo.getAvailableQuantity(entityId, variantId, ctx);
+        return Ok(available);
+    }
+    async listLevels(params, actor, ctx) {
+        if (params?.entityId) {
+            const levels = await this.repo.findLevelsByEntityId(params.entityId, ctx);
+            return Ok(levels);
+        }
+        if (params?.warehouseId) {
+            const levels = await this.repo.findLevelsByWarehouseId(params.warehouseId, ctx);
+            return Ok(levels);
+        }
+        const levels = await this.repo.findAllLevels(ctx);
+        return Ok(levels);
+    }
+    async checkMultiple(entityIds, ctx) {
+        const data = await this.repo.getAvailableQuantities(entityIds, ctx);
+        return Ok(data);
+    }
+    async getLevelsByEntityId(entityId, ctx) {
+        const levels = await this.repo.findLevelsByEntityId(entityId, ctx);
+        return Ok(levels);
+    }
+    async reserve(input, actor, ctx) {
+        if (input.quantity <= 0) {
+            return Err(new CommerceValidationError("Reservation quantity must be greater than zero."));
+        }
+        const warehouseId = input.warehouseId ?? (await this.pickWarehouse(actor, ctx));
+        const performedBy = input.performedBy ?? actor?.userId ?? "system";
+        const variantId = input.variantId ?? null;
+        // If we have a transaction context, use the concurrency-safe
+        // reserveWithLock (SELECT FOR UPDATE). This is the correct path
+        // for checkout — it prevents two concurrent requests from both
+        // reserving the last unit.
+        if (ctx?.tx) {
+            const reserveResult = await this.repo.reserveWithLock(input.entityId, variantId, warehouseId, input.quantity, ctx);
+            if (!reserveResult.ok) {
+                return Err(new CommerceValidationError(reserveResult.reason));
+            }
+            await this.repo.createMovement({
+                entityId: input.entityId,
+                warehouseId,
+                type: "reservation",
+                quantity: input.quantity,
+                performedBy,
+                referenceType: "order",
+                referenceId: input.orderId,
+                ...(input.variantId != null
+                    ? { variantId: input.variantId }
+                    : {}),
+            }, ctx);
+            return Ok(undefined);
+        }
+        // Fallback: no transaction provided. Wrap in a transaction so we can
+        // use reserveWithLock (SELECT FOR UPDATE) for concurrency safety.
+        const result = await this.deps.database.transaction(async (tx) => {
+            const txCtx = createTxContext(tx, { actor: actor ?? null });
+            const reserveResult = await this.repo.reserveWithLock(input.entityId, variantId, warehouseId, input.quantity, txCtx);
+            if (!reserveResult.ok) {
+                return Err(new CommerceValidationError(reserveResult.reason));
+            }
+            await this.repo.createMovement({
+                entityId: input.entityId,
+                warehouseId,
+                type: "reservation",
+                quantity: input.quantity,
+                performedBy,
+                referenceType: "order",
+                referenceId: input.orderId,
+                ...(input.variantId != null
+                    ? { variantId: input.variantId }
+                    : {}),
+            }, txCtx);
+            return Ok(undefined);
+        });
+        return result;
+    }
+    async release(input, actor, ctx) {
+        const warehouseId = input.warehouseId ?? (await this.pickWarehouse(actor, ctx));
+        const performedBy = input.performedBy ?? actor?.userId ?? "system";
+        const variantId = input.variantId ?? null;
+        const doRelease = async (txCtx) => {
+            const releaseResult = await this.repo.releaseWithLock(input.entityId, variantId, warehouseId, input.quantity, txCtx);
+            if (!releaseResult.ok) {
+                return Err(new CommerceValidationError(releaseResult.reason));
+            }
+            await this.repo.createMovement({
+                entityId: input.entityId,
+                warehouseId,
+                type: "release",
+                quantity: input.quantity,
+                performedBy,
+                referenceType: "order",
+                referenceId: input.orderId,
+                ...(input.variantId != null
+                    ? { variantId: input.variantId }
+                    : {}),
+            }, txCtx);
+            return Ok(undefined);
+        };
+        // If we already have a transaction, use it directly
+        if (ctx?.tx) {
+            return doRelease(ctx);
+        }
+        // Otherwise wrap in a new transaction for locking safety
+        return this.deps.database.transaction(async (tx) => {
+            return doRelease(createTxContext(tx, { actor: actor ?? null }));
+        });
+    }
+    async adjust(input, actor, ctx) {
+        try {
+            assertPermission(actor ?? null, "inventory:adjust");
+        }
+        catch (error) {
+            return Err(toCommerceError(error));
+        }
+        const warehouseId = input.warehouseId ?? (await this.pickWarehouse(actor, ctx));
+        // Use upsertLevel to create or update
+        const existingLevel = await this.repo.findLevelByKey(input.entityId, warehouseId, input.variantId, ctx);
+        let level;
+        if (existingLevel) {
+            const newQuantity = Math.max(0, existingLevel.quantityOnHand + input.adjustment);
+            const updated = await this.repo.updateLevel(existingLevel.id, { quantityOnHand: newQuantity }, ctx);
+            level = updated;
+        }
+        else {
+            level = await this.repo.createLevel({
+                entityId: input.entityId,
+                warehouseId,
+                quantityOnHand: Math.max(0, input.adjustment),
+                quantityReserved: 0,
+                quantityIncoming: 0,
+                ...(input.variantId !== undefined
+                    ? { variantId: input.variantId }
+                    : {}),
+            }, ctx);
+        }
+        await this.repo.createMovement({
+            entityId: input.entityId,
+            warehouseId,
+            type: "adjustment",
+            quantity: input.adjustment,
+            reason: input.reason,
+            performedBy: input.performedBy ?? actor?.userId ?? "system",
+            ...(input.variantId !== undefined
+                ? { variantId: input.variantId }
+                : {}),
+            ...(input.referenceType !== undefined
+                ? { referenceType: input.referenceType }
+                : {}),
+            ...(input.referenceId !== undefined
+                ? { referenceId: input.referenceId }
+                : {}),
+        }, ctx);
+        const context = createHookContext({
+            actor: actor ?? null,
+            tx: ctx?.tx ?? null,
+            logger: createLogger("inventory.adjust"),
+            services: this.deps.services,
+            context: { moduleName: "inventory" },
+        });
+        const afterHooks = this.deps.hooks.resolve("inventory.afterAdjust");
+        await runAfterHooks(afterHooks, null, level, "update", context);
+        return Ok(level);
+    }
+    /**
+     * Set inventory to an absolute quantity (not a delta).
+     *
+     * Used by external store webhooks where the source system reports
+     * the current stock level (e.g., Shopify sends `{ available: 6 }`).
+     * Computes the delta internally so audit movements stay correct.
+     */
+    async setAbsolute(input, actor, ctx) {
+        const warehouseId = input.warehouseId ?? (await this.pickWarehouse(actor, ctx));
+        const existingLevel = await this.repo.findLevelByKey(input.entityId, warehouseId, input.variantId, ctx);
+        const currentOnHand = existingLevel?.quantityOnHand ?? 0;
+        const delta = input.quantity - currentOnHand;
+        // Delegate to adjust() so hooks, movements, and permission checks are consistent
+        return this.adjust({
+            entityId: input.entityId,
+            warehouseId,
+            adjustment: delta,
+            reason: input.reason ?? "External store absolute inventory sync",
+            ...(input.variantId !== undefined ? { variantId: input.variantId } : {}),
+        }, actor, ctx);
+    }
+    /**
+     * Deduct inventory on fulfillment (system-level, no permission check).
+     *
+     * Decrements quantityOnHand for fulfilled items. This is a system
+     * operation triggered by order status → fulfilled, not a manual
+     * stock adjustment. Creates a "fulfillment" type movement for audit.
+     *
+     * Net effect when paired with release():
+     *   Before: on_hand=100, reserved=5, available=95
+     *   After deduct+release: on_hand=95, reserved=0, available=95
+     */
+    async deductForFulfillment(input, ctx) {
+        const warehouseId = input.warehouseId ?? (await this.pickWarehouse(null, ctx));
+        const variantId = input.variantId ?? null;
+        const level = await this.repo.findLevelByKey(input.entityId, warehouseId, variantId != null ? variantId : undefined, ctx);
+        if (!level) {
+            // No inventory record — nothing to deduct
+            return Ok(undefined);
+        }
+        const newOnHand = Math.max(0, level.quantityOnHand - input.quantity);
+        await this.repo.updateLevel(level.id, { quantityOnHand: newOnHand }, ctx);
+        await this.repo.createMovement({
+            entityId: input.entityId,
+            warehouseId,
+            type: "fulfillment",
+            quantity: -input.quantity,
+            performedBy: "system",
+            referenceType: "order",
+            referenceId: input.orderId,
+            ...(variantId != null ? { variantId } : {}),
+        }, ctx);
+        return Ok(undefined);
+    }
+    async setUnitCost(entityId, warehouseId, unitCost, variantId, ctx) {
+        const level = await this.repo.findLevelByKey(entityId, warehouseId, variantId, ctx);
+        if (!level) {
+            return Err(new CommerceNotFoundError(`Inventory level not found for entity ${entityId} at warehouse ${warehouseId}.`));
+        }
+        const updated = await this.repo.updateLevel(level.id, { unitCost }, ctx);
+        return Ok(updated);
+    }
+}

package/dist/modules/media/adapter.d.ts

@@ -0,0 +1,16 @@
+import type { Result } from "../../kernel/result.js";
+export interface StoredFile {
+    key: string;
+    url: string;
+    contentType: string;
+    size?: number;
+}
+export interface StorageAdapter {
+    readonly providerId: string;
+    upload(key: string, data: ArrayBuffer | ReadableStream, contentType: string): Promise<Result<StoredFile>>;
+    getUrl(key: string): Promise<Result<string>>;
+    getSignedUrl(key: string, expiresIn: number): Promise<Result<string>>;
+    delete(key: string): Promise<Result<void>>;
+    list(prefix: string): Promise<Result<StoredFile[]>>;
+}
+//# sourceMappingURL=adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/modules/media/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,cAAc,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC;IAC1G,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAC7C,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IACtE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3C,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;CACrD"}

package/dist/modules/media/adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/modules/media/repository/index.d.ts

@@ -0,0 +1,35 @@
+import type { TxContext } from "../../../kernel/database/tx-context.js";
+import type { DrizzleDatabase } from "../../../kernel/database/drizzle-db.js";
+import { mediaAssets, entityMedia } from "../schema.js";
+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 declare class MediaRepository {
+    private readonly db;
+    constructor(db: DrizzleDatabase);
+    private getDb;
+    findAssetById(id: string, ctx?: TxContext, orgId?: string): Promise<MediaAsset | undefined>;
+    findAssetByStorageKey(storageKey: string, ctx?: TxContext): Promise<MediaAsset | undefined>;
+    findAssetsByIds(ids: string[], ctx?: TxContext): Promise<MediaAsset[]>;
+    createAsset(data: MediaAssetInsert, ctx?: TxContext): Promise<MediaAsset>;
+    updateAsset(id: string, data: Partial<Omit<MediaAssetInsert, "id">>, ctx?: TxContext): Promise<MediaAsset | undefined>;
+    deleteAsset(id: string, ctx?: TxContext): Promise<boolean>;
+    findEntityMedia(entityId: string, variantId?: string, ctx?: TxContext): Promise<EntityMedia[]>;
+    findEntityMediaByRole(entityId: string, role: EntityMedia["role"], variantId?: string, ctx?: TxContext): Promise<EntityMedia[]>;
+    findPrimaryMedia(entityId: string, variantId?: string, ctx?: TxContext): Promise<EntityMedia | undefined>;
+    createEntityMedia(data: EntityMediaInsert, ctx?: TxContext): Promise<EntityMedia>;
+    createEntityMediaBatch(data: EntityMediaInsert[], ctx?: TxContext): Promise<EntityMedia[]>;
+    updateEntityMediaSortOrder(entityId: string, mediaAssetId: string, sortOrder: number, variantId?: string, ctx?: TxContext): Promise<EntityMedia | undefined>;
+    removeEntityMedia(entityId: string, mediaAssetId: string, variantId?: string, ctx?: TxContext): Promise<boolean>;
+    removeAllEntityMedia(entityId: string, ctx?: TxContext): Promise<void>;
+    removeAllMediaByAssetId(mediaAssetId: string, ctx?: TxContext): Promise<void>;
+    findAssetsForEntity(entityId: string, variantId?: string, ctx?: TxContext): Promise<MediaAsset[]>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/media/repository/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/media/repository/index.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,176 @@
+import { eq, and, inArray } from "drizzle-orm";
+import { mediaAssets, entityMedia } from "../schema.js";
+/**
+ * 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);
+    }
+}