@unifiedcommerce/core 0.0.1

package/dist/kernel/database/drizzle-db.js

@@ -0,0 +1,20 @@
+/**
+ * Drizzle Database Type Definitions
+ *
+ * This module provides type-safe, driver-agnostic database access for
+ * PostgreSQL repositories.
+ *
+ * We use `PgDatabase` from `drizzle-orm/pg-core` — the base class that all
+ * PostgreSQL drivers extend (postgres-js, pglite, node-postgres, bun-sql).
+ * This means:
+ *
+ * - Repositories accept any PG driver without casts
+ * - PGlite in tests and postgres-js in production use the same type
+ * - Row types are fully inferred from pgTable schema definitions
+ * - No coupling to any specific driver package
+ */
+import * as schema from "./schema";
+/**
+ * Re-export schema for convenience
+ */
+export { schema };

package/dist/kernel/database/migrate.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Programmatic database schema management.
+ *
+ * For npm consumers who don't have access to the raw .ts schema files,
+ * this module provides:
+ *
+ * 1. `getSchemaFiles()` — returns schema module paths for use in drizzle.config.ts
+ * 2. `getSchema()` — returns the combined Drizzle schema object
+ * 3. `pushSchema()` — programmatic push (creates tables if not exist)
+ *
+ * Usage in consumer's drizzle.config.ts:
+ *
+ *   import { getSchema } from "@unifiedcommerce/core";
+ *   import { defineConfig } from "drizzle-kit";
+ *
+ *   export default defineConfig({
+ *     dialect: "postgresql",
+ *     schema: getSchema(),
+ *     dbCredentials: { url: process.env.DATABASE_URL! },
+ *   });
+ */
+import type { CommerceConfig } from "../../config/types";
+import * as schema from "./schema";
+/**
+ * Returns the combined Drizzle schema object with all table definitions.
+ * Use this in your own drizzle.config.ts or for programmatic schema inspection.
+ */
+export declare function getSchema(): typeof schema;
+/**
+ * Returns core schema merged with all plugin schemas from `config.customSchemas[]`.
+ * Throws if a plugin table name collides with a core table name.
+ */
+export declare function buildSchema(config?: CommerceConfig): Record<string, unknown>;
+/**
+ * Returns a list of all schema table names defined by the commerce engine.
+ */
+export declare function getTableNames(): string[];
+//# sourceMappingURL=migrate.d.ts.map

package/dist/kernel/database/migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../../../src/kernel/database/migrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAEnC;;;GAGG;AACH,wBAAgB,SAAS,kBAExB;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAwB5E;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,MAAM,EAAE,CASxC"}

package/dist/kernel/database/migrate.js

@@ -0,0 +1,61 @@
+/**
+ * Programmatic database schema management.
+ *
+ * For npm consumers who don't have access to the raw .ts schema files,
+ * this module provides:
+ *
+ * 1. `getSchemaFiles()` — returns schema module paths for use in drizzle.config.ts
+ * 2. `getSchema()` — returns the combined Drizzle schema object
+ * 3. `pushSchema()` — programmatic push (creates tables if not exist)
+ *
+ * Usage in consumer's drizzle.config.ts:
+ *
+ *   import { getSchema } from "@unifiedcommerce/core";
+ *   import { defineConfig } from "drizzle-kit";
+ *
+ *   export default defineConfig({
+ *     dialect: "postgresql",
+ *     schema: getSchema(),
+ *     dbCredentials: { url: process.env.DATABASE_URL! },
+ *   });
+ */
+import * as schema from "./schema";
+/**
+ * Returns the combined Drizzle schema object with all table definitions.
+ * Use this in your own drizzle.config.ts or for programmatic schema inspection.
+ */
+export function getSchema() {
+    return schema;
+}
+/**
+ * Returns core schema merged with all plugin schemas from `config.customSchemas[]`.
+ * Throws if a plugin table name collides with a core table name.
+ */
+export function buildSchema(config) {
+    const merged = { ...schema };
+    if (!config?.customSchemas?.length)
+        return merged;
+    const coreKeys = new Set(Object.keys(schema));
+    for (const pluginSchema of config.customSchemas) {
+        for (const [key, value] of Object.entries(pluginSchema)) {
+            if (coreKeys.has(key)) {
+                throw new Error(`Plugin schema name collision: "${key}" already exists in core schema`);
+            }
+            if (key in merged) {
+                throw new Error(`Plugin schema name collision: "${key}" is defined by multiple plugins`);
+            }
+            merged[key] = value;
+        }
+    }
+    return merged;
+}
+/**
+ * Returns a list of all schema table names defined by the commerce engine.
+ */
+export function getTableNames() {
+    return Object.entries(schema)
+        .filter(([_, value]) => value != null &&
+        typeof value === "object" &&
+        "getSQL" in value)
+        .map(([key]) => key);
+}

package/dist/kernel/database/plugin-types.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Canonical database types for plugin service constructors.
+ *
+ * Replaces the copy-pasted type definitions in every plugin's types.ts:
+ *   type Db = PgDatabase<PgQueryResultHKT, Record<string, unknown>>
+ *
+ * Import from core instead:
+ *   import type { PluginDb, PluginTxFn } from "@unifiedcommerce/core";
+ */
+import type { PgDatabase, PgQueryResultHKT } from "drizzle-orm/pg-core";
+/**
+ * Database instance type for plugin services.
+ * This is the Drizzle PgDatabase with an opaque schema record.
+ */
+export type PluginDb = PgDatabase<PgQueryResultHKT, Record<string, unknown>>;
+/**
+ * Transaction function type for plugin services that need
+ * transactional guarantees (e.g., POS transaction complete,
+ * gift card debit, inventory reservation).
+ *
+ * Usage:
+ *   constructor(private db: PluginDb, private txFn: PluginTxFn) {}
+ *
+ *   async doWork() {
+ *     return this.txFn(async (tx) => {
+ *       await tx.insert(...).values(...);
+ *       await tx.update(...).set(...);
+ *     });
+ *   }
+ */
+export type PluginTxFn = <T>(fn: (tx: PluginDb) => Promise<T>) => Promise<T>;
+//# sourceMappingURL=plugin-types.d.ts.map

package/dist/kernel/database/plugin-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-types.d.ts","sourceRoot":"","sources":["../../../src/kernel/database/plugin-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAExE;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAE7E;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC"}

package/dist/kernel/database/plugin-types.js

@@ -0,0 +1,10 @@
+/**
+ * Canonical database types for plugin service constructors.
+ *
+ * Replaces the copy-pasted type definitions in every plugin's types.ts:
+ *   type Db = PgDatabase<PgQueryResultHKT, Record<string, unknown>>
+ *
+ * Import from core instead:
+ *   import type { PluginDb, PluginTxFn } from "@unifiedcommerce/core";
+ */
+export {};

package/dist/kernel/database/schema.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Combined schema barrel for Drizzle.
+ *
+ * Single source of truth for all core table definitions. Both drizzle-kit
+ * (via drizzle.config.ts) and the TypeScript type system consume this file.
+ *
+ * Drizzle-kit resolves re-exports, so pointing the config schema option
+ * at this one file discovers every core table. Plugin schemas live in
+ * their own packages and are referenced via glob patterns.
+ */
+export * from "../../auth/auth-schema";
+export * from "../../modules/catalog/schema";
+export * from "../../modules/inventory/schema";
+export * from "../../modules/cart/schema";
+export * from "../../modules/orders/schema";
+export * from "../../modules/customers/schema";
+export * from "../../modules/pricing/schema";
+export * from "../../modules/promotions/schema";
+export * from "../../modules/media/schema";
+export * from "../../modules/webhooks/schema";
+export * from "../../modules/fulfillment/schema";
+export * from "../jobs/schema";
+export * from "../../modules/audit/schema";
+//# sourceMappingURL=schema.d.ts.map

package/dist/kernel/database/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/kernel/database/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,cAAc,wBAAwB,CAAC;AAGvC,cAAc,8BAA8B,CAAC;AAG7C,cAAc,gCAAgC,CAAC;AAG/C,cAAc,2BAA2B,CAAC;AAG1C,cAAc,6BAA6B,CAAC;AAG5C,cAAc,gCAAgC,CAAC;AAG/C,cAAc,8BAA8B,CAAC;AAG7C,cAAc,iCAAiC,CAAC;AAGhD,cAAc,4BAA4B,CAAC;AAG3C,cAAc,+BAA+B,CAAC;AAG9C,cAAc,kCAAkC,CAAC;AAGjD,cAAc,gBAAgB,CAAC;AAG/B,cAAc,4BAA4B,CAAC"}

package/dist/kernel/database/schema.js

@@ -0,0 +1,36 @@
+/**
+ * Combined schema barrel for Drizzle.
+ *
+ * Single source of truth for all core table definitions. Both drizzle-kit
+ * (via drizzle.config.ts) and the TypeScript type system consume this file.
+ *
+ * Drizzle-kit resolves re-exports, so pointing the config schema option
+ * at this one file discovers every core table. Plugin schemas live in
+ * their own packages and are referenced via glob patterns.
+ */
+// Auth (Better Auth generated tables)
+export * from "../../auth/auth-schema";
+// Catalog module
+export * from "../../modules/catalog/schema";
+// Inventory module
+export * from "../../modules/inventory/schema";
+// Cart module
+export * from "../../modules/cart/schema";
+// Orders module
+export * from "../../modules/orders/schema";
+// Customers module
+export * from "../../modules/customers/schema";
+// Pricing module
+export * from "../../modules/pricing/schema";
+// Promotions module
+export * from "../../modules/promotions/schema";
+// Media module
+export * from "../../modules/media/schema";
+// Webhooks module
+export * from "../../modules/webhooks/schema";
+// Fulfillment module
+export * from "../../modules/fulfillment/schema";
+// Jobs (kernel)
+export * from "../jobs/schema";
+// Audit module
+export * from "../../modules/audit/schema";

package/dist/kernel/database/scoped-db.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Scoped DB Proxy
+ *
+ * Wraps a Drizzle PgDatabase instance so that INSERT operations on
+ * org-scoped tables automatically include the actor's organizationId.
+ *
+ * Plugin route handlers receive this scoped db via the router() builder.
+ * They write normal Drizzle inserts without ever mentioning organizationId:
+ *
+ *   const [card] = await db.insert(giftCards)
+ *     .values({ code: "ABC", balance: 5000 })
+ *     .returning();
+ *   // organizationId is auto-set from the actor context
+ *
+ * SELECT/UPDATE/DELETE scoping is handled at the repository/service layer
+ * via resolveOrgId(). The proxy focuses on INSERT auto-stamping because
+ * that is the operation most commonly forgotten by plugin developers.
+ */
+export declare function createScopedDb<TDb>(rawDb: TDb, organizationId: string): TDb;
+//# sourceMappingURL=scoped-db.d.ts.map

package/dist/kernel/database/scoped-db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-db.d.ts","sourceRoot":"","sources":["../../../src/kernel/database/scoped-db.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAUH,wBAAgB,cAAc,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,cAAc,EAAE,MAAM,GAAG,GAAG,CAwC3E"}

package/dist/kernel/database/scoped-db.js

@@ -0,0 +1,62 @@
+/**
+ * Scoped DB Proxy
+ *
+ * Wraps a Drizzle PgDatabase instance so that INSERT operations on
+ * org-scoped tables automatically include the actor's organizationId.
+ *
+ * Plugin route handlers receive this scoped db via the router() builder.
+ * They write normal Drizzle inserts without ever mentioning organizationId:
+ *
+ *   const [card] = await db.insert(giftCards)
+ *     .values({ code: "ABC", balance: 5000 })
+ *     .returning();
+ *   // organizationId is auto-set from the actor context
+ *
+ * SELECT/UPDATE/DELETE scoping is handled at the repository/service layer
+ * via resolveOrgId(). The proxy focuses on INSERT auto-stamping because
+ * that is the operation most commonly forgotten by plugin developers.
+ */
+import { getTableColumns } from "drizzle-orm";
+function isOrgScoped(table) {
+    const columns = getTableColumns(table);
+    return "organizationId" in columns;
+}
+export function createScopedDb(rawDb, organizationId) {
+    if (!rawDb || typeof rawDb !== "object")
+        return rawDb;
+    return new Proxy(rawDb, {
+        get(target, prop, receiver) {
+            const value = Reflect.get(target, prop, receiver);
+            if (prop === "insert" && typeof value === "function") {
+                return (table) => {
+                    const builder = value.call(target, table);
+                    if (!isOrgScoped(table))
+                        return builder;
+                    // Wrap .values() to auto-inject organizationId
+                    const originalValues = builder.values;
+                    if (typeof originalValues !== "function")
+                        return builder;
+                    return new Proxy(builder, {
+                        get(t, p, r) {
+                            if (p === "values") {
+                                return (data) => {
+                                    const stamp = (row) => ({
+                                        ...row,
+                                        organizationId,
+                                    });
+                                    const stamped = Array.isArray(data)
+                                        ? data.map(stamp)
+                                        : stamp(data);
+                                    return originalValues.call(t, stamped);
+                                };
+                            }
+                            const v = Reflect.get(t, p, r);
+                            return typeof v === "function" ? v.bind(t) : v;
+                        },
+                    });
+                };
+            }
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+}

package/dist/kernel/database/tx-context.d.ts

@@ -0,0 +1,15 @@
+import type { Actor } from "../../auth/types";
+import type { DatabaseAdapter } from "./adapter";
+export interface TxContext<TTx = unknown> {
+    tx: TTx;
+    actor: Actor | null;
+    requestId: string;
+}
+export interface WithTransactionOptions {
+    actor: Actor | null;
+    requestId?: string;
+}
+export declare function createTxContext<TTx>(tx: TTx, options: WithTransactionOptions): TxContext<TTx>;
+export declare function withTransaction<TDb, TTx, TResult>(database: DatabaseAdapter<TDb, TTx>, options: WithTransactionOptions, fn: (ctx: TxContext<TTx>) => Promise<TResult>): Promise<TResult>;
+export declare function reuseOrCreateTxContext<TTx>(tx: TTx, options: WithTransactionOptions, existing?: TxContext<TTx> | null): TxContext<TTx>;
+//# sourceMappingURL=tx-context.d.ts.map

package/dist/kernel/database/tx-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx-context.d.ts","sourceRoot":"","sources":["../../../src/kernel/database/tx-context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,MAAM,WAAW,SAAS,CAAC,GAAG,GAAG,OAAO;IACtC,EAAE,EAAE,GAAG,CAAC;IACR,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,eAAe,CAAC,GAAG,EACjC,EAAE,EAAE,GAAG,EACP,OAAO,EAAE,sBAAsB,GAC9B,SAAS,CAAC,GAAG,CAAC,CAMhB;AAED,wBAAsB,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EACrD,QAAQ,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,CAAC,EACnC,OAAO,EAAE,sBAAsB,EAC/B,EAAE,EAAE,CAAC,GAAG,EAAE,SAAS,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,GAC5C,OAAO,CAAC,OAAO,CAAC,CAIlB;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EACxC,EAAE,EAAE,GAAG,EACP,OAAO,EAAE,sBAAsB,EAC/B,QAAQ,CAAC,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,GAC/B,SAAS,CAAC,GAAG,CAAC,CAKhB"}

package/dist/kernel/database/tx-context.js

@@ -0,0 +1,19 @@
+import { randomUUID } from "node:crypto";
+export function createTxContext(tx, options) {
+    return {
+        tx,
+        actor: options.actor,
+        requestId: options.requestId ?? randomUUID(),
+    };
+}
+export async function withTransaction(database, options, fn) {
+    return database.transaction(async (tx) => {
+        return fn(createTxContext(tx, options));
+    });
+}
+export function reuseOrCreateTxContext(tx, options, existing) {
+    if (existing) {
+        return existing;
+    }
+    return createTxContext(tx, options);
+}

package/dist/kernel/error-mapper.d.ts

@@ -0,0 +1,3 @@
+import type { ContentfulStatusCode } from "hono/utils/http-status";
+export declare function mapErrorToStatus(error: unknown): ContentfulStatusCode;
+//# sourceMappingURL=error-mapper.d.ts.map

package/dist/kernel/error-mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-mapper.d.ts","sourceRoot":"","sources":["../../src/kernel/error-mapper.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAUnE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,oBAAoB,CAGrE"}

package/dist/kernel/error-mapper.js

@@ -0,0 +1,12 @@
+import { toCommerceError } from "./errors";
+const statusByCode = {
+    NOT_FOUND: 404,
+    VALIDATION_FAILED: 422,
+    FORBIDDEN: 403,
+    CONFLICT: 409,
+    INVALID_TRANSITION: 422,
+};
+export function mapErrorToStatus(error) {
+    const normalized = toCommerceError(error);
+    return statusByCode[normalized.code] ?? 500;
+}

package/dist/kernel/errors.d.ts

@@ -0,0 +1,38 @@
+export interface CommerceError {
+    code: string;
+    message: string;
+    details?: unknown;
+}
+export interface FieldError {
+    field: string;
+    message: string;
+}
+export declare class CommerceNotFoundError extends Error implements CommerceError {
+    details?: unknown | undefined;
+    code: "NOT_FOUND";
+    constructor(message: string, details?: unknown | undefined);
+}
+export declare class CommerceValidationError extends Error implements CommerceError {
+    fieldErrors?: FieldError[] | undefined;
+    details?: unknown | undefined;
+    code: "VALIDATION_FAILED";
+    constructor(message: string, fieldErrors?: FieldError[] | undefined, details?: unknown | undefined);
+}
+export declare class CommerceForbiddenError extends Error implements CommerceError {
+    details?: unknown | undefined;
+    code: "FORBIDDEN";
+    constructor(message: string, details?: unknown | undefined);
+}
+export declare class CommerceConflictError extends Error implements CommerceError {
+    details?: unknown | undefined;
+    code: "CONFLICT";
+    constructor(message: string, details?: unknown | undefined);
+}
+export declare class CommerceInvalidTransitionError extends Error implements CommerceError {
+    details?: unknown | undefined;
+    code: "INVALID_TRANSITION";
+    constructor(message: string, details?: unknown | undefined);
+}
+export declare function isCommerceError(value: unknown): value is CommerceError;
+export declare function toCommerceError(error: unknown): CommerceError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/kernel/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/kernel/errors.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,qBAAsB,SAAQ,KAAM,YAAW,aAAa;IAI9D,OAAO,CAAC,EAAE,OAAO;IAH1B,IAAI,EAAG,WAAW,CAAU;gBAE1B,OAAO,EAAE,MAAM,EACR,OAAO,CAAC,EAAE,OAAO,YAAA;CAK3B;AAED,qBAAa,uBAAwB,SAAQ,KAAM,YAAW,aAAa;IAIhE,WAAW,CAAC,EAAE,UAAU,EAAE;IAC1B,OAAO,CAAC,EAAE,OAAO;IAJ1B,IAAI,EAAG,mBAAmB,CAAU;gBAElC,OAAO,EAAE,MAAM,EACR,WAAW,CAAC,EAAE,UAAU,EAAE,YAAA,EAC1B,OAAO,CAAC,EAAE,OAAO,YAAA;CAK3B;AAED,qBAAa,sBAAuB,SAAQ,KAAM,YAAW,aAAa;IAI/D,OAAO,CAAC,EAAE,OAAO;IAH1B,IAAI,EAAG,WAAW,CAAU;gBAE1B,OAAO,EAAE,MAAM,EACR,OAAO,CAAC,EAAE,OAAO,YAAA;CAK3B;AAED,qBAAa,qBAAsB,SAAQ,KAAM,YAAW,aAAa;IAI9D,OAAO,CAAC,EAAE,OAAO;IAH1B,IAAI,EAAG,UAAU,CAAU;gBAEzB,OAAO,EAAE,MAAM,EACR,OAAO,CAAC,EAAE,OAAO,YAAA;CAK3B;AAED,qBAAa,8BAA+B,SAAQ,KAAM,YAAW,aAAa;IAIvE,OAAO,CAAC,EAAE,OAAO;IAH1B,IAAI,EAAG,oBAAoB,CAAU;gBAEnC,OAAO,EAAE,MAAM,EACR,OAAO,CAAC,EAAE,OAAO,YAAA;CAK3B;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAGtE;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,CAgB7D"}

package/dist/kernel/errors.js

@@ -0,0 +1,69 @@
+export class CommerceNotFoundError extends Error {
+    details;
+    code = "NOT_FOUND";
+    constructor(message, details) {
+        super(message);
+        this.details = details;
+        this.name = "CommerceNotFoundError";
+    }
+}
+export class CommerceValidationError extends Error {
+    fieldErrors;
+    details;
+    code = "VALIDATION_FAILED";
+    constructor(message, fieldErrors, details) {
+        super(message);
+        this.fieldErrors = fieldErrors;
+        this.details = details;
+        this.name = "CommerceValidationError";
+    }
+}
+export class CommerceForbiddenError extends Error {
+    details;
+    code = "FORBIDDEN";
+    constructor(message, details) {
+        super(message);
+        this.details = details;
+        this.name = "CommerceForbiddenError";
+    }
+}
+export class CommerceConflictError extends Error {
+    details;
+    code = "CONFLICT";
+    constructor(message, details) {
+        super(message);
+        this.details = details;
+        this.name = "CommerceConflictError";
+    }
+}
+export class CommerceInvalidTransitionError extends Error {
+    details;
+    code = "INVALID_TRANSITION";
+    constructor(message, details) {
+        super(message);
+        this.details = details;
+        this.name = "CommerceInvalidTransitionError";
+    }
+}
+export function isCommerceError(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    return "code" in value && "message" in value;
+}
+export function toCommerceError(error) {
+    if (isCommerceError(error)) {
+        return error;
+    }
+    if (error instanceof Error) {
+        return {
+            code: "INTERNAL_ERROR",
+            message: error.message,
+            details: { name: error.name },
+        };
+    }
+    return {
+        code: "INTERNAL_ERROR",
+        message: "Unexpected server error",
+        details: error,
+    };
+}

package/dist/kernel/factory/in-memory-repository-factory.d.ts

@@ -0,0 +1,20 @@
+import type { BaseRepository } from "./repository-factory";
+/**
+ * Creates an in-memory implementation of BaseRepository for testing.
+ *
+ * Data is stored in a Map<string, TRow>. The `_store` property is exposed
+ * for test assertions (e.g., checking store size, seeding data).
+ *
+ * Usage:
+ * ```typescript
+ * const repo = createInMemoryRepository<Promotion, PromotionInsert>()
+ * await repo.create({ id: "promo-1", name: "Summer Sale", ... })
+ * const found = await repo.findById("promo-1")
+ * ```
+ */
+export declare function createInMemoryRepository<TRow extends {
+    id: string;
+}, TInsert>(): BaseRepository<TRow, TInsert> & {
+    _store: Map<string, TRow>;
+};
+//# sourceMappingURL=in-memory-repository-factory.d.ts.map

package/dist/kernel/factory/in-memory-repository-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-repository-factory.d.ts","sourceRoot":"","sources":["../../../src/kernel/factory/in-memory-repository-factory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAwB,MAAM,sBAAsB,CAAC;AAEjF;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EAC3B,OAAO,KACJ,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG;IAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;CAAE,CAoFjE"}

package/dist/kernel/factory/in-memory-repository-factory.js

@@ -0,0 +1,83 @@
+import { CommerceNotFoundError } from "../errors";
+/**
+ * Creates an in-memory implementation of BaseRepository for testing.
+ *
+ * Data is stored in a Map<string, TRow>. The `_store` property is exposed
+ * for test assertions (e.g., checking store size, seeding data).
+ *
+ * Usage:
+ * ```typescript
+ * const repo = createInMemoryRepository<Promotion, PromotionInsert>()
+ * await repo.create({ id: "promo-1", name: "Summer Sale", ... })
+ * const found = await repo.findById("promo-1")
+ * ```
+ */
+export function createInMemoryRepository() {
+    const store = new Map();
+    function generateId() {
+        // Use crypto.randomUUID when available, fall back to timestamp-based
+        if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+            return crypto.randomUUID();
+        }
+        return `mem-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    }
+    function applyFilters(rows, filters) {
+        if (!filters)
+            return rows;
+        return rows.filter((row) => Object.entries(filters).every(([key, value]) => value === undefined || row[key] === value));
+    }
+    function applyPagination(rows, options) {
+        if (!options)
+            return rows;
+        const offset = options.offset ?? 0;
+        const sliced = rows.slice(offset);
+        if (options.limit !== undefined) {
+            return sliced.slice(0, options.limit);
+        }
+        return sliced;
+    }
+    const repo = {
+        _store: store,
+        async findById(id) {
+            return store.get(id);
+        },
+        async findMany(filters, options) {
+            const all = Array.from(store.values());
+            const filtered = applyFilters(all, filters);
+            return applyPagination(filtered, options);
+        },
+        async findAndCount(filters, options) {
+            const all = Array.from(store.values());
+            const filtered = applyFilters(all, filters);
+            const paginated = applyPagination(filtered, options);
+            return { rows: paginated, total: filtered.length };
+        },
+        async create(data) {
+            const id = data.id ??
+                generateId();
+            const row = { ...data, id };
+            store.set(id, row);
+            return row;
+        },
+        async createMany(data) {
+            const results = [];
+            for (const d of data) {
+                results.push(await repo.create(d));
+            }
+            return results;
+        },
+        async update(id, data) {
+            const existing = store.get(id);
+            if (!existing) {
+                throw new CommerceNotFoundError(`Record ${id} not found.`);
+            }
+            const updated = { ...existing, ...data };
+            store.set(id, updated);
+            return updated;
+        },
+        async delete(id) {
+            store.delete(id);
+        },
+    };
+    return repo;
+}