actly 1.1.5 → 1.3.0

package/dist/core/tenant.cjs

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTenantStore = createTenantStore;
+exports.createAsyncTenantStore = createAsyncTenantStore;
+const memory_js_1 = require("../stores/memory.js");
+const act_js_1 = require("./act.js");
+const limits_js_1 = require("../utils/limits.js");
+function createTenantStore(options = {}) {
+    const maxSize = options.maxSize ?? limits_js_1.LIMITS.DEFAULT_STORE_MAX_SIZE;
+    const autoCleanup = options.autoCleanup ?? true;
+    const cleanupIntervalMs = options.cleanupIntervalMs ?? 60_000;
+    const maxTenants = options.maxTenants ?? limits_js_1.LIMITS.MAX_TENANTS;
+    const tenants = new Map();
+    return {
+        get(tenantId) {
+            let entry = tenants.get(tenantId);
+            if (entry) {
+                tenants.delete(tenantId);
+                tenants.set(tenantId, entry);
+                return entry.scoped;
+            }
+            if (maxTenants !== Number.POSITIVE_INFINITY && tenants.size >= maxTenants) {
+                const lruId = tenants.keys().next().value;
+                if (lruId !== undefined) {
+                    const lru = tenants.get(lruId);
+                    if (lru) {
+                        try {
+                            lru.store.destroy();
+                        }
+                        catch { }
+                    }
+                    tenants.delete(lruId);
+                }
+            }
+            const store = new memory_js_1.InMemoryStore({ maxSize, autoCleanup, cleanupIntervalMs });
+            const scoped = (0, act_js_1.withStore)(store);
+            entry = { store, scoped };
+            tenants.set(tenantId, entry);
+            return entry.scoped;
+        },
+        evict(tenantId) {
+            const entry = tenants.get(tenantId);
+            if (entry) {
+                entry.store.destroy();
+                tenants.delete(tenantId);
+            }
+        },
+        size() {
+            return tenants.size;
+        },
+        destroy() {
+            for (const [, entry] of tenants) {
+                entry.store.destroy();
+            }
+            tenants.clear();
+        },
+    };
+}
+function createAsyncTenantStore(storeFactory, options = {}) {
+    const maxTenants = options.maxTenants ?? limits_js_1.LIMITS.MAX_TENANTS;
+    const tenants = new Map();
+    const safeDestroy = (store) => {
+        try {
+            const result = store.destroy?.();
+            if (result && typeof result.then === 'function') {
+                ;
+                result.catch(() => { });
+            }
+        }
+        catch {
+        }
+    };
+    return {
+        get(tenantId) {
+            let entry = tenants.get(tenantId);
+            if (entry) {
+                tenants.delete(tenantId);
+                tenants.set(tenantId, entry);
+                return entry.scoped;
+            }
+            if (maxTenants !== Number.POSITIVE_INFINITY && tenants.size >= maxTenants) {
+                const lruId = tenants.keys().next().value;
+                if (lruId !== undefined) {
+                    const lru = tenants.get(lruId);
+                    if (lru)
+                        safeDestroy(lru.store);
+                    tenants.delete(lruId);
+                }
+            }
+            const store = storeFactory(tenantId);
+            const scoped = (0, act_js_1.withStore)(store);
+            entry = { store, scoped };
+            tenants.set(tenantId, entry);
+            return entry.scoped;
+        },
+        evict(tenantId) {
+            const entry = tenants.get(tenantId);
+            if (entry) {
+                safeDestroy(entry.store);
+                tenants.delete(tenantId);
+            }
+        },
+        size() {
+            return tenants.size;
+        },
+        destroy() {
+            for (const [, entry] of tenants) {
+                safeDestroy(entry.store);
+            }
+            tenants.clear();
+        },
+    };
+}

package/dist/core/tenant.d.ts

@@ -0,0 +1,24 @@
+import type { ScopedActSync, ScopedActAsync } from './act.js';
+import type { AsyncStateStore } from '../stores/base.js';
+export interface TenantStoreOptions {
+    maxSize?: number;
+    autoCleanup?: boolean;
+    cleanupIntervalMs?: number;
+    maxTenants?: number;
+}
+export interface TenantManager {
+    get(tenantId: string): ScopedActSync | ScopedActAsync;
+    evict(tenantId: string): void;
+    size(): number;
+    destroy(): void;
+}
+export declare function createTenantStore(options?: TenantStoreOptions): TenantManager;
+export declare function createAsyncTenantStore(storeFactory: (tenantId: string) => AsyncStateStore, options?: {
+    maxTenants?: number;
+}): {
+    get: (tenantId: string) => ScopedActAsync;
+    evict: (tenantId: string) => void;
+    size: () => number;
+    destroy: () => void;
+};
+//# sourceMappingURL=tenant.d.ts.map

package/dist/core/tenant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tenant.d.ts","sourceRoot":"","sources":["../../src/core/tenant.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAGxD,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAa1B,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,cAAc,CAAA;IACrD,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,IAAI,IAAI,MAAM,CAAA;IACd,OAAO,IAAI,IAAI,CAAA;CAChB;AAWD,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,kBAAuB,GAAG,aAAa,CAwDjF;AAOD,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,eAAe,EACnD,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,GACpC;IACD,GAAG,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,cAAc,CAAA;IACzC,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC,IAAI,EAAE,MAAM,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB,CAkEA"}

package/dist/core/tenant.js

@@ -0,0 +1,109 @@
+import { InMemoryStore } from '../stores/memory.js';
+import { withStore } from './act.js';
+import { LIMITS } from '../utils/limits.js';
+export function createTenantStore(options = {}) {
+    const maxSize = options.maxSize ?? LIMITS.DEFAULT_STORE_MAX_SIZE;
+    const autoCleanup = options.autoCleanup ?? true;
+    const cleanupIntervalMs = options.cleanupIntervalMs ?? 60_000;
+    const maxTenants = options.maxTenants ?? LIMITS.MAX_TENANTS;
+    const tenants = new Map();
+    return {
+        get(tenantId) {
+            let entry = tenants.get(tenantId);
+            if (entry) {
+                tenants.delete(tenantId);
+                tenants.set(tenantId, entry);
+                return entry.scoped;
+            }
+            if (maxTenants !== Number.POSITIVE_INFINITY && tenants.size >= maxTenants) {
+                const lruId = tenants.keys().next().value;
+                if (lruId !== undefined) {
+                    const lru = tenants.get(lruId);
+                    if (lru) {
+                        try {
+                            lru.store.destroy();
+                        }
+                        catch { }
+                    }
+                    tenants.delete(lruId);
+                }
+            }
+            const store = new InMemoryStore({ maxSize, autoCleanup, cleanupIntervalMs });
+            const scoped = withStore(store);
+            entry = { store, scoped };
+            tenants.set(tenantId, entry);
+            return entry.scoped;
+        },
+        evict(tenantId) {
+            const entry = tenants.get(tenantId);
+            if (entry) {
+                entry.store.destroy();
+                tenants.delete(tenantId);
+            }
+        },
+        size() {
+            return tenants.size;
+        },
+        destroy() {
+            for (const [, entry] of tenants) {
+                entry.store.destroy();
+            }
+            tenants.clear();
+        },
+    };
+}
+export function createAsyncTenantStore(storeFactory, options = {}) {
+    const maxTenants = options.maxTenants ?? LIMITS.MAX_TENANTS;
+    const tenants = new Map();
+    const safeDestroy = (store) => {
+        try {
+            const result = store.destroy?.();
+            if (result && typeof result.then === 'function') {
+                ;
+                result.catch(() => { });
+            }
+        }
+        catch {
+        }
+    };
+    return {
+        get(tenantId) {
+            let entry = tenants.get(tenantId);
+            if (entry) {
+                tenants.delete(tenantId);
+                tenants.set(tenantId, entry);
+                return entry.scoped;
+            }
+            if (maxTenants !== Number.POSITIVE_INFINITY && tenants.size >= maxTenants) {
+                const lruId = tenants.keys().next().value;
+                if (lruId !== undefined) {
+                    const lru = tenants.get(lruId);
+                    if (lru)
+                        safeDestroy(lru.store);
+                    tenants.delete(lruId);
+                }
+            }
+            const store = storeFactory(tenantId);
+            const scoped = withStore(store);
+            entry = { store, scoped };
+            tenants.set(tenantId, entry);
+            return entry.scoped;
+        },
+        evict(tenantId) {
+            const entry = tenants.get(tenantId);
+            if (entry) {
+                safeDestroy(entry.store);
+                tenants.delete(tenantId);
+            }
+        },
+        size() {
+            return tenants.size;
+        },
+        destroy() {
+            for (const [, entry] of tenants) {
+                safeDestroy(entry.store);
+            }
+            tenants.clear();
+        },
+    };
+}

package/dist/errors.cjs

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HedgeTimeoutError = exports.ResourceExhaustedError = exports.RateLimitError = exports.BulkheadOverflowError = exports.CircuitBreakerOpenError = exports.ValidationError = exports.RetryExhaustedError = exports.TotalTimeoutError = exports.TimeoutError = exports.ActlyAbortError = exports.ActlyError = void 0;
+exports.isActlyError = isActlyError;
+class ActlyError extends Error {
+    key;
+    constructor(message, options) {
+        super(message, options?.cause !== undefined ? { cause: options.cause } : undefined);
+        this.name = new.target.name;
+        if (options?.key !== undefined) {
+            Object.defineProperty(this, 'key', { value: options.key, enumerable: true });
+        }
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+    toJSON(opts) {
+        const obj = {
+            name: this.name,
+            code: this.code,
+            message: opts?.redact ? sanitizeErrorMessageForJSON(this.message) : this.message,
+        };
+        if (this.key !== undefined)
+            obj.key = this.key;
+        if (this.stack !== undefined)
+            obj.stack = this.stack;
+        for (const prop of Object.keys(this)) {
+            if (!(prop in obj)) {
+                try {
+                    obj[prop] = this[prop];
+                }
+                catch {
+                }
+            }
+        }
+        return obj;
+    }
+}
+exports.ActlyError = ActlyError;
+function isActlyError(e) {
+    return (e != null &&
+        typeof e === 'object' &&
+        typeof e.code === 'string' &&
+        String(e.code).startsWith('ACTLY_'));
+}
+function sanitizeErrorMessageForJSON(msg) {
+    let str;
+    if (msg instanceof Error) {
+        str = String(msg.message ?? '');
+    }
+    else {
+        str = String(msg ?? '');
+    }
+    if (str.length > 4096)
+        str = str.slice(0, 4096) + '…[truncated]';
+    return str.replace(/[<>]/g, (c) => (c === '<' ? '&lt;' : '&gt;'));
+}
+class ActlyAbortError extends ActlyError {
+    code = 'ACTLY_ABORT';
+    constructor(options) {
+        const causeMsg = options?.cause instanceof Error ? options.cause.message : String(options?.cause ?? 'aborted');
+        super(`Actly operation aborted: ${causeMsg}`, options);
+    }
+}
+exports.ActlyAbortError = ActlyAbortError;
+class TimeoutError extends ActlyError {
+    code = 'ACTLY_TIMEOUT';
+    ms;
+    constructor(ms, options) {
+        super(`ACT timed out after ${ms}ms`, options);
+        this.ms = ms;
+    }
+}
+exports.TimeoutError = TimeoutError;
+class TotalTimeoutError extends ActlyError {
+    code = 'ACTLY_TOTAL_TIMEOUT';
+    ms;
+    constructor(ms, options) {
+        super(`ACT total timeout exceeded after ${ms}ms`, options);
+        this.ms = ms;
+    }
+}
+exports.TotalTimeoutError = TotalTimeoutError;
+class RetryExhaustedError extends ActlyError {
+    code = 'ACTLY_RETRY_EXHAUSTED';
+    attempts;
+    lastError;
+    errors;
+    constructor(options) {
+        const lastMsg = options.lastError instanceof Error ? options.lastError.message : String(options.lastError);
+        super(`ACT retry exhausted after ${options.attempts} attempts; last error: ${lastMsg}`, { key: options.key, cause: options.lastError });
+        this.attempts = options.attempts;
+        this.lastError = options.lastError;
+        this.errors = options.errors;
+    }
+}
+exports.RetryExhaustedError = RetryExhaustedError;
+class ValidationError extends ActlyError {
+    code = 'ACTLY_VALIDATION';
+    constructor(message, options) {
+        super(message, options);
+        if (options?.field !== undefined) {
+            Object.defineProperty(this, 'field', { value: options.field, enumerable: true });
+        }
+    }
+    field;
+}
+exports.ValidationError = ValidationError;
+class CircuitBreakerOpenError extends ActlyError {
+    code = 'ACTLY_CIRCUIT_OPEN';
+    constructor(key, ms, options) {
+        super(`Circuit breaker open for key "${key}" — retry after ${ms}ms`, { key, cause: options?.cause });
+    }
+}
+exports.CircuitBreakerOpenError = CircuitBreakerOpenError;
+class BulkheadOverflowError extends ActlyError {
+    code = 'ACTLY_BULKHEAD_FULL';
+    constructor(key, maxConcurrent, options) {
+        super(`Bulkhead full for key "${key}" — maxConcurrent ${maxConcurrent} reached`, { key, cause: options?.cause });
+    }
+}
+exports.BulkheadOverflowError = BulkheadOverflowError;
+class RateLimitError extends ActlyError {
+    code = 'ACTLY_RATE_LIMIT';
+    constructor(key, maxCalls, windowMs, options) {
+        super(`Rate limit exceeded for key "${key}" — ${maxCalls} calls per ${windowMs}ms`, { key, cause: options?.cause });
+    }
+}
+exports.RateLimitError = RateLimitError;
+class ResourceExhaustedError extends ActlyError {
+    code = 'ACTLY_RESOURCE_EXHAUSTED';
+    current;
+    limit;
+    constructor(current, limit, options) {
+        super(`Actly: resource exhausted — ${current} in-flight calls exceed process limit ${limit}. ` +
+            `Set ACTLY_NO_INFLIGHT_LIMIT=1 to disable this guard (at your own risk).`, options);
+        this.current = current;
+        this.limit = limit;
+    }
+}
+exports.ResourceExhaustedError = ResourceExhaustedError;
+class HedgeTimeoutError extends ActlyError {
+    code = 'ACTLY_HEDGE_TIMEOUT';
+    delayMs;
+    constructor(options) {
+        const ms = options?.delayMs ?? 0;
+        super(`ACT hedge timed out after ${ms}ms`, options);
+        this.delayMs = ms;
+    }
+}
+exports.HedgeTimeoutError = HedgeTimeoutError;

package/dist/errors.d.ts

@@ -0,0 +1,94 @@
+export declare abstract class ActlyError extends Error {
+    abstract readonly code: string;
+    readonly key?: string;
+    constructor(message: string, options?: {
+        key?: string;
+        cause?: unknown;
+    });
+    toJSON(opts?: {
+        redact?: boolean;
+    }): Record<string, unknown>;
+}
+export declare function isActlyError(e: unknown): e is ActlyError;
+export declare class ActlyAbortError extends ActlyError {
+    readonly code: "ACTLY_ABORT";
+    constructor(options?: {
+        key?: string;
+        cause?: unknown;
+    });
+}
+export declare class TimeoutError extends ActlyError {
+    readonly code: "ACTLY_TIMEOUT";
+    readonly ms: number;
+    constructor(ms: number, options?: {
+        key?: string;
+        cause?: unknown;
+    });
+}
+export declare class TotalTimeoutError extends ActlyError {
+    readonly code: "ACTLY_TOTAL_TIMEOUT";
+    readonly ms: number;
+    constructor(ms: number, options?: {
+        key?: string;
+        cause?: unknown;
+    });
+}
+export declare class RetryExhaustedError extends ActlyError {
+    readonly code: "ACTLY_RETRY_EXHAUSTED";
+    readonly attempts: number;
+    readonly lastError: unknown;
+    readonly errors: readonly unknown[];
+    constructor(options: {
+        key?: string;
+        attempts: number;
+        lastError: unknown;
+        errors: readonly unknown[];
+    });
+}
+export declare class ValidationError extends ActlyError {
+    readonly code: "ACTLY_VALIDATION";
+    constructor(message: string, options?: {
+        field?: string;
+        cause?: unknown;
+    });
+    readonly field?: string;
+}
+export declare class CircuitBreakerOpenError extends ActlyError {
+    readonly code: "ACTLY_CIRCUIT_OPEN";
+    readonly key: string;
+    constructor(key: string, ms: number, options?: {
+        cause?: unknown;
+    });
+}
+export declare class BulkheadOverflowError extends ActlyError {
+    readonly code: "ACTLY_BULKHEAD_FULL";
+    readonly key: string;
+    constructor(key: string, maxConcurrent: number, options?: {
+        cause?: unknown;
+    });
+}
+export declare class RateLimitError extends ActlyError {
+    readonly code: "ACTLY_RATE_LIMIT";
+    readonly key: string;
+    constructor(key: string, maxCalls: number, windowMs: number, options?: {
+        cause?: unknown;
+    });
+}
+export declare class ResourceExhaustedError extends ActlyError {
+    readonly code: "ACTLY_RESOURCE_EXHAUSTED";
+    readonly current: number;
+    readonly limit: number;
+    constructor(current: number, limit: number, options?: {
+        cause?: unknown;
+    });
+}
+export declare class HedgeTimeoutError extends ActlyError {
+    readonly code: "ACTLY_HEDGE_TIMEOUT";
+    readonly delayMs: number;
+    constructor(options?: {
+        key?: string;
+        delayMs?: number;
+        cause?: unknown;
+    });
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

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

package/dist/errors.js

@@ -0,0 +1,134 @@
+export class ActlyError extends Error {
+    key;
+    constructor(message, options) {
+        super(message, options?.cause !== undefined ? { cause: options.cause } : undefined);
+        this.name = new.target.name;
+        if (options?.key !== undefined) {
+            Object.defineProperty(this, 'key', { value: options.key, enumerable: true });
+        }
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+    toJSON(opts) {
+        const obj = {
+            name: this.name,
+            code: this.code,
+            message: opts?.redact ? sanitizeErrorMessageForJSON(this.message) : this.message,
+        };
+        if (this.key !== undefined)
+            obj.key = this.key;
+        if (this.stack !== undefined)
+            obj.stack = this.stack;
+        for (const prop of Object.keys(this)) {
+            if (!(prop in obj)) {
+                try {
+                    obj[prop] = this[prop];
+                }
+                catch {
+                }
+            }
+        }
+        return obj;
+    }
+}
+export function isActlyError(e) {
+    return (e != null &&
+        typeof e === 'object' &&
+        typeof e.code === 'string' &&
+        String(e.code).startsWith('ACTLY_'));
+}
+function sanitizeErrorMessageForJSON(msg) {
+    let str;
+    if (msg instanceof Error) {
+        str = String(msg.message ?? '');
+    }
+    else {
+        str = String(msg ?? '');
+    }
+    if (str.length > 4096)
+        str = str.slice(0, 4096) + '…[truncated]';
+    return str.replace(/[<>]/g, (c) => (c === '<' ? '&lt;' : '&gt;'));
+}
+export class ActlyAbortError extends ActlyError {
+    code = 'ACTLY_ABORT';
+    constructor(options) {
+        const causeMsg = options?.cause instanceof Error ? options.cause.message : String(options?.cause ?? 'aborted');
+        super(`Actly operation aborted: ${causeMsg}`, options);
+    }
+}
+export class TimeoutError extends ActlyError {
+    code = 'ACTLY_TIMEOUT';
+    ms;
+    constructor(ms, options) {
+        super(`ACT timed out after ${ms}ms`, options);
+        this.ms = ms;
+    }
+}
+export class TotalTimeoutError extends ActlyError {
+    code = 'ACTLY_TOTAL_TIMEOUT';
+    ms;
+    constructor(ms, options) {
+        super(`ACT total timeout exceeded after ${ms}ms`, options);
+        this.ms = ms;
+    }
+}
+export class RetryExhaustedError extends ActlyError {
+    code = 'ACTLY_RETRY_EXHAUSTED';
+    attempts;
+    lastError;
+    errors;
+    constructor(options) {
+        const lastMsg = options.lastError instanceof Error ? options.lastError.message : String(options.lastError);
+        super(`ACT retry exhausted after ${options.attempts} attempts; last error: ${lastMsg}`, { key: options.key, cause: options.lastError });
+        this.attempts = options.attempts;
+        this.lastError = options.lastError;
+        this.errors = options.errors;
+    }
+}
+export class ValidationError extends ActlyError {
+    code = 'ACTLY_VALIDATION';
+    constructor(message, options) {
+        super(message, options);
+        if (options?.field !== undefined) {
+            Object.defineProperty(this, 'field', { value: options.field, enumerable: true });
+        }
+    }
+    field;
+}
+export class CircuitBreakerOpenError extends ActlyError {
+    code = 'ACTLY_CIRCUIT_OPEN';
+    constructor(key, ms, options) {
+        super(`Circuit breaker open for key "${key}" — retry after ${ms}ms`, { key, cause: options?.cause });
+    }
+}
+export class BulkheadOverflowError extends ActlyError {
+    code = 'ACTLY_BULKHEAD_FULL';
+    constructor(key, maxConcurrent, options) {
+        super(`Bulkhead full for key "${key}" — maxConcurrent ${maxConcurrent} reached`, { key, cause: options?.cause });
+    }
+}
+export class RateLimitError extends ActlyError {
+    code = 'ACTLY_RATE_LIMIT';
+    constructor(key, maxCalls, windowMs, options) {
+        super(`Rate limit exceeded for key "${key}" — ${maxCalls} calls per ${windowMs}ms`, { key, cause: options?.cause });
+    }
+}
+export class ResourceExhaustedError extends ActlyError {
+    code = 'ACTLY_RESOURCE_EXHAUSTED';
+    current;
+    limit;
+    constructor(current, limit, options) {
+        super(`Actly: resource exhausted — ${current} in-flight calls exceed process limit ${limit}. ` +
+            `Set ACTLY_NO_INFLIGHT_LIMIT=1 to disable this guard (at your own risk).`, options);
+        this.current = current;
+        this.limit = limit;
+    }
+}
+export class HedgeTimeoutError extends ActlyError {
+    code = 'ACTLY_HEDGE_TIMEOUT';
+    delayMs;
+    constructor(options) {
+        const ms = options?.delayMs ?? 0;
+        super(`ACT hedge timed out after ${ms}ms`, options);
+        this.delayMs = ms;
+    }
+}