@fjell/cache 4.6.5 → 4.6.10

package/examples/basic-cache-example.ts

@@ -0,0 +1,273 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * Basic Cache Example
+ *
+ * This example demonstrates the fundamental usage of fjell-cache for caching data models.
+ * It shows how to create caches, perform basic operations like get/set/all, and manage
+ * cached data with mock storage operations.
+ *
+ * Perfect for understanding the basics of fjell-cache before moving to advanced features.
+ */
+
+import { createCache } from '../src/Cache';
+import { createInstance } from '../src/Instance';
+import { createRegistry } from '../src/Registry';
+import { ClientApi } from '@fjell/client-api';
+import { Item, PriKey } from '@fjell/core';
+import { createCoordinate } from '@fjell/registry';
+
+// Define our data models
+interface User extends Item<'user'> {
+  id: string;
+  name: string;
+  email: string;
+  role: 'admin' | 'user' | 'guest';
+}
+
+interface Task extends Item<'task'> {
+  id: string;
+  title: string;
+  description: string;
+  assignedTo?: string;
+  status: 'pending' | 'in-progress' | 'completed';
+  priority: 'low' | 'medium' | 'high';
+}
+
+// Mock storage for demonstration (in real apps, this would be your database/API)
+const mockUserStorage = new Map<string, User>();
+const mockTaskStorage = new Map<string, Task>();
+
+// Simple mock API for Users (simplified to avoid type issues)
+const createUserApi = (): Partial<ClientApi<User, 'user'>> => ({
+  async all(query = {}) {
+    console.log('📦 Fetching all users from storage...');
+    return Array.from(mockUserStorage.values());
+  },
+
+  async one(query = {}) {
+    const users = await this.all!(query);
+    return users[0] || null;
+  },
+
+  async get(key: PriKey<'user'>) {
+    console.log(`🔍 Getting user with key: ${key.pk}`);
+    const user = mockUserStorage.get(String(key.pk));
+    if (!user) {
+      throw new Error(`User not found: ${key.pk}`);
+    }
+    return user;
+  },
+
+  async find(finder = 'all') {
+    return await this.all!({});
+  }
+});
+
+// Simple mock API for Tasks
+const createTaskApi = (): Partial<ClientApi<Task, 'task'>> => ({
+  async all(query = {}) {
+    console.log('📦 Fetching all tasks from storage...');
+    return Array.from(mockTaskStorage.values());
+  },
+
+  async one(query = {}) {
+    const tasks = await this.all!(query);
+    return tasks[0] || null;
+  },
+
+  async get(key: PriKey<'task'>) {
+    console.log(`🔍 Getting task with key: ${key.pk}`);
+    const task = mockTaskStorage.get(String(key.pk));
+    if (!task) {
+      throw new Error(`Task not found: ${key.pk}`);
+    }
+    return task;
+  },
+
+  async find(finder = 'all') {
+    return await this.all!({});
+  }
+});
+
+// Helper function to create test data
+const createTestUser = (id: string, name: string, email: string, role: 'admin' | 'user' | 'guest'): User => {
+  const user: User = {
+    id,
+    name,
+    email,
+    role,
+    key: { kt: 'user', pk: id },
+    events: {
+      created: { at: new Date() },
+      updated: { at: new Date() },
+      deleted: { at: null }
+    }
+  };
+  mockUserStorage.set(id, user);
+  console.log(`✅ Created user: ${user.name} (${user.email})`);
+  return user;
+};
+
+const createTestTask = (id: string, title: string, description: string, assignedTo: string, status: 'pending' | 'in-progress' | 'completed', priority: 'low' | 'medium' | 'high'): Task => {
+  const task: Task = {
+    id,
+    title,
+    description,
+    assignedTo,
+    status,
+    priority,
+    key: { kt: 'task', pk: id },
+    events: {
+      created: { at: new Date() },
+      updated: { at: new Date() },
+      deleted: { at: null }
+    }
+  };
+  mockTaskStorage.set(id, task);
+  console.log(`✅ Created task: ${task.title}`);
+  return task;
+};
+
+// Main example function
+export const runBasicCacheExample = async (): Promise<void> => {
+  console.log('\n🚀 Fjell-Cache Basic Example');
+  console.log('============================\n');
+
+  console.log('This example demonstrates basic cache operations with User and Task models.\n');
+
+  // Step 1: Create registry and cache instances
+  console.log('Step 1: Setting up cache infrastructure');
+  console.log('--------------------------------------');
+
+  const registry = createRegistry();
+  console.log('✅ Created cache registry');
+
+  const userApi = createUserApi() as ClientApi<User, 'user'>;
+  const taskApi = createTaskApi() as ClientApi<Task, 'task'>;
+  console.log('✅ Created mock APIs for users and tasks');
+
+  const userCache = await createCache(userApi, 'user');
+  const taskCache = await createCache(taskApi, 'task');
+  console.log('✅ Created cache instances');
+
+  const userInstance = createInstance(registry, createCoordinate('user'), userCache);
+  const taskInstance = createInstance(registry, createCoordinate('task'), taskCache);
+  console.log('✅ Created cache model instances\n');
+
+  // Step 2: Create some test data
+  console.log('Step 2: Creating test data');
+  console.log('-------------------------');
+
+  const user1 = createTestUser('user-1', 'Alice Johnson', 'alice@example.com', 'admin');
+  const user2 = createTestUser('user-2', 'Bob Smith', 'bob@example.com', 'user');
+
+  const task1 = createTestTask('task-1', 'Setup project repository', 'Initialize Git repo and create basic structure', user1.id, 'completed', 'high');
+  const task2 = createTestTask('task-2', 'Implement user authentication', 'Add login and registration functionality', user2.id, 'in-progress', 'medium');
+
+  console.log('✅ Created test users and tasks\n');
+
+  // Step 3: Cache operations - Fetch and cache all items
+  console.log('Step 3: Cache operations - Fetching all items');
+  console.log('----------------------------------------------');
+
+  const [, allUsers] = await userInstance.cache.all();
+  console.log(`📋 Cached ${allUsers.length} users:`, allUsers.map(u => u.name));
+
+  const [, allTasks] = await taskInstance.cache.all();
+  console.log(`📋 Cached ${allTasks.length} tasks:`, allTasks.map(t => t.title));
+  console.log('');
+
+  // Step 4: Individual item retrieval from cache
+  console.log('Step 4: Individual item retrieval');
+  console.log('---------------------------------');
+
+  const [, cachedUser1] = await userInstance.cache.get(user1.key);
+  console.log(`👤 Retrieved from cache: ${cachedUser1?.name} (${cachedUser1?.email})`);
+
+  const [, cachedTask1] = await taskInstance.cache.get(task1.key);
+  console.log(`📝 Retrieved from cache: ${cachedTask1?.title} - Status: ${cachedTask1?.status}`);
+  console.log('');
+
+  // Step 5: Cache hit vs miss demonstration
+  console.log('Step 5: Cache behavior demonstration');
+  console.log('-----------------------------------');
+
+  // This should hit the cache (no API call)
+  console.log('🎯 Second retrieval (should hit cache):');
+  const [, cachedUser1Again] = await userInstance.cache.retrieve(user1.key);
+  console.log(`👤 Retrieved: ${cachedUser1Again?.name} (cache hit)`);
+
+  // Create a new user and demonstrate cache miss
+  const user3 = createTestUser('user-3', 'Charlie Brown', 'charlie@example.com', 'guest');
+
+  console.log('🎯 New item retrieval (cache miss, will fetch from API):');
+  const [, cachedUser3] = await userInstance.cache.get(user3.key);
+  console.log(`👤 Retrieved: ${cachedUser3?.name} (fetched from API and cached)`);
+  console.log('');
+
+  // Step 6: Cache updates
+  console.log('Step 6: Cache updates');
+  console.log('--------------------');
+
+  const updatedTask2 = { ...task2, status: 'completed' as const, description: 'Add login and registration functionality - COMPLETED!' };
+  mockTaskStorage.set(task2.id, updatedTask2);
+
+  // Update cache with new version
+  await taskInstance.cache.set(updatedTask2.key, updatedTask2);
+  console.log(`🔄 Updated task in cache: ${updatedTask2.title} - New status: ${updatedTask2.status}`);
+  console.log('');
+
+  // Step 7: Query operations
+  console.log('Step 7: Query operations');
+  console.log('-----------------------');
+
+  const [, foundTasks] = await taskInstance.cache.find('all');
+  console.log(`🔍 Found ${foundTasks.length} tasks through cache query`);
+
+  const [, oneTask] = await taskInstance.cache.one();
+  console.log(`📝 Retrieved one task: ${oneTask?.title}`);
+  console.log('');
+
+  // Step 8: Cache statistics and management
+  console.log('Step 8: Cache management');
+  console.log('-----------------------');
+
+  console.log('📊 Cache Statistics:');
+  console.log(`   👥 Users in cache: ${allUsers.length}`);
+  console.log(`   📝 Tasks in cache: ${allTasks.length}`);
+  console.log(`   🎯 User cache coordinate: ${userInstance.coordinate.kta[0]}`);
+  console.log(`   🎯 Task cache coordinate: ${taskInstance.coordinate.kta[0]}`);
+  console.log('');
+
+  // Step 9: Cleanup demonstration
+  console.log('Step 9: Cleanup demonstration');
+  console.log('-----------------------------');
+
+  mockUserStorage.delete('user-3');
+  console.log('🗑️ Removed user from storage');
+
+  // Cache still has the old data until next fetch
+  const [, stillCachedUser3] = await userInstance.cache.retrieve(user3.key);
+  console.log(`🎯 Cache still contains removed user: ${stillCachedUser3?.name || 'null'}`);
+
+  // Fresh fetch will update cache
+  const [, freshAllUsers] = await userInstance.cache.all();
+  console.log(`📋 Fresh fetch shows ${freshAllUsers.length} users (cache updated)`);
+  console.log('');
+
+  console.log('🎉 Basic Cache Example Complete!');
+  console.log('================================\n');
+
+  console.log('Key concepts demonstrated:');
+  console.log('• Cache creation with registry and instances');
+  console.log('• Basic cache operations (get, set, all, find, one)');
+  console.log('• Cache hits vs misses');
+  console.log('• Cache updates and management');
+  console.log('• Integration with mock storage APIs');
+  console.log('• Cache lifecycle and data consistency\n');
+};
+
+// Run the example if this file is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runBasicCacheExample().catch(console.error);
+}

package/examples/cache-map-example.ts

@@ -0,0 +1,265 @@
+/**
+ * Cache Map Example
+ *
+ * This example demonstrates the lower-level CacheMap functionality of fjell-cache.
+ * CacheMap provides direct key-value storage and retrieval with support for
+ * complex fjell keys and efficient item management.
+ *
+ * Shows how to:
+ * - Create and manage CacheMap instances directly
+ * - Store and retrieve items with complex keys
+ * - Use basic operations and key management
+ * - Handle key normalization and comparison
+ * - Manage cache lifecycle and cleanup
+ */
+
+import { CacheMap } from '../src/CacheMap';
+import { ComKey, Item, PriKey } from '@fjell/core';
+
+// Define test data models
+interface Document extends Item<'document'> {
+  id: string;
+  title: string;
+  content: string;
+  author: string;
+  tags: string[];
+  createdAt: Date;
+}
+
+interface Comment extends Item<'comment', 'document'> {
+  id: string;
+  documentId: string;
+  content: string;
+  author: string;
+  createdAt: Date;
+}
+
+// Helper to create test data
+const createDocument = (id: string, title: string, content: string, author: string, tags: string[]): Document => ({
+  id, title, content, author, tags, createdAt: new Date(),
+  key: { kt: 'document', pk: id },
+  events: { created: { at: new Date() }, updated: { at: new Date() }, deleted: { at: null } }
+});
+
+const createComment = (id: string, documentId: string, content: string, author: string): Comment => ({
+  id, documentId, content, author, createdAt: new Date(),
+  key: { kt: 'comment', pk: id, loc: [{ kt: 'document', lk: documentId }] },
+  events: { created: { at: new Date() }, updated: { at: new Date() }, deleted: { at: null } }
+});
+
+export const runCacheMapExample = async (): Promise<void> => {
+  console.log('\n🚀 Fjell-Cache CacheMap Example');
+  console.log('==============================\n');
+
+  console.log('This example demonstrates direct CacheMap operations for low-level cache management.\n');
+
+  // Step 1: Create CacheMap instances
+  console.log('Step 1: Creating CacheMap instances');
+  console.log('-----------------------------------');
+
+  // Create CacheMaps for different item types
+  const documentCacheMap = new CacheMap<Document, 'document'>(['document']);
+  const commentCacheMap = new CacheMap<Comment, 'comment', 'document'>(['comment', 'document']);
+
+  console.log('✅ Created CacheMap instances for documents and comments');
+  console.log(`   📄 Document CacheMap: supports primary keys only`);
+  console.log(`   💬 Comment CacheMap: supports contained items with location hierarchy\n`);
+
+  // Step 2: Create test data
+  console.log('Step 2: Creating test data');
+  console.log('-------------------------');
+
+  const doc1 = createDocument('doc-1', 'Getting Started with Fjell', 'This is a comprehensive guide...', 'Alice', ['guide', 'tutorial']);
+  const doc2 = createDocument('doc-2', 'Advanced Caching Patterns', 'Learn advanced techniques...', 'Bob', ['advanced', 'caching']);
+  const doc3 = createDocument('doc-3', 'Performance Optimization', 'Tips for better performance...', 'Charlie', ['performance', 'optimization']);
+
+  const comment1 = createComment('comment-1', doc1.id, 'Great tutorial! Very helpful.', 'David');
+  const comment2 = createComment('comment-2', doc1.id, 'Thanks for sharing this.', 'Eve');
+  const comment3 = createComment('comment-3', doc2.id, 'Excellent advanced techniques.', 'Frank');
+
+  console.log('✅ Created test documents and comments\n');
+
+  // Step 3: Basic CacheMap operations
+  console.log('Step 3: Basic CacheMap operations');
+  console.log('---------------------------------');
+
+  // Set items in cache
+  documentCacheMap.set(doc1.key, doc1);
+  documentCacheMap.set(doc2.key, doc2);
+  documentCacheMap.set(doc3.key, doc3);
+
+  commentCacheMap.set(comment1.key, comment1);
+  commentCacheMap.set(comment2.key, comment2);
+  commentCacheMap.set(comment3.key, comment3);
+
+  console.log('📥 Stored all items in CacheMaps');
+  console.log(`   📄 Documents cached: ${documentCacheMap.values().length}`);
+  console.log(`   💬 Comments cached: ${commentCacheMap.values().length}`);
+
+  // Get individual items
+  const retrievedDoc1 = documentCacheMap.get(doc1.key);
+  const retrievedComment1 = commentCacheMap.get(comment1.key);
+
+  console.log(`\n🔍 Retrieved items by key:`);
+  console.log(`   📄 Document: "${retrievedDoc1?.title}" by ${retrievedDoc1?.author}`);
+  console.log(`   💬 Comment: "${retrievedComment1?.content}" by ${retrievedComment1?.author}`);
+
+  // Step 4: Key operations and checking
+  console.log('\n\nStep 4: Key operations and checking');
+  console.log('----------------------------------');
+
+  // Check if keys exist
+  const hasDoc1 = documentCacheMap.includesKey(doc1.key);
+  const hasDoc4 = documentCacheMap.includesKey({ kt: 'document', pk: 'doc-4' });
+
+  console.log(`🔑 Key existence checks:`);
+  console.log(`   📄 Document 1 exists: ${hasDoc1}`);
+  console.log(`   📄 Document 4 exists: ${hasDoc4}`);
+
+  // Get all keys
+  const allDocKeys = documentCacheMap.keys();
+  const allCommentKeys = commentCacheMap.keys();
+
+  console.log(`\n🗂️ All cached keys:`);
+  console.log(`   📄 Document keys: ${allDocKeys.length} items`);
+  allDocKeys.forEach(key => console.log(`      - ${(key as PriKey<'document'>).pk}`));
+
+  console.log(`   💬 Comment keys: ${allCommentKeys.length} items`);
+  allCommentKeys.forEach(key => console.log(`      - ${(key as ComKey<'comment', 'document'>).pk} in document ${(key as ComKey<'comment', 'document'>).loc?.[0]?.lk}`));
+
+  // Step 5: Bulk operations
+  console.log('\n\nStep 5: Bulk operations');
+  console.log('----------------------');
+
+  // Get all items
+  const allDocuments = documentCacheMap.allIn([]);
+  const allComments = commentCacheMap.allIn([]);
+
+  console.log(`📋 Retrieved all items:`);
+  console.log(`   📄 Documents: ${allDocuments.length} items`);
+  allDocuments.forEach(doc => console.log(`      - "${doc.title}" (${doc.tags.join(', ')})`));
+
+  console.log(`   💬 Comments: ${allComments.length} items`);
+  allComments.forEach(comment => console.log(`      - "${comment.content}" on doc ${comment.documentId}`));
+
+  // Get all values (another way to access items)
+  const allDocumentValues = documentCacheMap.values();
+  console.log(`\n📦 Document values count: ${allDocumentValues.length}`);
+
+  // Step 6: Location-based operations for contained items
+  console.log('\n\nStep 6: Location-based operations');
+  console.log('---------------------------------');
+
+  // Get comments for specific document (using location filtering)
+  const doc1Comments = commentCacheMap.allIn([{ kt: 'document' as const, lk: doc1.id }] as any);
+
+  console.log(`🔍 Location-based retrieval:`);
+  console.log(`   💬 Comments in document "${doc1.title}": ${doc1Comments.length} found`);
+  doc1Comments.forEach(comment => console.log(`      - "${comment.content}" by ${comment.author}`));
+
+  // Step 7: Update operations
+  console.log('\n\nStep 7: Update operations');
+  console.log('------------------------');
+
+  // Update an existing document
+  const updatedDoc1 = {
+    ...doc1,
+    title: 'Getting Started with Fjell - Updated',
+    tags: [...doc1.tags, 'updated'],
+    events: { ...doc1.events, updated: { at: new Date() } }
+  };
+
+  documentCacheMap.set(updatedDoc1.key, updatedDoc1);
+  const retrievedUpdatedDoc = documentCacheMap.get(updatedDoc1.key);
+
+  console.log(`🔄 Updated document:`);
+  console.log(`   📄 New title: "${retrievedUpdatedDoc?.title}"`);
+  console.log(`   🏷️ New tags: ${retrievedUpdatedDoc?.tags.join(', ')}`);
+
+  // Step 8: Deletion operations
+  console.log('\n\nStep 8: Deletion operations');
+  console.log('--------------------------');
+
+  // Delete a specific item
+  documentCacheMap.delete(doc3.key);
+  console.log(`🗑️ Deleted document: doc-3`);
+  console.log(`   📄 Documents remaining: ${documentCacheMap.values().length}`);
+
+  // Try to get deleted item
+  const deletedDocCheck = documentCacheMap.get(doc3.key);
+  console.log(`   🔍 Deleted document still exists: ${deletedDocCheck !== null}`);
+
+  // Step 9: Performance and statistics
+  console.log('\n\nStep 9: Performance and statistics');
+  console.log('---------------------------------');
+
+  console.log(`📊 CacheMap Statistics:`);
+  console.log(`   📄 Document CacheMap:`);
+  console.log(`      - Items: ${documentCacheMap.values().length}`);
+  console.log(`      - Keys: ${documentCacheMap.keys().length}`);
+  console.log(`      - Values: ${documentCacheMap.values().length}`);
+
+  console.log(`   💬 Comment CacheMap:`);
+  console.log(`      - Items: ${commentCacheMap.values().length}`);
+  console.log(`      - Keys: ${commentCacheMap.keys().length}`);
+  console.log(`      - Values: ${commentCacheMap.values().length}`);
+
+  // Performance test - bulk operations
+  const startTime = Date.now();
+  for (let i = 0; i < 1000; i++) {
+    const tempDoc = createDocument(`temp-${i}`, `Temp Doc ${i}`, 'Content', 'Author', ['temp']);
+    documentCacheMap.set(tempDoc.key, tempDoc);
+  }
+  const insertTime = Date.now() - startTime;
+
+  console.log(`\n⚡ Performance test:`);
+  console.log(`   📥 Inserted 1000 items in ${insertTime}ms`);
+  console.log(`   📊 Total documents: ${documentCacheMap.values().length}`);
+
+  // Clean up performance test data
+  const cleanupStart = Date.now();
+  for (let i = 0; i < 1000; i++) {
+    documentCacheMap.delete({ kt: 'document', pk: `temp-${i}` });
+  }
+  const cleanupTime = Date.now() - cleanupStart;
+
+  console.log(`   🧹 Cleaned up 1000 items in ${cleanupTime}ms`);
+  console.log(`   📊 Documents after cleanup: ${documentCacheMap.values().length}`);
+
+  // Step 10: Clone operations
+  console.log('\n\nStep 10: Clone operations');
+  console.log('------------------------');
+
+  // Clone the cache map
+  const clonedDocumentCache = documentCacheMap.clone();
+  console.log(`📋 Cloned document cache:`);
+  console.log(`   📄 Original cache: ${documentCacheMap.values().length} items`);
+  console.log(`   📄 Cloned cache: ${clonedDocumentCache.values().length} items`);
+
+  // Modify original to show independence
+  const newDoc = createDocument('doc-clone-test', 'Clone Test Doc', 'Testing cloning', 'Test Author', ['test']);
+  documentCacheMap.set(newDoc.key, newDoc);
+
+  console.log(`\n📊 After adding to original:`);
+  console.log(`   📄 Original cache: ${documentCacheMap.values().length} items`);
+  console.log(`   📄 Cloned cache: ${clonedDocumentCache.values().length} items`);
+  console.log(`   ✅ Clones are independent`);
+
+  console.log('\n🎉 CacheMap Example Complete!');
+  console.log('=============================\n');
+
+  console.log('Key concepts demonstrated:');
+  console.log('• Direct CacheMap instantiation and management');
+  console.log('• Primary key and composite key operations');
+  console.log('• Bulk operations (allIn, values, keys)');
+  console.log('• Location-based filtering for contained items');
+  console.log('• Update and delete operations');
+  console.log('• Performance characteristics');
+  console.log('• Key normalization and comparison');
+  console.log('• Cache cloning and independence\n');
+};
+
+// Run the example if this file is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runCacheMapExample().catch(console.error);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fjell/cache",
   "description": "Cache for Fjell",
-  "version": "4.6.5",
+  "version": "4.6.10",
   "keywords": [
     "cache",
     "fjell"
@@ -19,30 +19,31 @@
     }
   },
   "dependencies": {
-    "@fjell/client-api": "^4.4.5",
-    "@fjell/core": "^4.4.6",
-    "@fjell/http-api": "^4.4.4",
-    "@fjell/logging": "^4.4.6"
+    "@fjell/client-api": "^4.4.7",
+    "@fjell/core": "^4.4.7",
+    "@fjell/http-api": "^4.4.5",
+    "@fjell/logging": "^4.4.7",
+    "@fjell/registry": "^4.4.7"
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.1",
-    "@eslint/js": "^9.30.1",
-    "@swc/core": "^1.12.11",
+    "@eslint/js": "^9.31.0",
+    "@swc/core": "^1.13.1",
     "@tsconfig/recommended": "^1.0.10",
     "@types/multer": "^2.0.0",
-    "@types/node": "^24.0.12",
-    "@typescript-eslint/eslint-plugin": "^8.36.0",
-    "@typescript-eslint/parser": "^8.36.0",
+    "@types/node": "^24.0.15",
+    "@typescript-eslint/eslint-plugin": "^8.37.0",
+    "@typescript-eslint/parser": "^8.37.0",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
     "concurrently": "^9.2.0",
-    "eslint": "^9.30.1",
+    "eslint": "^9.31.0",
     "nodemon": "^3.1.10",
     "rimraf": "^6.0.1",
     "ts-node": "^10.9.2",
     "tsc-alias": "^1.8.16",
     "typescript": "^5.8.3",
-    "vite": "^7.0.3",
+    "vite": "^7.0.5",
     "vite-plugin-dts": "^4.5.4",
     "vite-plugin-node": "^7.0.0",
     "vitest": "^3.2.4"

package/vitest.config.ts

@@ -21,7 +21,7 @@ export default defineConfig({
       thresholds: {
         lines: 89,
         functions: 85,
-        branches: 94,
+        branches: 93,
         statements: 89,
       },
     },
@@ -41,4 +41,4 @@ export default defineConfig({
   build: {
     sourcemap: true,
   },
-})
+})

package/dist/CacheRegistry.cjs.js

@@ -1,66 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const logger$1 = require('./logger.cjs.js');
-
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-const logger = logger$1.default.get('CacheRegistry');
-class CacheRegistry {
-    constructor(){
-        // TODO: My use of Generics has Boxed me into a corner where I can't reference AbstractCache without the types
-        _define_property(this, "cacheMap", {});
-        _define_property(this, "registerCache", async (cache)=>{
-            try {
-                logger.debug('Attempting to register cache with pkTypes:', cache.pkTypes);
-                const key = JSON.stringify(cache.pkTypes);
-                if (this.cacheMap[key]) {
-                    logger.debug(`Cache with pkTypes ${key} already exists, will be overwritten`);
-                }
-                this.cacheMap[key] = cache;
-                logger.debug('Cache registered successfully with key:', key);
-            } catch (error) {
-                logger.error('Failed to register cache:', error);
-                throw error;
-            }
-        });
-        _define_property(this, "getCache", (kts)=>{
-            logger.debug('Attempting to get cache for key types:', kts);
-            const key = JSON.stringify(kts);
-            logger.debug('Looking up cache with key:', key);
-            const cache = this.cacheMap[key];
-            if (!cache) {
-                logger.warning(`No cache found for key types: ${key}`);
-            }
-            return cache;
-        });
-        _define_property(this, "printRegisteredCaches", ()=>{
-            logger.debug('Printing all registered caches:');
-            const cacheCount = Object.keys(this.cacheMap).length;
-            logger.debug(`Total number of registered caches: ${cacheCount}`);
-            if (cacheCount === 0) {
-                logger.debug('No caches are currently registered');
-            }
-            Object.entries(this.cacheMap).forEach(([keyTypes])=>{
-                logger.debug(`Cache with key types: ${keyTypes}`);
-            });
-        });
-        logger.debug('CacheRegistry instance created');
-    }
-}
-_define_property(CacheRegistry, "instance", void 0);
-
-exports.CacheRegistry = CacheRegistry;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGVSZWdpc3RyeS5janMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/CacheRegistry.d.ts

@@ -1,10 +0,0 @@
-import { Item } from '@fjell/core';
-import { Cache } from './Cache';
-export declare class CacheRegistry {
-    private static instance;
-    constructor();
-    private cacheMap;
-    registerCache: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(cache: Cache<Item<S, L1, L2, L3, L4, L5>, S, L1, L2, L3, L4, L5>) => Promise<void>;
-    getCache: (kts: string[]) => any;
-    printRegisteredCaches: () => void;
-}