aws-instance-info 0.1.0

package/dist/elasticache.async.d.ts

@@ -0,0 +1,210 @@
+import { clearElastiCacheCache, getElastiCacheCacheStats } from './elasticache.cache.js';
+import type { ElastiCacheCategory, ElastiCacheFamily, ElastiCacheFamilyData, ElastiCacheInfo, ElastiCacheNodeDetails, ElastiCacheNodeType } from './types.js';
+export { clearElastiCacheCache, getElastiCacheCacheStats };
+/**
+ * Get the Elasticache info manifest containing lists of all families and node types.
+ * This is a lightweight file that can be used to enumerate available data.
+ *
+ * @returns Promise resolving to ElastiCacheInfo object with families, nodeTypes, and categories arrays
+ *
+ * @example
+ * ```typescript
+ * import { getElastiCacheInfo } from 'aws-instance-info/async'
+ *
+ * const info = await getElastiCacheInfo()
+ * console.log(info.families) // ['M5', 'R6g', 'T3', ...]
+ * console.log(info.nodeTypes) // ['cache.m5.large', 'cache.r6g.xlarge', ...]
+ * console.log(info.categories) // ['general_purpose', 'memory_optimized', ...]
+ * ```
+ */
+export declare function getElastiCacheInfo(): Promise<ElastiCacheInfo>;
+/**
+ * Get detailed information for a specific Elasticache node type.
+ * Loads only the JSON file for the requested node type. Results are cached using LRU.
+ *
+ * @param nodeType - The node type (e.g., "cache.m5.large")
+ * @returns Promise resolving to node type details including vCPUs, memory, and network specs
+ *
+ * @example
+ * ```typescript
+ * import { getElastiCacheNodeInfo } from 'aws-instance-info/async'
+ *
+ * const node = await getElastiCacheNodeInfo('cache.m5.large')
+ * console.log(node.nodeType) // 'cache.m5.large'
+ * console.log(node.vCPUs) // 2
+ * console.log(node.memoryGiB) // 6.38
+ * console.log(node.networkPerformance) // 'Up to 10 Gigabit'
+ * ```
+ */
+export declare function getElastiCacheNodeInfo(nodeType: ElastiCacheNodeType): Promise<ElastiCacheNodeDetails>;
+/**
+ * Get all data for an Elasticache node family.
+ * Includes the list of node types in the family. Results are cached using LRU.
+ *
+ * @param family - The node family (e.g., "M5")
+ * @returns Promise resolving to family data including category and node type list
+ *
+ * @example
+ * ```typescript
+ * import { getElastiCacheFamily } from 'aws-instance-info/async'
+ *
+ * const family = await getElastiCacheFamily('M5')
+ * console.log(family.category) // 'general_purpose'
+ * console.log(family.nodeTypes) // ['cache.m5.large', 'cache.m5.xlarge', ...]
+ * ```
+ */
+export declare function getElastiCacheFamily(family: ElastiCacheFamily): Promise<ElastiCacheFamilyData>;
+/**
+ * Get all node types belonging to a specific Elasticache family.
+ * This loads the family file but only returns the list of node types.
+ *
+ * @param family - The node family (e.g., "M5")
+ * @returns Promise resolving to array of node type names in the family
+ *
+ * @example
+ * ```typescript
+ * import { getElastiCacheFamilyNodeTypes } from 'aws-instance-info/async'
+ *
+ * const nodeTypes = await getElastiCacheFamilyNodeTypes('M5')
+ * console.log(nodeTypes) // ['cache.m5.large', 'cache.m5.xlarge', 'cache.m5.2xlarge', ...]
+ * ```
+ */
+export declare function getElastiCacheFamilyNodeTypes(family: ElastiCacheFamily): Promise<ElastiCacheNodeType[]>;
+/**
+ * Get the category for an Elasticache node family.
+ *
+ * @param family - The node family (e.g., "M5")
+ * @returns Promise resolving to the category (e.g., "general_purpose")
+ *
+ * @example
+ * ```typescript
+ * import { getElastiCacheFamilyCategory } from 'aws-instance-info/async'
+ *
+ * const category = await getElastiCacheFamilyCategory('M5')
+ * console.log(category) // 'general_purpose'
+ *
+ * const category2 = await getElastiCacheFamilyCategory('R6g')
+ * console.log(category2) // 'memory_optimized'
+ * ```
+ */
+export declare function getElastiCacheFamilyCategory(family: ElastiCacheFamily): Promise<ElastiCacheCategory>;
+/**
+ * Get all available Elasticache node families.
+ *
+ * @returns Promise resolving to array of all family names
+ *
+ * @example
+ * ```typescript
+ * import { getAllElastiCacheFamilies } from 'aws-instance-info/async'
+ *
+ * const families = await getAllElastiCacheFamilies()
+ * console.log(families) // ['M5', 'M6g', 'R6g', 'R7g', 'T3', 'T4g', ...]
+ * console.log(families.length) // ~13
+ * ```
+ */
+export declare function getAllElastiCacheFamilies(): Promise<ElastiCacheFamily[]>;
+/**
+ * Get all available Elasticache node types.
+ *
+ * @returns Promise resolving to array of all node type names
+ *
+ * @example
+ * ```typescript
+ * import { getAllElastiCacheNodeTypes } from 'aws-instance-info/async'
+ *
+ * const nodeTypes = await getAllElastiCacheNodeTypes()
+ * console.log(nodeTypes) // ['cache.m5.large', 'cache.m5.xlarge', 'cache.r6g.2xlarge', ...]
+ * console.log(nodeTypes.length) // ~73
+ * ```
+ */
+export declare function getAllElastiCacheNodeTypes(): Promise<ElastiCacheNodeType[]>;
+/**
+ * Get all available Elasticache categories.
+ *
+ * @returns Promise resolving to array of all category names
+ *
+ * @example
+ * ```typescript
+ * import { getAllElastiCacheCategories } from 'aws-instance-info/async'
+ *
+ * const categories = await getAllElastiCacheCategories()
+ * console.log(categories)
+ * // ['general_purpose', 'memory_optimized', 'network_optimized', 'burstable_performance']
+ * ```
+ */
+export declare function getAllElastiCacheCategories(): Promise<ElastiCacheCategory[]>;
+/**
+ * Check if an Elasticache node type exists in the dataset.
+ *
+ * @param nodeType - The node type to check
+ * @returns Promise resolving to true if the node type exists, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { isValidElastiCacheNodeType } from 'aws-instance-info/async'
+ *
+ * console.log(await isValidElastiCacheNodeType('cache.m5.large')) // true
+ * console.log(await isValidElastiCacheNodeType('cache.m5.invalid')) // false
+ * console.log(await isValidElastiCacheNodeType('cache.t3.micro')) // true
+ * ```
+ */
+export declare function isValidElastiCacheNodeType(nodeType: string): Promise<boolean>;
+/**
+ * Check if an Elasticache node family exists in the dataset.
+ *
+ * @param family - The family name to check
+ * @returns Promise resolving to true if the family exists, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { isValidElastiCacheFamily } from 'aws-instance-info/async'
+ *
+ * console.log(await isValidElastiCacheFamily('M5')) // true
+ * console.log(await isValidElastiCacheFamily('R6g')) // true
+ * console.log(await isValidElastiCacheFamily('Invalid')) // false
+ * ```
+ */
+export declare function isValidElastiCacheFamily(family: string): Promise<boolean>;
+/**
+ * Get multiple Elasticache node types at once. Loads nodes in parallel for better performance.
+ *
+ * @param nodeTypes - Array of node types to fetch
+ * @returns Promise resolving to Map of node type to details
+ *
+ * @example
+ * ```typescript
+ * import { getElastiCacheNodes } from 'aws-instance-info/async'
+ *
+ * const nodes = await getElastiCacheNodes(['cache.m5.large', 'cache.m5.xlarge', 'cache.r6g.2xlarge'])
+ *
+ * for (const [type, details] of nodes) {
+ *   console.log(`${type}: ${details.vCPUs} vCPUs, ${details.memoryGiB} GiB`)
+ * }
+ * // cache.m5.large: 2 vCPUs, 6.38 GiB
+ * // cache.m5.xlarge: 4 vCPUs, 12.93 GiB
+ * // cache.r6g.2xlarge: 8 vCPUs, 52.82 GiB
+ * ```
+ */
+export declare function getElastiCacheNodes(nodeTypes: ElastiCacheNodeType[]): Promise<Map<ElastiCacheNodeType, ElastiCacheNodeDetails>>;
+/**
+ * Get multiple Elasticache families at once. Loads families in parallel for better performance.
+ *
+ * @param families - Array of family names to fetch
+ * @returns Promise resolving to Map of family name to family data
+ *
+ * @example
+ * ```typescript
+ * import { getElastiCacheFamilies } from 'aws-instance-info/async'
+ *
+ * const families = await getElastiCacheFamilies(['M5', 'R6g', 'T3'])
+ *
+ * for (const [name, data] of families) {
+ *   console.log(`${name}: ${data.category}, ${data.nodeTypes.length} node types`)
+ * }
+ * // M5: general_purpose, 6 node types
+ * // R6g: memory_optimized, 7 node types
+ * // T3: burstable_performance, 3 node types
+ * ```
+ */
+export declare function getElastiCacheFamilies(families: ElastiCacheFamily[]): Promise<Map<ElastiCacheFamily, ElastiCacheFamilyData>>;
+//# sourceMappingURL=elasticache.async.d.ts.map

package/dist/elasticache.async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elasticache.async.d.ts","sourceRoot":"","sources":["../lib/elasticache.async.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,qBAAqB,EAErB,wBAAwB,EAGzB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EACjB,qBAAqB,EACrB,eAAe,EACf,sBAAsB,EACtB,mBAAmB,EACpB,MAAM,YAAY,CAAA;AAGnB,OAAO,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,CAAA;AAS1D;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,eAAe,CAAC,CAOnE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,mBAAmB,GAC5B,OAAO,CAAC,sBAAsB,CAAC,CASjC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAAC,qBAAqB,CAAC,CAShC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,6BAA6B,CACjD,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAGhC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,4BAA4B,CAChD,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAAC,mBAAmB,CAAC,CAG9B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,yBAAyB,IAAI,OAAO,CACxD,iBAAiB,EAAE,CACpB,CAGA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,0BAA0B,IAAI,OAAO,CACzD,mBAAmB,EAAE,CACtB,CAGA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,2BAA2B,IAAI,OAAO,CAC1D,mBAAmB,EAAE,CACtB,CAGA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,0BAA0B,CAC9C,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,OAAO,CAAC,CAGlB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,OAAO,CAAC,CAGlB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,mBAAmB,CACvC,SAAS,EAAE,mBAAmB,EAAE,GAC/B,OAAO,CAAC,GAAG,CAAC,mBAAmB,EAAE,sBAAsB,CAAC,CAAC,CAS3D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,iBAAiB,EAAE,GAC5B,OAAO,CAAC,GAAG,CAAC,iBAAiB,EAAE,qBAAqB,CAAC,CAAC,CASxD"}

package/dist/elasticache.async.js

@@ -0,0 +1,273 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { ELASTICACHE_DATA_DIR, clearElastiCacheCache, familyCache, getElastiCacheCacheStats, infoCacheHolder, nodeCache, } from './elasticache.cache.js';
+/* Re-export cache utilities (these remain synchronous) */
+export { clearElastiCacheCache, getElastiCacheCacheStats };
+/* Internal helper function to load and parse JSON files asynchronously */
+async function loadJson(relativePath) {
+    const fullPath = join(ELASTICACHE_DATA_DIR, relativePath);
+    const content = await readFile(fullPath, 'utf-8');
+    return JSON.parse(content);
+}
+/**
+ * Get the Elasticache info manifest containing lists of all families and node types.
+ * This is a lightweight file that can be used to enumerate available data.
+ *
+ * @returns Promise resolving to ElastiCacheInfo object with families, nodeTypes, and categories arrays
+ *
+ * @example
+ * ```typescript
+ * import { getElastiCacheInfo } from 'aws-instance-info/async'
+ *
+ * const info = await getElastiCacheInfo()
+ * console.log(info.families) // ['M5', 'R6g', 'T3', ...]
+ * console.log(info.nodeTypes) // ['cache.m5.large', 'cache.r6g.xlarge', ...]
+ * console.log(info.categories) // ['general_purpose', 'memory_optimized', ...]
+ * ```
+ */
+export async function getElastiCacheInfo() {
+    if (infoCacheHolder.value) {
+        return infoCacheHolder.value;
+    }
+    infoCacheHolder.value = await loadJson('info.json');
+    return infoCacheHolder.value;
+}
+/**
+ * Get detailed information for a specific Elasticache node type.
+ * Loads only the JSON file for the requested node type. Results are cached using LRU.
+ *
+ * @param nodeType - The node type (e.g., "cache.m5.large")
+ * @returns Promise resolving to node type details including vCPUs, memory, and network specs
+ *
+ * @example
+ * ```typescript
+ * import { getElastiCacheNodeInfo } from 'aws-instance-info/async'
+ *
+ * const node = await getElastiCacheNodeInfo('cache.m5.large')
+ * console.log(node.nodeType) // 'cache.m5.large'
+ * console.log(node.vCPUs) // 2
+ * console.log(node.memoryGiB) // 6.38
+ * console.log(node.networkPerformance) // 'Up to 10 Gigabit'
+ * ```
+ */
+export async function getElastiCacheNodeInfo(nodeType) {
+    const cached = nodeCache.get(nodeType);
+    if (cached) {
+        return cached;
+    }
+    const data = await loadJson(`nodes/${nodeType}.json`);
+    nodeCache.set(nodeType, data);
+    return data;
+}
+/**
+ * Get all data for an Elasticache node family.
+ * Includes the list of node types in the family. Results are cached using LRU.
+ *
+ * @param family - The node family (e.g., "M5")
+ * @returns Promise resolving to family data including category and node type list
+ *
+ * @example
+ * ```typescript
+ * import { getElastiCacheFamily } from 'aws-instance-info/async'
+ *
+ * const family = await getElastiCacheFamily('M5')
+ * console.log(family.category) // 'general_purpose'
+ * console.log(family.nodeTypes) // ['cache.m5.large', 'cache.m5.xlarge', ...]
+ * ```
+ */
+export async function getElastiCacheFamily(family) {
+    const cached = familyCache.get(family);
+    if (cached) {
+        return cached;
+    }
+    const data = await loadJson(`families/${family}.json`);
+    familyCache.set(family, data);
+    return data;
+}
+/**
+ * Get all node types belonging to a specific Elasticache family.
+ * This loads the family file but only returns the list of node types.
+ *
+ * @param family - The node family (e.g., "M5")
+ * @returns Promise resolving to array of node type names in the family
+ *
+ * @example
+ * ```typescript
+ * import { getElastiCacheFamilyNodeTypes } from 'aws-instance-info/async'
+ *
+ * const nodeTypes = await getElastiCacheFamilyNodeTypes('M5')
+ * console.log(nodeTypes) // ['cache.m5.large', 'cache.m5.xlarge', 'cache.m5.2xlarge', ...]
+ * ```
+ */
+export async function getElastiCacheFamilyNodeTypes(family) {
+    const familyData = await getElastiCacheFamily(family);
+    return familyData.nodeTypes;
+}
+/**
+ * Get the category for an Elasticache node family.
+ *
+ * @param family - The node family (e.g., "M5")
+ * @returns Promise resolving to the category (e.g., "general_purpose")
+ *
+ * @example
+ * ```typescript
+ * import { getElastiCacheFamilyCategory } from 'aws-instance-info/async'
+ *
+ * const category = await getElastiCacheFamilyCategory('M5')
+ * console.log(category) // 'general_purpose'
+ *
+ * const category2 = await getElastiCacheFamilyCategory('R6g')
+ * console.log(category2) // 'memory_optimized'
+ * ```
+ */
+export async function getElastiCacheFamilyCategory(family) {
+    const familyData = await getElastiCacheFamily(family);
+    return familyData.category;
+}
+/**
+ * Get all available Elasticache node families.
+ *
+ * @returns Promise resolving to array of all family names
+ *
+ * @example
+ * ```typescript
+ * import { getAllElastiCacheFamilies } from 'aws-instance-info/async'
+ *
+ * const families = await getAllElastiCacheFamilies()
+ * console.log(families) // ['M5', 'M6g', 'R6g', 'R7g', 'T3', 'T4g', ...]
+ * console.log(families.length) // ~13
+ * ```
+ */
+export async function getAllElastiCacheFamilies() {
+    const info = await getElastiCacheInfo();
+    return info.families;
+}
+/**
+ * Get all available Elasticache node types.
+ *
+ * @returns Promise resolving to array of all node type names
+ *
+ * @example
+ * ```typescript
+ * import { getAllElastiCacheNodeTypes } from 'aws-instance-info/async'
+ *
+ * const nodeTypes = await getAllElastiCacheNodeTypes()
+ * console.log(nodeTypes) // ['cache.m5.large', 'cache.m5.xlarge', 'cache.r6g.2xlarge', ...]
+ * console.log(nodeTypes.length) // ~73
+ * ```
+ */
+export async function getAllElastiCacheNodeTypes() {
+    const info = await getElastiCacheInfo();
+    return info.nodeTypes;
+}
+/**
+ * Get all available Elasticache categories.
+ *
+ * @returns Promise resolving to array of all category names
+ *
+ * @example
+ * ```typescript
+ * import { getAllElastiCacheCategories } from 'aws-instance-info/async'
+ *
+ * const categories = await getAllElastiCacheCategories()
+ * console.log(categories)
+ * // ['general_purpose', 'memory_optimized', 'network_optimized', 'burstable_performance']
+ * ```
+ */
+export async function getAllElastiCacheCategories() {
+    const info = await getElastiCacheInfo();
+    return info.categories;
+}
+/**
+ * Check if an Elasticache node type exists in the dataset.
+ *
+ * @param nodeType - The node type to check
+ * @returns Promise resolving to true if the node type exists, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { isValidElastiCacheNodeType } from 'aws-instance-info/async'
+ *
+ * console.log(await isValidElastiCacheNodeType('cache.m5.large')) // true
+ * console.log(await isValidElastiCacheNodeType('cache.m5.invalid')) // false
+ * console.log(await isValidElastiCacheNodeType('cache.t3.micro')) // true
+ * ```
+ */
+export async function isValidElastiCacheNodeType(nodeType) {
+    const info = await getElastiCacheInfo();
+    return info.nodeTypes.includes(nodeType);
+}
+/**
+ * Check if an Elasticache node family exists in the dataset.
+ *
+ * @param family - The family name to check
+ * @returns Promise resolving to true if the family exists, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { isValidElastiCacheFamily } from 'aws-instance-info/async'
+ *
+ * console.log(await isValidElastiCacheFamily('M5')) // true
+ * console.log(await isValidElastiCacheFamily('R6g')) // true
+ * console.log(await isValidElastiCacheFamily('Invalid')) // false
+ * ```
+ */
+export async function isValidElastiCacheFamily(family) {
+    const info = await getElastiCacheInfo();
+    return info.families.includes(family);
+}
+/**
+ * Get multiple Elasticache node types at once. Loads nodes in parallel for better performance.
+ *
+ * @param nodeTypes - Array of node types to fetch
+ * @returns Promise resolving to Map of node type to details
+ *
+ * @example
+ * ```typescript
+ * import { getElastiCacheNodes } from 'aws-instance-info/async'
+ *
+ * const nodes = await getElastiCacheNodes(['cache.m5.large', 'cache.m5.xlarge', 'cache.r6g.2xlarge'])
+ *
+ * for (const [type, details] of nodes) {
+ *   console.log(`${type}: ${details.vCPUs} vCPUs, ${details.memoryGiB} GiB`)
+ * }
+ * // cache.m5.large: 2 vCPUs, 6.38 GiB
+ * // cache.m5.xlarge: 4 vCPUs, 12.93 GiB
+ * // cache.r6g.2xlarge: 8 vCPUs, 52.82 GiB
+ * ```
+ */
+export async function getElastiCacheNodes(nodeTypes) {
+    const results = await Promise.all(nodeTypes.map(async (nodeType) => {
+        const details = await getElastiCacheNodeInfo(nodeType);
+        return [nodeType, details];
+    }));
+    return new Map(results);
+}
+/**
+ * Get multiple Elasticache families at once. Loads families in parallel for better performance.
+ *
+ * @param families - Array of family names to fetch
+ * @returns Promise resolving to Map of family name to family data
+ *
+ * @example
+ * ```typescript
+ * import { getElastiCacheFamilies } from 'aws-instance-info/async'
+ *
+ * const families = await getElastiCacheFamilies(['M5', 'R6g', 'T3'])
+ *
+ * for (const [name, data] of families) {
+ *   console.log(`${name}: ${data.category}, ${data.nodeTypes.length} node types`)
+ * }
+ * // M5: general_purpose, 6 node types
+ * // R6g: memory_optimized, 7 node types
+ * // T3: burstable_performance, 3 node types
+ * ```
+ */
+export async function getElastiCacheFamilies(families) {
+    const results = await Promise.all(families.map(async (family) => {
+        const data = await getElastiCacheFamily(family);
+        return [family, data];
+    }));
+    return new Map(results);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/elasticache.cache.d.ts

@@ -0,0 +1,50 @@
+import { LRUCache } from 'lru-cache';
+import type { ElastiCacheFamilyData, ElastiCacheInfo, ElastiCacheNodeDetails } from './types.js';
+/** Base directory for Elasticache data files */
+export declare const ELASTICACHE_DATA_DIR: string;
+export declare const nodeCache: LRUCache<string, ElastiCacheNodeDetails, unknown>;
+export declare const familyCache: LRUCache<string, ElastiCacheFamilyData, unknown>;
+/** Info cache wrapper to allow mutation */
+export declare const infoCacheHolder: {
+    value: ElastiCacheInfo | null;
+};
+/**
+ * Clear all Elasticache cached data.
+ * Useful for testing or when you need to free memory.
+ *
+ * @example
+ * ```typescript
+ * import { clearElastiCacheCache, getElastiCacheCacheStats } from 'aws-instance-info'
+ *
+ * console.log(getElastiCacheCacheStats()) // { nodes: 10, families: 3, infoLoaded: true }
+ *
+ * clearElastiCacheCache()
+ *
+ * console.log(getElastiCacheCacheStats()) // { nodes: 0, families: 0, infoLoaded: false }
+ * ```
+ */
+export declare function clearElastiCacheCache(): void;
+/**
+ * Get Elasticache cache statistics.
+ * Useful for debugging or monitoring memory usage.
+ *
+ * @returns Object with cache statistics
+ *
+ * @example
+ * ```typescript
+ * import { getElastiCacheCacheStats, getElastiCacheNodeInfo } from 'aws-instance-info'
+ *
+ * getElastiCacheNodeInfo('cache.m5.large')
+ * getElastiCacheNodeInfo('cache.m5.xlarge')
+ *
+ * const stats = getElastiCacheCacheStats()
+ * console.log(stats)
+ * // { nodes: 2, families: 0, infoLoaded: true }
+ * ```
+ */
+export declare function getElastiCacheCacheStats(): {
+    nodes: number;
+    families: number;
+    infoLoaded: boolean;
+};
+//# sourceMappingURL=elasticache.cache.d.ts.map

package/dist/elasticache.cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elasticache.cache.d.ts","sourceRoot":"","sources":["../lib/elasticache.cache.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAMpC,OAAO,KAAK,EACV,qBAAqB,EACrB,eAAe,EACf,sBAAsB,EACvB,MAAM,YAAY,CAAA;AAMnB,gDAAgD;AAChD,eAAO,MAAM,oBAAoB,QAA+C,CAAA;AAGhF,eAAO,MAAM,SAAS,mDAEpB,CAAA;AACF,eAAO,MAAM,WAAW,kDAEtB,CAAA;AAEF,2CAA2C;AAC3C,eAAO,MAAM,eAAe,EAAE;IAAE,KAAK,EAAE,eAAe,GAAG,IAAI,CAAA;CAE5D,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAI5C;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,IAAI;IAC1C,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,OAAO,CAAA;CACpB,CAMA"}

package/dist/elasticache.cache.js

@@ -0,0 +1,66 @@
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { LRUCache } from 'lru-cache';
+import { ELASTICACHE_FAMILY_CACHE_SIZE, ELASTICACHE_NODE_CACHE_SIZE, } from './constants.js';
+/* File Paths */
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/** Base directory for Elasticache data files */
+export const ELASTICACHE_DATA_DIR = join(__dirname, '..', 'data', 'elasticache');
+/* Internal Caches - shared between sync and async APIs */
+export const nodeCache = new LRUCache({
+    max: ELASTICACHE_NODE_CACHE_SIZE,
+});
+export const familyCache = new LRUCache({
+    max: ELASTICACHE_FAMILY_CACHE_SIZE,
+});
+/** Info cache wrapper to allow mutation */
+export const infoCacheHolder = {
+    value: null,
+};
+/**
+ * Clear all Elasticache cached data.
+ * Useful for testing or when you need to free memory.
+ *
+ * @example
+ * ```typescript
+ * import { clearElastiCacheCache, getElastiCacheCacheStats } from 'aws-instance-info'
+ *
+ * console.log(getElastiCacheCacheStats()) // { nodes: 10, families: 3, infoLoaded: true }
+ *
+ * clearElastiCacheCache()
+ *
+ * console.log(getElastiCacheCacheStats()) // { nodes: 0, families: 0, infoLoaded: false }
+ * ```
+ */
+export function clearElastiCacheCache() {
+    nodeCache.clear();
+    familyCache.clear();
+    infoCacheHolder.value = null;
+}
+/**
+ * Get Elasticache cache statistics.
+ * Useful for debugging or monitoring memory usage.
+ *
+ * @returns Object with cache statistics
+ *
+ * @example
+ * ```typescript
+ * import { getElastiCacheCacheStats, getElastiCacheNodeInfo } from 'aws-instance-info'
+ *
+ * getElastiCacheNodeInfo('cache.m5.large')
+ * getElastiCacheNodeInfo('cache.m5.xlarge')
+ *
+ * const stats = getElastiCacheCacheStats()
+ * console.log(stats)
+ * // { nodes: 2, families: 0, infoLoaded: true }
+ * ```
+ */
+export function getElastiCacheCacheStats() {
+    return {
+        nodes: nodeCache.size,
+        families: familyCache.size,
+        infoLoaded: infoCacheHolder.value !== null,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxhc3RpY2FjaGUuY2FjaGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvZWxhc3RpY2FjaGUuY2FjaGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDekMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLFVBQVUsQ0FBQTtBQUN4QyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBRXBDLE9BQU8sRUFDTCw2QkFBNkIsRUFDN0IsMkJBQTJCLEdBQzVCLE1BQU0sZ0JBQWdCLENBQUE7QUFPdkIsZ0JBQWdCO0FBQ2hCLE1BQU0sVUFBVSxHQUFHLGFBQWEsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFBO0FBQ2pELE1BQU0sU0FBUyxHQUFHLE9BQU8sQ0FBQyxVQUFVLENBQUMsQ0FBQTtBQUVyQyxnREFBZ0Q7QUFDaEQsTUFBTSxDQUFDLE1BQU0sb0JBQW9CLEdBQUcsSUFBSSxDQUFDLFNBQVMsRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLGFBQWEsQ0FBQyxDQUFBO0FBRWhGLDBEQUEwRDtBQUMxRCxNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUcsSUFBSSxRQUFRLENBQWlDO0lBQ3BFLEdBQUcsRUFBRSwyQkFBMkI7Q0FDakMsQ0FBQyxDQUFBO0FBQ0YsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHLElBQUksUUFBUSxDQUFnQztJQUNyRSxHQUFHLEVBQUUsNkJBQTZCO0NBQ25DLENBQUMsQ0FBQTtBQUVGLDJDQUEyQztBQUMzQyxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQXNDO0lBQ2hFLEtBQUssRUFBRSxJQUFJO0NBQ1osQ0FBQTtBQUVEOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBQ0gsTUFBTSxVQUFVLHFCQUFxQjtJQUNuQyxTQUFTLENBQUMsS0FBSyxFQUFFLENBQUE7SUFDakIsV0FBVyxDQUFDLEtBQUssRUFBRSxDQUFBO0lBQ25CLGVBQWUsQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFBO0FBQzlCLENBQUM7QUFFRDs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FpQkc7QUFDSCxNQUFNLFVBQVUsd0JBQXdCO0lBS3RDLE9BQU87UUFDTCxLQUFLLEVBQUUsU0FBUyxDQUFDLElBQUk7UUFDckIsUUFBUSxFQUFFLFdBQVcsQ0FBQyxJQUFJO1FBQzFCLFVBQVUsRUFBRSxlQUFlLENBQUMsS0FBSyxLQUFLLElBQUk7S0FDM0MsQ0FBQTtBQUNILENBQUMifQ==