@pikku/inspector 0.6.4 → 0.7.0

package/dist/visit.d.ts

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

package/dist/visit.js

@@ -1,18 +1,23 @@
 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-http-route.js';
+import { addHTTPRoute } from './add-http-route.js';
 import { addSchedule } from './add-schedule.js';
+import { addFunctions } from './add-functions.js';
 import { addChannel } from './add-channel.js';
-export const visit = (checker, node, state, filters) => {
+export const visitSetup = (checker, node, state, filters) => {
     addFileExtendsCoreType(node, checker, state.singletonServicesTypeImportMap, 'CoreSingletonServices');
     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, filters);
+    addFunctions(node, checker, state, filters);
+    ts.forEachChild(node, (child) => visitSetup(checker, child, state, filters));
+};
+export const visitRoutes = (checker, node, state, filters) => {
+    addHTTPRoute(node, checker, state, filters);
     addSchedule(node, checker, state, filters);
     addChannel(node, checker, state, filters);
-    ts.forEachChild(node, (child) => visit(checker, child, state, filters));
+    ts.forEachChild(node, (child) => visitRoutes(checker, child, state, filters));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.6.4",
+  "version": "0.7.0",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "type": "module",
@@ -17,7 +17,7 @@
     "test:coverage": "bash run-tests.sh --coverage"
   },
   "dependencies": {
-    "@pikku/core": "^0.6.22",
+    "@pikku/core": "^0.7.0",
     "path-to-regexp": "^8.2.0",
     "typescript": "^5.6"
   },

package/src/add-channel.ts

@@ -1,180 +0,0 @@
-import * as ts from 'typescript'
-import { getPropertyValue } from './get-property-value.js'
-import { pathToRegexp } from 'path-to-regexp'
-import { APIDocs } from '@pikku/core'
-import { getInputTypes } from './add-http-route.js'
-import {
-  getPropertyAssignment,
-  getFunctionTypes,
-  matchesFilters,
-} from './utils.js'
-import { ChannelMeta } from '@pikku/core/channel'
-import { TypesMap } from './types-map.js'
-import { InspectorFilters, InspectorState } from './types.js'
-
-const addMessagesRoutes = (
-  obj: ts.ObjectLiteralExpression,
-  checker: ts.TypeChecker,
-  typesMap: TypesMap
-) => {
-  const messageTypes: ChannelMeta['messageRoutes'] = {}
-
-  // Find the onMessageRoute property
-  const messagesProperty = obj.properties.find(
-    (p) =>
-      ts.isPropertyAssignment(p) &&
-      ts.isIdentifier(p.name) &&
-      p.name.text === 'onMessageRoute'
-  )
-
-  if (!messagesProperty || !ts.isPropertyAssignment(messagesProperty)) {
-    console.log(
-      'onMessageRoute property not found or is not a valid assignment.'
-    )
-    return {}
-  }
-
-  const initializer = messagesProperty.initializer
-  // Ensure initializer is an object literal expression
-  if (!ts.isObjectLiteralExpression(initializer)) {
-    console.log('onMessageRoute is not an object literal.')
-    return {}
-  }
-
-  // Iterate over the first level properties (like 'event')
-  initializer.properties.forEach((property) => {
-    const channel = property.name!.getText()
-    messageTypes[channel] = {}
-
-    if (ts.isPropertyAssignment(property)) {
-      const nestedObject = property.initializer
-      if (ts.isObjectLiteralExpression(nestedObject)) {
-        const keys = nestedObject.properties.map((p) => p.name?.getText())
-        for (const route of keys) {
-          if (route) {
-            const result = getFunctionTypes(checker, nestedObject, {
-              funcName: route,
-              inputIndex: 0,
-              outputIndex: 1,
-              typesMap,
-            })
-            const inputs = result?.inputs || null
-            const outputs = result?.outputs || null
-            const type = result?.type || null
-            messageTypes[channel][route] = { inputs, outputs, type }
-          }
-        }
-      } else {
-        console.warn('Nested property is not an object literal:', nestedObject)
-      }
-    } else {
-      console.warn(
-        `Property "${property.getText()}" is a ${ts.SyntaxKind[property.kind]}`
-      )
-    }
-  })
-
-  return messageTypes
-}
-
-export const addChannel = (
-  node: ts.Node,
-  checker: ts.TypeChecker,
-  state: InspectorState,
-  filters: InspectorFilters
-) => {
-  if (!ts.isCallExpression(node)) {
-    return
-  }
-
-  const args = node.arguments
-  const firstArg = args[0]
-  const expression = node.expression
-
-  // Check if the call is to addRoute
-  if (!ts.isIdentifier(expression) || expression.text !== 'addChannel') {
-    return
-  }
-
-  if (!firstArg) {
-    return
-  }
-
-  let docs: APIDocs | undefined
-  let paramsValues: string[] | null = []
-  let queryValues: string[] | [] = []
-  let tags: string[] | undefined = undefined
-  let inputType: string | null = null
-  let route: string | null = null
-  let name: string | null = null
-
-  // Check if the first argument is an object literal
-  if (ts.isObjectLiteralExpression(firstArg)) {
-    const obj = firstArg
-
-    name = getPropertyValue(obj, 'name') as string | null
-    route = getPropertyValue(obj, 'route') as string | null
-
-    if (!name) {
-      console.error('Channel name is required')
-      return
-    }
-
-    if (route) {
-      const { keys } = pathToRegexp(route)
-      paramsValues = keys.reduce((result, { type, name }) => {
-        if (type === 'param') {
-          result.push(name)
-        }
-        return result
-      }, [] as string[])
-    } else {
-      route = ''
-    }
-
-    docs = (getPropertyValue(obj, 'docs') as APIDocs) || undefined
-    queryValues = (getPropertyValue(obj, 'query') as string[]) || []
-    tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
-
-    const connect = !!getPropertyAssignment(obj, 'onConnect')
-    const disconnect = !!getPropertyAssignment(obj, 'onDisconnect')
-    const { inputs, outputs, type } = getFunctionTypes(checker, obj, {
-      funcName: 'onMessage',
-      inputIndex: 0,
-      outputIndex: 1,
-      typesMap: state.channels.typesMap,
-    })
-    const message = { inputs, outputs, type }
-    const messageRoutes = addMessagesRoutes(
-      obj,
-      checker,
-      state.channels.typesMap
-    )
-
-    if (!matchesFilters(filters, { tags }, { type: 'channel', name })) {
-      return
-    }
-
-    state.channels.files.add(node.getSourceFile().fileName)
-    state.channels.meta.push({
-      name,
-      route,
-      input: inputType,
-      params: paramsValues.length > 0 ? paramsValues : undefined,
-      query: queryValues.length > 0 ? queryValues : undefined,
-      inputTypes: getInputTypes(
-        state.channels.metaInputTypes,
-        'get',
-        inputType,
-        queryValues,
-        paramsValues
-      ),
-      connect,
-      disconnect,
-      message: message || undefined,
-      messageRoutes,
-      docs,
-      tags,
-    })
-  }
-}

package/src/add-file-extends-core-type.ts

@@ -1,50 +0,0 @@
-import * as ts from 'typescript'
-import { PathToNameAndType } from './types.js'
-
-// const VRAMEWORK_TYPES = ['CoreConfig', 'CoreService', 'CoreServices', 'CoreSingletonService', 'CoreSessionService']
-
-export const addFileExtendsCoreType = (
-  node: ts.Node,
-  checker: ts.TypeChecker,
-  methods: PathToNameAndType,
-  expectedTypeName: string
-) => {
-  if (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) {
-    const fileName = node.getSourceFile().fileName
-    const typeName = node.name?.getText()
-
-    // Check if the class or interface extends the expected type
-    if (node.heritageClauses) {
-      for (const clause of node.heritageClauses) {
-        if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
-          for (const type of clause.types) {
-            const extendedTypeName = type.expression.getText()
-            let extendedTypeDeclarationPath: string | null = null
-
-            // Check if the extended type matches the expected type name
-            if (extendedTypeName === expectedTypeName) {
-              // Retrieve the symbol of the extended type
-              const typeSymbol = checker.getSymbolAtLocation(type.expression)
-              const declaration =
-                typeSymbol &&
-                typeSymbol.declarations &&
-                typeSymbol.declarations[0]
-              if (declaration) {
-                const sourceFile = declaration.getSourceFile()
-                extendedTypeDeclarationPath = sourceFile.fileName // Get the path of the file where the extended type was declared
-              }
-
-              const variables = methods[fileName] || []
-              variables.push({
-                variable: undefined,
-                type: typeName,
-                typePath: extendedTypeDeclarationPath,
-              })
-              methods[fileName] = variables
-            }
-          }
-        }
-      }
-    }
-  }
-}

package/src/add-file-with-config.ts

@@ -1,45 +0,0 @@
-import * as ts from 'typescript'
-import { doesTypeExtendsCore } from './does-type-extend-core-type.js'
-import { PathToNameAndType } from './types.js'
-
-export const addFileWithConfig = (
-  node: ts.Node,
-  checker: ts.TypeChecker,
-  configs: PathToNameAndType
-) => {
-  if (ts.isVariableDeclaration(node)) {
-    const fileName = node.getSourceFile().fileName
-    const variableSymbol = checker.getSymbolAtLocation(node.name)
-
-    if (variableSymbol) {
-      const variableType = checker.getTypeOfSymbolAtLocation(
-        variableSymbol,
-        node.name
-      )
-      const variableName = node.name.getText()
-      const variableTypeText = node.type?.getText()
-
-      // Check if the type extends CoreConfig
-      if (doesTypeExtendsCore(variableType, checker, new Set(), 'CoreConfig')) {
-        // Retrieve the symbol of the type (if it has one)
-        const typeSymbol = variableType.symbol
-        let typeDeclarationPath: string | null = null
-        const declaration =
-          typeSymbol && typeSymbol.declarations && typeSymbol.declarations[0]
-
-        if (declaration) {
-          const sourceFile = declaration.getSourceFile()
-          typeDeclarationPath = sourceFile.fileName // Get the path of the file where the type was declared
-        }
-
-        const variables = configs[fileName] || []
-        variables.push({
-          variable: variableName,
-          type: variableTypeText || null,
-          typePath: typeDeclarationPath,
-        })
-        configs[fileName] = variables
-      }
-    }
-  }
-}

package/src/add-file-with-factory.ts

@@ -1,65 +0,0 @@
-import * as ts from 'typescript'
-import { PathToNameAndType } from './types.js'
-
-export const addFileWithFactory = (
-  node: ts.Node,
-  checker: ts.TypeChecker,
-  methods: PathToNameAndType = new Map(),
-  expectedTypeName: string
-) => {
-  if (ts.isVariableDeclaration(node)) {
-    const fileName = node.getSourceFile().fileName
-    const variableTypeNode = node.type
-    const variableName = node.name.getText()
-
-    if (variableTypeNode && ts.isTypeReferenceNode(variableTypeNode)) {
-      const typeNameNode = variableTypeNode.typeName || null
-
-      let typeDeclarationPath: string | null = null
-
-      // Check if the type name matches the expected type name
-      if (
-        ts.isIdentifier(typeNameNode) &&
-        typeNameNode.text === expectedTypeName
-      ) {
-        const typeSymbol = checker.getSymbolAtLocation(typeNameNode)
-        const declaration =
-          typeSymbol && typeSymbol.declarations && typeSymbol.declarations[0]
-        if (declaration) {
-          const sourceFile = declaration.getSourceFile()
-          typeDeclarationPath = sourceFile.fileName // Get the path of the file where the type was declared
-        }
-
-        const variables = methods[fileName] || []
-        variables.push({
-          variable: variableName,
-          type: typeNameNode.getText(),
-          typePath: typeDeclarationPath,
-        })
-        methods[fileName] = variables
-      }
-
-      // Handle qualified type names if necessary
-      else if (ts.isQualifiedName(typeNameNode)) {
-        const lastName = typeNameNode.right.text
-        if (lastName === expectedTypeName) {
-          const typeSymbol = checker.getSymbolAtLocation(typeNameNode.right)
-          const declaration =
-            typeSymbol && typeSymbol.declarations && typeSymbol.declarations[0]
-          if (declaration) {
-            const sourceFile = declaration.getSourceFile()
-            typeDeclarationPath = sourceFile.fileName // Get the path of the file where the type was declared
-          }
-
-          const variables = methods[fileName] || []
-          variables.push({
-            variable: variableName,
-            type: typeNameNode.getText(),
-            typePath: typeDeclarationPath,
-          })
-          methods[fileName] = variables
-        }
-      }
-    }
-  }
-}

package/src/add-http-route.ts

@@ -1,138 +0,0 @@
-import * as ts from 'typescript'
-import { getPropertyValue } from './get-property-value.js'
-import { pathToRegexp } from 'path-to-regexp'
-import { HTTPMethod } from '@pikku/core/http'
-import { APIDocs } from '@pikku/core'
-import { extractTypeKeys, getFunctionTypes, matchesFilters } from './utils.js'
-import { MetaInputTypes, InspectorState, InspectorFilters } from './types.js'
-
-export const getInputTypes = (
-  metaTypes: MetaInputTypes,
-  methodType: string,
-  inputType: string | null,
-  queryValues: string[],
-  paramsValues: string[]
-) => {
-  if (!inputType) {
-    return undefined
-  }
-
-  if (inputType) {
-    metaTypes.set(inputType, {
-      query: queryValues,
-      params: paramsValues,
-      body: ['post', 'put', 'patch'].includes(methodType)
-        ? [...new Set([...queryValues, ...paramsValues])]
-        : [],
-    })
-  }
-
-  return undefined
-}
-
-export const addRoute = (
-  node: ts.Node,
-  checker: ts.TypeChecker,
-  state: InspectorState,
-  filters: InspectorFilters
-) => {
-  if (!ts.isCallExpression(node)) {
-    return
-  }
-
-  const args = node.arguments
-  const firstArg = args[0]
-  const expression = node.expression
-
-  // Check if the call is to addRoute
-  if (!ts.isIdentifier(expression) || expression.text !== 'addRoute') {
-    return
-  }
-
-  if (!firstArg) {
-    return
-  }
-
-  let docs: APIDocs | undefined
-  let methodValue: string | null = null
-  let paramsValues: string[] | null = []
-  let queryValues: string[] | [] = []
-  let tags: string[] | [] = []
-  let routeValue: string | null = null
-
-  // Check if the first argument is an object literal
-  if (ts.isObjectLiteralExpression(firstArg)) {
-    const obj = firstArg
-
-    routeValue = getPropertyValue(obj, 'route') as string | null
-    if (!routeValue) {
-      return
-    }
-
-    const { keys } = pathToRegexp(routeValue)
-    paramsValues = keys.reduce((result, { type, name }) => {
-      if (type === 'param') {
-        result.push(name)
-      }
-      return result
-    }, [] as string[])
-
-    docs = (getPropertyValue(obj, 'docs') as APIDocs) || undefined
-    methodValue = getPropertyValue(obj, 'method') as string
-    queryValues = (getPropertyValue(obj, 'query') as string[]) || []
-    tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
-
-    if (
-      !matchesFilters(filters, { tags }, { type: 'http', name: routeValue })
-    ) {
-      return
-    }
-
-    let { inputs, outputs, inputTypes } = getFunctionTypes(checker, obj, {
-      funcName: 'func',
-      inputIndex: 0,
-      outputIndex: 1,
-      typesMap: state.http.typesMap,
-    })
-
-    const input = inputs ? inputs[0] || null : null
-    const output = outputs ? outputs[0] || null : null
-
-    if (inputs && inputs?.length > 1) {
-      console.error(
-        `Only one input type is currently allowed for method '${methodValue}' and route '${routeValue}': \n\t${inputs.join('\n\t')}`
-      )
-    }
-
-    if (outputs && outputs?.length > 1) {
-      console.error(
-        `Only one output type is currently allowed for method '${methodValue}' and route '${routeValue}': \n\t${outputs.join('\n\t')}`
-      )
-    }
-
-    if (inputTypes[0] && !['post', 'put', 'patch'].includes(methodValue)) {
-      queryValues = [
-        ...new Set([...queryValues, ...extractTypeKeys(inputTypes[0])]),
-      ].filter((query) => !paramsValues?.includes(query))
-    }
-
-    state.http.files.add(node.getSourceFile().fileName)
-    state.http.meta.push({
-      route: routeValue,
-      method: methodValue! as HTTPMethod,
-      input,
-      output,
-      params: paramsValues.length > 0 ? paramsValues : undefined,
-      query: queryValues.length > 0 ? queryValues : undefined,
-      inputTypes: getInputTypes(
-        state.http.metaInputTypes,
-        methodValue,
-        input,
-        queryValues,
-        paramsValues
-      ),
-      docs,
-      tags,
-    })
-  }
-}

package/src/add-schedule.ts

@@ -1,56 +0,0 @@
-import * as ts from 'typescript'
-import { getPropertyValue } from './get-property-value.js'
-import { APIDocs } from '@pikku/core'
-import { InspectorFilters, InspectorState } from './types.js'
-import { matchesFilters } from './utils.js'
-
-export const addSchedule = (
-  node: ts.Node,
-  _checker: ts.TypeChecker,
-  state: InspectorState,
-  filters: InspectorFilters
-) => {
-  if (!ts.isCallExpression(node)) {
-    return
-  }
-
-  const args = node.arguments
-  const firstArg = args[0]
-  const expression = node.expression
-
-  // Check if the call is to addScheduledTask
-  if (!ts.isIdentifier(expression) || expression.text !== 'addScheduledTask') {
-    return
-  }
-
-  if (!firstArg) {
-    return
-  }
-
-  if (ts.isObjectLiteralExpression(firstArg)) {
-    const obj = firstArg
-
-    const nameValue = getPropertyValue(obj, 'name') as string | null
-    const scheduleValue = getPropertyValue(obj, 'schedule') as string | null
-    const docs = (getPropertyValue(obj, 'docs') as APIDocs) || undefined
-    const tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
-
-    if (!nameValue || !scheduleValue) {
-      return
-    }
-
-    if (
-      !matchesFilters(filters, { tags }, { type: 'schedule', name: nameValue })
-    ) {
-      return
-    }
-
-    state.scheduledTasks.files.add(node.getSourceFile().fileName)
-    state.scheduledTasks.meta.push({
-      name: nameValue,
-      schedule: scheduleValue,
-      docs,
-      tags,
-    })
-  }
-}

package/src/does-type-extend-core-type.ts

@@ -1,53 +0,0 @@
-import * as ts from 'typescript'
-
-export const doesTypeExtendsCore = (
-  type: ts.Type,
-  checker: ts.TypeChecker,
-  visitedTypes: Set<ts.Type>,
-  coreType: string
-): boolean => {
-  if (!type || !checker) return false
-
-  // Avoid infinite recursion by checking if we've already visited this type
-  if (visitedTypes.has(type)) {
-    return false
-  }
-  visitedTypes.add(type)
-
-  const typeSymbol = type.getSymbol()
-  if (typeSymbol) {
-    // Check if the type is the core type
-    if (typeSymbol.getName() === coreType) {
-      return true
-    }
-
-    // For interface and class types, check their base types
-    if (type.isClassOrInterface()) {
-      const baseTypes = type.getBaseTypes() || []
-      for (const baseType of baseTypes) {
-        if (doesTypeExtendsCore(baseType, checker, visitedTypes, coreType)) {
-          return true
-        }
-      }
-    }
-  }
-
-  // For type aliases, get the aliased type
-  if (type.aliasSymbol) {
-    const aliasedType = checker.getDeclaredTypeOfSymbol(type.aliasSymbol)
-    if (doesTypeExtendsCore(aliasedType, checker, visitedTypes, coreType)) {
-      return true
-    }
-  }
-
-  // For union and intersection types, check all constituent types
-  if (type.isUnionOrIntersection()) {
-    for (const subType of type.types) {
-      if (doesTypeExtendsCore(subType, checker, visitedTypes, coreType)) {
-        return true
-      }
-    }
-  }
-
-  return false
-}