@unifiedcommerce/core 0.0.1

package/dist/runtime/shutdown.js

@@ -0,0 +1,34 @@
+/**
+ * Sets up graceful shutdown handlers for SIGTERM and SIGINT.
+ *
+ * On signal:
+ * 1. Stops accepting new connections
+ * 2. Runs cleanup (close DB pool, flush logs)
+ * 3. Force-exits after timeout if cleanup hangs
+ */
+export function setupGracefulShutdown(opts) {
+    const { cleanup, logger, timeoutMs = 30_000 } = opts;
+    let isShuttingDown = false;
+    async function shutdown(signal) {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        logger.info({ signal }, "shutdown signal received, draining connections");
+        const forceTimer = setTimeout(() => {
+            logger.error("shutdown timeout exceeded, forcing exit");
+            process.exit(1);
+        }, timeoutMs);
+        forceTimer.unref();
+        try {
+            await cleanup();
+            logger.info("graceful shutdown complete");
+            process.exit(0);
+        }
+        catch (err) {
+            logger.error({ err }, "error during shutdown");
+            process.exit(1);
+        }
+    }
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+    process.on("SIGINT", () => shutdown("SIGINT"));
+}

package/dist/runtime/state-manager.d.ts

@@ -0,0 +1,14 @@
+import type { DatabaseAdapter } from "../kernel/database/adapter";
+import type { RuntimeState } from "./state";
+export declare class StateManager {
+    private readonly database;
+    private readonly storage;
+    private readonly repository;
+    private cache;
+    private cacheInitialized;
+    constructor(database: DatabaseAdapter);
+    getStateProxy(): RuntimeState;
+    runWithState<T>(fn: () => Promise<T>): Promise<T>;
+    wrapService<TService extends object>(service: TService): TService;
+}
+//# sourceMappingURL=state-manager.d.ts.map

package/dist/runtime/state-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-manager.d.ts","sourceRoot":"","sources":["../../src/runtime/state-manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAU5C,qBAAa,YAAY;IAMX,OAAO,CAAC,QAAQ,CAAC,QAAQ;IALrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyC;IACjE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAyB;IACpD,OAAO,CAAC,KAAK,CAAsC;IACnD,OAAO,CAAC,gBAAgB,CAAS;gBAEJ,QAAQ,EAAE,eAAe;IAItD,aAAa,IAAI,YAAY;IAgCvB,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IA8BvD,WAAW,CAAC,QAAQ,SAAS,MAAM,EAAE,OAAO,EAAE,QAAQ,GAAG,QAAQ;CAiBlE"}

package/dist/runtime/state-manager.js

@@ -0,0 +1,84 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createRuntimeState } from "./state";
+import { RuntimeStateRepository } from "./state-repository";
+export class StateManager {
+    database;
+    storage = new AsyncLocalStorage();
+    repository;
+    cache = createRuntimeState();
+    cacheInitialized = false;
+    constructor(database) {
+        this.database = database;
+        this.repository = new RuntimeStateRepository(database);
+    }
+    getStateProxy() {
+        const manager = this;
+        return new Proxy({}, {
+            get(_target, key) {
+                const active = manager.storage.getStore();
+                const source = active?.state ?? manager.cache;
+                return source[key];
+            },
+            set(_target, key, value) {
+                const active = manager.storage.getStore();
+                if (!active) {
+                    manager.cache[key] = value;
+                    return true;
+                }
+                active.dirty = true;
+                active.state[key] = value;
+                return true;
+            },
+            ownKeys() {
+                const active = manager.storage.getStore();
+                const source = active?.state ?? manager.cache;
+                return Reflect.ownKeys(source);
+            },
+            getOwnPropertyDescriptor(_target, key) {
+                const active = manager.storage.getStore();
+                const source = active?.state ?? manager.cache;
+                return Object.getOwnPropertyDescriptor(source, key);
+            },
+        });
+    }
+    async runWithState(fn) {
+        const existing = this.storage.getStore();
+        if (existing) {
+            existing.dirty = true;
+            return fn();
+        }
+        return this.database.transaction(async (tx) => {
+            if (!this.cacheInitialized) {
+                this.cache = await this.repository.load(tx);
+                this.cacheInitialized = true;
+            }
+            const context = {
+                tx,
+                state: this.cache,
+                dirty: true,
+            };
+            const result = await this.storage.run(context, fn);
+            if (context.dirty) {
+                await this.repository.save(context.state, tx);
+                this.cache = context.state;
+            }
+            return result;
+        });
+    }
+    wrapService(service) {
+        const manager = this;
+        return new Proxy(service, {
+            get(target, property, receiver) {
+                const value = Reflect.get(target, property, receiver);
+                if (typeof value !== "function") {
+                    return value;
+                }
+                return (...args) => {
+                    return manager.runWithState(async () => {
+                        return value.apply(target, args);
+                    });
+                };
+            },
+        });
+    }
+}

package/dist/runtime/state-repository.d.ts

@@ -0,0 +1,13 @@
+import type { DatabaseAdapter } from "../kernel/database/adapter";
+import type { RuntimeState } from "./state";
+export declare class RuntimeStateRepository {
+    private readonly database;
+    private initialized;
+    private readonly fallbackRecords;
+    constructor(database: DatabaseAdapter);
+    private supportsSql;
+    private ensureTable;
+    load(tx?: unknown): Promise<RuntimeState>;
+    save(state: RuntimeState, tx?: unknown): Promise<void>;
+}
+//# sourceMappingURL=state-repository.d.ts.map

package/dist/runtime/state-repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-repository.d.ts","sourceRoot":"","sources":["../../src/runtime/state-repository.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAuH5C,qBAAa,sBAAsB;IAIrB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAHrC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA6B;gBAEhC,QAAQ,EAAE,eAAe;IAEtD,OAAO,CAAC,WAAW;YAIL,WAAW;IA0BnB,IAAI,CAAC,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,YAAY,CAAC;IAoCzC,IAAI,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CA2B7D"}

package/dist/runtime/state-repository.js

@@ -0,0 +1,160 @@
+import { sql } from "drizzle-orm";
+import { createRuntimeState } from "./state";
+const STATE_BUCKET = "kernel_state";
+const DATE_KEY_PATTERN = /(At|From|Until)$/;
+function serializeJson(value) {
+    return JSON.stringify(value);
+}
+function parseJson(value) {
+    return JSON.parse(value);
+}
+function reviveDates(value, keyHint = "") {
+    if (Array.isArray(value)) {
+        return value.map((item) => reviveDates(item));
+    }
+    if (value && typeof value === "object") {
+        const output = {};
+        for (const [key, nested] of Object.entries(value)) {
+            output[key] = reviveDates(nested, key);
+        }
+        return output;
+    }
+    if (typeof value === "string"
+        && DATE_KEY_PATTERN.test(keyHint)
+        && !Number.isNaN(Date.parse(value))) {
+        return new Date(value);
+    }
+    return value;
+}
+async function runQuery(db, query) {
+    if (typeof db.run === "function") {
+        await db.run(query);
+        return;
+    }
+    if (typeof db.execute === "function") {
+        await db.execute(query);
+        return;
+    }
+    throw new Error("Database client does not support run/execute operations.");
+}
+async function allRows(db, query) {
+    if (typeof db.all === "function") {
+        return db.all(query);
+    }
+    if (typeof db.execute === "function") {
+        const result = await db.execute(query);
+        if (Array.isArray(result)) {
+            return result;
+        }
+        if (result &&
+            typeof result === "object" &&
+            "rows" in result &&
+            Array.isArray(result.rows)) {
+            return result.rows;
+        }
+        return [];
+    }
+    throw new Error("Database client does not support all/execute operations.");
+}
+function encodeField(value) {
+    if (value instanceof Map) {
+        return {
+            kind: "map",
+            entries: [...value.entries()],
+        };
+    }
+    if (Array.isArray(value)) {
+        return {
+            kind: "array",
+            values: value,
+        };
+    }
+    throw new Error("Unsupported memory state field kind during encoding.");
+}
+function decodeField(field) {
+    if (field.kind === "map") {
+        return new Map(field.entries
+            .map(([key, value]) => [key, reviveDates(value)]));
+    }
+    if (field.kind === "array") {
+        return field.values.map((value) => reviveDates(value));
+    }
+    throw new Error("Unsupported memory state field kind during decoding.");
+}
+export class RuntimeStateRepository {
+    database;
+    initialized = false;
+    fallbackRecords = new Map();
+    constructor(database) {
+        this.database = database;
+    }
+    supportsSql(db) {
+        return typeof db.run === "function" || typeof db.execute === "function";
+    }
+    async ensureTable(db) {
+        if (this.initialized) {
+            return;
+        }
+        if (!this.supportsSql(db)) {
+            this.initialized = true;
+            return;
+        }
+        await runQuery(db, sql `
+        CREATE TABLE IF NOT EXISTS uc_records (
+          bucket TEXT NOT NULL,
+          id TEXT NOT NULL,
+          payload TEXT NOT NULL,
+          updated_at TEXT NOT NULL,
+          PRIMARY KEY (bucket, id)
+        );
+      `);
+        this.initialized = true;
+    }
+    async load(tx) {
+        const db = (tx ?? this.database.db);
+        await this.ensureTable(db);
+        const state = createRuntimeState();
+        if (!this.supportsSql(db)) {
+            for (const [fieldName, payload] of this.fallbackRecords.entries()) {
+                const key = fieldName;
+                if (!(key in state)) {
+                    continue;
+                }
+                const encoded = parseJson(payload);
+                state[key] = decodeField(encoded);
+            }
+            return state;
+        }
+        const rows = await allRows(db, sql `SELECT id, payload FROM uc_records WHERE bucket = ${STATE_BUCKET};`);
+        for (const row of rows) {
+            const key = row.id;
+            if (!(key in state)) {
+                continue;
+            }
+            const encoded = parseJson(row.payload);
+            state[key] = decodeField(encoded);
+        }
+        return state;
+    }
+    async save(state, tx) {
+        const db = (tx ?? this.database.db);
+        await this.ensureTable(db);
+        const entries = Object.entries(state);
+        if (!this.supportsSql(db)) {
+            for (const [fieldName, fieldValue] of entries) {
+                const encoded = encodeField(fieldValue);
+                this.fallbackRecords.set(String(fieldName), serializeJson(encoded));
+            }
+            return;
+        }
+        for (const [fieldName, fieldValue] of entries) {
+            const encoded = encodeField(fieldValue);
+            await runQuery(db, sql `
+          INSERT INTO uc_records (bucket, id, payload, updated_at)
+          VALUES (${STATE_BUCKET}, ${String(fieldName)}, ${serializeJson(encoded)}, ${new Date().toISOString()})
+          ON CONFLICT (bucket, id)
+          DO UPDATE SET payload = excluded.payload, updated_at = excluded.updated_at;
+        `);
+        }
+    }
+}

package/dist/runtime/state.d.ts

@@ -0,0 +1,382 @@
+import type { OrderState } from "../kernel/state-machine/machine";
+export interface SellableEntityRecord {
+    id: string;
+    type: string;
+    slug: string;
+    status: "draft" | "active" | "archived" | "discontinued";
+    isVisible: boolean;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+    publishedAt?: Date;
+}
+export interface SellableAttributeRecord {
+    id: string;
+    entityId: string;
+    locale: string;
+    title: string;
+    subtitle?: string;
+    description?: string;
+    richDescription?: unknown;
+    seoTitle?: string;
+    seoDescription?: string;
+}
+export interface SellableCustomFieldRecord {
+    id: string;
+    entityId: string;
+    fieldName: string;
+    fieldType: "text" | "number" | "boolean" | "date" | "json" | "relation";
+    value: unknown;
+}
+export interface CategoryRecord {
+    id: string;
+    parentId?: string;
+    slug: string;
+    sortOrder: number;
+    metadata: Record<string, unknown>;
+}
+export interface EntityCategoryRecord {
+    entityId: string;
+    categoryId: string;
+    sortOrder: number;
+}
+export interface BrandRecord {
+    id: string;
+    slug: string;
+    displayName: string;
+    metadata: Record<string, unknown>;
+}
+export interface EntityBrandRecord {
+    entityId: string;
+    brandId: string;
+    sortOrder: number;
+}
+export interface OptionTypeRecord {
+    id: string;
+    entityId: string;
+    name: string;
+    displayName: string;
+    sortOrder: number;
+}
+export interface OptionValueRecord {
+    id: string;
+    optionTypeId: string;
+    value: string;
+    displayValue: string;
+    sortOrder: number;
+    metadata: Record<string, unknown>;
+}
+export interface VariantRecord {
+    id: string;
+    entityId: string;
+    sku?: string;
+    barcode?: string;
+    status: "active" | "discontinued";
+    sortOrder: number;
+    metadata: Record<string, unknown>;
+}
+export interface VariantOptionValueRecord {
+    variantId: string;
+    optionValueId: string;
+}
+export interface MediaAssetRecord {
+    id: string;
+    storageKey: string;
+    filename: string;
+    contentType: string;
+    size: number;
+    width?: number;
+    height?: number;
+    alt?: string;
+    metadata: Record<string, unknown>;
+    uploadedAt: Date;
+}
+export interface EntityMediaRecord {
+    entityId: string;
+    variantId?: string;
+    mediaAssetId: string;
+    role: "primary" | "gallery" | "thumbnail" | "video" | "document";
+    sortOrder: number;
+}
+export interface WarehouseRecord {
+    id: string;
+    name: string;
+    code: string;
+    address?: Record<string, unknown>;
+    isActive: boolean;
+    priority: number;
+    metadata: Record<string, unknown>;
+}
+export interface InventoryLevelRecord {
+    id: string;
+    entityId: string;
+    variantId?: string;
+    warehouseId: string;
+    quantityOnHand: number;
+    quantityReserved: number;
+    quantityIncoming: number;
+    unitCost?: number;
+    reorderThreshold?: number;
+    reorderQuantity?: number;
+    lastRestockedAt?: Date;
+    updatedAt: Date;
+}
+export interface InventoryMovementRecord {
+    id: string;
+    entityId: string;
+    variantId?: string;
+    warehouseId: string;
+    type: "receipt" | "sale" | "return" | "adjustment" | "transfer" | "reservation" | "release";
+    quantity: number;
+    referenceType?: string;
+    referenceId?: string;
+    reason?: string;
+    performedBy: string;
+    performedAt: Date;
+}
+export interface PriceRecord {
+    id: string;
+    entityId: string;
+    variantId?: string;
+    currency: string;
+    amount: number;
+    customerGroupId?: string;
+    minQuantity?: number;
+    maxQuantity?: number;
+    validFrom?: Date;
+    validUntil?: Date;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export type PriceModifierType = "percentage_discount" | "fixed_discount" | "markup" | "override";
+export interface PriceModifierRecord {
+    id: string;
+    name: string;
+    type: PriceModifierType;
+    value: number;
+    priority: number;
+    entityId?: string;
+    variantId?: string;
+    customerGroupId?: string;
+    currency?: string;
+    minQuantity?: number;
+    maxQuantity?: number;
+    conditions?: Record<string, unknown>;
+    validFrom?: Date;
+    validUntil?: Date;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export type PromotionType = "percentage_off_order" | "fixed_off_order" | "percentage_off_item" | "fixed_off_item" | "free_shipping" | "buy_x_get_y";
+export interface PromotionRecord {
+    id: string;
+    code?: string;
+    name: string;
+    type: PromotionType;
+    value: number;
+    buyQuantity?: number;
+    getQuantity?: number;
+    isAutomatic: boolean;
+    isActive: boolean;
+    priority: number;
+    conditions: Record<string, unknown>;
+    usageLimitTotal?: number;
+    usageLimitPerCustomer?: number;
+    validFrom?: Date;
+    validUntil?: Date;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface PromotionUsageRecord {
+    id: string;
+    promotionId: string;
+    customerId?: string;
+    orderId?: string;
+    usedAt: Date;
+}
+export interface AnalyticsEventRecord {
+    id: string;
+    event: string;
+    orderId?: string;
+    status?: string;
+    total?: number;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+}
+export interface CartRecord {
+    id: string;
+    customerId?: string;
+    status: "active" | "merged" | "checked_out" | "abandoned";
+    currency: string;
+    metadata: Record<string, unknown>;
+    expiresAt: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface CartLineItemRecord {
+    id: string;
+    cartId: string;
+    entityId: string;
+    variantId?: string;
+    quantity: number;
+    unitPriceSnapshot: number;
+    currency: string;
+    metadata: Record<string, unknown>;
+    addedAt: Date;
+}
+export interface OrderRecord {
+    id: string;
+    orderNumber: string;
+    customerId?: string;
+    status: OrderState;
+    currency: string;
+    subtotal: number;
+    taxTotal: number;
+    shippingTotal: number;
+    discountTotal: number;
+    grandTotal: number;
+    metadata: Record<string, unknown>;
+    placedAt: Date;
+    fulfilledAt?: Date;
+    cancelledAt?: Date;
+}
+export interface OrderLineItemRecord {
+    id: string;
+    orderId: string;
+    entityId: string;
+    entityType: string;
+    variantId?: string;
+    sku?: string;
+    title: string;
+    quantity: number;
+    unitPrice: number;
+    totalPrice: number;
+    taxAmount: number;
+    discountAmount: number;
+    fulfillmentStatus: string;
+    metadata: Record<string, unknown>;
+}
+export interface OrderStatusHistoryRecord {
+    id: string;
+    orderId: string;
+    fromStatus: string;
+    toStatus: string;
+    reason?: string;
+    changedBy: string;
+    changedAt: Date;
+}
+export interface CustomerRecord {
+    id: string;
+    userId: string;
+    email?: string;
+    phone?: string;
+    firstName?: string;
+    lastName?: string;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+    posOperatorPin?: string;
+}
+export interface CustomerAddressRecord {
+    id: string;
+    customerId: string;
+    type: "shipping" | "billing";
+    isDefault: boolean;
+    firstName: string;
+    lastName: string;
+    line1: string;
+    line2?: string;
+    city: string;
+    state?: string;
+    postalCode?: string;
+    country: string;
+    phone?: string;
+}
+export interface WebhookEndpointRecord {
+    id: string;
+    url: string;
+    secret: string;
+    events: string[];
+    isActive: boolean;
+    metadata: Record<string, unknown>;
+}
+export interface WebhookDeliveryRecord {
+    id: string;
+    endpointId: string;
+    eventName: string;
+    payload: unknown;
+    statusCode?: number;
+    attemptCount: number;
+    nextRetryAt?: Date;
+    deliveredAt?: Date;
+    failedAt?: Date;
+    createdAt: Date;
+}
+export interface FulfillmentRecordStore {
+    id: string;
+    orderId: string;
+    type: string;
+    status: string;
+    carrier?: string;
+    trackingNumber?: string;
+    trackingUrl?: string;
+    estimatedDelivery?: string;
+    shippedAt?: string;
+    deliveredAt?: string;
+    lineItems: Array<{
+        id: string;
+        title: string;
+        quantity: number;
+        sku?: string;
+    }>;
+    customerId?: string;
+    entityType?: string;
+    entityId?: string;
+    downloadUrl?: string;
+    downloadExpiresAt?: string;
+    maxDownloads?: number;
+    downloadCount?: number;
+    grantedAt?: string;
+    expiresAt?: string;
+    isActive?: boolean;
+}
+export interface RuntimeState {
+    entities: Map<string, SellableEntityRecord>;
+    attributes: Map<string, SellableAttributeRecord[]>;
+    customFields: Map<string, SellableCustomFieldRecord[]>;
+    categories: Map<string, CategoryRecord>;
+    entityCategories: EntityCategoryRecord[];
+    brands: Map<string, BrandRecord>;
+    entityBrands: EntityBrandRecord[];
+    optionTypes: Map<string, OptionTypeRecord>;
+    optionValues: Map<string, OptionValueRecord>;
+    variants: Map<string, VariantRecord>;
+    variantOptionValues: VariantOptionValueRecord[];
+    mediaAssets: Map<string, MediaAssetRecord>;
+    entityMedia: EntityMediaRecord[];
+    warehouses: Map<string, WarehouseRecord>;
+    inventoryLevels: Map<string, InventoryLevelRecord>;
+    inventoryMovements: InventoryMovementRecord[];
+    prices: Map<string, PriceRecord>;
+    priceModifiers: Map<string, PriceModifierRecord>;
+    promotions: Map<string, PromotionRecord>;
+    promotionUsages: PromotionUsageRecord[];
+    analyticsEvents: AnalyticsEventRecord[];
+    carts: Map<string, CartRecord>;
+    cartLineItems: Map<string, CartLineItemRecord[]>;
+    orders: Map<string, OrderRecord>;
+    orderLineItems: Map<string, OrderLineItemRecord[]>;
+    orderStatusHistory: OrderStatusHistoryRecord[];
+    customers: Map<string, CustomerRecord>;
+    customerByUserId: Map<string, string>;
+    customerAddresses: Map<string, CustomerAddressRecord[]>;
+    webhookEndpoints: Map<string, WebhookEndpointRecord>;
+    webhookDeliveries: WebhookDeliveryRecord[];
+    fulfillments: Map<string, FulfillmentRecordStore[]>;
+    orderSequenceByYear: Map<number, number>;
+}
+export declare function createRuntimeState(): RuntimeState;
+//# sourceMappingURL=state.d.ts.map