ag-common 0.0.854 → 0.0.855

package/dist/api/helpers/google/apikey.js

@@ -1,15 +1,12 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.blockKeyService = exports.getAvailableCombinations = void 0;
-const node_cache_1 = __importDefault(require("node-cache"));
 const common_1 = require("../../../common");
 const log_1 = require("../../../common/helpers/log");
 const truncate_1 = require("../../../common/helpers/string/truncate");
+const helpers_1 = require("../../../node/helpers");
 // Initialize NodeCache with 1 hour TTL for blocklisted key combinations
-const blocklist = new node_cache_1.default({ stdTTL: 3600 });
+const blocklist = new helpers_1.TypedNodeCache({ stdTTL: 3600 });
 // Helper to generate blocklist key
 const getBlocklistKey = (apiKey, service) => `${(0, truncate_1.truncate)(apiKey, 10)}_${service}`;
 // Helper to check if a key+service combination is blocklisted

package/dist/node/helpers/fetch.d.ts

@@ -10,3 +10,4 @@ export declare function fetchToMemory(imageUrl: string): Promise<{
     type: string;
     arraybuffer: ArrayBuffer;
 } | undefined>;
+export declare function fetchExists(imageUrl: string): Promise<boolean>;

package/dist/node/helpers/fetch.js

@@ -14,9 +14,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchFile = fetchFile;
 exports.fetchToMemory = fetchToMemory;
+exports.fetchExists = fetchExists;
 const fs_1 = __importDefault(require("fs"));
+const withRetry_1 = require("../../api/helpers/withRetry");
 const log_1 = require("../../common/helpers/log");
 const headers_1 = require("./headers");
+const node_cache_1 = require("./node-cache");
 /**
  * download(fetch) file
  * @param p
@@ -72,3 +75,30 @@ function fetchToMemory(imageUrl) {
         }
     });
 }
+const imageExistsCache = new node_cache_1.TypedNodeCache({ stdTTL: 60 * 60 * 24 });
+function fetchExists(imageUrl) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cached = imageExistsCache.get(imageUrl);
+        if (typeof cached === 'boolean') {
+            return cached;
+        }
+        const response = yield (0, withRetry_1.withRetry)(() => __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(imageUrl, {
+                method: 'HEAD',
+                headers: (0, headers_1.getFetchHeaders)(),
+            });
+            if (response.status === 200)
+                return true;
+            if (response.status === 404)
+                return false;
+            throw new Error(`Unexpected status: ${response.status}`);
+        }), 'imageExistsAtUrl');
+        if (response === false) {
+            imageExistsCache.set(imageUrl, false, 1);
+        }
+        else {
+            imageExistsCache.set(imageUrl, true);
+        }
+        return response;
+    });
+}

package/dist/node/helpers/index.d.ts

@@ -1,3 +1,4 @@
 export * from './fetch';
 export * from './fs';
 export * from './headers';
+export * from './node-cache';

package/dist/node/helpers/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./fetch"), exports);
 __exportStar(require("./fs"), exports);
 __exportStar(require("./headers"), exports);
+__exportStar(require("./node-cache"), exports);

package/dist/node/helpers/node-cache.d.ts

@@ -0,0 +1,71 @@
+import NodeCache from 'node-cache';
+export interface CacheOptions {
+    stdTTL?: number;
+    checkperiod?: number;
+    useClones?: boolean;
+    deleteOnExpire?: boolean;
+    enableLegacyCallbacks?: boolean;
+    maxKeys?: number;
+}
+export declare class TypedNodeCache<T = any> {
+    private cache;
+    constructor(options?: CacheOptions);
+    /**
+     * Normalizes the key to lowercase for case-insensitive operations
+     */
+    private normalizeKey;
+    /**
+     * Get a value from the cache
+     */
+    get(key: string): T | undefined;
+    /**
+     * Set a value in the cache
+     */
+    set(key: string, value: T, ttl?: number): boolean;
+    /**
+     * Delete a key from the cache
+     */
+    del(key: string): number;
+    /**
+     * Check if a key exists in the cache
+     */
+    has(key: string): boolean;
+    /**
+     * Get multiple values from the cache
+     */
+    mget(keys: string[]): {
+        [key: string]: T;
+    };
+    /**
+     * Set multiple values in the cache
+     */
+    mset(keyValuePairs: Array<{
+        key: string;
+        val: T;
+        ttl?: number;
+    }>): boolean;
+    /**
+     * Get all keys in the cache
+     */
+    keys(): string[];
+    /**
+     * Get cache statistics
+     */
+    getStats(): NodeCache.Stats;
+    /**
+     * Flush all data from the cache
+     */
+    flushAll(): void;
+    /**
+     * Close the cache and clear all timers
+     */
+    close(): void;
+    /**
+     * Get the TTL for a key
+     */
+    getTtl(key: string): number | undefined;
+    /**
+     * Set the TTL for a key
+     */
+    ttl(key: string, ttl: number): boolean;
+}

package/dist/node/helpers/node-cache.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedNodeCache = void 0;
+const node_cache_1 = __importDefault(require("node-cache"));
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class TypedNodeCache {
+    constructor(options = {}) {
+        this.cache = new node_cache_1.default(Object.assign({ stdTTL: 3600, checkperiod: 120 }, options));
+    }
+    /**
+     * Normalizes the key to lowercase for case-insensitive operations
+     */
+    normalizeKey(key) {
+        return key.toLowerCase();
+    }
+    /**
+     * Get a value from the cache
+     */
+    get(key) {
+        return this.cache.get(this.normalizeKey(key));
+    }
+    /**
+     * Set a value in the cache
+     */
+    set(key, value, ttl) {
+        if (ttl !== undefined) {
+            return this.cache.set(this.normalizeKey(key), value, ttl);
+        }
+        return this.cache.set(this.normalizeKey(key), value);
+    }
+    /**
+     * Delete a key from the cache
+     */
+    del(key) {
+        return this.cache.del(this.normalizeKey(key));
+    }
+    /**
+     * Check if a key exists in the cache
+     */
+    has(key) {
+        return this.cache.has(this.normalizeKey(key));
+    }
+    /**
+     * Get multiple values from the cache
+     */
+    mget(keys) {
+        const normalizedKeys = keys.map((key) => this.normalizeKey(key));
+        return this.cache.mget(normalizedKeys);
+    }
+    /**
+     * Set multiple values in the cache
+     */
+    mset(keyValuePairs) {
+        const normalizedPairs = keyValuePairs.map((pair) => (Object.assign(Object.assign({}, pair), { key: this.normalizeKey(pair.key) })));
+        return this.cache.mset(normalizedPairs);
+    }
+    /**
+     * Get all keys in the cache
+     */
+    keys() {
+        return this.cache.keys();
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        return this.cache.getStats();
+    }
+    /**
+     * Flush all data from the cache
+     */
+    flushAll() {
+        this.cache.flushAll();
+    }
+    /**
+     * Close the cache and clear all timers
+     */
+    close() {
+        this.cache.close();
+    }
+    /**
+     * Get the TTL for a key
+     */
+    getTtl(key) {
+        return this.cache.getTtl(this.normalizeKey(key));
+    }
+    /**
+     * Set the TTL for a key
+     */
+    ttl(key, ttl) {
+        return this.cache.ttl(this.normalizeKey(key), ttl);
+    }
+}
+exports.TypedNodeCache = TypedNodeCache;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.854",
+  "version": "0.0.855",
   "name": "ag-common",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",