@unifiedcommerce/core 0.4.4 → 0.4.5

package/dist/kernel/jobs/runner.js

@@ -0,0 +1,114 @@
+import { eq, and, sql } from "drizzle-orm";
+import { commerceJobs } from "./schema.js";
+/**
+ * Claims and processes pending jobs from the `commerce_jobs` table.
+ *
+ * Uses `FOR UPDATE SKIP LOCKED` to allow multiple runners to process
+ * jobs in parallel without conflicts. Each runner claims a batch,
+ * marks them as processing, then executes handlers outside the
+ * claim transaction.
+ */
+export async function runPendingJobs(args) {
+    const { db, tasks, queue = "default", limit = 10, logger, services, } = args;
+    let processed = 0;
+    let failed = 0;
+    // Phase 1: Claim jobs atomically
+    const claimed = await db.transaction(async (tx) => {
+        const pending = await tx
+            .select()
+            .from(commerceJobs)
+            .where(and(eq(commerceJobs.status, "pending"), eq(commerceJobs.queue, queue), sql `(${commerceJobs.waitUntil} IS NULL OR ${commerceJobs.waitUntil} <= now())`))
+            .orderBy(commerceJobs.createdAt)
+            .limit(limit)
+            .for("update", { skipLocked: true });
+        for (const job of pending) {
+            await tx
+                .update(commerceJobs)
+                .set({
+                status: "processing",
+                processingStartedAt: new Date(),
+                updatedAt: new Date(),
+            })
+                .where(eq(commerceJobs.id, job.id));
+        }
+        return pending;
+    });
+    // Phase 2: Execute each claimed job outside the claim transaction
+    for (const job of claimed) {
+        const task = tasks.get(job.taskSlug);
+        if (!task) {
+            logger.warn("Unknown task slug — job marked as failed. Register the task handler in config.jobs.tasks.", {
+                taskSlug: job.taskSlug,
+                jobId: job.id,
+            });
+            await db
+                .update(commerceJobs)
+                .set({
+                status: "failed",
+                error: `Unknown task slug: ${job.taskSlug}`,
+                updatedAt: new Date(),
+                completedAt: new Date(),
+            })
+                .where(eq(commerceJobs.id, job.id));
+            failed++;
+            continue;
+        }
+        try {
+            const result = await task.handler({
+                input: job.input,
+                ctx: { logger, db, services },
+            });
+            await db
+                .update(commerceJobs)
+                .set({
+                status: "succeeded",
+                output: result.output,
+                attempts: job.attempts + 1,
+                updatedAt: new Date(),
+                completedAt: new Date(),
+            })
+                .where(eq(commerceJobs.id, job.id));
+            processed++;
+        }
+        catch (err) {
+            logger.error("Job handler failed", {
+                taskSlug: job.taskSlug,
+                jobId: job.id,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            const attempts = job.attempts + 1;
+            const maxAttempts = job.maxAttempts;
+            if (attempts >= maxAttempts) {
+                await db
+                    .update(commerceJobs)
+                    .set({
+                    status: "failed",
+                    error: err instanceof Error ? err.message : String(err),
+                    attempts,
+                    updatedAt: new Date(),
+                    completedAt: new Date(),
+                })
+                    .where(eq(commerceJobs.id, job.id));
+                failed++;
+            }
+            else {
+                // Compute backoff delay
+                const retries = task.retries;
+                const delay = retries?.backoff?.type === "exponential"
+                    ? retries.backoff.delay * Math.pow(2, attempts - 1)
+                    : (retries?.backoff?.delay ?? 1000);
+                await db
+                    .update(commerceJobs)
+                    .set({
+                    status: "pending",
+                    error: err instanceof Error ? err.message : String(err),
+                    attempts,
+                    waitUntil: new Date(Date.now() + delay),
+                    updatedAt: new Date(),
+                })
+                    .where(eq(commerceJobs.id, job.id));
+            }
+        }
+    }
+    return { processed, failed };
+}

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

@@ -0,0 +1,280 @@
+export declare const commerceJobs: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "commerce_jobs";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "commerce_jobs";
+            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: "commerce_jobs";
+            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;
+        }, {}, {}>;
+        queue: import("drizzle-orm/pg-core").PgColumn<{
+            name: "queue";
+            tableName: "commerce_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        taskSlug: import("drizzle-orm/pg-core").PgColumn<{
+            name: "task_slug";
+            tableName: "commerce_jobs";
+            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;
+        }, {}, {}>;
+        input: import("drizzle-orm/pg-core").PgColumn<{
+            name: "input";
+            tableName: "commerce_jobs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        output: import("drizzle-orm/pg-core").PgColumn<{
+            name: "output";
+            tableName: "commerce_jobs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "commerce_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: "pending" | "processing" | "succeeded" | "failed";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["pending", "processing", "succeeded", "failed"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        attempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempts";
+            tableName: "commerce_jobs";
+            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;
+        }, {}, {}>;
+        maxAttempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "max_attempts";
+            tableName: "commerce_jobs";
+            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;
+        }, {}, {}>;
+        error: import("drizzle-orm/pg-core").PgColumn<{
+            name: "error";
+            tableName: "commerce_jobs";
+            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;
+        }, {}, {}>;
+        waitUntil: import("drizzle-orm/pg-core").PgColumn<{
+            name: "wait_until";
+            tableName: "commerce_jobs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        concurrencyKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "concurrency_key";
+            tableName: "commerce_jobs";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "commerce_jobs";
+            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;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "commerce_jobs";
+            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;
+        }, {}, {}>;
+        processingStartedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "processing_started_at";
+            tableName: "commerce_jobs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        completedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "completed_at";
+            tableName: "commerce_jobs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/kernel/jobs/schema.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCtB,CAAC"}

package/dist/kernel/jobs/schema.js

@@ -0,0 +1,37 @@
+import { pgTable, uuid, text, jsonb, integer, timestamp, index, } from "drizzle-orm/pg-core";
+import { organization } from "../../auth/auth-schema.js";
+export const commerceJobs = pgTable("commerce_jobs", {
+    id: uuid("id").primaryKey().defaultRandom(),
+    organizationId: text("organization_id")
+        .notNull()
+        .references(() => organization.id, { onDelete: "cascade" }),
+    queue: text("queue").notNull().default("default"),
+    taskSlug: text("task_slug").notNull(),
+    input: jsonb("input").notNull().default("{}"),
+    output: jsonb("output"),
+    status: text("status", {
+        enum: ["pending", "processing", "succeeded", "failed"],
+    })
+        .notNull()
+        .default("pending"),
+    attempts: integer("attempts").notNull().default(0),
+    maxAttempts: integer("max_attempts").notNull().default(1),
+    error: text("error"),
+    waitUntil: timestamp("wait_until", { withTimezone: true }),
+    concurrencyKey: text("concurrency_key"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    processingStartedAt: timestamp("processing_started_at", {
+        withTimezone: true,
+    }),
+    completedAt: timestamp("completed_at", { withTimezone: true }),
+}, (table) => ({
+    statusQueueIdx: index("idx_jobs_status_queue").on(table.status, table.queue),
+    taskSlugIdx: index("idx_jobs_task_slug").on(table.taskSlug),
+    waitUntilIdx: index("idx_jobs_wait_until").on(table.waitUntil),
+    orgIdx: index("idx_jobs_org").on(table.organizationId),
+}));

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

@@ -0,0 +1,30 @@
+import type { Logger, ServiceContainer } from "../hooks/types.js";
+import type { DrizzleDatabase } from "../database/drizzle-db.js";
+export interface TaskContext {
+    logger: Logger;
+    db: DrizzleDatabase;
+    services: ServiceContainer;
+}
+export interface TaskRetryConfig {
+    attempts: number;
+    backoff?: {
+        type: "fixed" | "exponential";
+        delay: number;
+    };
+}
+export interface TaskDefinition<TInput extends Record<string, unknown> = Record<string, unknown>, TOutput extends Record<string, unknown> = Record<string, unknown>> {
+    slug: string;
+    handler: (args: {
+        input: TInput;
+        ctx: TaskContext;
+    }) => Promise<{
+        output: TOutput;
+    }>;
+    retries?: TaskRetryConfig;
+    concurrency?: {
+        key: (input: TInput) => string;
+        exclusive?: boolean;
+        supersedes?: boolean;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/kernel/jobs/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAEjE,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,eAAe,CAAC;IACpB,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,OAAO,GAAG,aAAa,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5D;AAED,MAAM,WAAW,cAAc,CAC7B,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChE,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAEjE,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,CAAC,IAAI,EAAE;QACd,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,WAAW,CAAC;KAClB,KAAK,OAAO,CAAC;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACnC,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,WAAW,CAAC,EAAE;QACZ,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;QAC/B,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB,CAAC;CACH"}

package/dist/kernel/jobs/types.js

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

package/dist/kernel/local-api.d.ts

@@ -0,0 +1,103 @@
+import type { Actor } from "../auth/types.js";
+import type { Kernel } from "../runtime/kernel.js";
+/**
+ * Proxy-based Local API — the Payload-style programmatic interface.
+ *
+ * Automatically exposes EVERY service on `kernel.services` (core + plugins)
+ * without hardcoding method signatures. Uses a Proxy to intercept property
+ * access and wrap each service method to auto-inject `actor` and `txCtx`.
+ *
+ * ## Usage in Next.js / TanStack Start / SvelteKit:
+ *
+ * ```typescript
+ * import { createCommerce } from "@unifiedcommerce/core";
+ * import config from "./commerce.config.js";
+ *
+ * const commerce = await createCommerce(config);
+ *
+ * // Server action / loader — no HTTP round-trip
+ * const products = await commerce.api.catalog.list({ limit: 10 });
+ * const order = await commerce.api.orders.getById("order-123");
+ *
+ * // Plugin services are automatically available
+ * const balance = await commerce.api.giftCards.checkBalance("CARD-CODE");
+ * const points = await commerce.api.loyalty.redeemPoints("org", "cust", 100);
+ * ```
+ *
+ * ## Usage from a hook:
+ *
+ * ```typescript
+ * const api = createLocalAPI(kernel, { actor, tx });
+ * const product = await api.catalog.getById("prod-123");
+ * ```
+ *
+ * ## How it works:
+ *
+ * 1. `api.catalog` → Proxy intercepts, finds `kernel.services.catalog`
+ * 2. `api.catalog.getById(id)` → Proxy intercepts method call
+ * 3. Wraps the call: `kernel.services.catalog.getById(id, actor, txCtx)`
+ * 4. Returns the result directly — no HTTP, no serialization
+ *
+ * The Proxy auto-appends `actor` and `txCtx` to every method call.
+ * Service methods that accept `(actor, ctx)` as the last two params
+ * get them injected automatically. Methods that don't accept them
+ * still work — extra args are harmlessly ignored by JavaScript.
+ */
+/** Options for creating a local API instance */
+export interface LocalAPIOptions {
+    actor?: Actor | null;
+    tx?: unknown;
+    requestId?: string;
+}
+/**
+ * Maps a service type to strip actor/txCtx params from each method.
+ * Plugin authors get clean autocomplete: `api.catalog.create(input)`
+ * instead of `api.catalog.create(input, actor, txCtx)`.
+ */
+type CleanService<T> = {
+    [K in keyof T]: T[K] extends (...args: infer _A) => infer R ? (...args: unknown[]) => R : T[K];
+};
+/** The full local API type — all kernel services with cleaned signatures */
+export type CommerceLocalAPI<TServices extends Record<string, unknown> = Kernel["services"]> = {
+    [K in keyof TServices]: TServices[K] extends Record<string, unknown> ? CleanService<TServices[K]> : TServices[K];
+};
+/**
+ * Create a proxy-based local API over kernel services.
+ * Every service method gets `actor` and `txCtx` auto-injected.
+ */
+export declare function createLocalAPI(kernel: Kernel, options?: LocalAPIOptions): CommerceLocalAPI;
+/**
+ * @deprecated Use `createLocalAPI(kernel, { actor, tx })` instead.
+ * Kept for backward compatibility with existing hook code.
+ */
+export declare class LocalAPI {
+    private _proxy;
+    constructor(ctx: {
+        actor: Actor | null;
+        tx: unknown;
+        requestId: string;
+    }, kernel: Kernel);
+    get orders(): import("../modules/orders/service.js").OrderService;
+    get catalog(): import("../modules/catalog/service.js").CatalogServiceImpl;
+    get cart(): import("../modules/cart/service.js").CartService;
+    get inventory(): import("../modules/inventory/service.js").InventoryService;
+    get customers(): import("../modules/customers/service.js").CustomerService;
+    get pricing(): import("../modules/pricing/service.js").PricingService;
+    get promotions(): import("../modules/promotions/service.js").PromotionService;
+    get media(): import("../modules/media/service.js").MediaService;
+    get shipping(): import("../modules/shipping/service.js").ShippingService;
+    get search(): import("../modules/search/service.js").SearchService;
+    get webhooks(): import("../modules/webhooks/service.js").WebhookService & {
+        enqueueDelivery(payload: import("../runtime/kernel.js").WebhookDeliveryPayload): Promise<void>;
+    };
+    get fulfillment(): import("../modules/fulfillment/service.js").FulfillmentService;
+    get payments(): import("../modules/payments/service.js").PaymentsService;
+    get analytics(): import("../modules/analytics/service.js").AnalyticsService;
+    get tax(): import("../modules/tax/service.js").TaxService;
+    get audit(): import("../index.js").AuditService;
+    get organization(): import("../index.js").OrganizationService;
+    /** Access any service (including plugins) by name */
+    service(name: string): unknown;
+}
+export {};
+//# sourceMappingURL=local-api.d.ts.map

package/dist/kernel/local-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-api.d.ts","sourceRoot":"","sources":["../../src/kernel/local-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAGnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAIH,gDAAgD;AAChD,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IACrB,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,KAAK,YAAY,CAAC,CAAC,IAAI;KACpB,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC,GACvD,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,GACzB,CAAC,CAAC,CAAC,CAAC;CACT,CAAC;AAEF,4EAA4E;AAC5E,MAAM,MAAM,gBAAgB,CAC1B,SAAS,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,IAC5D;KACD,CAAC,IAAI,MAAM,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChE,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAC1B,SAAS,CAAC,CAAC,CAAC;CACjB,CAAC;AAMF;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,eAAoB,GAC5B,gBAAgB,CAsDlB;AAID;;;GAGG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAAmB;gBAG/B,GAAG,EAAE;QAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;QAAC,EAAE,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,EAC5D,MAAM,EAAE,MAAM;IAShB,IAAI,MAAM,wDAAiC;IAC3C,IAAI,OAAO,+DAAkC;IAC7C,IAAI,IAAI,qDAA+B;IACvC,IAAI,SAAS,+DAAoC;IACjD,IAAI,SAAS,8DAAoC;IACjD,IAAI,OAAO,2DAAkC;IAC7C,IAAI,UAAU,gEAAqC;IACnD,IAAI,KAAK,uDAAgC;IACzC,IAAI,QAAQ,6DAAmC;IAC/C,IAAI,MAAM,yDAAiC;IAC3C,IAAI,QAAQ;;MAAmC;IAC/C,IAAI,WAAW,mEAAsC;IACrD,IAAI,QAAQ,6DAAmC;IAC/C,IAAI,SAAS,+DAAoC;IACjD,IAAI,GAAG,mDAA8B;IACrC,IAAI,KAAK,uCAAgC;IACzC,IAAI,YAAY,8CAAuC;IAEvD,qDAAqD;IACrD,OAAO,CAAC,IAAI,EAAE,MAAM;CAGrB"}

package/dist/kernel/local-api.js

@@ -0,0 +1,89 @@
+// ─── Implementation ─────────────────────────────────────────────────────────
+const SERVICE_METHOD_CACHE = new WeakMap();
+/**
+ * Create a proxy-based local API over kernel services.
+ * Every service method gets `actor` and `txCtx` auto-injected.
+ */
+export function createLocalAPI(kernel, options = {}) {
+    const actor = options.actor ?? null;
+    const txCtx = options.tx != null
+        ? {
+            tx: options.tx,
+            actor,
+            requestId: options.requestId ?? crypto.randomUUID(),
+        }
+        : undefined;
+    // Top-level proxy: intercept service access (e.g., api.catalog, api.giftCards)
+    // The Proxy transforms method signatures at runtime (auto-injecting actor/txCtx),
+    // so the cast from Kernel["services"] to CommerceLocalAPI is safe.
+    return new Proxy(kernel.services, {
+        get(target, serviceName) {
+            const service = target[serviceName];
+            // Non-object services (e.g., email config) — return as-is
+            if (service == null || typeof service !== "object") {
+                return service;
+            }
+            // Method-level proxy: intercept method calls on the service
+            return new Proxy(service, {
+                get(svcTarget, methodName) {
+                    const method = svcTarget[methodName];
+                    if (typeof method !== "function") {
+                        return method;
+                    }
+                    // Check cache to avoid re-creating wrapper functions
+                    let methodCache = SERVICE_METHOD_CACHE.get(svcTarget);
+                    if (!methodCache) {
+                        methodCache = new Map();
+                        SERVICE_METHOD_CACHE.set(svcTarget, methodCache);
+                    }
+                    const cacheKey = `${methodName}:${actor?.userId ?? "null"}`;
+                    let cached = methodCache.get(cacheKey);
+                    if (cached)
+                        return cached;
+                    // Create wrapped method that auto-injects actor + txCtx
+                    cached = (...args) => {
+                        return method.call(svcTarget, ...args, actor, txCtx);
+                    };
+                    methodCache.set(cacheKey, cached);
+                    return cached;
+                },
+            });
+        },
+    });
+}
+// ─── Legacy Class API (backward compat) ─────────────────────────────────────
+/**
+ * @deprecated Use `createLocalAPI(kernel, { actor, tx })` instead.
+ * Kept for backward compatibility with existing hook code.
+ */
+export class LocalAPI {
+    _proxy;
+    constructor(ctx, kernel) {
+        this._proxy = createLocalAPI(kernel, {
+            actor: ctx.actor,
+            tx: ctx.tx,
+            requestId: ctx.requestId,
+        });
+    }
+    get orders() { return this._proxy.orders; }
+    get catalog() { return this._proxy.catalog; }
+    get cart() { return this._proxy.cart; }
+    get inventory() { return this._proxy.inventory; }
+    get customers() { return this._proxy.customers; }
+    get pricing() { return this._proxy.pricing; }
+    get promotions() { return this._proxy.promotions; }
+    get media() { return this._proxy.media; }
+    get shipping() { return this._proxy.shipping; }
+    get search() { return this._proxy.search; }
+    get webhooks() { return this._proxy.webhooks; }
+    get fulfillment() { return this._proxy.fulfillment; }
+    get payments() { return this._proxy.payments; }
+    get analytics() { return this._proxy.analytics; }
+    get tax() { return this._proxy.tax; }
+    get audit() { return this._proxy.audit; }
+    get organization() { return this._proxy.organization; }
+    /** Access any service (including plugins) by name */
+    service(name) {
+        return this._proxy[name];
+    }
+}