@pikku/inspector 0.6.2

package/dist/types-map.js

@@ -0,0 +1,103 @@
+export class TypesMap {
+    map = new Map();
+    customTypes = new Map();
+    addCustomType(name, type, references) {
+        this.customTypes.set(name, { type, references });
+    }
+    addType(originalName, path) {
+        this.map.set(originalName, { originalName, path });
+    }
+    addUniqueType(originalName, path) {
+        const uniqueName = `${originalName}_${Math.random().toString(36).substring(7)}`;
+        this.map.set(uniqueName, { originalName, path });
+        return uniqueName;
+    }
+    getUniqueName(name) {
+        const meta = this.getTypeMeta(name);
+        return meta.uniqueName;
+    }
+    getTypeMeta(name) {
+        if (['string', 'number', 'boolean', 'null'].includes(name)) {
+            return {
+                originalName: name,
+                uniqueName: name,
+                path: null,
+            };
+        }
+        if (this.customTypes.has(name)) {
+            return {
+                originalName: name,
+                uniqueName: name,
+                path: null,
+            };
+        }
+        let meta = this.map.get(name);
+        if (!meta) {
+            meta = Array.from(this.map.entries()).find(([_, { originalName }]) => originalName === name)?.[1];
+        }
+        if (!meta) {
+            throw new Error(`Type ${name} not found in typesMap`);
+        }
+        const getName = this.squash();
+        return {
+            uniqueName: getName(name),
+            originalName: meta.originalName,
+            path: meta?.path,
+        };
+    }
+    exists(originalName, path) {
+        const found = Array.from(this.map.entries()).find(([_, type]) => {
+            return type.path === path && type.originalName === originalName;
+        });
+        return found ? found[0] : undefined;
+    }
+    squash() {
+        const duplicateNames = new Set();
+        const pathToNamesMap = new Map();
+        const nameOccurrences = new Map();
+        // First pass: Track occurrences of each original name across paths
+        this.map.forEach(({ path, originalName }) => {
+            if (path) {
+                if (!nameOccurrences.has(originalName)) {
+                    nameOccurrences.set(originalName, new Set());
+                }
+                nameOccurrences.get(originalName).add(path);
+            }
+        });
+        // Second pass: Populate pathToNamesMap
+        this.map.forEach(({ path, originalName }, uniqueName) => {
+            if (!path)
+                return;
+            if (!pathToNamesMap.has(path)) {
+                pathToNamesMap.set(path, new Map());
+            }
+            const isDuplicate = nameOccurrences.get(originalName).size > 1;
+            if (isDuplicate) {
+                duplicateNames.add(uniqueName);
+            }
+            // Use uniqueName only if the originalName is duplicated across files
+            const nameToUse = isDuplicate ? uniqueName : originalName;
+            pathToNamesMap.get(path).set(nameToUse, originalName);
+        });
+        const getName = (uniqueName) => {
+            if (duplicateNames.has(uniqueName)) {
+                return uniqueName;
+            }
+            if (uniqueName === 'string' ||
+                uniqueName === 'number' ||
+                uniqueName === 'boolean' ||
+                uniqueName === 'null') {
+                return uniqueName;
+            }
+            if (!this.map.has(uniqueName)) {
+                const found = Array.from(this.map.entries()).find(([_, { originalName }]) => originalName === uniqueName)?.[1];
+                if (!found) {
+                    throw new Error(`Type ${uniqueName} not found in typesMap`);
+                }
+                return found.originalName;
+            }
+            return this.map.get(uniqueName).originalName;
+        };
+        return getName;
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,49 @@
+import { ChannelsMeta } from '@pikku/core/channel';
+import { HTTPRoutesMeta } from '@pikku/core/http';
+import { ScheduledTasksMeta } from '@pikku/core/scheduler';
+import { TypesMap } from './types-map.js';
+export type PathToNameAndType = Map<string, {
+    variable: string;
+    type: string | null;
+    typePath: string | null;
+}[]>;
+export type MetaInputTypes = Map<string, {
+    query: string[] | undefined;
+    params: string[] | undefined;
+    body: string[] | undefined;
+}>;
+export type APIFunctionMeta = Array<{
+    name: string;
+    input: string;
+    output: string;
+    file: string;
+}>;
+export type InspectorAPIFunction = {
+    typesMap: TypesMap;
+    meta: APIFunctionMeta;
+};
+export interface InspectorHTTPState {
+    typesMap: TypesMap;
+    metaInputTypes: MetaInputTypes;
+    meta: HTTPRoutesMeta;
+    files: Set<string>;
+}
+export interface InspectorChannelState {
+    typesMap: TypesMap;
+    metaInputTypes: MetaInputTypes;
+    meta: ChannelsMeta;
+    files: Set<string>;
+}
+export interface InspectorState {
+    sessionServicesTypeImportMap: PathToNameAndType;
+    userSessionTypeImportMap: PathToNameAndType;
+    singletonServicesFactories: PathToNameAndType;
+    sessionServicesFactories: PathToNameAndType;
+    configFactories: PathToNameAndType;
+    http: InspectorHTTPState;
+    channels: InspectorChannelState;
+    scheduledTasks: {
+        meta: ScheduledTasksMeta;
+        files: Set<string>;
+    };
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,30 @@
+import * as ts from 'typescript';
+import { TypesMap } from './types-map.js';
+type FunctionTypes = {
+    inputTypes: ts.Type[];
+    inputs: null | string[];
+    outputTypes: ts.Type[];
+    outputs: null | string[];
+};
+export declare const extractTypeKeys: (type: ts.Type) => string[];
+export declare const nullifyTypes: (type: string | null) => string | null;
+export declare const getNamesAndTypes: (checker: ts.TypeChecker, typesMap: TypesMap, direction: "Input" | "Output", funcName: string, type: ts.Type) => {
+    names: string[];
+    types: ts.Type[];
+};
+export declare const isPrimitiveType: (type: ts.Type) => boolean;
+export declare const resolveUnionTypes: (checker: ts.TypeChecker, type: ts.Type) => {
+    types: ts.Type[];
+    names: string[];
+};
+export declare const resolveTypeImports: (type: ts.Type, resolvedTypes: TypesMap, isCustom: boolean) => string[];
+export declare const getPropertyAssignment: (obj: ts.ObjectLiteralExpression, name: string) => ts.ObjectLiteralElementLike | null;
+export declare const getTypeArgumentsOfType: (checker: ts.TypeChecker, type: ts.Type) => readonly ts.Type[] | null;
+export declare const getFunctionTypes: (checker: ts.TypeChecker, obj: ts.ObjectLiteralExpression, { typesMap, funcName, subFunctionName, inputIndex, outputIndex, }: {
+    typesMap: TypesMap;
+    subFunctionName?: string;
+    funcName: string;
+    inputIndex: number;
+    outputIndex: number;
+}) => FunctionTypes;
+export {};

package/dist/utils.js

@@ -0,0 +1,245 @@
+import * as ts from 'typescript';
+export const extractTypeKeys = (type) => {
+    return type.getProperties().map((symbol) => symbol.getName());
+};
+export const nullifyTypes = (type) => {
+    if (type === 'void' ||
+        type === 'undefined' ||
+        type === 'unknown' ||
+        type === 'any') {
+        return null;
+    }
+    return type;
+};
+const isValidVariableName = (name) => {
+    const regex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+    return regex.test(name);
+};
+export const getNamesAndTypes = (checker, typesMap, direction, funcName, type) => {
+    const result = {
+        names: new Set(),
+        types: [],
+    };
+    const { names, types } = resolveUnionTypes(checker, type);
+    const firstName = names[0];
+    if (names.length > 1 || (firstName && !isValidVariableName(firstName))) {
+        const aliasType = names.join(' | ');
+        const aliasName = `${funcName.charAt(0).toUpperCase()}${funcName.slice(1)}${direction}`;
+        result.names = new Set([aliasName]);
+        result.types = types;
+        const references = types
+            .map((t) => resolveTypeImports(t, typesMap, true))
+            .flat();
+        typesMap.addCustomType(aliasName, aliasType, references);
+    }
+    else {
+        const uniqueNames = names
+            .map((name, i) => {
+            const type = types[i];
+            if (!type) {
+                throw new Error('TODO: Expected a type here to match name');
+            }
+            if (isPrimitiveType(type)) {
+                return name;
+            }
+            return resolveTypeImports(type, typesMap, false);
+        })
+            .flat();
+        result.names = new Set(uniqueNames);
+        result.types = types;
+    }
+    return {
+        names: Array.from(result.names),
+        types: result.types,
+    };
+};
+export const isPrimitiveType = (type) => {
+    const primitiveFlags = ts.TypeFlags.Number |
+        ts.TypeFlags.String |
+        ts.TypeFlags.Boolean |
+        ts.TypeFlags.BigInt |
+        ts.TypeFlags.ESSymbol |
+        ts.TypeFlags.Void |
+        ts.TypeFlags.Undefined |
+        ts.TypeFlags.Null |
+        ts.TypeFlags.Any |
+        ts.TypeFlags.Unknown;
+    return (type.flags & primitiveFlags) !== 0;
+};
+export const resolveUnionTypes = (checker, type) => {
+    const types = [];
+    const names = [];
+    // Check if it's a union type AND not part of an intersection
+    if (type.isUnion() && !(type.flags & ts.TypeFlags.Intersection)) {
+        for (const t of type.types) {
+            const name = nullifyTypes(checker.typeToString(t));
+            if (name) {
+                types.push(t);
+                names.push(name);
+            }
+        }
+    }
+    else {
+        const name = nullifyTypes(checker.typeToString(type));
+        if (name) {
+            types.push(type);
+            names.push(name);
+        }
+    }
+    return { types, names };
+};
+export const resolveTypeImports = (type, resolvedTypes, isCustom) => {
+    const types = [];
+    const visitType = (currentType) => {
+        const symbol = currentType.aliasSymbol || currentType.getSymbol();
+        if (symbol) {
+            const declarations = symbol.getDeclarations();
+            const declaration = declarations?.[0];
+            if (declaration) {
+                const sourceFile = declaration.getSourceFile();
+                const path = sourceFile.fileName;
+                // Skip built-in utility types or TypeScript lib types
+                if (!path.includes('node_modules/typescript') &&
+                    symbol.getName() !== '__type' &&
+                    !isPrimitiveType(currentType)) {
+                    const originalName = symbol.getName();
+                    // Check if the type is already in the map
+                    let uniqueName = resolvedTypes.exists(originalName, path);
+                    if (!uniqueName) {
+                        if (isCustom) {
+                            uniqueName = resolvedTypes.addUniqueType(originalName, path);
+                        }
+                        else {
+                            resolvedTypes.addType(originalName, path);
+                            uniqueName = originalName;
+                        }
+                    }
+                    types.push(uniqueName);
+                }
+            }
+        }
+        if (isCustom) {
+            // Handle nested utility types like Partial, Pick, etc.
+            if (currentType.aliasTypeArguments) {
+                currentType.aliasTypeArguments.forEach(visitType);
+            }
+            // Handle intersections and unions
+            if (currentType.isUnionOrIntersection()) {
+                currentType.types.forEach(visitType);
+            }
+            // Handle object types with type arguments
+            if (currentType.flags & ts.TypeFlags.Object &&
+                currentType.objectFlags & ts.ObjectFlags.Reference) {
+                const typeRef = currentType;
+                typeRef.typeArguments?.forEach(visitType);
+            }
+        }
+    };
+    visitType(type);
+    return types;
+};
+export const getPropertyAssignment = (obj, name) => {
+    const property = obj.properties.find((p) => (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
+        ts.isIdentifier(p.name) &&
+        p.name.text === name);
+    if (!property) {
+        console.error(`Missing property '${name}' in object`);
+        return null;
+    }
+    return property;
+};
+export const getTypeArgumentsOfType = (checker, type) => {
+    if (type.isUnionOrIntersection()) {
+        const types = [];
+        for (const subType of type.types) {
+            const subTypeArgs = getTypeArgumentsOfType(checker, subType);
+            if (subTypeArgs) {
+                types.push(...subTypeArgs);
+            }
+        }
+        return types.length > 0 ? types : null;
+    }
+    // If the type is a TypeReference with typeArguments, return them
+    if (type.flags & ts.TypeFlags.Object &&
+        type.objectFlags & ts.ObjectFlags.Reference) {
+        const typeRef = type;
+        if (typeRef.typeArguments && typeRef.typeArguments.length > 0) {
+            return typeRef.typeArguments;
+        }
+    }
+    // If the type is an alias with aliasTypeArguments, return them
+    if (type.aliasTypeArguments && type.aliasTypeArguments.length > 0) {
+        return type.aliasTypeArguments;
+    }
+    return null;
+};
+export const getFunctionTypes = (checker, obj, { typesMap, funcName, subFunctionName = funcName, inputIndex, outputIndex, }) => {
+    const result = {
+        inputTypes: [],
+        inputs: null,
+        outputTypes: [],
+        outputs: null,
+    };
+    const property = getPropertyAssignment(obj, subFunctionName);
+    if (!property) {
+        return result;
+    }
+    let type;
+    // Handle shorthand property assignment
+    if (ts.isShorthandPropertyAssignment(property)) {
+        const symbol = checker.getShorthandAssignmentValueSymbol(property);
+        if (symbol) {
+            type = checker.getTypeOfSymbolAtLocation(symbol, property);
+            if (funcName === 'func') {
+                funcName = symbol.name;
+            }
+        }
+    }
+    // Handle regular property assignment
+    else if (ts.isPropertyAssignment(property)) {
+        if (ts.isObjectLiteralExpression(property.initializer)) {
+            return getFunctionTypes(checker, property.initializer, {
+                typesMap,
+                funcName,
+                subFunctionName: 'func',
+                inputIndex,
+                outputIndex,
+            });
+        }
+        if (property.initializer) {
+            type = checker.getTypeAtLocation(property.initializer);
+            if (funcName === 'func') {
+                funcName = property.initializer.getText();
+            }
+        }
+    }
+    if (!type) {
+        console.error(`Unable to resolve type for property '${funcName}'`);
+        return result;
+    }
+    // Access type arguments from TypeReference
+    const typeArguments = getTypeArgumentsOfType(checker, type);
+    if (!typeArguments || typeArguments.length === 0) {
+        // This is the case for inline functions. In this case we would want to
+        // get the types from the second argument of the function...
+        console.error(`\x1b[31m• No generic type arguments found for ${funcName}. Support for inline functions is not yet implemented.\x1b[0m`);
+        return result;
+    }
+    if (inputIndex !== undefined && inputIndex < typeArguments.length) {
+        const { names, types } = getNamesAndTypes(checker, typesMap, 'Input', funcName, typeArguments[inputIndex]);
+        result.inputs = names;
+        result.inputTypes = types;
+    }
+    else {
+        console.log(`No input defined for ${funcName}`);
+    }
+    if (outputIndex !== undefined && outputIndex < typeArguments.length) {
+        const { names, types } = getNamesAndTypes(checker, typesMap, 'Output', funcName, typeArguments[outputIndex]);
+        result.outputs = names;
+        result.outputTypes = types;
+    }
+    else {
+        console.info(`No output defined for ${funcName}`);
+    }
+    return result;
+};

package/dist/visit.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript';
+import { InspectorState } from './types.js';
+export declare const visit: (checker: ts.TypeChecker, node: ts.Node, state: InspectorState) => void;

package/dist/visit.js

@@ -0,0 +1,17 @@
+import * as ts from 'typescript';
+import { addFileWithFactory } from './add-file-with-factory.js';
+import { addFileExtendsCoreType } from './add-file-extends-core-type.js';
+import { addRoute } from './add-route.js';
+import { addSchedule } from './add-schedule.js';
+import { addChannel } from './add-channel.js';
+export const visit = (checker, node, state) => {
+    addFileExtendsCoreType(node, checker, state.sessionServicesTypeImportMap, 'CoreServices');
+    addFileExtendsCoreType(node, checker, state.userSessionTypeImportMap, 'CoreUserSession');
+    addFileWithFactory(node, checker, state.singletonServicesFactories, 'CreateSingletonServices');
+    addFileWithFactory(node, checker, state.sessionServicesFactories, 'CreateSessionServices');
+    addFileWithFactory(node, checker, state.configFactories, 'CreateConfig');
+    addRoute(node, checker, state);
+    addSchedule(node, checker, state);
+    addChannel(node, checker, state);
+    ts.forEachChild(node, (child) => visit(checker, child, state));
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@pikku/inspector",
+  "version": "0.6.2",
+  "author": "yasser.fadl@gmail.com",
+  "license": "MIT",
+  "type": "module",
+  "module": "dist/index.js",
+  "main": "dist/index.js",
+  "scripts": {
+    "tsc": "tsc",
+    "build:esm": "tsc -b",
+    "build": "yarn build:esm",
+    "ncu": "ncu -x '/.*glob.*/'",
+    "release": "yarn build && npm test",
+    "test": "bash run-tests.sh",
+    "test:watch": "bash run-tests.sh --watch",
+    "test:coverage": "bash run-tests.sh --coverage"
+  },
+  "dependencies": {
+    "@pikku/core": "^0.6.5",
+    "path-to-regexp": "^8.2.0",
+    "typescript": "^5.6"
+  },
+  "devDependencies": {
+    "@types/node": "^22.7.8"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/run-tests.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+
+# Enable nullglob to handle cases where no files match the pattern
+shopt -s nullglob
+
+# Initialize variables for options
+watch_mode=false
+coverage_mode=false
+
+# Parse command-line options
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --watch)
+      watch_mode=true
+      shift
+      ;;
+    --coverage)
+      coverage_mode=true
+      shift
+      ;;
+    *)
+      echo "Unknown option: $1"
+      exit 1
+      ;;
+  esac
+done
+
+# Define the pattern to match your test files
+pattern="src/*.test.ts"
+
+# Expand the pattern into an array of files
+files=($(find src -type f -name "*.test.ts"))
+
+# Check if any files matched the pattern
+if [ ${#files[@]} -eq 0 ]; then
+  echo "No test files found matching pattern: $pattern"
+  exit 0
+fi
+
+# Construct the node command
+node_cmd="node --import tsx --test"
+
+# Append options based on flags
+if [ "$watch_mode" = true ]; then
+  node_cmd="$node_cmd --watch"
+fi
+
+if [ "$coverage_mode" = true ]; then
+  node_cmd="$node_cmd --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info"
+fi
+
+# Execute the node command with the expanded list of files
+$node_cmd "${files[@]}"