@unifiedcommerce/core 0.0.1

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

@@ -0,0 +1,71 @@
+import { type InferSelectModel, type InferInsertModel } from "drizzle-orm";
+import type { PgTableWithColumns, TableConfig } from "drizzle-orm/pg-core";
+import type { TxContext } from "../database/tx-context";
+import type { DrizzleDatabase } from "../database/drizzle-db";
+/**
+ * Filter type — partial record of column values to match with eq().
+ * Only keys that exist on TRow and have non-undefined values are used.
+ */
+export type Filters<TRow> = Partial<TRow>;
+/**
+ * Options for findMany / findAndCount queries.
+ */
+export interface FindOptions {
+    limit?: number;
+    offset?: number;
+    orderBy?: Array<{
+        column: string;
+        direction: "asc" | "desc";
+    }>;
+    withDeleted?: boolean;
+}
+/**
+ * Standard CRUD operations derived from a Drizzle pgTable schema.
+ * All methods support optional TxContext for transaction participation.
+ */
+export interface BaseRepository<TRow, TInsert> {
+    findById(id: string, ctx?: TxContext): Promise<TRow | undefined>;
+    findMany(filters?: Filters<TRow>, options?: FindOptions, ctx?: TxContext): Promise<TRow[]>;
+    findAndCount(filters?: Filters<TRow>, options?: FindOptions, ctx?: TxContext): Promise<{
+        rows: TRow[];
+        total: number;
+    }>;
+    create(data: TInsert, ctx?: TxContext): Promise<TRow>;
+    createMany(data: TInsert[], ctx?: TxContext): Promise<TRow[]>;
+    update(id: string, data: Partial<TInsert>, ctx?: TxContext): Promise<TRow>;
+    delete(id: string, ctx?: TxContext): Promise<void>;
+}
+/**
+ * Extended repository for tables with a `deleted_at` column.
+ * Adds softDelete and restore operations.
+ */
+export interface SoftDeletableRepository<TRow, TInsert> extends BaseRepository<TRow, TInsert> {
+    softDelete(id: string, ctx?: TxContext): Promise<void>;
+    restore(id: string, ctx?: TxContext): Promise<TRow>;
+}
+/**
+ * Type-level check: does the table config have a `deletedAt` or `deleted_at` column?
+ */
+type HasDeletedAt<T extends PgTableWithColumns<TableConfig>> = "deletedAt" extends keyof T ? true : "deleted_at" extends keyof T ? true : false;
+/**
+ * Conditional repository type: if the table has a deleted_at column,
+ * return SoftDeletableRepository; otherwise BaseRepository.
+ */
+export type RepositoryFor<T extends PgTableWithColumns<TableConfig>> = HasDeletedAt<T> extends true ? SoftDeletableRepository<InferSelectModel<T>, InferInsertModel<T>> : BaseRepository<InferSelectModel<T>, InferInsertModel<T>>;
+/**
+ * Creates a typed repository with standard CRUD operations from a Drizzle table schema.
+ *
+ * Usage:
+ * ```typescript
+ * const repo = createRepository(schema.promotions, db)
+ * const row = await repo.findById("abc-123")
+ * const rows = await repo.findMany({ status: "active" }, { limit: 10 })
+ * ```
+ *
+ * Tables with a `deletedAt` column automatically get `softDelete()` and `restore()`.
+ * Domain-specific queries should remain in dedicated repository classes that
+ * delegate standard CRUD to the factory-created instance.
+ */
+export declare function createRepository<T extends PgTableWithColumns<TableConfig>>(table: T, db: DrizzleDatabase): RepositoryFor<T>;
+export {};
+//# sourceMappingURL=repository-factory.d.ts.map

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

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

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

@@ -0,0 +1,136 @@
+import { eq, and, isNull, sql, getTableColumns, } from "drizzle-orm";
+import { CommerceNotFoundError } from "../errors";
+/**
+ * Creates a typed repository with standard CRUD operations from a Drizzle table schema.
+ *
+ * Usage:
+ * ```typescript
+ * const repo = createRepository(schema.promotions, db)
+ * const row = await repo.findById("abc-123")
+ * const rows = await repo.findMany({ status: "active" }, { limit: 10 })
+ * ```
+ *
+ * Tables with a `deletedAt` column automatically get `softDelete()` and `restore()`.
+ * Domain-specific queries should remain in dedicated repository classes that
+ * delegate standard CRUD to the factory-created instance.
+ */
+export function createRepository(table, db) {
+    // Use getTableColumns for type-safe column access
+    const columns = getTableColumns(table);
+    // Runtime check for soft-delete column
+    const hasSoftDelete = "deletedAt" in columns || "deleted_at" in columns;
+    const deletedAtColumn = columns["deletedAt"] ?? columns["deleted_at"] ?? null;
+    const idColumn = columns["id"];
+    // Drizzle's generic types require PgTable at the boundary.
+    // We cast once here rather than at every call site.
+    const pgTable = table;
+    function getDb(ctx) {
+        return ctx?.tx ?? db;
+    }
+    function buildWhereConditions(filters, includeDeleted = false) {
+        const conditions = [];
+        // Automatically exclude soft-deleted rows unless explicitly requested
+        if (hasSoftDelete && !includeDeleted && deletedAtColumn) {
+            conditions.push(isNull(deletedAtColumn));
+        }
+        if (filters) {
+            for (const [key, value] of Object.entries(filters)) {
+                const col = columns[key];
+                if (value !== undefined && col) {
+                    conditions.push(eq(col, value));
+                }
+            }
+        }
+        return conditions;
+    }
+    const repo = {
+        async findById(id, ctx) {
+            const conditions = buildWhereConditions(undefined, false);
+            conditions.push(eq(idColumn, id));
+            const rows = await getDb(ctx)
+                .select()
+                .from(pgTable)
+                .where(and(...conditions));
+            return rows[0];
+        },
+        async findMany(filters, options = {}, ctx) {
+            const conditions = buildWhereConditions(filters, options.withDeleted);
+            let query = getDb(ctx).select().from(pgTable).$dynamic();
+            if (conditions.length > 0) {
+                query = query.where(and(...conditions));
+            }
+            if (options.limit !== undefined) {
+                query = query.limit(options.limit);
+            }
+            if (options.offset !== undefined) {
+                query = query.offset(options.offset);
+            }
+            return query;
+        },
+        async findAndCount(filters, options = {}, ctx) {
+            const rows = await repo.findMany(filters, options, ctx);
+            const conditions = buildWhereConditions(filters, options.withDeleted);
+            let countQuery = getDb(ctx)
+                .select({ count: sql `count(*)::int` })
+                .from(pgTable)
+                .$dynamic();
+            if (conditions.length > 0) {
+                countQuery = countQuery.where(and(...conditions));
+            }
+            const countResult = await countQuery;
+            return { rows, total: countResult[0]?.count ?? 0 };
+        },
+        async create(data, ctx) {
+            const rows = await getDb(ctx)
+                .insert(pgTable)
+                .values(data)
+                .returning();
+            return rows[0];
+        },
+        async createMany(data, ctx) {
+            if (data.length === 0)
+                return [];
+            const rows = await getDb(ctx)
+                .insert(pgTable)
+                .values(data)
+                .returning();
+            return rows;
+        },
+        async update(id, data, ctx) {
+            const rows = await getDb(ctx)
+                .update(pgTable)
+                .set(data)
+                .where(eq(idColumn, id))
+                .returning();
+            if (!rows[0]) {
+                throw new CommerceNotFoundError(`Record ${id} not found.`);
+            }
+            return rows[0];
+        },
+        async delete(id, ctx) {
+            await getDb(ctx).delete(pgTable).where(eq(idColumn, id));
+        },
+    };
+    if (hasSoftDelete && deletedAtColumn) {
+        const softRepo = repo;
+        softRepo.softDelete = async (id, ctx) => {
+            await getDb(ctx)
+                .update(pgTable)
+                .set({ deletedAt: new Date() })
+                .where(eq(idColumn, id));
+        };
+        softRepo.restore = async (id, ctx) => {
+            const rows = await getDb(ctx)
+                .update(pgTable)
+                .set({ deletedAt: null })
+                .where(eq(idColumn, id))
+                .returning();
+            if (!rows[0]) {
+                throw new CommerceNotFoundError(`Record ${id} not found.`);
+            }
+            return rows[0];
+        };
+        return softRepo;
+    }
+    return repo;
+}

package/dist/kernel/hooks/create-context.d.ts

@@ -0,0 +1,25 @@
+import type { Actor } from "../../auth/types";
+import type { JobsAdapter } from "../jobs/adapter";
+import type { PluginDb } from "../database/plugin-types";
+import type { HookContext, HookOrigin, Logger, ServiceContainer } from "./types";
+export interface CreateHookContextArgs {
+    actor: Actor | null;
+    tx?: unknown;
+    logger: Logger;
+    services: ServiceContainer;
+    context?: Record<string, unknown>;
+    requestId?: string;
+    origin?: HookOrigin;
+    jobs?: JobsAdapter;
+    db?: PluginDb;
+    kernel?: {
+        database: {
+            db: PluginDb;
+        };
+    };
+}
+/**
+ * Creates a HookContext with sensible defaults.
+ */
+export declare function createHookContext(args: CreateHookContextArgs): HookContext;
+//# sourceMappingURL=create-context.d.ts.map

package/dist/kernel/hooks/create-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-context.d.ts","sourceRoot":"","sources":["../../../src/kernel/hooks/create-context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEjF,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,CAAC,EAAE,QAAQ,CAAC;IACd,MAAM,CAAC,EAAE;QAAE,QAAQ,EAAE;YAAE,EAAE,EAAE,QAAQ,CAAA;SAAE,CAAA;KAAE,CAAC;CACzC;AAID;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,qBAAqB,GAAG,WAAW,CAiB1E"}

package/dist/kernel/hooks/create-context.js

@@ -0,0 +1,22 @@
+import { randomUUID } from "node:crypto";
+import { NullJobsAdapter } from "../jobs/adapter";
+const nullJobs = new NullJobsAdapter();
+/**
+ * Creates a HookContext with sensible defaults.
+ */
+export function createHookContext(args) {
+    // Resolve db: prefer explicit db arg, fall back to kernel.database.db
+    const db = args.db ?? args.kernel?.database?.db ?? null;
+    const ctx = {
+        actor: args.actor,
+        tx: args.tx ?? null,
+        logger: args.logger,
+        services: args.services,
+        context: args.context ?? {},
+        requestId: args.requestId ?? randomUUID(),
+        origin: args.origin ?? "rest",
+        jobs: args.jobs ?? nullJobs,
+        db: db,
+    };
+    return ctx;
+}

package/dist/kernel/hooks/executor.d.ts

@@ -0,0 +1,12 @@
+import type { AfterHook, BeforeHook, HookContext, HookOperation } from "./types";
+export interface HookError {
+    hookName: string;
+    message: string;
+}
+export interface HookReport {
+    errors: HookError[];
+    hasErrors: boolean;
+}
+export declare function runBeforeHooks<T>(hooks: BeforeHook<T>[], data: T, operation: HookOperation, context: HookContext): Promise<T>;
+export declare function runAfterHooks<T>(hooks: AfterHook<T>[], originalData: T | null, committedResult: T, operation: HookOperation, context: HookContext): Promise<HookReport>;
+//# sourceMappingURL=executor.d.ts.map

package/dist/kernel/hooks/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/kernel/hooks/executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAEjF,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;CACpB;AAmBD,wBAAsB,cAAc,CAAC,CAAC,EACpC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,EACtB,IAAI,EAAE,CAAC,EACP,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,CAAC,CAAC,CAmBZ;AAED,wBAAsB,aAAa,CAAC,CAAC,EACnC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,EACrB,YAAY,EAAE,CAAC,GAAG,IAAI,EACtB,eAAe,EAAE,CAAC,EAClB,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,UAAU,CAAC,CA0BrB"}

package/dist/kernel/hooks/executor.js

@@ -0,0 +1,50 @@
+/** Default hook timeout: 20 seconds */
+const HOOK_TIMEOUT_MS = 20_000;
+function withTimeout(promiseOrValue, timeoutMs, hookName) {
+    const promise = Promise.resolve(promiseOrValue);
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`Hook "${hookName}" timed out after ${timeoutMs}ms`)), timeoutMs);
+        promise.then((val) => { clearTimeout(timer); resolve(val); }, (err) => { clearTimeout(timer); reject(err); });
+    });
+}
+export async function runBeforeHooks(hooks, data, operation, context) {
+    let current = data;
+    for (const hook of hooks) {
+        const hookName = hook.name || "(anonymous beforeHook)";
+        try {
+            current = await withTimeout(hook({ data: current, operation, context }), HOOK_TIMEOUT_MS, hookName);
+        }
+        catch (error) {
+            context.logger.error(`Before-hook "${hookName}" failed during ${operation}`, {
+                error: error instanceof Error ? error.message : String(error),
+                requestId: context.requestId,
+            });
+            throw error; // Re-throw — beforeHooks MUST succeed
+        }
+    }
+    return current;
+}
+export async function runAfterHooks(hooks, originalData, committedResult, operation, context) {
+    const errors = [];
+    for (const hook of hooks) {
+        const hookName = hook.name || "(anonymous afterHook)";
+        try {
+            await withTimeout(hook({
+                data: originalData,
+                result: committedResult,
+                operation,
+                context,
+            }), HOOK_TIMEOUT_MS, hookName);
+        }
+        catch (error) {
+            errors.push({
+                hookName,
+                message: error instanceof Error ? error.message : String(error),
+            });
+            context.logger.error(`After-hook "${hookName}" failed`, {
+                error,
+            });
+        }
+    }
+    return { errors, hasErrors: errors.length > 0 };
+}

package/dist/kernel/hooks/registry.d.ts

@@ -0,0 +1,28 @@
+export type HookHandler = (...args: never[]) => unknown;
+export declare class HookRegistry {
+    private registry;
+    private logger?;
+    registerConfigHooks(hookName: string, handlers: HookHandler[]): void;
+    append(hookName: string, handler: HookHandler): void;
+    prepend(hookName: string, handler: HookHandler): void;
+    resolve(hookName: string): HookHandler[];
+    /**
+     * Emit a plugin event to all registered listeners.
+     *
+     * Unlike the before/after hook pattern (which transforms data through
+     * a pipeline), emit is fire-and-forget notification. Errors in handlers
+     * are caught and logged but do not propagate to the emitter.
+     *
+     * Usage:
+     *   kernel.hooks.emit("production.afterComplete", { orderId, quantity });
+     *
+     * Any plugin can listen:
+     *   hooks: () => [{ key: "production.afterComplete", handler: async (payload) => { ... } }]
+     */
+    setLogger(logger: {
+        error: (obj: Record<string, unknown>, msg: string) => void;
+    }): void;
+    emit(key: string, payload: unknown): Promise<void>;
+    private ensureEntry;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/kernel/hooks/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/kernel/hooks/registry.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC;AAQxD,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAgC;IAChD,OAAO,CAAC,MAAM,CAAC,CAAiE;IAEhF,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,IAAI;IAKpE,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI;IAKpD,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI;IAKrD,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,EAAE;IAMxC;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,GAAG,IAAI;IAIjF,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAcxD,OAAO,CAAC,WAAW;CASpB"}

package/dist/kernel/hooks/registry.js

@@ -0,0 +1,58 @@
+export class HookRegistry {
+    registry = new Map();
+    logger;
+    registerConfigHooks(hookName, handlers) {
+        this.ensureEntry(hookName);
+        this.registry.get(hookName).configured = [...handlers];
+    }
+    append(hookName, handler) {
+        this.ensureEntry(hookName);
+        this.registry.get(hookName).appended.push(handler);
+    }
+    prepend(hookName, handler) {
+        this.ensureEntry(hookName);
+        this.registry.get(hookName).prepended.push(handler);
+    }
+    resolve(hookName) {
+        const entry = this.registry.get(hookName);
+        if (!entry)
+            return [];
+        return [...entry.prepended, ...entry.configured, ...entry.appended];
+    }
+    /**
+     * Emit a plugin event to all registered listeners.
+     *
+     * Unlike the before/after hook pattern (which transforms data through
+     * a pipeline), emit is fire-and-forget notification. Errors in handlers
+     * are caught and logged but do not propagate to the emitter.
+     *
+     * Usage:
+     *   kernel.hooks.emit("production.afterComplete", { orderId, quantity });
+     *
+     * Any plugin can listen:
+     *   hooks: () => [{ key: "production.afterComplete", handler: async (payload) => { ... } }]
+     */
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    async emit(key, payload) {
+        const handlers = this.resolve(key);
+        for (const handler of handlers) {
+            try {
+                await handler(payload);
+            }
+            catch (err) {
+                this.logger?.error({ err, hookKey: key }, `Event handler failed for "${key}"`);
+            }
+        }
+    }
+    ensureEntry(hookName) {
+        if (!this.registry.has(hookName)) {
+            this.registry.set(hookName, {
+                prepended: [],
+                configured: [],
+                appended: [],
+            });
+        }
+    }
+}

package/dist/kernel/hooks/types.d.ts

@@ -0,0 +1,37 @@
+import type { Actor } from "../../auth/types";
+import type { JobsAdapter } from "../jobs/adapter";
+import type { PluginDb } from "../database/plugin-types";
+export type HookOperation = "create" | "update" | "delete" | "read" | "list" | "statusChange" | "addItem" | "removeItem" | "custom";
+export interface Logger {
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+}
+export interface ServiceContainer {
+    [key: string]: unknown;
+}
+export type HookOrigin = "rest" | "local" | "mcp";
+export interface HookContext {
+    actor: Actor | null;
+    tx: unknown;
+    logger: Logger;
+    services: ServiceContainer;
+    context: Record<string, unknown>;
+    requestId: string;
+    origin: HookOrigin;
+    jobs: JobsAdapter;
+    /** Drizzle database instance. Fully typed — use directly for queries in hook handlers. */
+    db: PluginDb;
+}
+export type BeforeHook<TData> = (args: {
+    data: TData;
+    operation: HookOperation;
+    context: HookContext;
+}) => Promise<TData> | TData;
+export type AfterHook<TData> = (args: {
+    data: TData | null;
+    result: TData;
+    operation: HookOperation;
+    context: HookContext;
+}) => Promise<void> | void;
+//# sourceMappingURL=types.d.ts.map

package/dist/kernel/hooks/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/kernel/hooks/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEzD,MAAM,MAAM,aAAa,GACrB,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,MAAM,GACN,cAAc,GACd,SAAS,GACT,YAAY,GACZ,QAAQ,CAAC;AAEb,MAAM,WAAW,MAAM;IACrB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAC9C;AAED,MAAM,WAAW,gBAAgB;IAC/B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAElD,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,WAAW,CAAC;IAClB,0FAA0F;IAC1F,EAAE,EAAE,QAAQ,CAAC;CACd;AAED,MAAM,MAAM,UAAU,CAAC,KAAK,IAAI,CAAC,IAAI,EAAE;IACrC,IAAI,EAAE,KAAK,CAAC;IACZ,SAAS,EAAE,aAAa,CAAC;IACzB,OAAO,EAAE,WAAW,CAAC;CACtB,KAAK,OAAO,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;AAE7B,MAAM,MAAM,SAAS,CAAC,KAAK,IAAI,CAAC,IAAI,EAAE;IACpC,IAAI,EAAE,KAAK,GAAG,IAAI,CAAC;IACnB,MAAM,EAAE,KAAK,CAAC;IACd,SAAS,EAAE,aAAa,CAAC;IACzB,OAAO,EAAE,WAAW,CAAC;CACtB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC"}

package/dist/kernel/hooks/types.js

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

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

@@ -0,0 +1,30 @@
+/**
+ * Converts a PluginResultErr into a structured HTTP error response.
+ *
+ * Replaces the `throw new Error(result.error)` pattern in plugin routes
+ * which always produces HTTP 500 with no structured error code.
+ *
+ * Usage in routes:
+ *   const result = await service.doSomething(orgId, input);
+ *   if (!result.ok) return toHttpError(result);
+ *   return result.value;
+ *
+ * The function infers HTTP status from the error code or message content:
+ *   - "NOT_FOUND" or "not found"        --> 404
+ *   - "FORBIDDEN" or "permission"        --> 403
+ *   - "CONFLICT" or "already exists"     --> 409
+ *   - "VALIDATION" or "cannot/must"      --> 422
+ *   - Everything else                    --> 400
+ */
+import type { PluginResultErr } from "./result";
+export interface HttpErrorResponse {
+    status: 400 | 403 | 404 | 409 | 422;
+    body: {
+        error: {
+            code: string;
+            message: string;
+        };
+    };
+}
+export declare function toHttpError(result: PluginResultErr): HttpErrorResponse;
+//# sourceMappingURL=http-error.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http-error.d.ts","sourceRoot":"","sources":["../../src/kernel/http-error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IACpC,IAAI,EAAE;QAAE,KAAK,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;CACpD;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,eAAe,GAAG,iBAAiB,CAiBtE"}

package/dist/kernel/http-error.js

@@ -0,0 +1,35 @@
+/**
+ * Converts a PluginResultErr into a structured HTTP error response.
+ *
+ * Replaces the `throw new Error(result.error)` pattern in plugin routes
+ * which always produces HTTP 500 with no structured error code.
+ *
+ * Usage in routes:
+ *   const result = await service.doSomething(orgId, input);
+ *   if (!result.ok) return toHttpError(result);
+ *   return result.value;
+ *
+ * The function infers HTTP status from the error code or message content:
+ *   - "NOT_FOUND" or "not found"        --> 404
+ *   - "FORBIDDEN" or "permission"        --> 403
+ *   - "CONFLICT" or "already exists"     --> 409
+ *   - "VALIDATION" or "cannot/must"      --> 422
+ *   - Everything else                    --> 400
+ */
+export function toHttpError(result) {
+    const message = result.error;
+    const code = result.code;
+    if (code === "NOT_FOUND" || /not found/i.test(message)) {
+        return { status: 404, body: { error: { code: "NOT_FOUND", message } } };
+    }
+    if (code === "FORBIDDEN" || /permission|forbidden|unauthorized/i.test(message)) {
+        return { status: 403, body: { error: { code: "FORBIDDEN", message } } };
+    }
+    if (code === "CONFLICT" || /already|duplicate|exists|unique/i.test(message)) {
+        return { status: 409, body: { error: { code: "CONFLICT", message } } };
+    }
+    if (code === "VALIDATION" || /invalid|cannot|must|required|exceeded|negative/i.test(message)) {
+        return { status: 422, body: { error: { code: "VALIDATION_FAILED", message } } };
+    }
+    return { status: 400, body: { error: { code: code ?? "BAD_REQUEST", message } } };
+}

package/dist/kernel/jobs/adapter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Minimal interface for enqueueing background jobs.
+ * The full DrizzleJobsAdapter implements this; hooks receive
+ * it on HookContext.jobs so they can defer work without caring
+ * about the underlying storage.
+ */
+export interface JobsAdapter {
+    enqueue(taskSlug: string, input: Record<string, unknown>, options?: EnqueueOptions): Promise<string>;
+}
+export interface EnqueueOptions {
+    queue?: string;
+    maxAttempts?: number;
+    delayMs?: number;
+    concurrencyKey?: string;
+    supersedes?: boolean;
+    organizationId?: string;
+}
+/**
+ * No-op adapter used when no jobs backend is configured.
+ * All enqueue calls silently succeed and return a placeholder ID.
+ */
+export declare class NullJobsAdapter implements JobsAdapter {
+    enqueue(_taskSlug: string, _input: Record<string, unknown>, _options?: EnqueueOptions): Promise<string>;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/kernel/jobs/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/kernel/jobs/adapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,CACL,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,MAAM,CAAC,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;GAGG;AACH,qBAAa,eAAgB,YAAW,WAAW;IAC3C,OAAO,CACX,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,QAAQ,CAAC,EAAE,cAAc,GACxB,OAAO,CAAC,MAAM,CAAC;CAGnB"}

package/dist/kernel/jobs/adapter.js

@@ -0,0 +1,9 @@
+/**
+ * No-op adapter used when no jobs backend is configured.
+ * All enqueue calls silently succeed and return a placeholder ID.
+ */
+export class NullJobsAdapter {
+    async enqueue(_taskSlug, _input, _options) {
+        return "null-job-id";
+    }
+}

package/dist/kernel/jobs/drizzle-adapter.d.ts

@@ -0,0 +1,15 @@
+import type { DrizzleDatabase } from "../database/drizzle-db";
+import type { TaskDefinition } from "./types";
+import type { JobsAdapter, EnqueueOptions } from "./adapter";
+/**
+ * PostgreSQL-backed job queue adapter using the application's own database.
+ * Stores jobs in the `commerce_jobs` table. Supports concurrency keys
+ * and supersede semantics for deduplication.
+ */
+export declare class DrizzleJobsAdapter implements JobsAdapter {
+    private db;
+    private tasks;
+    constructor(db: DrizzleDatabase, tasks: Map<string, TaskDefinition>);
+    enqueue(taskSlug: string, input: Record<string, unknown>, options?: EnqueueOptions): Promise<string>;
+}
+//# sourceMappingURL=drizzle-adapter.d.ts.map

package/dist/kernel/jobs/drizzle-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle-adapter.d.ts","sourceRoot":"","sources":["../../../src/kernel/jobs/drizzle-adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAI7D;;;;GAIG;AACH,qBAAa,kBAAmB,YAAW,WAAW;IAElD,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,KAAK;gBADL,EAAE,EAAE,eAAe,EACnB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC;IAGtC,OAAO,CACX,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,MAAM,CAAC;CAmCnB"}

package/dist/kernel/jobs/drizzle-adapter.js

@@ -0,0 +1,42 @@
+import { eq, and } from "drizzle-orm";
+import { DEFAULT_ORG_ID } from "../../auth/org";
+import { commerceJobs } from "./schema";
+/**
+ * PostgreSQL-backed job queue adapter using the application's own database.
+ * Stores jobs in the `commerce_jobs` table. Supports concurrency keys
+ * and supersede semantics for deduplication.
+ */
+export class DrizzleJobsAdapter {
+    db;
+    tasks;
+    constructor(db, tasks) {
+        this.db = db;
+        this.tasks = tasks;
+    }
+    async enqueue(taskSlug, input, options) {
+        // If supersedes is set, delete existing pending jobs with the same concurrency key
+        if (options?.concurrencyKey && options.supersedes) {
+            await this.db
+                .delete(commerceJobs)
+                .where(and(eq(commerceJobs.concurrencyKey, options.concurrencyKey), eq(commerceJobs.status, "pending")));
+        }
+        // Look up task definition for default retry config
+        const task = this.tasks.get(taskSlug);
+        const maxAttempts = options?.maxAttempts ?? task?.retries?.attempts ?? 1;
+        const rows = await this.db
+            .insert(commerceJobs)
+            .values({
+            organizationId: options?.organizationId ?? DEFAULT_ORG_ID,
+            taskSlug,
+            input,
+            queue: options?.queue ?? "default",
+            maxAttempts,
+            waitUntil: options?.delayMs
+                ? new Date(Date.now() + options.delayMs)
+                : null,
+            concurrencyKey: options?.concurrencyKey ?? null,
+        })
+            .returning({ id: commerceJobs.id });
+        return rows[0].id;
+    }
+}