@fjell/registry 4.4.6 → 4.4.9

package/README.md

@@ -41,6 +41,7 @@ interface Registry {
   createInstance: <...>(...) => Instance<...>;
   register: (...) => void; // Deprecated
   get: (...) => Instance | null;
+  getCoordinates: () => Coordinate[]; // Discover all registered coordinates
   instanceTree: InstanceTree;
 }
 
@@ -65,6 +66,7 @@ interface RegistryHub {
   get: (type: string, kta: string[], options?: { scopes?: string[] }) => Instance | null;
   getRegistry: (type: string) => Registry | null;
   getRegisteredTypes: () => string[];
+  getAllCoordinates: () => CoordinateWithRegistry[]; // Discover coordinates across all registries
   unregisterRegistry: (type: string) => boolean;
 }
 ```
@@ -184,6 +186,44 @@ const specificRegistry = hub.getRegistry('services');
 hub.unregisterRegistry('cache'); // Remove if needed
 ```
 
+### 2a. **RegistryHub: Cross-Registry Coordinate Discovery** ✅
+```typescript
+// Discover all coordinates across ALL registries in the hub
+const allCoordinates = hub.getAllCoordinates();
+console.log(`Found ${allCoordinates.length} total services`);
+
+// Each coordinate includes its registry type
+allCoordinates.forEach(({ coordinate, registryType }) => {
+  console.log(`${registryType}: ${coordinate.kta.join('.')} [${coordinate.scopes.join(', ')}]`);
+});
+
+// Group coordinates by registry type for analysis
+const byRegistry = allCoordinates.reduce((acc, item) => {
+  if (!acc[item.registryType]) acc[item.registryType] = [];
+  acc[item.registryType].push(item.coordinate);
+  return acc;
+}, {} as Record<string, Coordinate[]>);
+
+// Environment-based analysis across all registries
+const productionServices = allCoordinates.filter(c =>
+  c.coordinate.scopes.includes('production')
+);
+const productionByRegistry = productionServices.reduce((acc, c) => {
+  acc[c.registryType] = (acc[c.registryType] || 0) + 1;
+  return acc;
+}, {} as Record<string, number>);
+
+console.log('Production services by registry:', productionByRegistry);
+// Output: { services: 2, data: 3, cache: 1 }
+```
+
+**Use Cases for hub.getAllCoordinates():**
+- **System-Wide Health Monitoring**: Check services across all registry domains
+- **Architecture Analysis**: Understand service distribution across domains
+- **Environment Validation**: Ensure complete deployment across all registry types
+- **Cross-Registry Dependencies**: Map service relationships between domains
+- **Documentation Generation**: Auto-generate complete system catalogs
+
 ### 3. Multiple Implementations with Scopes
 ```typescript
 const registry = createRegistry('data');
@@ -258,7 +298,42 @@ registry.register(['User'], userService, { scopes: ['firestore'] });
 // Use registry.createInstance() instead! ✅
 ```
 
-### 7. Cascade Pattern
+### 7. Coordinate Discovery with getCoordinates()
+The Registry provides introspection capabilities to discover all registered instances:
+```typescript
+const registry = createRegistry('services');
+
+// Register various services
+registry.createInstance(['User'], ['firestore'], userFirestoreFactory);
+registry.createInstance(['User'], ['postgresql'], userPostgresFactory);
+registry.createInstance(['Cache', 'Redis'], ['production'], redisFactory);
+registry.createInstance(['Cache', 'Memory'], ['development'], memoryFactory);
+
+// Discover all registered coordinates
+const coordinates = registry.getCoordinates();
+console.log(`Found ${coordinates.length} registered services`);
+
+// Analyze registration patterns
+coordinates.forEach(coord => {
+  console.log(`Service: ${coord.kta.join('.')} | Scopes: ${coord.scopes.join(', ')}`);
+});
+
+// Group by environment for health checks
+const productionServices = coordinates.filter(c => c.scopes.includes('production'));
+const developmentServices = coordinates.filter(c => c.scopes.includes('development'));
+
+// Service discovery - find all cache implementations
+const cacheServices = coordinates.filter(c => c.kta.includes('Cache'));
+```
+
+**Use Cases for getCoordinates():**
+- **Health Monitoring**: Verify all expected services are registered
+- **Development Tools**: Debug service registration in development
+- **Service Discovery**: Find available implementations at runtime
+- **Environment Validation**: Ensure proper scope configuration
+- **Documentation Generation**: Auto-generate service catalogs
+
+### 8. Cascade Pattern
 The Registry enables automatic service discovery:
 ```typescript
 // System receives an item and automatically finds the right service
@@ -385,9 +460,11 @@ hub.registerRegistry(createClientApiRegistry()); // → 'fjell-client-api'
 3. **Contextual Scoping**: Environment-aware service selection
 4. **Hierarchical Organization**: Natural type hierarchy support
 5. **Dependency Injection**: Clean separation of configuration and usage
-6. **Self-Documenting Registries**: Registry type is built-in, no external tracking needed
-7. **Cross-Registry Access**: Unified interface for accessing instances across multiple registries
-8. **Error Prevention**: Impossible to register a registry under the wrong type
+6. **Service Introspection**: Discover all registered coordinates with `getCoordinates()`
+7. **Cross-Registry Discovery**: System-wide coordinate discovery with `getAllCoordinates()`
+8. **Self-Documenting Registries**: Registry type is built-in, no external tracking needed
+9. **Cross-Registry Access**: Unified interface for accessing instances across multiple registries
+10. **Error Prevention**: Impossible to register a registry under the wrong type
 
 ## Migration Strategy
 

package/dist/Registry.cjs

@@ -115,16 +115,35 @@ const createRegistry = (type, registryHub)=>{
         }
         return null;
     };
+    const getCoordinates = ()=>{
+        const coordinates = [];
+        const traverseTree = (node)=>{
+            for(const keyType in node){
+                const treeNode = node[keyType];
+                // Collect coordinates from instances at this level
+                for (const scopedInstance of treeNode.instances){
+                    coordinates.push(scopedInstance.instance.coordinate);
+                }
+                // Recursively traverse children if they exist
+                if (treeNode.children) {
+                    traverseTree(treeNode.children);
+                }
+            }
+        };
+        traverseTree(instanceTree);
+        return coordinates;
+    };
     const registry = {
         type,
         registryHub,
         createInstance,
         register,
         get,
+        getCoordinates,
         instanceTree
     };
     return registry;
 };
 
 exports.createRegistry = createRegistry;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnkuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnkuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/Registry.js

@@ -111,16 +111,35 @@ const createRegistry = (type, registryHub)=>{
         }
         return null;
     };
+    const getCoordinates = ()=>{
+        const coordinates = [];
+        const traverseTree = (node)=>{
+            for(const keyType in node){
+                const treeNode = node[keyType];
+                // Collect coordinates from instances at this level
+                for (const scopedInstance of treeNode.instances){
+                    coordinates.push(scopedInstance.instance.coordinate);
+                }
+                // Recursively traverse children if they exist
+                if (treeNode.children) {
+                    traverseTree(treeNode.children);
+                }
+            }
+        };
+        traverseTree(instanceTree);
+        return coordinates;
+    };
     const registry = {
         type,
         registryHub,
         createInstance,
         register,
         get,
+        getCoordinates,
         instanceTree
     };
     return registry;
 };
 
 export { createRegistry };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnkuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnkuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/RegistryHub.cjs

@@ -63,16 +63,32 @@ const createRegistryHub = ()=>{
         }
         return false;
     };
+    const getAllCoordinates = ()=>{
+        const allCoordinates = [];
+        for(const registryType in registries){
+            const registry = registries[registryType];
+            const coordinates = registry.getCoordinates();
+            coordinates.forEach((coordinate)=>{
+                allCoordinates.push({
+                    coordinate,
+                    registryType
+                });
+            });
+        }
+        logger.debug(`Retrieved ${allCoordinates.length} total coordinates from ${Object.keys(registries).length} registries`);
+        return allCoordinates;
+    };
     const hub = {
         createRegistry,
         registerRegistry,
         get,
         getRegistry,
         getRegisteredTypes,
+        getAllCoordinates,
         unregisterRegistry
     };
     return hub;
 };
 
 exports.createRegistryHub = createRegistryHub;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnlIdWIuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnlIdWIuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/RegistryHub.js

@@ -59,16 +59,32 @@ const createRegistryHub = ()=>{
         }
         return false;
     };
+    const getAllCoordinates = ()=>{
+        const allCoordinates = [];
+        for(const registryType in registries){
+            const registry = registries[registryType];
+            const coordinates = registry.getCoordinates();
+            coordinates.forEach((coordinate)=>{
+                allCoordinates.push({
+                    coordinate,
+                    registryType
+                });
+            });
+        }
+        logger.debug(`Retrieved ${allCoordinates.length} total coordinates from ${Object.keys(registries).length} registries`);
+        return allCoordinates;
+    };
     const hub = {
         createRegistry,
         registerRegistry,
         get,
         getRegistry,
         getRegisteredTypes,
+        getAllCoordinates,
         unregisterRegistry
     };
     return hub;
 };
 
 export { createRegistryHub };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnlIdWIuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnlIdWIuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/index.cjs

@@ -154,12 +154,31 @@ const createRegistry = (type, registryHub)=>{
         }
         return null;
     };
+    const getCoordinates = ()=>{
+        const coordinates = [];
+        const traverseTree = (node)=>{
+            for(const keyType in node){
+                const treeNode = node[keyType];
+                // Collect coordinates from instances at this level
+                for (const scopedInstance of treeNode.instances){
+                    coordinates.push(scopedInstance.instance.coordinate);
+                }
+                // Recursively traverse children if they exist
+                if (treeNode.children) {
+                    traverseTree(treeNode.children);
+                }
+            }
+        };
+        traverseTree(instanceTree);
+        return coordinates;
+    };
     const registry = {
         type,
         registryHub,
         createInstance,
         register,
         get,
+        getCoordinates,
         instanceTree
     };
     return registry;
@@ -376,12 +395,28 @@ const createRegistryHub = ()=>{
         }
         return false;
     };
+    const getAllCoordinates = ()=>{
+        const allCoordinates = [];
+        for(const registryType in registries){
+            const registry = registries[registryType];
+            const coordinates = registry.getCoordinates();
+            coordinates.forEach((coordinate)=>{
+                allCoordinates.push({
+                    coordinate,
+                    registryType
+                });
+            });
+        }
+        logger.debug(`Retrieved ${allCoordinates.length} total coordinates from ${Object.keys(registries).length} registries`);
+        return allCoordinates;
+    };
     const hub = {
         createRegistry,
         registerRegistry,
         get,
         getRegistry,
         getRegisteredTypes,
+        getAllCoordinates,
         unregisterRegistry
     };
     return hub;

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types.d.ts

@@ -1,5 +1,12 @@
 import { Instance } from './Instance';
 import { Coordinate } from './Coordinate';
+/**
+ * Represents a coordinate along with information about which registry contains it.
+ */
+export interface CoordinateWithRegistry {
+    coordinate: Coordinate<any, any | never, any | never, any | never, any | never, any | never>;
+    registryType: string;
+}
 /**
  * The RegistryHub interface provides a higher-level registry that manages multiple Registry instances.
  */
@@ -26,6 +33,10 @@ export interface RegistryHub {
      * Lists all registered type keys.
      */
     readonly getRegisteredTypes: () => string[];
+    /**
+     * Retrieves all coordinates from all registered registries along with their registry type information.
+     */
+    readonly getAllCoordinates: () => CoordinateWithRegistry[];
     /**
      * Removes a registry from the hub.
      */
@@ -87,4 +98,8 @@ export interface Registry {
     }) => Instance<any, any | never, any | never, any | never, any | never, any | never> | null;
     /** The tree structure representing the hierarchy of instances */
     instanceTree: InstanceTree;
+    /**
+     * Retrieves all coordinates currently registered in the registry.
+     */
+    getCoordinates: () => Coordinate<any, any | never, any | never, any | never, any | never, any | never>[];
 }

package/docs/README.md

@@ -0,0 +1,74 @@
+# Fjell Registry Documentation Site
+
+This is a React-based documentation site for the Fjell Registry package. It provides an interactive and modern way to view the project documentation with syntax highlighting and responsive design.
+
+## Features
+
+- 📱 **Responsive Design** - Works on desktop, tablet, and mobile
+- 🎨 **Modern UI** - Clean, modern interface with Fjell branding
+- 🔍 **Syntax Highlighting** - Code blocks with proper syntax highlighting
+- 📖 **Markdown Support** - Full GitHub Flavored Markdown support
+- 🚀 **Fast Loading** - Built with Vite for optimal performance
+
+## Development
+
+### Prerequisites
+
+- Node.js 22+
+- pnpm
+
+### Local Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Start development server
+pnpm run dev
+
+# Build for production
+pnpm run build
+
+# Preview production build
+pnpm run preview
+```
+
+### Testing
+
+```bash
+# Run tests
+pnpm run test
+
+# Run tests in watch mode
+pnpm run test:watch
+```
+
+## Deployment
+
+The site is automatically deployed to GitHub Pages when changes are pushed to the main branch or any release branch. The deployment is handled by the `.github/workflows/deploy-docs.yml` workflow.
+
+## Architecture
+
+- **React 19** - Modern React with hooks
+- **TypeScript** - Full type safety
+- **Vite** - Fast build tool and dev server
+- **React Markdown** - Renders README.md dynamically
+- **React Syntax Highlighter** - Beautiful code syntax highlighting
+- **Vitest** - Fast unit testing framework
+
+## Configuration
+
+The site is configured to:
+- Fetch the main README.md from the project root
+- Use the `/fjell-registry/` base path for GitHub Pages
+- Support dark theme code highlighting
+- Include responsive breakpoints for mobile devices
+
+## Contributing
+
+The documentation site automatically reflects changes to the main README.md file. To update the site itself:
+
+1. Make changes to the React components in `src/`
+2. Test locally with `pnpm run dev`
+3. Commit your changes
+4. The site will automatically deploy via GitHub Actions

package/docs/index.html

@@ -0,0 +1,17 @@
+<!doctype html>
+<html lang="en">
+
+<head>
+  <meta charset="UTF-8" />
+  <link rel="icon" type="image/svg+xml" href="/fjell-icon.svg" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>🏔️ Fjell Registry - TypeScript Registry Library</title>
+  <meta name="description" content="Common Registry for Fjell - A powerful TypeScript registry system">
+</head>
+
+<body>
+  <div id="root"></div>
+  <script type="module" src="/src/main.tsx"></script>
+</body>
+
+</html>