@nest-omni/core 3.1.1-12 → 3.1.1-13

package/cache/dependencies/db.dependency.d.ts

@@ -0,0 +1,15 @@
+import { DataSource } from 'typeorm';
+import type { CacheDependency } from '../interfaces/cache-dependency.interface';
+export declare class DbDependency implements CacheDependency {
+    private readonly sql;
+    private readonly paramsFactory?;
+    private readonly name?;
+    private static dataSource;
+    constructor(sql: string, paramsFactory?: (...args: any[]) => any[], name?: string);
+    static setDataSource(dataSource: DataSource): void;
+    static getDataSource(): DataSource | null;
+    getKey(): string;
+    getData(): Promise<any>;
+    isChanged(oldData: any): Promise<boolean>;
+    private hashCode;
+}

package/cache/dependencies/db.dependency.js

@@ -0,0 +1,71 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbDependency = void 0;
+class DbDependency {
+    constructor(sql, paramsFactory, name) {
+        this.sql = sql;
+        this.paramsFactory = paramsFactory;
+        this.name = name;
+        if (!sql || typeof sql !== 'string') {
+            throw new Error('DbDependency requires a valid SQL query');
+        }
+    }
+    static setDataSource(dataSource) {
+        this.dataSource = dataSource;
+    }
+    static getDataSource() {
+        return this.dataSource;
+    }
+    getKey() {
+        const queryHash = this.hashCode(this.sql);
+        const name = this.name || 'db';
+        return `db:${name}:${queryHash}`;
+    }
+    getData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!DbDependency.dataSource) {
+                throw new Error('DbDependency requires DataSource to be set. Call DbDependency.setDataSource(dataSource) during app initialization.');
+            }
+            try {
+                const params = ((_a = this.paramsFactory) === null || _a === void 0 ? void 0 : _a.call(this)) || [];
+                const result = yield DbDependency.dataSource.query(this.sql, params);
+                return JSON.stringify(result);
+            }
+            catch (error) {
+                throw new Error(`DbDependency query failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    isChanged(oldData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const currentData = yield this.getData();
+                return oldData !== currentData;
+            }
+            catch (_a) {
+                return true;
+            }
+        });
+    }
+    hashCode(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash;
+        }
+        return Math.abs(hash).toString(36);
+    }
+}
+exports.DbDependency = DbDependency;
+DbDependency.dataSource = null;

package/cache/dependencies/file.dependency.d.ts

@@ -0,0 +1,17 @@
+import type { CacheDependency } from '../interfaces/cache-dependency.interface';
+export declare class FileDependency implements CacheDependency {
+    private readonly filePath;
+    constructor(filePath: string | ((...args: any[]) => string));
+    getKey(): string;
+    getData(): Promise<{
+        path: string;
+        mtime: number;
+        size: number;
+    }>;
+    isChanged(oldData: {
+        path: string;
+        mtime: number;
+        size: number;
+    } | null): Promise<boolean>;
+    private resolveFilePath;
+}

package/cache/dependencies/file.dependency.js

@@ -0,0 +1,63 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileDependency = void 0;
+const node_fs_1 = require("node:fs");
+class FileDependency {
+    constructor(filePath) {
+        if (!filePath) {
+            throw new Error('FileDependency requires a file path');
+        }
+        this.filePath = filePath;
+    }
+    getKey() {
+        const path = typeof this.filePath === 'function' ? 'dynamic' : this.filePath;
+        return `file:${path}`;
+    }
+    getData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = yield this.resolveFilePath();
+            try {
+                const stats = yield node_fs_1.promises.stat(path);
+                return {
+                    path,
+                    mtime: stats.mtimeMs,
+                    size: stats.size,
+                };
+            }
+            catch (error) {
+                throw new Error(`FileDependency: Cannot access file ${path}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    isChanged(oldData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const currentData = yield this.getData();
+                return (currentData.path !== oldData.path ||
+                    currentData.mtime !== oldData.mtime ||
+                    currentData.size !== oldData.size);
+            }
+            catch (_a) {
+                return true;
+            }
+        });
+    }
+    resolveFilePath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof this.filePath === 'function') {
+                return this.filePath();
+            }
+            return this.filePath;
+        });
+    }
+}
+exports.FileDependency = FileDependency;

package/cache/dependencies/index.d.ts

@@ -0,0 +1,6 @@
+export * from './callback.dependency';
+export * from './chain.dependency';
+export * from './db.dependency';
+export * from './file.dependency';
+export * from './tag.dependency';
+export * from './time.dependency';

package/cache/dependencies/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("./callback.dependency"), exports);
+__exportStar(require("./chain.dependency"), exports);
+__exportStar(require("./db.dependency"), exports);
+__exportStar(require("./file.dependency"), exports);
+__exportStar(require("./tag.dependency"), exports);
+__exportStar(require("./time.dependency"), exports);

package/cache/dependencies/tag.dependency.d.ts

@@ -0,0 +1,16 @@
+import type { CacheDependency } from '../interfaces/cache-dependency.interface';
+export declare class TagDependency implements CacheDependency {
+    private readonly tags;
+    private static readonly PREFIX;
+    private static tagVersions;
+    constructor(tags: string[]);
+    static getTagVersion(tag: string): number;
+    static invalidateTag(tag: string): void;
+    static invalidateTags(tags: string[]): void;
+    static resetAllTags(): void;
+    static getAllTags(): Map<string, number>;
+    getKey(): string;
+    getData(): Promise<Record<string, number>>;
+    isChanged(oldData: Record<string, number>): Promise<boolean>;
+    reset(): Promise<void>;
+}

package/cache/dependencies/tag.dependency.js

@@ -0,0 +1,75 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagDependency = void 0;
+class TagDependency {
+    constructor(tags) {
+        this.tags = tags;
+        if (!tags || tags.length === 0) {
+            throw new Error('TagDependency requires at least one tag');
+        }
+    }
+    static getTagVersion(tag) {
+        return this.tagVersions.get(tag) || 0;
+    }
+    static invalidateTag(tag) {
+        const currentVersion = this.tagVersions.get(tag) || 0;
+        this.tagVersions.set(tag, currentVersion + 1);
+    }
+    static invalidateTags(tags) {
+        for (const tag of tags) {
+            this.invalidateTag(tag);
+        }
+    }
+    static resetAllTags() {
+        this.tagVersions.clear();
+    }
+    static getAllTags() {
+        return new Map(this.tagVersions);
+    }
+    getKey() {
+        return `tag:${this.tags.sort().join(',')}`;
+    }
+    getData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = {};
+            for (const tag of this.tags) {
+                data[tag] = TagDependency.getTagVersion(tag);
+            }
+            return data;
+        });
+    }
+    isChanged(oldData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!oldData || typeof oldData !== 'object') {
+                return true;
+            }
+            for (const tag of this.tags) {
+                const currentVersion = TagDependency.getTagVersion(tag);
+                const oldVersion = oldData[tag];
+                if (currentVersion !== oldVersion) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+    reset() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const tag of this.tags) {
+                TagDependency.invalidateTag(tag);
+            }
+        });
+    }
+}
+exports.TagDependency = TagDependency;
+TagDependency.PREFIX = 'cache:tag:';
+TagDependency.tagVersions = new Map();

package/cache/dependencies/time.dependency.d.ts

@@ -0,0 +1,19 @@
+import type { CacheDependency } from '../interfaces/cache-dependency.interface';
+export declare class TimeDependency implements CacheDependency {
+    private readonly duration;
+    private createdAt;
+    constructor(duration: number | (() => number));
+    getKey(): string;
+    getData(): Promise<{
+        createdAt: number;
+        duration: number;
+    }>;
+    isChanged(oldData: {
+        createdAt: number;
+        duration: number;
+    }): Promise<boolean>;
+    reset(): Promise<void>;
+    getRemainingTime(): number;
+    isExpired(): boolean;
+    private resolveDuration;
+}

package/cache/dependencies/time.dependency.js

@@ -0,0 +1,71 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeDependency = void 0;
+class TimeDependency {
+    constructor(duration) {
+        if (typeof duration !== 'number' && typeof duration !== 'function') {
+            throw new Error('TimeDependency requires duration in milliseconds or a function returning duration');
+        }
+        if (typeof duration === 'number' && duration <= 0) {
+            throw new Error('TimeDependency duration must be positive');
+        }
+        this.duration = duration;
+        this.createdAt = Date.now();
+    }
+    getKey() {
+        const durationValue = this.resolveDuration();
+        return `time:${durationValue}:${this.createdAt}`;
+    }
+    getData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                createdAt: this.createdAt,
+                duration: this.resolveDuration(),
+            };
+        });
+    }
+    isChanged(oldData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!oldData || typeof oldData !== 'object') {
+                return true;
+            }
+            const now = Date.now();
+            const elapsed = now - oldData.createdAt;
+            return elapsed >= oldData.duration;
+        });
+    }
+    reset() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.createdAt = Date.now();
+        });
+    }
+    getRemainingTime() {
+        const duration = this.resolveDuration();
+        const elapsed = Date.now() - this.createdAt;
+        const remaining = duration - elapsed;
+        return Math.max(0, remaining);
+    }
+    isExpired() {
+        return this.getRemainingTime() === 0;
+    }
+    resolveDuration() {
+        if (typeof this.duration === 'function') {
+            const value = this.duration();
+            if (typeof value !== 'number' || value <= 0) {
+                throw new Error('TimeDependency duration function must return a positive number');
+            }
+            return value;
+        }
+        return this.duration;
+    }
+}
+exports.TimeDependency = TimeDependency;

package/cache/examples/quick-start.d.ts

@@ -0,0 +1,5 @@
+export declare class AppModule {
+}
+export { AppModule as ExampleAppModule };
+export declare class UserModule {
+}