@pikku/cli 0.9.14 → 0.9.16-next.0

package/src/utils/pikku-files-and-methods.ts

@@ -0,0 +1,148 @@
+import {
+  PathToNameAndType,
+  InspectorState,
+  InspectorOptions,
+} from '@pikku/inspector'
+
+interface Meta {
+  file: string
+  variable: string
+  type: string
+  typePath: string
+  errors: Map<string, string[]>
+}
+
+export type FilesAndMethods = {
+  userSessionType: Meta
+  sessionServicesType: Meta
+  singletonServicesType: Meta
+  pikkuConfigFactory: Meta
+  singletonServicesFactory: Meta
+  sessionServicesFactory: Meta
+}
+
+const getMetaTypes = (
+  type: string,
+  map: PathToNameAndType,
+  desiredType?: string
+): Meta | undefined => {
+  const errors = new Map()
+
+  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, 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`
+    errors.set(helpMessage, map)
+  } else if (totalValues.length > 1) {
+    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, errors }
+    }
+  }
+
+  return
+}
+
+/**
+ * @deprecated Use state.filesAndMethods from InspectorState instead
+ */
+export const getPikkuFilesAndMethods = async (
+  state: InspectorState,
+  options: InspectorOptions['types'] = {}
+): Promise<FilesAndMethods> => {
+  const {
+    singletonServicesTypeImportMap,
+    sessionServicesTypeImportMap,
+    userSessionTypeImportMap,
+    sessionServicesFactories,
+    singletonServicesFactories,
+    configFactories,
+  } = state
+
+  const {
+    configFileType,
+    userSessionType,
+    singletonServicesFactoryType,
+    sessionServicesFactoryType,
+  } = options
+  let errors = new Map<string, PathToNameAndType>()
+
+  const result: Partial<FilesAndMethods> = {
+    userSessionType: getMetaTypes(
+      'CoreUserSession',
+      userSessionTypeImportMap,
+      userSessionType
+    ),
+    singletonServicesType: getMetaTypes(
+      'CoreSingletonServices',
+      singletonServicesTypeImportMap
+    ),
+    sessionServicesType: getMetaTypes(
+      'CoreServices',
+      sessionServicesTypeImportMap
+    ),
+    pikkuConfigFactory: getMetaTypes(
+      'CoreConfig',
+      configFactories,
+      configFileType
+    ),
+    singletonServicesFactory: getMetaTypes(
+      'CreateSingletonServices',
+      singletonServicesFactories,
+      singletonServicesFactoryType
+    ),
+    sessionServicesFactory: getMetaTypes(
+      'CreateSessionServices',
+      sessionServicesFactories,
+      sessionServicesFactoryType
+    ),
+  }
+
+  if (errors.size > 0) {
+    const result: string[] = ['Found errors:']
+    errors.forEach((filesAndMethods, message) => {
+      result.push(`- ${message}`)
+      filesAndMethods.forEach((methods, file) => {
+        result.push(
+          `\t* methods: ${methods.map(({ variable, type }) => `${variable}: ${type}`).join(', ')}`
+        )
+      })
+    })
+    throw new Error(result.join('\n'))
+  }
+
+  return result as FilesAndMethods
+}

package/src/{schema-generator.ts → utils/schema-generator.ts}

@@ -1,9 +1,10 @@
 import { createGenerator, RootlessError } from 'ts-json-schema-generator'
-import { CLILogger, writeFileInDir } from './utils.js'
+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 } from '@pikku/inspector'
+import { CLILogger } from '../services/cli-logger.service.js'
 
 export async function generateSchemas(
   logger: CLILogger,
@@ -58,6 +59,7 @@ export async function generateSchemas(
     additionalProperties: false,
   })
   const schemas: Record<string, JSONValue> = {}
+
   schemasSet.forEach((schema) => {
     try {
       schemas[schema] = generator.createSchema(schema) as JSONValue

package/src/{serialize-import-map.ts → utils/serialize-import-map.ts}

@@ -1,5 +1,5 @@
 import { TypesMap } from '@pikku/inspector'
-import { getFileImportRelativePath } from './utils.js'
+import { getFileImportRelativePath } from './file-import-path.js'
 
 export const serializeImportMap = (
   relativeToPath: string,

package/tsconfig.json

@@ -8,8 +8,8 @@
     "declaration": true,
     "resolveJsonModule": true
   },
-  "include": ["bin/**/*.ts", "src/**/*.ts"],
-  "exclude": ["**/*.test.ts", "node_modules", "bin/dist"],
+  "include": ["bin/**/*.ts", "src/**/*.ts", ".pikku/**/*.ts", "types/*.ts"],
+  "exclude": ["**/*.test.ts", "node_modules"],
   "references": [
     {
       "path": "../core/tsconfig.json"

package/types/application-types.d.ts

@@ -0,0 +1,20 @@
+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> {}
+
+export interface SingletonServices extends CoreSingletonServices<Config> {
+  logger: CLILogger
+  getInspectorState: (refresh?: boolean = false) => Promise<InspectorState>
+}
+
+export interface Services extends CoreServices<SingletonServices, {}> {}
+
+export interface UserSession extends CoreUserSession {}

package/types/config.d.ts

@@ -0,0 +1,192 @@
+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
+  functionsMetaMinFile: string
+  functionTypesFile: string
+
+  // HTTP
+  httpWiringsFile: string
+  httpWiringMetaFile: string
+  httpMapDeclarationFile: string
+  httpTypesFile: string
+
+  // Channels
+  channelsWiringFile: string
+  channelsWiringMetaFile: string
+  channelsMapDeclarationFile: string
+  channelsTypesFile: string
+
+  // RPC Internal
+  rpcInternalWiringMetaFile: string
+  rpcInternalMapDeclarationFile: string
+
+  // RPC Exposed
+  rpcMapDeclarationFile: string
+
+  // Schedulers
+  schedulersWiringFile: string
+  schedulersWiringMetaFile: string
+  schedulersTypesFile: string
+
+  // Queue processors
+  queueWorkersWiringFile: string
+  queueWorkersWiringMetaFile: string
+  queueMapDeclarationFile: string
+  queueTypesFile: string
+
+  // MCP
+  mcpWiringsFile: string
+  mcpWiringsMetaFile: string
+  mcpTypesFile: string
+
+  // CLI
+  cliWiringsFile: string
+  cliWiringMetaFile: string
+  cliBootstrapFile: string
+  cliTypesFile: string
+
+  // Services
+  servicesFile: string
+
+  // Middleware
+  middlewareFile: string
+  middlewareGroupsMetaFile: string
+
+  // Application bootstrap
+  bootstrapFile: string
+  bootstrapFiles: Record<PikkuWiringTypes, string>
+}
+
+export type PikkuCLIInput = {
+  $schema?: string
+
+  extends?: string
+
+  rootDir: string
+  srcDirectories: string[]
+  packageMappings: Record<string, string>
+  supportsImportAttributes: boolean
+
+  configDir: string
+  tsconfig: string
+
+  nextBackendFile?: string
+  nextHTTPFile?: string
+  fetchFile?: string
+  websocketFile?: string
+  rpcWiringsFile?: string
+  queueWiringsFile?: string
+  mcpJsonFile?: string
+
+  openAPI?: {
+    outputFile: string
+    additionalInfo: OpenAPISpecInfo
+  }
+
+  cli?: {
+    entrypoints?: Record<
+      string,
+      | string
+      | { type: 'cli'; path: string }
+      | {
+          type: 'channel'
+          name?: string
+          route?: string
+          wirePath: string
+          path?: string
+        }
+      | Array<
+          | string
+          | { type: 'cli'; path: string }
+          | {
+              type: 'channel'
+              name?: string
+              route?: string
+              wirePath: string
+              path?: string
+            }
+        >
+    >
+  }
+
+  middlewareServices?: string[]
+
+  schemasFromTypes?: string[]
+
+  filters: InspectorFilters
+} & PikkuCLICoreOutputFiles
+
+export type PikkuCLIConfig = {
+  $schema?: string
+
+  extends?: string
+
+  rootDir: string
+  srcDirectories: string[]
+  packageMappings: Record<string, string>
+  supportsImportAttributes: boolean
+
+  configFile?: string
+  tags?: string[]
+  types?: string[]
+
+  configDir: string
+  tsconfig: string
+
+  nextBackendFile?: string
+  nextHTTPFile?: string
+  fetchFile?: string
+  websocketFile?: string
+  rpcWiringsFile?: string
+  queueWiringsFile?: string
+  mcpJsonFile?: string
+
+  openAPI?: {
+    outputFile: string
+    additionalInfo: OpenAPISpecInfo
+  }
+
+  cli?: {
+    entrypoints?: Record<
+      string,
+      | string
+      | { type: 'cli'; path: string }
+      | {
+          type: 'channel'
+          name?: string
+          route?: string
+          wirePath: string
+          path?: string
+        }
+      | Array<
+          | string
+          | { type: 'cli'; path: string }
+          | {
+              type: 'channel'
+              name?: string
+              route?: string
+              wirePath: string
+              path?: string
+            }
+        >
+    >
+  }
+
+  middlewareServices?: string[]
+
+  schemasFromTypes?: string[]
+
+  filters: InspectorFilters
+} & PikkuCLICoreOutputFiles