@pikku/cli 0.11.2 → 0.12.0

package/src/utils/schema-generator.ts

@@ -1,172 +0,0 @@
-import { createGenerator, RootlessError } from 'ts-json-schema-generator'
-import { writeFileInDir } from './file-writer.js'
-import { mkdir, writeFile } from 'fs/promises'
-import { FunctionsMeta, JSONValue } from '@pikku/core'
-import { HTTPWiringsMeta } from '@pikku/core/http'
-import { TypesMap, ErrorCode } from '@pikku/inspector'
-import { CLILogger } from '../services/cli-logger.service.js'
-
-export async function generateSchemas(
-  logger: CLILogger,
-  tsconfig: string,
-  typesMap: TypesMap,
-  functionMeta: FunctionsMeta,
-  httpWiringsMeta: HTTPWiringsMeta,
-  additionalTypes?: string[],
-  additionalProperties: boolean = false
-): Promise<Record<string, JSONValue>> {
-  const schemasSet = new Set(typesMap.customTypes.keys())
-  for (const { inputs, outputs } of Object.values(functionMeta)) {
-    const types = [...(inputs || []), ...(outputs || [])]
-    for (const type of types) {
-      try {
-        const uniqueName = typesMap.getUniqueName(type)
-        if (uniqueName) {
-          schemasSet.add(uniqueName)
-        }
-      } catch {
-        // Skip types not in typesMap (e.g., inline types in generated workflow workers)
-      }
-    }
-  }
-
-  for (const wiringRoutes of Object.values(httpWiringsMeta)) {
-    for (const { inputTypes } of Object.values(wiringRoutes)) {
-      if (inputTypes?.body) {
-        schemasSet.add(inputTypes.body)
-      }
-      if (inputTypes?.query) {
-        schemasSet.add(inputTypes.query)
-      }
-      if (inputTypes?.params) {
-        schemasSet.add(inputTypes.params)
-      }
-    }
-  }
-
-  // Add additional types from schemasFromTypes config
-  if (additionalTypes) {
-    for (const type of additionalTypes) {
-      schemasSet.add(type)
-    }
-  }
-
-  const generator = createGenerator({
-    tsconfig,
-    skipTypeCheck: true,
-    topRef: false,
-    discriminatorType: 'open-api',
-    expose: 'export',
-    jsDoc: 'extended',
-    sortProps: true,
-    strictTuples: false,
-    encodeRefs: false,
-    additionalProperties,
-  })
-  const schemas: Record<string, JSONValue> = {}
-
-  schemasSet.forEach((schema) => {
-    try {
-      schemas[schema] = generator.createSchema(schema) as JSONValue
-    } catch (e) {
-      // Ignore rootless errors
-      if (e instanceof RootlessError) {
-        logger.error(
-          `[${ErrorCode.SCHEMA_NO_ROOT}] Error generating schema since it has no root: ${schema}`
-        )
-        return
-      }
-      logger.error(
-        `[${ErrorCode.SCHEMA_GENERATION_ERROR}] Error generating schema: ${schema}. Message: ${e.message}`
-      )
-    }
-  })
-
-  return schemas
-}
-
-export async function saveSchemas(
-  logger: CLILogger,
-  schemaParentDir: string,
-  schemas: Record<string, JSONValue>,
-  typesMap: TypesMap,
-  functionsMeta: FunctionsMeta,
-  supportsImportAttributes: boolean,
-  additionalTypes?: string[]
-) {
-  await writeFileInDir(
-    logger,
-    `${schemaParentDir}/register.gen.ts`,
-    'export const empty = null;'
-  )
-
-  const desiredSchemas = new Set<string>([
-    ...Object.values(functionsMeta)
-      .map(({ inputs, outputs }) => {
-        const types: (string | undefined)[] = []
-        if (inputs?.[0]) {
-          try {
-            types.push(typesMap.getUniqueName(inputs[0]))
-          } catch {
-            // Skip types not in typesMap (e.g., inline types in generated workflow workers)
-          }
-        }
-        if (outputs?.[0]) {
-          try {
-            types.push(typesMap.getUniqueName(outputs[0]))
-          } catch {
-            // Skip types not in typesMap (e.g., inline types in generated workflow workers)
-          }
-        }
-        return types
-      })
-      .flat()
-      .filter(
-        (s): s is string =>
-          !!s &&
-          !['boolean', 'string', 'number', 'null', 'undefined'].includes(s)
-      ),
-    ...typesMap.customTypes.keys(),
-    ...(additionalTypes || []),
-  ])
-
-  if (desiredSchemas.size === 0) {
-    logger.info(`• Skipping schemas since none found.\x1b[0m`)
-    return
-  }
-
-  await mkdir(`${schemaParentDir}/schemas`, { recursive: true })
-  await Promise.all(
-    Object.entries(schemas).map(async ([schemaName, schema]) => {
-      if (desiredSchemas.has(schemaName)) {
-        await writeFile(
-          `${schemaParentDir}/schemas/${schemaName}.schema.json`,
-          JSON.stringify(schema),
-          'utf-8'
-        )
-      }
-    })
-  )
-
-  // Only include schemas that were successfully generated
-  const availableSchemas = Array.from(desiredSchemas).filter(
-    (schema) => schemas[schema]
-  )
-
-  const schemaImports = availableSchemas
-    .map(
-      (schema) => `
-import * as ${schema} from './schemas/${schema}.schema.json' ${supportsImportAttributes ? `with { type: 'json' }` : ''}
-addSchema('${schema}', ${schema})
-`
-    )
-    .join('\n')
-
-  await writeFileInDir(
-    logger,
-    `${schemaParentDir}/register.gen.ts`,
-    `import { addSchema } from '@pikku/core/schema'
-${schemaImports}`,
-    { logWrite: true }
-  )
-}

package/src/utils/serialize-import-map.ts

@@ -1,102 +0,0 @@
-import { TypesMap } from '@pikku/inspector'
-import { getFileImportRelativePath } from './file-import-path.js'
-
-export const serializeImportMap = (
-  relativeToPath: string,
-  packageMappings: Record<string, string>,
-  typesMap: TypesMap,
-  requiredTypes: Set<string>
-) => {
-  const paths = new Map<string, string[]>()
-  Array.from(requiredTypes).forEach((requiredType) => {
-    let originalName, uniqueName, path
-
-    try {
-      const typeMeta = typesMap.getTypeMeta(requiredType)
-      originalName = typeMeta.originalName
-      uniqueName = typeMeta.uniqueName
-      path = typeMeta.path
-    } catch (e) {
-      // Handle missing types by trying to find a suitable import path
-      // Look through all existing types in the map to find a path that might contain this type
-      let foundPath: string | null = null
-
-      // Get all unique paths from the typesMap
-      const allPaths = new Set<string>()
-      typesMap.customTypes.forEach(({ type, references }) => {
-        references.forEach((ref) => {
-          try {
-            const refMeta = typesMap.getTypeMeta(ref)
-            if (refMeta.path) {
-              allPaths.add(refMeta.path)
-            }
-          } catch {
-            // Continue
-          }
-        })
-      })
-
-      // Also check direct types in the map
-      try {
-        const mapEntries = (typesMap as any).map?.entries?.() || []
-        for (const [_, typeMeta] of mapEntries) {
-          if (typeMeta.path) {
-            allPaths.add(typeMeta.path)
-          }
-        }
-      } catch {
-        // Continue
-      }
-
-      // For PascalCase types, prefer paths that look like type definition files
-      if (/^[A-Z]/.test(requiredType)) {
-        for (const candidatePath of allPaths) {
-          if (
-            candidatePath.includes('types') ||
-            candidatePath.includes('.d.')
-          ) {
-            foundPath = candidatePath
-            break
-          }
-        }
-
-        // If no types file found, use the first available path
-        if (!foundPath && allPaths.size > 0) {
-          foundPath = Array.from(allPaths)[0] || null
-        }
-      }
-
-      if (foundPath) {
-        originalName = requiredType
-        uniqueName = requiredType
-        path = foundPath
-      } else {
-        // No suitable path found, skip
-        return
-      }
-    }
-
-    if (!path) {
-      // This is a custom type that exists in file, so we don't need to import it
-      return
-    }
-    const variables = paths.get(path) || []
-
-    const importName =
-      originalName === uniqueName
-        ? originalName
-        : `${originalName} as ${uniqueName}`
-    if (!variables.includes(importName)) {
-      variables.push(importName)
-    }
-    paths.set(path, variables)
-  })
-
-  const imports: string[] = []
-  for (const [path, variables] of paths.entries()) {
-    imports.push(
-      `import type { ${variables.join(', ')} } from '${getFileImportRelativePath(relativeToPath, path, packageMappings)}'`
-    )
-  }
-  return imports.join('\n')
-}

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": ".",
-    "module": "Node18",
-    "outDir": "dist",
-    "target": "esnext",
-    "declaration": true,
-    "resolveJsonModule": true
-  },
-  "include": ["bin/**/*.ts", "src/**/*.ts", ".pikku/**/*.ts", "types/*.ts"],
-  "exclude": ["**/*.test.ts", "node_modules"],
-  "references": [
-    {
-      "path": "../core/tsconfig.json"
-    },
-    {
-      "path": "../inspector/tsconfig.json"
-    }
-  ]
-}

package/types/application-types.d.ts

@@ -1,27 +0,0 @@
-import type {
-  CoreConfig,
-  CoreServices,
-  CoreSingletonServices,
-  CoreUserSession,
-} from '@pikku/core'
-import type { CLILogger } from '../src/services/cli-logger.service.js'
-import { PikkuCLIConfig } from '../types/config.d.ts'
-import { InspectorState } from '@pikku/inspector'
-
-export interface Config extends CoreConfig<PikkuCLIConfig> {
-  // Preloaded inspector state from stateInput file (if provided)
-  preloadedInspectorState?: Omit<InspectorState, 'typesLookup'>
-}
-
-export interface SingletonServices extends CoreSingletonServices<Config> {
-  logger: CLILogger
-  getInspectorState: (
-    refresh?: boolean,
-    setupOnly?: boolean,
-    bootstrapMode?: boolean
-  ) => Promise<InspectorState>
-}
-
-export interface Services extends CoreServices<SingletonServices> {}
-
-export interface UserSession extends CoreUserSession {}

package/types/config.d.ts

@@ -1,270 +0,0 @@
-import { InspectorFilters } from '@pikku/inspector'
-import { OpenAPISpecInfo } from '../src/functions/wirings/http/openapi-spec-generator.ts'
-import { PikkuWiringTypes } from '@pikku/core'
-
-export interface PikkuCLICoreOutputFiles {
-  // Base directory
-  outDir: string
-
-  // Schema and types
-  schemaDirectory: string
-  typesDeclarationFile: string
-
-  // Function definitions
-  functionsFile: string
-  functionsMetaFile: string
-  functionsMetaJsonFile: string
-  functionsMetaMinFile: string
-  functionsMetaMinJsonFile: string
-  functionTypesFile: string
-
-  // HTTP
-  httpWiringsFile: string
-  httpWiringMetaFile: string
-  httpWiringMetaJsonFile: string
-  httpMapDeclarationFile: string
-  httpTypesFile: string
-
-  // Channels
-  channelsWiringFile: string
-  channelsWiringMetaFile: string
-  channelsWiringMetaJsonFile: string
-  channelsMapDeclarationFile: string
-  channelsTypesFile: string
-
-  // RPC Internal
-  rpcInternalWiringMetaFile: string
-  rpcInternalWiringMetaJsonFile: string
-  rpcInternalMapDeclarationFile: string
-
-  // RPC Exposed
-  rpcMapDeclarationFile: string
-
-  // Schedulers
-  schedulersWiringFile: string
-  schedulersWiringMetaFile: string
-  schedulersWiringMetaJsonFile: string
-  schedulersTypesFile: string
-
-  // Queue processors
-  queueWorkersWiringFile: string
-  queueWorkersWiringMetaFile: string
-  queueWorkersWiringMetaJsonFile: string
-  queueMapDeclarationFile: string
-  queueTypesFile: string
-
-  // Workflows
-  workflowsWiringFile: string
-  workflowsWiringMetaFile: string
-  workflowsWiringMetaJsonFile: string
-  workflowsWorkersFile: string
-  workflowMapDeclarationFile: string
-  workflowTypesFile: string
-
-  // MCP
-  mcpWiringsFile: string
-  mcpWiringsMetaFile: string
-  mcpWiringsMetaJsonFile: string
-  mcpTypesFile: string
-
-  // CLI
-  cliWiringsFile: string
-  cliWiringMetaFile: string
-  cliWiringMetaJsonFile: string
-  cliBootstrapFile: string
-  cliTypesFile: string
-
-  // Services
-  servicesFile: string
-
-  // Middleware
-  middlewareFile: string
-  middlewareGroupsMetaFile: string
-  middlewareGroupsMetaJsonFile: string
-
-  // Permissions
-  permissionsFile: string
-
-  // Application bootstrap
-  bootstrapFile: string
-}
-
-export type PikkuCLIInput = {
-  $schema?: string
-
-  extends?: string
-
-  rootDir: string
-  srcDirectories: string[]
-  ignoreFiles?: string[]
-  packageMappings: Record<string, string>
-
-  configDir: string
-  tsconfig: string
-
-  nextBackendFile?: string
-  nextHTTPFile?: string
-  fetchFile?: string
-  websocketFile?: string
-  rpcWiringsFile?: string
-  queueWiringsFile?: string
-  mcpJsonFile?: string
-
-  openAPI?: {
-    outputFile: string
-    additionalInfo: OpenAPISpecInfo
-  }
-
-  schema?: {
-    additionalProperties?: boolean
-    supportsImportAttributes?: boolean
-  }
-
-  cli?: {
-    entrypoints?: Record<
-      string,
-      | string
-      | { type: 'local'; path: string }
-      | {
-          type: 'channel'
-          name?: string
-          route?: string
-          wirePath: string
-          path?: string
-        }
-      | Array<
-          | string
-          | { type: 'local'; path: string }
-          | {
-              type: 'channel'
-              name?: string
-              route?: string
-              wirePath: string
-              path?: string
-            }
-        >
-    >
-  }
-
-  workflows?:
-    | {
-        singleQueue: true
-        path: string
-        orchestratorQueue?: string
-        workerQueue?: string
-      }
-    | {
-        singleQueue: false
-        dir: string
-        orchestratorQueuePrefix?: string
-        workerQueuePrefix?: string
-      }
-
-  rpc?: {
-    remoteRpcWorkersPath?: string
-    publicRpcPath?: string
-  }
-
-  forceRequiredServices?: string[]
-
-  schemasFromTypes?: string[]
-
-  stateOutput?: string
-  stateInput?: string
-
-  filters: InspectorFilters
-} & PikkuCLICoreOutputFiles
-
-export type PikkuCLIConfig = {
-  $schema?: string
-
-  extends?: string
-
-  rootDir: string
-  srcDirectories: string[]
-  ignoreFiles?: string[]
-  packageMappings: Record<string, string>
-
-  configFile?: string
-  tags?: string[]
-  types?: string[]
-
-  userSessionType?: string
-  singletonServicesFactoryType?: string
-  wireServicesFactoryType?: string
-
-  configDir: string
-  tsconfig: string
-
-  nextBackendFile?: string
-  nextHTTPFile?: string
-  fetchFile?: string
-  websocketFile?: string
-  rpcWiringsFile?: string
-  queueWiringsFile?: string
-  mcpJsonFile?: string
-
-  openAPI?: {
-    outputFile: string
-    additionalInfo: OpenAPISpecInfo
-  }
-
-  schema?: {
-    additionalProperties?: boolean
-    supportsImportAttributes?: boolean
-  }
-
-  cli?: {
-    entrypoints?: Record<
-      string,
-      | string
-      | { type: 'local'; path: string }
-      | {
-          type: 'channel'
-          name?: string
-          route?: string
-          wirePath: string
-          path?: string
-        }
-      | Array<
-          | string
-          | { type: 'local'; path: string }
-          | {
-              type: 'channel'
-              name?: string
-              route?: string
-              wirePath: string
-              path?: string
-            }
-        >
-    >
-  }
-
-  workflows?:
-    | {
-        singleQueue: true
-        path: string
-        orchestratorQueue?: string
-        workerQueue?: string
-      }
-    | {
-        singleQueue: false
-        dir: string
-        orchestratorQueuePrefix?: string
-        workerQueuePrefix?: string
-      }
-
-  rpc?: {
-    remoteRpcWorkersPath?: string
-    publicRpcPath?: string
-  }
-
-  forceRequiredServices?: string[]
-
-  schemasFromTypes?: string[]
-
-  stateOutput?: string
-  stateInput?: string
-
-  filters: InspectorFilters
-} & PikkuCLICoreOutputFiles