@unifiedcommerce/core 0.4.2 → 0.4.4

package/dist/kernel/jobs/runner.js

@@ -1,114 +0,0 @@
-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

@@ -1,280 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,37 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

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

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

@@ -1,103 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,89 +0,0 @@
-// ─── 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];
-    }
-}