@fjell/registry 4.4.10 → 4.4.11

package/dist/index.cjs

@@ -45,6 +45,200 @@ const isInstance = (instance)=>{
     return instance !== null && instance !== undefined && instance.coordinate !== undefined && instance.registry !== undefined;
 };
 
+/**
+ * Represents a service client (another service making the request)
+ */ function _define_property$4(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;
+}
+/**
+ * Internal class for tracking Registry statistics with complex coordinate combinations and client tracking
+ */ class RegistryStats {
+    /**
+   * Records a get() call for the specified coordinate and client
+   */ recordGetCall(kta, scopes, client) {
+        this.totalCalls++;
+        const ktaKey = kta.join('.');
+        const scopeKey = this.createScopeKey(scopes || []);
+        const clientKey = this.createClientKey(client);
+        if (!this.coordinateCalls.has(ktaKey)) {
+            this.coordinateCalls.set(ktaKey, new Map());
+        }
+        const scopeMap = this.coordinateCalls.get(ktaKey);
+        if (!scopeMap.has(scopeKey)) {
+            scopeMap.set(scopeKey, new Map());
+        }
+        const clientMap = scopeMap.get(scopeKey);
+        const currentCount = clientMap.get(clientKey) || 0;
+        clientMap.set(clientKey, currentCount + 1);
+    }
+    /**
+   * Gets the current statistics snapshot
+   */ getStatistics() {
+        const coordinateCallRecords = [];
+        let serviceCalls = 0;
+        let applicationCalls = 0;
+        let unidentifiedCalls = 0;
+        for (const [ktaKey, scopeMap] of this.coordinateCalls){
+            for (const [scopeKey, clientMap] of scopeMap){
+                const clientCalls = [];
+                let totalCount = 0;
+                for (const [clientKey, count] of clientMap){
+                    const client = this.parseClientKey(clientKey);
+                    if (client !== null) {
+                        clientCalls.push({
+                            client,
+                            count
+                        });
+                    }
+                    totalCount += count;
+                    // Update client summary
+                    if (clientKey === '__no_client__') {
+                        unidentifiedCalls += count;
+                    } else if (typeof client === 'string') {
+                        applicationCalls += count;
+                    } else if (client !== null) {
+                        serviceCalls += count;
+                    }
+                }
+                coordinateCallRecords.push({
+                    kta: ktaKey.split('.'),
+                    scopes: this.parseScopeKey(scopeKey),
+                    count: totalCount,
+                    clientCalls: [
+                        ...clientCalls
+                    ] // Return a copy
+                });
+            }
+        }
+        return {
+            totalGetCalls: this.totalCalls,
+            coordinateCallRecords: [
+                ...coordinateCallRecords
+            ],
+            clientSummary: {
+                serviceCalls,
+                applicationCalls,
+                unidentifiedCalls
+            }
+        };
+    }
+    /**
+   * Gets call count for a specific coordinate combination
+   */ getCallCount(kta, scopes) {
+        const ktaKey = kta.join('.');
+        const scopeKey = this.createScopeKey(scopes || []);
+        const scopeMap = this.coordinateCalls.get(ktaKey);
+        if (!scopeMap) return 0;
+        const clientMap = scopeMap.get(scopeKey);
+        if (!clientMap) return 0;
+        let total = 0;
+        for (const count of clientMap.values()){
+            total += count;
+        }
+        return total;
+    }
+    /**
+   * Gets call count for a specific coordinate combination from a specific client
+   */ getCallCountByClient(kta, scopes, client) {
+        const ktaKey = kta.join('.');
+        const scopeKey = this.createScopeKey(scopes || []);
+        const clientKey = this.createClientKey(client);
+        const scopeMap = this.coordinateCalls.get(ktaKey);
+        if (!scopeMap) return 0;
+        const clientMap = scopeMap.get(scopeKey);
+        if (!clientMap) return 0;
+        return clientMap.get(clientKey) || 0;
+    }
+    /**
+   * Gets total calls for a specific kta (across all scopes)
+   */ getTotalCallsForKta(kta) {
+        const ktaKey = kta.join('.');
+        const scopeMap = this.coordinateCalls.get(ktaKey);
+        if (!scopeMap) return 0;
+        let total = 0;
+        for (const clientMap of scopeMap.values()){
+            for (const count of clientMap.values()){
+                total += count;
+            }
+        }
+        return total;
+    }
+    /**
+   * Gets all unique kta paths that have been called
+   */ getCalledKtaPaths() {
+        const ktaPaths = [];
+        for (const ktaKey of this.coordinateCalls.keys()){
+            ktaPaths.push(ktaKey.split('.'));
+        }
+        return ktaPaths;
+    }
+    /**
+   * Creates a normalized scope key from scopes array
+   */ createScopeKey(scopes) {
+        if (scopes.length === 0) return '__no_scopes__';
+        return [
+            ...scopes
+        ].sort().join(',');
+    }
+    /**
+   * Parses a scope key back to scopes array
+   */ parseScopeKey(scopeKey) {
+        if (scopeKey === '__no_scopes__') return [];
+        return scopeKey.split(',');
+    }
+    /**
+   * Creates a normalized client key from client identifier
+   */ createClientKey(client) {
+        if (!client) return '__no_client__';
+        if (typeof client === 'string') {
+            return `app:${client}`;
+        }
+        // Service client
+        const coordKey = `${client.coordinate.kta.join('.')};${this.createScopeKey(client.coordinate.scopes)}`;
+        return `service:${client.registryType}:${coordKey}`;
+    }
+    /**
+   * Parses a client key back to client identifier
+   */ parseClientKey(clientKey) {
+        if (clientKey === '__no_client__') return null;
+        if (clientKey.startsWith('app:')) {
+            return clientKey.substring(4);
+        }
+        if (clientKey.startsWith('service:')) {
+            const parts = clientKey.substring(8).split(':');
+            if (parts.length !== 2) return null;
+            const registryType = parts[0];
+            const coordParts = parts[1].split(';');
+            if (coordParts.length !== 2) return null;
+            const kta = coordParts[0].split('.');
+            const scopes = this.parseScopeKey(coordParts[1]);
+            return {
+                registryType,
+                coordinate: {
+                    kta,
+                    scopes
+                }
+            };
+        }
+        return null;
+    }
+    constructor(){
+        _define_property$4(this, "totalCalls", 0);
+        // Map structure: ktaKey -> scopeKey -> clientKey -> count
+        _define_property$4(this, "coordinateCalls", new Map());
+    }
+}
+
 const logger$1 = LibLogger.get("Registry");
 const findScopedInstance = (scopedInstances, requestedScopes)=>{
     if (!requestedScopes || requestedScopes.length === 0) {
@@ -68,13 +262,39 @@ const findScopedInstance = (scopedInstances, requestedScopes)=>{
 };
 const createRegistry = (type, registryHub)=>{
     const instanceTree = {};
+    // Statistics tracking
+    const registryStats = new RegistryStats();
+    /**
+   * Creates a proxied Registry that automatically injects client information for service-to-service calls
+   */ const createProxiedRegistry = (callingCoordinate)=>{
+        const serviceClient = {
+            registryType: type,
+            coordinate: {
+                kta: callingCoordinate.kta,
+                scopes: callingCoordinate.scopes
+            }
+        };
+        return {
+            ...registry,
+            get: (kta, options)=>{
+                // Automatically inject the calling service as the client if no client is specified
+                const clientToUse = (options === null || options === void 0 ? void 0 : options.client) || serviceClient;
+                return registry.get(kta, {
+                    ...options,
+                    client: clientToUse
+                });
+            }
+        };
+    };
     const createInstance = (kta, scopes, factory)=>{
         logger$1.debug(`Creating and registering instance for key path and scopes`, kta, scopes, `in registry type: ${type}`);
         // Create coordinate for the instance
         const coordinate = createCoordinate(kta, scopes);
-        // Use factory to create the instance with the new context parameter
+        // Create a proxied registry that automatically tracks this service as the client
+        const proxiedRegistry = createProxiedRegistry(coordinate);
+        // Use factory to create the instance with the proxied registry
         const instance = factory(coordinate, {
-            registry,
+            registry: proxiedRegistry,
             registryHub
         });
         // Validate the created instance
@@ -126,6 +346,8 @@ const createRegistry = (type, registryHub)=>{
         registerInternal(kta, instance, options);
     };
     const get = (kta, options)=>{
+        // Track statistics with kta, scopes, and client
+        registryStats.recordGetCall(kta, options === null || options === void 0 ? void 0 : options.scopes, options === null || options === void 0 ? void 0 : options.client);
         const keyPath = [
             ...kta
         ].reverse();
@@ -172,6 +394,9 @@ const createRegistry = (type, registryHub)=>{
         traverseTree(instanceTree);
         return coordinates;
     };
+    const getStatistics = ()=>{
+        return registryStats.getStatistics();
+    };
     const registry = {
         type,
         registryHub,
@@ -179,6 +404,7 @@ const createRegistry = (type, registryHub)=>{
         register,
         get,
         getCoordinates,
+        getStatistics,
         instanceTree
     };
     return registry;
@@ -586,6 +812,7 @@ exports.RegistryCreationError = RegistryCreationError;
 exports.RegistryError = RegistryError;
 exports.RegistryFactoryError = RegistryFactoryError;
 exports.RegistryHubError = RegistryHubError;
+exports.RegistryStats = RegistryStats;
 exports.RegistryTypeNotFoundError = RegistryTypeNotFoundError;
 exports.ScopeNotFoundError = ScopeNotFoundError;
 exports.createCoordinate = createCoordinate;

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/index.d.ts

@@ -2,5 +2,6 @@ export * from './Coordinate';
 export * from './Instance';
 export * from './Registry';
 export * from './RegistryHub';
+export * from './RegistryStats';
 export * from './types';
 export * from './errors';

package/dist/index.js

@@ -2,8 +2,9 @@ export { createCoordinate } from './Coordinate.js';
 export { createInstance, isInstance } from './Instance.js';
 export { createRegistry } from './Registry.js';
 export { createRegistryHub } from './RegistryHub.js';
+export { RegistryStats } from './RegistryStats.js';
 export { InvalidFactoryResultError, InvalidInstanceRegistrationError, RegistryCreationError, RegistryError } from './errors/RegistryError.js';
 export { InstanceError, InstanceNotFoundError, NoChildrenAvailableError, NoInstancesAvailableError, NoInstancesRegisteredError, ScopeNotFoundError } from './errors/InstanceError.js';
 export { CoordinateError, InvalidCoordinateError, InvalidKTAError, InvalidScopesError } from './errors/CoordinateError.js';
 export { DuplicateRegistryTypeError, InvalidRegistryFactoryResultError, RegistryFactoryError, RegistryHubError, RegistryTypeNotFoundError } from './errors/RegistryHubError.js';
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7OzsifQ==

package/dist/types.d.ts

@@ -1,5 +1,6 @@
 import { Instance } from './Instance';
 import { Coordinate } from './Coordinate';
+import { ClientIdentifier, RegistryStatistics } from './RegistryStats';
 /**
  * Represents a coordinate along with information about which registry contains it.
  */
@@ -24,6 +25,7 @@ export interface RegistryHub {
      */
     readonly get: (type: string, kta: string[], options?: {
         scopes?: string[];
+        client?: ClientIdentifier;
     }) => Instance<any, any | never, any | never, any | never, any | never, any | never> | null;
     /**
      * Retrieves a registry instance by its type key.
@@ -95,6 +97,7 @@ export interface Registry {
      */
     get: (kta: string[], options?: {
         scopes?: string[];
+        client?: ClientIdentifier;
     }) => Instance<any, any | never, any | never, any | never, any | never, any | never> | null;
     /** The tree structure representing the hierarchy of instances */
     instanceTree: InstanceTree;
@@ -102,4 +105,8 @@ export interface Registry {
      * Retrieves all coordinates currently registered in the registry.
      */
     getCoordinates: () => Coordinate<any, any | never, any | never, any | never, any | never, any | never>[];
+    /**
+     * Retrieves statistics about get() method calls, including total calls and per-coordinate call counts.
+     */
+    getStatistics: () => RegistryStatistics;
 }

package/docs/README.md

@@ -4,11 +4,11 @@ This is a React-based documentation site for the Fjell Registry package. It prov
 
 ## 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
+- **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
 

package/docs/index.html

@@ -5,7 +5,7 @@
   <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>
+  <title>Fjell Registry - TypeScript Registry Library</title>
   <meta name="description" content="Common Registry for Fjell - A powerful TypeScript registry system">
 </head>