@pikku/inspector 0.9.5 → 0.10.0

package/dist/utils/filter-inspector-state.js

@@ -0,0 +1,382 @@
+import { aggregateRequiredServices } from './post-process.js';
+/**
+ * Match a value against a pattern with wildcard support
+ * Supports "*" at the beginning, end, or both (e.g., "send*", "*Payment", "*process*")
+ */
+function matchesWildcard(value, pattern) {
+    if (pattern === '*')
+        return true;
+    const startsWithWildcard = pattern.startsWith('*');
+    const endsWithWildcard = pattern.endsWith('*');
+    if (startsWithWildcard && endsWithWildcard) {
+        const middle = pattern.slice(1, -1);
+        if (middle === '')
+            return true;
+        return value.includes(middle);
+    }
+    else if (startsWithWildcard) {
+        const suffix = pattern.slice(1);
+        return value.endsWith(suffix) && value.length > suffix.length;
+    }
+    else if (endsWithWildcard) {
+        const prefix = pattern.slice(0, -1);
+        return value.startsWith(prefix) && value.length > prefix.length;
+    }
+    return value === pattern;
+}
+/**
+ * Check if metadata matches the given filters
+ */
+function matchesFilters(filters, meta, logger) {
+    // If no filters, allow everything
+    if (Object.keys(filters).length === 0)
+        return true;
+    // If all filter arrays are empty, allow everything
+    if ((!filters.names || filters.names.length === 0) &&
+        (!filters.tags || filters.tags.length === 0) &&
+        (!filters.types || filters.types.length === 0) &&
+        (!filters.directories || filters.directories.length === 0) &&
+        (!filters.httpRoutes || filters.httpRoutes.length === 0) &&
+        (!filters.httpMethods || filters.httpMethods.length === 0)) {
+        return true;
+    }
+    // Check type filter
+    if (filters.types && filters.types.length > 0) {
+        if (!filters.types.includes(meta.type)) {
+            logger.debug(`⒡ Filtered by type: ${meta.type}:${meta.name}`);
+            return false;
+        }
+    }
+    // Check directory filter
+    if (filters.directories && filters.directories.length > 0 && meta.filePath) {
+        const matchesDirectory = filters.directories.some((dir) => {
+            const normalizedFilePath = meta.filePath.replace(/\\/g, '/');
+            const normalizedDir = dir.replace(/\\/g, '/');
+            return normalizedFilePath.includes(normalizedDir);
+        });
+        if (!matchesDirectory) {
+            logger.debug(`⒡ Filtered by directory: ${meta.type}:${meta.name}`);
+            return false;
+        }
+    }
+    // Check tag filter
+    if (filters.tags && filters.tags.length > 0) {
+        if (!meta.tags || !filters.tags.some((tag) => meta.tags.includes(tag))) {
+            logger.debug(`⒡ Filtered by tags: ${meta.type}:${meta.name}`);
+            return false;
+        }
+    }
+    // Check name filter
+    if (filters.names && filters.names.length > 0) {
+        const nameMatches = filters.names.some((pattern) => matchesWildcard(meta.name, pattern));
+        if (!nameMatches) {
+            logger.debug(`⒡ Filtered by name: ${meta.type}:${meta.name}`);
+            return false;
+        }
+    }
+    // Check HTTP route filter
+    if (filters.httpRoutes && filters.httpRoutes.length > 0 && meta.httpRoute) {
+        const routeMatches = filters.httpRoutes.some((pattern) => matchesWildcard(meta.httpRoute, pattern));
+        if (!routeMatches) {
+            logger.debug(`⒡ Filtered by HTTP route: ${meta.httpRoute}`);
+            return false;
+        }
+    }
+    // Check HTTP method filter
+    if (filters.httpMethods &&
+        filters.httpMethods.length > 0 &&
+        meta.httpMethod) {
+        const normalizedMethod = meta.httpMethod.toUpperCase();
+        if (!filters.httpMethods.includes(normalizedMethod)) {
+            logger.debug(`⒡ Filtered by HTTP method: ${meta.httpMethod}`);
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Extract wire names from middleware/permissions metadata
+ */
+function extractWireNames(obj) {
+    if (!obj)
+        return [];
+    const names = [];
+    for (const key of Object.keys(obj)) {
+        if (obj[key] && typeof obj[key] === 'object' && 'name' in obj[key]) {
+            names.push(obj[key].name);
+        }
+    }
+    return names;
+}
+/**
+ * Filters inspector state based on provided filters
+ * This is applied post-inspection to support the inspect-once, filter-many pattern
+ */
+export function filterInspectorState(state, filters, logger) {
+    // If no filters, return original state
+    if (Object.keys(filters).length === 0 ||
+        ((!filters.names || filters.names.length === 0) &&
+            (!filters.tags || filters.tags.length === 0) &&
+            (!filters.types || filters.types.length === 0) &&
+            (!filters.directories || filters.directories.length === 0) &&
+            (!filters.httpRoutes || filters.httpRoutes.length === 0) &&
+            (!filters.httpMethods || filters.httpMethods.length === 0))) {
+        return state;
+    }
+    // Create a shallow copy with new Maps/Sets to avoid mutating the original
+    const filteredState = {
+        ...state,
+        serviceAggregation: {
+            ...state.serviceAggregation,
+            requiredServices: new Set(), // Reset requiredServices - will be recalculated
+            usedFunctions: new Set(),
+            usedMiddleware: new Set(),
+            usedPermissions: new Set(),
+        },
+        http: {
+            ...state.http,
+            meta: JSON.parse(JSON.stringify(state.http.meta)), // Deep clone metadata
+            files: new Set(), // Will be repopulated with filtered files
+        },
+        channels: {
+            ...state.channels,
+            meta: JSON.parse(JSON.stringify(state.channels.meta)),
+            files: new Set(), // Will be repopulated with filtered files
+        },
+        scheduledTasks: {
+            ...state.scheduledTasks,
+            meta: JSON.parse(JSON.stringify(state.scheduledTasks.meta)),
+            files: new Set(), // Will be repopulated with filtered files
+        },
+        queueWorkers: {
+            ...state.queueWorkers,
+            meta: JSON.parse(JSON.stringify(state.queueWorkers.meta)),
+            files: new Set(), // Will be repopulated with filtered files
+        },
+        mcpEndpoints: {
+            ...state.mcpEndpoints,
+            toolsMeta: JSON.parse(JSON.stringify(state.mcpEndpoints.toolsMeta)),
+            resourcesMeta: JSON.parse(JSON.stringify(state.mcpEndpoints.resourcesMeta)),
+            promptsMeta: JSON.parse(JSON.stringify(state.mcpEndpoints.promptsMeta)),
+            files: new Set(), // Will be repopulated with filtered files
+        },
+        cli: {
+            ...state.cli,
+            meta: JSON.parse(JSON.stringify(state.cli.meta)),
+            files: new Set(), // Will be repopulated with filtered files
+        },
+    };
+    // Filter HTTP routes
+    for (const method of Object.keys(filteredState.http.meta)) {
+        const routes = filteredState.http.meta[method];
+        for (const route of Object.keys(routes)) {
+            const routeMeta = routes[route];
+            // Get function file path for directory filtering
+            const funcFile = filteredState.functions.files.get(routeMeta.pikkuFuncName);
+            const filePath = funcFile?.path;
+            const matches = matchesFilters(filters, {
+                type: 'http',
+                name: routeMeta.pikkuFuncName, // Use function name, not route
+                tags: routeMeta.tags,
+                filePath,
+                httpRoute: routeMeta.route,
+                httpMethod: routeMeta.method,
+            }, logger);
+            if (!matches) {
+                delete routes[route];
+            }
+            else {
+                // Track used functions/middleware/permissions
+                if (routeMeta.pikkuFuncName) {
+                    filteredState.serviceAggregation.usedFunctions.add(routeMeta.pikkuFuncName);
+                }
+                extractWireNames(routeMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
+                extractWireNames(routeMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
+            }
+        }
+    }
+    // Repopulate http.files if any routes remain
+    const hasHttpRoutes = Object.values(filteredState.http.meta).some((routes) => Object.keys(routes).length > 0);
+    if (hasHttpRoutes) {
+        filteredState.http.files = new Set(state.http.files);
+    }
+    // Filter channels
+    for (const name of Object.keys(filteredState.channels.meta)) {
+        const channelMeta = filteredState.channels.meta[name];
+        const matches = matchesFilters(filters, {
+            type: 'channel',
+            name,
+            tags: channelMeta.tags,
+        }, logger);
+        if (!matches) {
+            delete filteredState.channels.meta[name];
+        }
+        else {
+            if (channelMeta.pikkuFuncName) {
+                filteredState.serviceAggregation.usedFunctions.add(channelMeta.pikkuFuncName);
+            }
+            extractWireNames(channelMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
+            extractWireNames(channelMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
+        }
+    }
+    // Repopulate channels.files if any channels remain
+    if (Object.keys(filteredState.channels.meta).length > 0) {
+        filteredState.channels.files = new Set(state.channels.files);
+    }
+    // Filter scheduled tasks
+    for (const name of Object.keys(filteredState.scheduledTasks.meta)) {
+        const taskMeta = filteredState.scheduledTasks.meta[name];
+        const matches = matchesFilters(filters, {
+            type: 'scheduler',
+            name,
+            tags: taskMeta.tags,
+        }, logger);
+        if (!matches) {
+            delete filteredState.scheduledTasks.meta[name];
+        }
+        else {
+            if (taskMeta.pikkuFuncName) {
+                filteredState.serviceAggregation.usedFunctions.add(taskMeta.pikkuFuncName);
+            }
+            extractWireNames(taskMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
+        }
+    }
+    // Repopulate scheduledTasks.files if any tasks remain
+    if (Object.keys(filteredState.scheduledTasks.meta).length > 0) {
+        filteredState.scheduledTasks.files = new Set(state.scheduledTasks.files);
+    }
+    // Filter queue workers
+    for (const name of Object.keys(filteredState.queueWorkers.meta)) {
+        const workerMeta = filteredState.queueWorkers.meta[name];
+        const matches = matchesFilters(filters, {
+            type: 'queue',
+            name,
+            tags: workerMeta.tags,
+        }, logger);
+        if (!matches) {
+            delete filteredState.queueWorkers.meta[name];
+        }
+        else {
+            if (workerMeta.pikkuFuncName) {
+                filteredState.serviceAggregation.usedFunctions.add(workerMeta.pikkuFuncName);
+            }
+            extractWireNames(workerMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
+        }
+    }
+    // Repopulate queueWorkers.files if any workers remain
+    if (Object.keys(filteredState.queueWorkers.meta).length > 0) {
+        filteredState.queueWorkers.files = new Set(state.queueWorkers.files);
+    }
+    // Filter MCP tools
+    for (const name of Object.keys(filteredState.mcpEndpoints.toolsMeta)) {
+        const toolMeta = filteredState.mcpEndpoints.toolsMeta[name];
+        const matches = matchesFilters(filters, {
+            type: 'mcp',
+            name,
+            tags: toolMeta.tags,
+        }, logger);
+        if (!matches) {
+            delete filteredState.mcpEndpoints.toolsMeta[name];
+        }
+        else {
+            if (toolMeta.pikkuFuncName) {
+                filteredState.serviceAggregation.usedFunctions.add(toolMeta.pikkuFuncName);
+            }
+            extractWireNames(toolMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
+            extractWireNames(toolMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
+        }
+    }
+    // Filter MCP resources
+    for (const name of Object.keys(filteredState.mcpEndpoints.resourcesMeta)) {
+        const resourceMeta = filteredState.mcpEndpoints.resourcesMeta[name];
+        const matches = matchesFilters(filters, {
+            type: 'mcp',
+            name,
+            tags: resourceMeta.tags,
+        }, logger);
+        if (!matches) {
+            delete filteredState.mcpEndpoints.resourcesMeta[name];
+        }
+        else {
+            if (resourceMeta.pikkuFuncName) {
+                filteredState.serviceAggregation.usedFunctions.add(resourceMeta.pikkuFuncName);
+            }
+            extractWireNames(resourceMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
+            extractWireNames(resourceMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
+        }
+    }
+    // Filter MCP prompts
+    for (const name of Object.keys(filteredState.mcpEndpoints.promptsMeta)) {
+        const promptMeta = filteredState.mcpEndpoints.promptsMeta[name];
+        const matches = matchesFilters(filters, {
+            type: 'mcp',
+            name,
+            tags: promptMeta.tags,
+        }, logger);
+        if (!matches) {
+            delete filteredState.mcpEndpoints.promptsMeta[name];
+        }
+        else {
+            if (promptMeta.pikkuFuncName) {
+                filteredState.serviceAggregation.usedFunctions.add(promptMeta.pikkuFuncName);
+            }
+            extractWireNames(promptMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
+            extractWireNames(promptMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
+        }
+    }
+    // Repopulate mcpEndpoints.files if any MCP endpoints remain
+    const hasMcpEndpoints = Object.keys(filteredState.mcpEndpoints.toolsMeta).length > 0 ||
+        Object.keys(filteredState.mcpEndpoints.resourcesMeta).length > 0 ||
+        Object.keys(filteredState.mcpEndpoints.promptsMeta).length > 0;
+    if (hasMcpEndpoints) {
+        filteredState.mcpEndpoints.files = new Set(state.mcpEndpoints.files);
+    }
+    // Filter CLI programs (note: CLI filtering might be more complex with nested commands)
+    const referencedRenderers = new Set();
+    for (const programName of Object.keys(filteredState.cli.meta.programs)) {
+        const programMeta = filteredState.cli.meta.programs[programName];
+        // Filter commands in the program
+        for (const commandName of Object.keys(programMeta.commands)) {
+            const commandMeta = programMeta.commands[commandName];
+            const matches = matchesFilters(filters, {
+                type: 'cli',
+                name: commandName,
+                tags: commandMeta.tags,
+            }, logger);
+            if (!matches) {
+                delete programMeta.commands[commandName];
+            }
+            else {
+                if (commandMeta.pikkuFuncName) {
+                    filteredState.serviceAggregation.usedFunctions.add(commandMeta.pikkuFuncName);
+                }
+                extractWireNames(commandMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
+                // Track referenced renderers
+                if (commandMeta.defaultRenderName) {
+                    referencedRenderers.add(commandMeta.defaultRenderName);
+                }
+            }
+        }
+        // Remove program if it has no commands left
+        if (Object.keys(programMeta.commands).length === 0) {
+            delete filteredState.cli.meta.programs[programName];
+        }
+    }
+    // Filter out renderers that aren't referenced by any remaining commands
+    for (const rendererName of Object.keys(filteredState.cli.meta.renderers || {})) {
+        if (!referencedRenderers.has(rendererName)) {
+            delete filteredState.cli.meta.renderers[rendererName];
+        }
+    }
+    // Repopulate cli.files if any CLI programs or referenced renderers remain
+    const hasCliPrograms = Object.keys(filteredState.cli.meta.programs).length > 0;
+    const hasCliRenderers = Object.keys(filteredState.cli.meta.renderers || {}).length > 0;
+    if (hasCliPrograms || hasCliRenderers) {
+        filteredState.cli.files = new Set(state.cli.files);
+    }
+    // Recalculate requiredServices based on filtered functions/middleware/permissions
+    // Need to cast to InspectorState temporarily for aggregateRequiredServices
+    const stateForAggregation = filteredState;
+    aggregateRequiredServices(stateForAggregation);
+    return filteredState;
+}

package/dist/utils/filter-utils.d.ts

@@ -0,0 +1,19 @@
+import { InspectorFilters, InspectorLogger } from '../types.js';
+import { PikkuWiringTypes } from '@pikku/core';
+/**
+ * Match a value against a pattern with wildcard support
+ * Supports "*" at the beginning, end, or both (e.g., "send*", "*Payment", "*process*")
+ * @param value - The value to check
+ * @param pattern - The pattern with optional "*" wildcard(s)
+ */
+export declare function matchesWildcard(value: string, pattern: string): boolean;
+export declare const matchesFilters: (filters: InspectorFilters, params: {
+    tags?: string[];
+    name?: string;
+}, meta: {
+    type: PikkuWiringTypes;
+    name: string;
+    filePath?: string;
+    httpRoute?: string;
+    httpMethod?: string;
+}, logger: InspectorLogger) => boolean;

package/dist/utils/filter-utils.js

@@ -0,0 +1,109 @@
+/**
+ * Match a value against a pattern with wildcard support
+ * Supports "*" at the beginning, end, or both (e.g., "send*", "*Payment", "*process*")
+ * @param value - The value to check
+ * @param pattern - The pattern with optional "*" wildcard(s)
+ */
+export function matchesWildcard(value, pattern) {
+    // If pattern is just '*', match everything
+    if (pattern === '*') {
+        return true;
+    }
+    const startsWithWildcard = pattern.startsWith('*');
+    const endsWithWildcard = pattern.endsWith('*');
+    if (startsWithWildcard && endsWithWildcard) {
+        // Pattern like "*middle*" - check if value contains the middle part
+        const middle = pattern.slice(1, -1);
+        if (middle === '') {
+            return true; // Pattern is "**", match everything
+        }
+        return value.includes(middle);
+    }
+    else if (startsWithWildcard) {
+        // Pattern like "*suffix" - check if value ends with suffix and has content before
+        const suffix = pattern.slice(1);
+        return value.endsWith(suffix) && value.length > suffix.length;
+    }
+    else if (endsWithWildcard) {
+        // Pattern like "prefix*" - check if value starts with prefix and has content after
+        const prefix = pattern.slice(0, -1);
+        return value.startsWith(prefix) && value.length > prefix.length;
+    }
+    // No wildcard, exact match
+    return value === pattern;
+}
+export const matchesFilters = (filters, params, meta, logger) => {
+    // If no filters are provided, allow everything
+    if (Object.keys(filters).length === 0) {
+        return true;
+    }
+    // If all filter arrays are empty, allow everything
+    if ((!filters.names || filters.names.length === 0) &&
+        (!filters.tags || filters.tags.length === 0) &&
+        (!filters.types || filters.types.length === 0) &&
+        (!filters.directories || filters.directories.length === 0) &&
+        (!filters.httpRoutes || filters.httpRoutes.length === 0) &&
+        (!filters.httpMethods || filters.httpMethods.length === 0)) {
+        return true;
+    }
+    // Check type filter
+    if (filters.types && filters.types.length > 0) {
+        if (!filters.types.includes(meta.type)) {
+            logger.debug(`⒡ Filtered by type: ${meta.type}:${meta.name}`);
+            return false;
+        }
+    }
+    // Check directory filter
+    if (filters.directories && filters.directories.length > 0) {
+        if (!meta.filePath) {
+            logger.debug(`⒡ Filtered by directory: ${meta.type}:${meta.name} (${meta.filePath})`);
+            return false;
+        }
+        const matchesDirectory = filters.directories.some((dir) => {
+            // Normalize paths for comparison
+            const normalizedFilePath = meta.filePath.replace(/\\/g, '/');
+            const normalizedDir = dir.replace(/\\/g, '/');
+            return normalizedFilePath.includes(normalizedDir);
+        });
+        if (!matchesDirectory) {
+            logger.debug(`⒡ Filtered by directory: ${meta.type}:${meta.name} (${meta.filePath})`);
+            return false;
+        }
+    }
+    // Check tag filter
+    if (filters.tags && filters.tags.length > 0) {
+        if (!params.tags ||
+            !filters.tags.some((tag) => params.tags.includes(tag))) {
+            logger.debug(`⒡ Filtered by tags: ${meta.type}:${meta.name}`);
+            return false;
+        }
+    }
+    // Check name filter (with wildcard support)
+    if (filters.names && filters.names.length > 0) {
+        const nameToMatch = params.name || meta.name;
+        const nameMatches = filters.names.some((pattern) => matchesWildcard(nameToMatch, pattern));
+        if (!nameMatches) {
+            logger.debug(`⒡ Filtered by name: ${meta.type}:${meta.name}`);
+            return false;
+        }
+    }
+    // Check HTTP route filter (with wildcard support)
+    if (filters.httpRoutes && filters.httpRoutes.length > 0 && meta.httpRoute) {
+        const routeMatches = filters.httpRoutes.some((pattern) => matchesWildcard(meta.httpRoute, pattern));
+        if (!routeMatches) {
+            logger.debug(`⒡ Filtered by HTTP route: ${meta.httpRoute}`);
+            return false;
+        }
+    }
+    // Check HTTP method filter
+    if (filters.httpMethods &&
+        filters.httpMethods.length > 0 &&
+        meta.httpMethod) {
+        const normalizedMethod = meta.httpMethod.toUpperCase();
+        if (!filters.httpMethods.includes(normalizedMethod)) {
+            logger.debug(`⒡ Filtered by HTTP method: ${meta.httpMethod}`);
+            return false;
+        }
+    }
+    return true;
+};

package/dist/utils/find-root-dir.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Finds the common ancestor directory of all the given file paths.
+ * This is used to determine the project root directory.
+ *
+ * @param filePaths - Array of absolute file paths
+ * @returns The common ancestor directory path
+ *
+ * @example
+ * findCommonAncestor([
+ *   '/Users/yasser/git/pikku/pikku/src/functions/a.ts',
+ *   '/Users/yasser/git/pikku/pikku/src/routes/b.ts'
+ * ])
+ * // Returns: '/Users/yasser/git/pikku/pikku'
+ */
+export declare function findCommonAncestor(filePaths: string[]): string;
+/**
+ * Converts an absolute file path to a relative path from the root directory.
+ *
+ * @param absolutePath - The absolute file path
+ * @param rootDir - The root directory to make the path relative to
+ * @returns A relative path from rootDir to the file
+ */
+export declare function toRelativePath(absolutePath: string, rootDir: string): string;

package/dist/utils/find-root-dir.js

@@ -0,0 +1,55 @@
+import path from 'path';
+/**
+ * Finds the common ancestor directory of all the given file paths.
+ * This is used to determine the project root directory.
+ *
+ * @param filePaths - Array of absolute file paths
+ * @returns The common ancestor directory path
+ *
+ * @example
+ * findCommonAncestor([
+ *   '/Users/yasser/git/pikku/pikku/src/functions/a.ts',
+ *   '/Users/yasser/git/pikku/pikku/src/routes/b.ts'
+ * ])
+ * // Returns: '/Users/yasser/git/pikku/pikku'
+ */
+export function findCommonAncestor(filePaths) {
+    if (filePaths.length === 0) {
+        return process.cwd();
+    }
+    if (filePaths.length === 1) {
+        return path.dirname(filePaths[0]);
+    }
+    // Normalize all paths and get their directory parts
+    const normalizedPaths = filePaths.map((p) => path.dirname(path.normalize(p)).split(path.sep));
+    // Start with the first path's parts
+    const firstPath = normalizedPaths[0];
+    let commonParts = [];
+    // Check each part of the first path
+    for (let i = 0; i < firstPath.length; i++) {
+        const part = firstPath[i];
+        // Check if this part exists in all other paths at the same position
+        const existsInAll = normalizedPaths.every((pathParts) => pathParts[i] === part);
+        if (existsInAll) {
+            commonParts.push(part);
+        }
+        else {
+            break;
+        }
+    }
+    // If no common parts, return root
+    if (commonParts.length === 0) {
+        return path.sep;
+    }
+    return commonParts.join(path.sep);
+}
+/**
+ * Converts an absolute file path to a relative path from the root directory.
+ *
+ * @param absolutePath - The absolute file path
+ * @param rootDir - The root directory to make the path relative to
+ * @returns A relative path from rootDir to the file
+ */
+export function toRelativePath(absolutePath, rootDir) {
+    return path.relative(rootDir, absolutePath);
+}

package/dist/utils/get-files-and-methods.d.ts

@@ -0,0 +1,22 @@
+import { PathToNameAndType, InspectorState, InspectorOptions } from '../types.js';
+interface Meta {
+    file: string;
+    variable: string;
+    type: string;
+    typePath: string;
+}
+export type FilesAndMethods = {
+    userSessionType: Meta;
+    sessionServicesType: Meta;
+    singletonServicesType: Meta;
+    pikkuConfigType: Meta;
+    pikkuConfigFactory: Meta;
+    singletonServicesFactory: Meta;
+    sessionServicesFactory: Meta;
+};
+export type FilesAndMethodsErrors = Map<string, PathToNameAndType>;
+export declare const getFilesAndMethods: ({ singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, configTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }: InspectorState, { configFileType, userSessionType, singletonServicesFactoryType, sessionServicesFactoryType, }?: InspectorOptions["types"]) => {
+    result: Partial<FilesAndMethods>;
+    errors: FilesAndMethodsErrors;
+};
+export {};

package/dist/utils/get-files-and-methods.js

@@ -0,0 +1,61 @@
+const getMetaTypes = (type, map, desiredType, errors) => {
+    if (desiredType) {
+        for (const [file, meta] of map.entries()) {
+            for (const { type: entryType, variable, typePath } of meta) {
+                if (entryType === desiredType) {
+                    if (entryType === null || typePath === null) {
+                        throw new Error(`Unknown state due to metaType calculation: entryType or typePath is null for ${desiredType} in ${file}`);
+                    }
+                    return { file, variable, type: entryType, typePath };
+                }
+            }
+        }
+        if (errors) {
+            errors.set(`No ${desiredType} found that extends ${type}`, map);
+        }
+        return;
+    }
+    const totalValues = Array.from(map.values()).flat();
+    if (totalValues.length === 0) {
+        const helpMessage = type === 'CoreConfig'
+            ? `No ${type} found. Make sure you have exported a createConfig function in your codebase:\n\n` +
+                `export const createConfig: CreateConfig<Config> = async () => {\n` +
+                `  return {}\n` +
+                `}\n\n` +
+                `Possible issues:\n` +
+                `- srcDirectories in pikku.config.json doesn't include the file with the createConfig method`
+            : `No ${type} found`;
+        if (errors) {
+            errors.set(helpMessage, map);
+        }
+    }
+    else if (totalValues.length > 1) {
+        if (errors) {
+            errors.set(`More than one ${type} found`, map);
+        }
+    }
+    else {
+        const entry = Array.from(map.entries())[0];
+        if (entry) {
+            const [file, [{ type: entryType, variable, typePath }]] = entry;
+            if (entryType === null || typePath === null) {
+                throw new Error(`Unknown state due to metaType calculation: entryType or typePath is null for ${type} in ${file}`);
+            }
+            return { file, type: entryType, variable, typePath };
+        }
+    }
+    return;
+};
+export const getFilesAndMethods = ({ singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, configTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }, { configFileType, userSessionType, singletonServicesFactoryType, sessionServicesFactoryType, } = {}) => {
+    const errors = new Map();
+    const result = {
+        userSessionType: getMetaTypes('CoreUserSession', userSessionTypeImportMap, userSessionType, errors),
+        singletonServicesType: getMetaTypes('CoreSingletonServices', singletonServicesTypeImportMap, undefined, errors),
+        sessionServicesType: getMetaTypes('CoreServices', sessionServicesTypeImportMap, undefined, errors),
+        pikkuConfigType: getMetaTypes('CoreConfig', configTypeImportMap, undefined, errors),
+        pikkuConfigFactory: getMetaTypes('CoreConfig', configFactories, configFileType, errors),
+        singletonServicesFactory: getMetaTypes('CreateSingletonServices', singletonServicesFactories, singletonServicesFactoryType, errors),
+        sessionServicesFactory: getMetaTypes('CreateSessionServices', sessionServicesFactories, sessionServicesFactoryType, errors),
+    };
+    return { result, errors };
+};