@oronts/vendure-data-hub-plugin 0.1.0

package/dist/src/services/runtime/distributed-lock.service.d.ts

@@ -0,0 +1,80 @@
+import { OnModuleInit, OnModuleDestroy } from '@nestjs/common';
+import { TransactionalConnection } from '@vendure/core';
+import { DataHubLoggerFactory } from '../logger';
+/**
+ * Lock configuration options
+ */
+interface LockOptions {
+    /** Lock timeout in milliseconds (default: 30000) */
+    ttlMs?: number;
+    /** Whether to wait for lock (default: false) */
+    waitForLock?: boolean;
+    /** Max wait time in milliseconds when waitForLock=true (default: 10000) */
+    waitTimeoutMs?: number;
+    /** Retry interval when waiting for lock (default: 100ms) */
+    retryIntervalMs?: number;
+}
+/**
+ * Lock acquisition result
+ */
+export interface LockResult {
+    /** Whether lock was acquired */
+    acquired: boolean;
+    /** Lock token for release (only if acquired) */
+    token?: string;
+    /** Owner ID of current lock holder (if not acquired) */
+    currentOwner?: string;
+    /** When the lock expires (ISO string) */
+    expiresAt?: string;
+}
+/**
+ * Distributed Locking Service
+ *
+ * Distributed locking for horizontal scaling with automatic fallback:
+ * 1. Redis (when available) - Best for multi-instance deployments
+ * 2. PostgreSQL table locks - Works with any PostgreSQL setup
+ * 3. In-memory locks - Fallback for single-instance deployments
+ *
+ * Configuration via environment variables:
+ * - DATAHUB_REDIS_URL: Redis connection URL (e.g., redis://localhost:6379)
+ * - DATAHUB_LOCK_BACKEND: Force a specific backend ('redis', 'postgres', 'memory')
+ */
+export declare class DistributedLockService implements OnModuleInit, OnModuleDestroy {
+    private readonly connection;
+    private readonly logger;
+    private backend;
+    private readonly instanceId;
+    private cleanupInterval?;
+    private isShuttingDown;
+    private readonly memoryLocks;
+    constructor(connection: TransactionalConnection, loggerFactory: DataHubLoggerFactory);
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    /** Acquire a distributed lock */
+    acquire(key: string, options?: LockOptions): Promise<LockResult>;
+    /** Release a distributed lock */
+    release(key: string, token: string): Promise<boolean>;
+    /** Extend a lock's TTL */
+    extend(key: string, token: string, ttlMs?: number): Promise<boolean>;
+    /** Check if a key is locked */
+    isLocked(key: string): Promise<{
+        locked: boolean;
+        owner?: string;
+        expiresAt?: string;
+    }>;
+    /** Execute a function with a lock */
+    withLock<T>(key: string, fn: () => Promise<T>, options?: LockOptions): Promise<T>;
+    /** Clean up expired locks */
+    cleanup(): Promise<number>;
+    private startCleanupInterval;
+    private generateToken;
+    private createFailedResult;
+}
+/** Error thrown when lock acquisition fails */
+export declare class LockAcquisitionError extends Error {
+    readonly key: string;
+    readonly currentOwner?: string | undefined;
+    constructor(key: string, currentOwner?: string | undefined);
+}
+export {};
+//# sourceMappingURL=distributed-lock.service.d.ts.map

package/dist/src/services/runtime/distributed-lock.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distributed-lock.service.d.ts","sourceRoot":"","sources":["../../../../src/services/runtime/distributed-lock.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC3E,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAiB,MAAM,WAAW,CAAC;AAOhE;;GAEG;AACH,UAAU,WAAW;IACjB,oDAAoD;IACpD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gDAAgD;IAChD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,2EAA2E;IAC3E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,4DAA4D;IAC5D,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB,gCAAgC;IAChC,QAAQ,EAAE,OAAO,CAAC;IAClB,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yCAAyC;IACzC,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;GAWG;AAEH,qBACa,sBAAuB,YAAW,YAAY,EAAE,eAAe;IASpE,OAAO,CAAC,QAAQ,CAAC,UAAU;IAR/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,eAAe,CAAC,CAAiB;IACzC,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsC;gBAG7C,UAAU,EAAE,uBAAuB,EACpD,aAAa,EAAE,oBAAoB;IAMjC,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAe7B,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAMtC,iCAAiC;IAC3B,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,UAAU,CAAC;IAkD1E,iCAAiC;IAC3B,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAM3D,0BAA0B;IACpB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAE,MAAwC,GAAG,OAAO,CAAC,OAAO,CAAC;IAM3G,+BAA+B;IACzB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAI7F,qCAAqC;IAC/B,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,CAAC,CAAC;IAW3F,6BAA6B;IAC7B,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IAI1B,OAAO,CAAC,oBAAoB;IAS5B,OAAO,CAAC,aAAa;YAIP,kBAAkB;CAInC;AAED,+CAA+C;AAC/C,qBAAa,oBAAqB,SAAQ,KAAK;aACf,GAAG,EAAE,MAAM;aAAkB,YAAY,CAAC,EAAE,MAAM;gBAAlD,GAAG,EAAE,MAAM,EAAkB,YAAY,CAAC,EAAE,MAAM,YAAA;CAIjF"}

package/dist/src/services/runtime/distributed-lock.service.js

@@ -0,0 +1,202 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LockAcquisitionError = exports.DistributedLockService = void 0;
+const crypto = __importStar(require("crypto"));
+const common_1 = require("@nestjs/common");
+const core_1 = require("@vendure/core");
+const logger_1 = require("../logger");
+const lock_backends_1 = require("./lock-backends");
+const index_1 = require("../../constants/index");
+const retry_utils_1 = require("../../utils/retry.utils");
+const error_utils_1 = require("../../utils/error.utils");
+const id_generation_utils_1 = require("../../utils/id-generation.utils");
+/**
+ * Distributed Locking Service
+ *
+ * Distributed locking for horizontal scaling with automatic fallback:
+ * 1. Redis (when available) - Best for multi-instance deployments
+ * 2. PostgreSQL table locks - Works with any PostgreSQL setup
+ * 3. In-memory locks - Fallback for single-instance deployments
+ *
+ * Configuration via environment variables:
+ * - DATAHUB_REDIS_URL: Redis connection URL (e.g., redis://localhost:6379)
+ * - DATAHUB_LOCK_BACKEND: Force a specific backend ('redis', 'postgres', 'memory')
+ */
+let DistributedLockService = class DistributedLockService {
+    constructor(connection, loggerFactory) {
+        this.connection = connection;
+        this.isShuttingDown = false;
+        this.memoryLocks = new Map();
+        this.logger = loggerFactory.createLogger('DistributedLockService');
+        this.instanceId = `instance-${crypto.randomUUID()}`;
+    }
+    async onModuleInit() {
+        const factory = new lock_backends_1.LockBackendFactory({
+            connection: this.connection,
+            memoryLocks: this.memoryLocks,
+            logger: this.logger,
+        });
+        this.backend = await factory.create();
+        this.startCleanupInterval();
+        this.logger.info('Distributed lock service initialized', {
+            instanceId: this.instanceId,
+            backend: this.backend.name,
+        });
+    }
+    async onModuleDestroy() {
+        this.isShuttingDown = true;
+        if (this.cleanupInterval)
+            clearInterval(this.cleanupInterval);
+        if (this.backend.close)
+            await this.backend.close();
+    }
+    /** Acquire a distributed lock */
+    async acquire(key, options = {}) {
+        const { ttlMs = index_1.DISTRIBUTED_LOCK.DEFAULT_TTL_MS, waitForLock = false, waitTimeoutMs = index_1.DISTRIBUTED_LOCK.DEFAULT_WAIT_TIMEOUT_MS, retryIntervalMs = index_1.DISTRIBUTED_LOCK.DEFAULT_RETRY_INTERVAL_MS, } = options;
+        const token = this.generateToken();
+        const startTime = Date.now();
+        let shouldContinue = true;
+        // Evict expired or oldest entries if the map exceeds the bound
+        if (this.memoryLocks.size >= index_1.DISTRIBUTED_LOCK.MAX_MEMORY_LOCKS) {
+            const now = Date.now();
+            // First pass: remove expired entries
+            for (const [k, entry] of this.memoryLocks) {
+                if (entry.expiresAt < now) {
+                    this.memoryLocks.delete(k);
+                }
+            }
+            // If still at capacity after clearing expired, evict the oldest entry
+            if (this.memoryLocks.size >= index_1.DISTRIBUTED_LOCK.MAX_MEMORY_LOCKS) {
+                const oldestKey = this.memoryLocks.keys().next().value;
+                if (oldestKey) {
+                    this.logger.warn('Evicting non-expired lock at capacity limit', {
+                        evictedKey: oldestKey,
+                        mapSize: this.memoryLocks.size,
+                        maxSize: index_1.DISTRIBUTED_LOCK.MAX_MEMORY_LOCKS,
+                    });
+                    this.memoryLocks.delete(oldestKey);
+                }
+            }
+        }
+        while (shouldContinue) {
+            if (await this.backend.acquire(key, token, ttlMs)) {
+                this.logger.debug('Lock acquired', { key, token, ttlMs });
+                return { acquired: true, token, expiresAt: new Date(Date.now() + ttlMs).toISOString() };
+            }
+            if (!waitForLock || Date.now() - startTime >= waitTimeoutMs) {
+                shouldContinue = false;
+            }
+            else {
+                await (0, retry_utils_1.sleep)(retryIntervalMs);
+            }
+        }
+        return this.createFailedResult(key);
+    }
+    /** Release a distributed lock */
+    async release(key, token) {
+        const released = await this.backend.release(key, token);
+        this.logger.debug(released ? 'Lock released' : 'Lock release failed', { key, token });
+        return released;
+    }
+    /** Extend a lock's TTL */
+    async extend(key, token, ttlMs = index_1.DISTRIBUTED_LOCK.DEFAULT_TTL_MS) {
+        const extended = await this.backend.extend(key, token, ttlMs);
+        if (extended)
+            this.logger.debug('Lock extended', { key, token, ttlMs });
+        return extended;
+    }
+    /** Check if a key is locked */
+    async isLocked(key) {
+        return this.backend.isLocked(key);
+    }
+    /** Execute a function with a lock */
+    async withLock(key, fn, options = {}) {
+        const result = await this.acquire(key, options);
+        if (!result.acquired || !result.token)
+            throw new LockAcquisitionError(key, result.currentOwner);
+        try {
+            return await fn();
+        }
+        finally {
+            await this.release(key, result.token);
+        }
+    }
+    /** Clean up expired locks */
+    cleanup() {
+        return this.backend.cleanup();
+    }
+    startCleanupInterval() {
+        this.cleanupInterval = setInterval(() => {
+            if (!this.isShuttingDown) {
+                this.cleanup().catch(err => this.logger.warn('Lock cleanup failed', { error: (0, error_utils_1.getErrorMessage)(err) }));
+            }
+        }, index_1.DISTRIBUTED_LOCK.CLEANUP_INTERVAL_MS);
+        this.cleanupInterval.unref?.();
+    }
+    generateToken() {
+        return (0, id_generation_utils_1.generateTimestampedId)(this.instanceId, 9);
+    }
+    async createFailedResult(key) {
+        const lockInfo = await this.backend.isLocked(key);
+        return { acquired: false, currentOwner: lockInfo.owner, expiresAt: lockInfo.expiresAt };
+    }
+};
+exports.DistributedLockService = DistributedLockService;
+exports.DistributedLockService = DistributedLockService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.TransactionalConnection,
+        logger_1.DataHubLoggerFactory])
+], DistributedLockService);
+/** Error thrown when lock acquisition fails */
+class LockAcquisitionError extends Error {
+    constructor(key, currentOwner) {
+        super(`Failed to acquire lock for: ${key}${currentOwner ? ` (held by ${currentOwner})` : ''}`);
+        this.key = key;
+        this.currentOwner = currentOwner;
+        this.name = 'LockAcquisitionError';
+    }
+}
+exports.LockAcquisitionError = LockAcquisitionError;
+//# sourceMappingURL=distributed-lock.service.js.map

package/dist/src/services/runtime/distributed-lock.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"distributed-lock.service.js","sourceRoot":"","sources":["../../../../src/services/runtime/distributed-lock.service.ts"],"names":[],"mappings":"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"}

package/dist/src/services/runtime/index.d.ts

@@ -0,0 +1,5 @@
+export * from './distributed-lock.service';
+export * from './runtime-config.service';
+export * from './circuit-breaker.service';
+export * from './batch-rollback.service';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/services/runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/runtime/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC"}

package/dist/src/services/runtime/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./distributed-lock.service"), exports);
+__exportStar(require("./runtime-config.service"), exports);
+__exportStar(require("./circuit-breaker.service"), exports);
+__exportStar(require("./batch-rollback.service"), exports);
+//# sourceMappingURL=index.js.map

package/dist/src/services/runtime/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/services/runtime/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6DAA2C;AAC3C,2DAAyC;AACzC,4DAA0C;AAC1C,2DAAyC"}

package/dist/src/services/runtime/lock-backends/index.d.ts

@@ -0,0 +1,6 @@
+export * from './lock-backend.interface';
+export * from './lock-backend.factory';
+export * from './memory-lock.backend';
+export * from './postgres-lock.backend';
+export * from './redis-lock.backend';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/services/runtime/lock-backends/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/runtime/lock-backends/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC"}

package/dist/src/services/runtime/lock-backends/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lock-backend.interface"), exports);
+__exportStar(require("./lock-backend.factory"), exports);
+__exportStar(require("./memory-lock.backend"), exports);
+__exportStar(require("./postgres-lock.backend"), exports);
+__exportStar(require("./redis-lock.backend"), exports);
+//# sourceMappingURL=index.js.map

package/dist/src/services/runtime/lock-backends/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/services/runtime/lock-backends/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2DAAyC;AACzC,yDAAuC;AACvC,wDAAsC;AACtC,0DAAwC;AACxC,uDAAqC"}

package/dist/src/services/runtime/lock-backends/lock-backend.factory.d.ts

@@ -0,0 +1,29 @@
+import { TransactionalConnection } from '@vendure/core';
+import { DataHubLogger } from '../../logger';
+import { LockBackend, MemoryLockEntry } from './lock-backend.interface';
+export interface BackendFactoryDependencies {
+    connection: TransactionalConnection;
+    memoryLocks: Map<string, MemoryLockEntry>;
+    logger: DataHubLogger;
+}
+/**
+ * Factory for creating lock backends based on configuration
+ *
+ * Selection priority:
+ * 1. Forced backend via DATAHUB_LOCK_BACKEND env var
+ * 2. Redis if DATAHUB_REDIS_URL is provided
+ * 3. Auto-detect Redis at default location (redis://localhost:6379)
+ * 4. Fall back to PostgreSQL backend
+ */
+export declare class LockBackendFactory {
+    private readonly deps;
+    constructor(deps: BackendFactoryDependencies);
+    /**
+     * Create the appropriate lock backend based on environment configuration
+     */
+    create(): Promise<LockBackend>;
+    private createMemoryBackend;
+    private createPostgresBackend;
+    private tryCreateRedisBackend;
+}
+//# sourceMappingURL=lock-backend.factory.d.ts.map

package/dist/src/services/runtime/lock-backends/lock-backend.factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-backend.factory.d.ts","sourceRoot":"","sources":["../../../../../src/services/runtime/lock-backends/lock-backend.factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAGxD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAMxE,MAAM,WAAW,0BAA0B;IACvC,UAAU,EAAE,uBAAuB,CAAC;IACpC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC1C,MAAM,EAAE,aAAa,CAAC;CACzB;AAED;;;;;;;;GAQG;AACH,qBAAa,kBAAkB;IACf,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,0BAA0B;IAE7D;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,WAAW,CAAC;IA6BpC,OAAO,CAAC,mBAAmB;IAI3B,OAAO,CAAC,qBAAqB;YAQf,qBAAqB;CAUtC"}

package/dist/src/services/runtime/lock-backends/lock-backend.factory.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LockBackendFactory = void 0;
+const enums_1 = require("../../../constants/enums");
+const index_1 = require("../../../constants/index");
+const memory_lock_backend_1 = require("./memory-lock.backend");
+const redis_lock_backend_1 = require("./redis-lock.backend");
+const postgres_lock_backend_1 = require("./postgres-lock.backend");
+const error_utils_1 = require("../../../utils/error.utils");
+/**
+ * Factory for creating lock backends based on configuration
+ *
+ * Selection priority:
+ * 1. Forced backend via DATAHUB_LOCK_BACKEND env var
+ * 2. Redis if DATAHUB_REDIS_URL is provided
+ * 3. Auto-detect Redis at default location (redis://localhost:6379)
+ * 4. Fall back to PostgreSQL backend
+ */
+class LockBackendFactory {
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * Create the appropriate lock backend based on environment configuration
+     */
+    async create() {
+        const forcedBackend = process.env.DATAHUB_LOCK_BACKEND;
+        const redisUrl = process.env.DATAHUB_REDIS_URL;
+        // Handle forced backend selection
+        if (forcedBackend === enums_1.LockBackendType.MEMORY) {
+            return this.createMemoryBackend();
+        }
+        if (forcedBackend === enums_1.LockBackendType.POSTGRES) {
+            return this.createPostgresBackend();
+        }
+        // Try Redis if URL provided or forced
+        if (redisUrl || forcedBackend === enums_1.LockBackendType.REDIS) {
+            const redis = await this.tryCreateRedisBackend(redisUrl);
+            if (redis)
+                return redis;
+        }
+        // Try auto-detect Redis at default location
+        if (!forcedBackend) {
+            const redis = await this.tryCreateRedisBackend(index_1.DISTRIBUTED_LOCK.DEFAULT_REDIS_URL);
+            if (redis)
+                return redis;
+        }
+        // Fall back to PostgreSQL
+        return this.createPostgresBackend();
+    }
+    createMemoryBackend() {
+        return new memory_lock_backend_1.MemoryLockBackend(this.deps.memoryLocks);
+    }
+    createPostgresBackend() {
+        return new postgres_lock_backend_1.PostgresLockBackend(this.deps.connection, this.deps.memoryLocks, this.deps.logger);
+    }
+    async tryCreateRedisBackend(url) {
+        try {
+            return await redis_lock_backend_1.RedisLockBackend.create(url ?? index_1.DISTRIBUTED_LOCK.DEFAULT_REDIS_URL, this.deps.logger);
+        }
+        catch (error) {
+            this.deps.logger.warn('Redis backend initialization failed, falling back', {
+                error: (0, error_utils_1.getErrorMessage)(error),
+            });
+            return null;
+        }
+    }
+}
+exports.LockBackendFactory = LockBackendFactory;
+//# sourceMappingURL=lock-backend.factory.js.map

package/dist/src/services/runtime/lock-backends/lock-backend.factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-backend.factory.js","sourceRoot":"","sources":["../../../../../src/services/runtime/lock-backends/lock-backend.factory.ts"],"names":[],"mappings":";;;AACA,oDAA2D;AAC3D,oDAA4D;AAG5D,+DAA0D;AAC1D,6DAAwD;AACxD,mEAA8D;AAC9D,4DAA6D;AAQ7D;;;;;;;;GAQG;AACH,MAAa,kBAAkB;IAC3B,YAA6B,IAAgC;QAAhC,SAAI,GAAJ,IAAI,CAA4B;IAAG,CAAC;IAEjE;;OAEG;IACH,KAAK,CAAC,MAAM;QACR,MAAM,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,oBAAmD,CAAC;QACtF,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC;QAE/C,kCAAkC;QAClC,IAAI,aAAa,KAAK,uBAAe,CAAC,MAAM,EAAE,CAAC;YAC3C,OAAO,IAAI,CAAC,mBAAmB,EAAE,CAAC;QACtC,CAAC;QAED,IAAI,aAAa,KAAK,uBAAe,CAAC,QAAQ,EAAE,CAAC;YAC7C,OAAO,IAAI,CAAC,qBAAqB,EAAE,CAAC;QACxC,CAAC;QAED,sCAAsC;QACtC,IAAI,QAAQ,IAAI,aAAa,KAAK,uBAAe,CAAC,KAAK,EAAE,CAAC;YACtD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC;YACzD,IAAI,KAAK;gBAAE,OAAO,KAAK,CAAC;QAC5B,CAAC;QAED,4CAA4C;QAC5C,IAAI,CAAC,aAAa,EAAE,CAAC;YACjB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,wBAAgB,CAAC,iBAAiB,CAAC,CAAC;YACnF,IAAI,KAAK;gBAAE,OAAO,KAAK,CAAC;QAC5B,CAAC;QAED,0BAA0B;QAC1B,OAAO,IAAI,CAAC,qBAAqB,EAAE,CAAC;IACxC,CAAC;IAEO,mBAAmB;QACvB,OAAO,IAAI,uCAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACxD,CAAC;IAEO,qBAAqB;QACzB,OAAO,IAAI,2CAAmB,CAC1B,IAAI,CAAC,IAAI,CAAC,UAAU,EACpB,IAAI,CAAC,IAAI,CAAC,WAAW,EACrB,IAAI,CAAC,IAAI,CAAC,MAAM,CACnB,CAAC;IACN,CAAC;IAEO,KAAK,CAAC,qBAAqB,CAAC,GAAY;QAC5C,IAAI,CAAC;YACD,OAAO,MAAM,qCAAgB,CAAC,MAAM,CAAC,GAAG,IAAI,wBAAgB,CAAC,iBAAiB,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACtG,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACb,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,mDAAmD,EAAE;gBACvE,KAAK,EAAE,IAAA,6BAAe,EAAC,KAAK,CAAC;aAChC,CAAC,CAAC;YACH,OAAO,IAAI,CAAC;QAChB,CAAC;IACL,CAAC;CACJ;AAzDD,gDAyDC"}

package/dist/src/services/runtime/lock-backends/lock-backend.interface.d.ts

@@ -0,0 +1,28 @@
+export interface LockState {
+    key: string;
+    owner: string;
+    acquiredAt: string;
+    expiresAt: string;
+    ttlMs: number;
+}
+export interface LockStatus {
+    locked: boolean;
+    owner?: string;
+    expiresAt?: string;
+}
+export interface MemoryLockEntry {
+    owner: string;
+    expiresAt: number;
+    acquiredAt: number;
+}
+export interface LockBackend {
+    readonly name: string;
+    acquire(key: string, owner: string, ttlMs: number): Promise<boolean>;
+    release(key: string, owner: string): Promise<boolean>;
+    extend(key: string, owner: string, ttlMs: number): Promise<boolean>;
+    isLocked(key: string): Promise<LockStatus>;
+    cleanup(): Promise<number>;
+    getActiveLocks?(): Promise<LockState[]>;
+    close?(): Promise<void>;
+}
+//# sourceMappingURL=lock-backend.interface.d.ts.map

package/dist/src/services/runtime/lock-backends/lock-backend.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-backend.interface.d.ts","sourceRoot":"","sources":["../../../../../src/services/runtime/lock-backends/lock-backend.interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACvB,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,eAAe;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACrE,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACtD,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACpE,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC3C,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC3B,cAAc,CAAC,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IACxC,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B"}

package/dist/src/services/runtime/lock-backends/lock-backend.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=lock-backend.interface.js.map

package/dist/src/services/runtime/lock-backends/lock-backend.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-backend.interface.js","sourceRoot":"","sources":["../../../../../src/services/runtime/lock-backends/lock-backend.interface.ts"],"names":[],"mappings":""}

package/dist/src/services/runtime/lock-backends/memory-lock.backend.d.ts

@@ -0,0 +1,23 @@
+import { LockBackend, LockState, LockStatus, MemoryLockEntry } from './lock-backend.interface';
+/**
+ * In-memory lock backend for single-instance deployments
+ *
+ * This backend stores locks in memory and is suitable for:
+ * - Development environments
+ * - Single-instance deployments
+ * - Fallback when other backends are unavailable
+ *
+ * Note: Locks are NOT shared across multiple instances.
+ */
+export declare class MemoryLockBackend implements LockBackend {
+    private readonly locks;
+    readonly name = "memory";
+    constructor(locks: Map<string, MemoryLockEntry>);
+    acquire(key: string, owner: string, ttlMs: number): Promise<boolean>;
+    release(key: string, owner: string): Promise<boolean>;
+    extend(key: string, owner: string, ttlMs: number): Promise<boolean>;
+    isLocked(key: string): Promise<LockStatus>;
+    cleanup(): Promise<number>;
+    getActiveLocks(): Promise<LockState[]>;
+}
+//# sourceMappingURL=memory-lock.backend.d.ts.map

package/dist/src/services/runtime/lock-backends/memory-lock.backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-lock.backend.d.ts","sourceRoot":"","sources":["../../../../../src/services/runtime/lock-backends/memory-lock.backend.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE/F;;;;;;;;;GASG;AACH,qBAAa,iBAAkB,YAAW,WAAW;IAGrC,OAAO,CAAC,QAAQ,CAAC,KAAK;IAFlC,QAAQ,CAAC,IAAI,YAAY;gBAEI,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC;IAE1D,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAmBpE,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAYrD,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAYnE,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAoB1C,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IAc1B,cAAc,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;CAkB/C"}

package/dist/src/services/runtime/lock-backends/memory-lock.backend.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryLockBackend = void 0;
+/**
+ * In-memory lock backend for single-instance deployments
+ *
+ * This backend stores locks in memory and is suitable for:
+ * - Development environments
+ * - Single-instance deployments
+ * - Fallback when other backends are unavailable
+ *
+ * Note: Locks are NOT shared across multiple instances.
+ */
+class MemoryLockBackend {
+    constructor(locks) {
+        this.locks = locks;
+        this.name = 'memory';
+    }
+    async acquire(key, owner, ttlMs) {
+        const now = Date.now();
+        const existing = this.locks.get(key);
+        // Check if lock exists and is still valid
+        if (existing && existing.expiresAt > now && existing.owner !== owner) {
+            return false;
+        }
+        // Acquire the lock
+        this.locks.set(key, {
+            owner,
+            expiresAt: now + ttlMs,
+            acquiredAt: now,
+        });
+        return true;
+    }
+    async release(key, owner) {
+        const existing = this.locks.get(key);
+        // Only release if we own the lock
+        if (!existing || existing.owner !== owner) {
+            return false;
+        }
+        this.locks.delete(key);
+        return true;
+    }
+    async extend(key, owner, ttlMs) {
+        const existing = this.locks.get(key);
+        // Only extend if we own the lock
+        if (!existing || existing.owner !== owner) {
+            return false;
+        }
+        existing.expiresAt = Date.now() + ttlMs;
+        return true;
+    }
+    async isLocked(key) {
+        const now = Date.now();
+        const existing = this.locks.get(key);
+        if (existing && existing.expiresAt > now) {
+            return {
+                locked: true,
+                owner: existing.owner,
+                expiresAt: new Date(existing.expiresAt).toISOString(),
+            };
+        }
+        // Clean up expired lock
+        if (existing) {
+            this.locks.delete(key);
+        }
+        return { locked: false };
+    }
+    async cleanup() {
+        const now = Date.now();
+        let count = 0;
+        for (const [key, entry] of this.locks.entries()) {
+            if (entry.expiresAt < now) {
+                this.locks.delete(key);
+                count++;
+            }
+        }
+        return count;
+    }
+    async getActiveLocks() {
+        const now = Date.now();
+        const locks = [];
+        for (const [key, entry] of this.locks.entries()) {
+            if (entry.expiresAt > now) {
+                locks.push({
+                    key,
+                    owner: entry.owner,
+                    acquiredAt: new Date(entry.acquiredAt).toISOString(),
+                    expiresAt: new Date(entry.expiresAt).toISOString(),
+                    ttlMs: entry.expiresAt - now,
+                });
+            }
+        }
+        return locks;
+    }
+}
+exports.MemoryLockBackend = MemoryLockBackend;
+//# sourceMappingURL=memory-lock.backend.js.map