@pikku/cli 0.9.14 → 0.9.16-next.0

package/src/utils/check-required-types.ts

@@ -0,0 +1,53 @@
+import { FilesAndMethodsErrors } from '@pikku/inspector'
+
+export type RequiredTypes = Partial<{
+  config: boolean
+  sessionServiceType: boolean
+  singletonServicesType: boolean
+  userSessionType: boolean
+  singletonServicesFactory: boolean
+  sessionServicesFactory: boolean
+}>
+
+export const checkRequiredTypes = (
+  errors: FilesAndMethodsErrors,
+  requires: RequiredTypes = {}
+): void => {
+  // Only throw if there are errors AND we require those types
+  const hasRequiredErrors = Array.from(errors.keys()).some((message) => {
+    if (requires.config && message.includes('CoreConfig')) return true
+    if (requires.sessionServiceType && message.includes('CoreServices'))
+      return true
+    if (
+      requires.singletonServicesType &&
+      message.includes('CoreSingletonServices')
+    )
+      return true
+    if (requires.userSessionType && message.includes('CoreUserSession'))
+      return true
+    if (
+      requires.singletonServicesFactory &&
+      message.includes('CreateSingletonServices')
+    )
+      return true
+    if (
+      requires.sessionServicesFactory &&
+      message.includes('CreateSessionServices')
+    )
+      return true
+    return false
+  })
+
+  if (hasRequiredErrors) {
+    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'))
+  }
+}

package/src/utils/custom-types-generator.ts

@@ -0,0 +1,49 @@
+import { TypesMap } from '@pikku/inspector'
+
+export function generateCustomTypes(
+  typesMap: TypesMap,
+  requiredTypes: Set<string>
+) {
+  return `
+// Custom types are those that are defined directly within generics
+// or are broken into simpler types
+${Array.from(typesMap.customTypes.entries())
+  .map(([name, { type, references }]) => {
+    references.forEach((name) => {
+      requiredTypes.add(name)
+    })
+
+    // Extract type names from the type string that might not be in references
+    const typeString = type
+    // Use regex to extract potential type names (PascalCase identifiers)
+    const typeNameRegex = /\b[A-Z][a-zA-Z0-9]*\b/g
+    const potentialTypes = typeString.match(typeNameRegex) || []
+
+    potentialTypes.forEach((typeName) => {
+      // Skip string literals and common keywords
+      if (
+        typeString.includes(`"${typeName}"`) ||
+        ['Pick', 'Omit', 'Partial', 'Required', 'Record', 'Readonly'].includes(
+          typeName
+        )
+      ) {
+        return
+      }
+
+      // Try to find this type in the typesMap and add it if found
+      try {
+        const typeMeta = typesMap.getTypeMeta(typeName)
+        if (typeMeta.path) {
+          // Add originalName to preserve canonical import name
+          requiredTypes.add(typeMeta.originalName)
+        }
+      } catch (e) {
+        // Type not found in map (ambient/builtin type) - ignore it
+        // Do NOT add to requiredTypes to avoid crashes in serializeImportMap
+      }
+    })
+
+    return `export type ${name} = ${type}`
+  })
+  .join('\n')}`
+}

package/src/{utils.test.ts → utils/file-import-path.test.ts}

@@ -1,6 +1,6 @@
 import { strict as assert } from 'assert'
 import { describe, test } from 'node:test'
-import { getFileImportRelativePath } from './utils.js'
+import { getFileImportRelativePath } from './file-import-path.js'
 
 describe('getFileImportRelativePath', () => {
   test('should return relative path for files in same directory', () => {

package/src/utils/file-import-path.ts

@@ -0,0 +1,53 @@
+import { relative, dirname, resolve } from 'path'
+
+export const getFileImportRelativePath = (
+  from: string,
+  to: string,
+  packageMappings: Record<string, string>
+): string => {
+  let filePath = relative(dirname(from), to)
+  if (!/^\.+\//.test(filePath)) {
+    filePath = `./${filePath}`
+  }
+
+  // If the path includes node_modules, strip everything before and including node_modules/
+  if (filePath.includes('node_modules')) {
+    const nodeModulesIndex = filePath.indexOf('node_modules/')
+    if (nodeModulesIndex !== -1) {
+      filePath = filePath.substring(nodeModulesIndex + 'node_modules/'.length)
+    }
+    return filePath.replace('.ts', '.js')
+  }
+
+  const absolutePath = resolve(dirname(from), to)
+  const fromAbsolutePath = resolve(dirname(from))
+
+  // Check if both files are in the same package directory
+  // If so, skip packageMappings to use relative paths
+  let inSamePackage = false
+  for (const [path] of Object.entries(packageMappings)) {
+    if (absolutePath.includes(path) && fromAbsolutePath.includes(path)) {
+      inSamePackage = true
+      break
+    }
+  }
+
+  // Only apply packageMappings if files are not in the same package
+  if (!inSamePackage) {
+    // let usesPackageName = false
+    for (const [path, packageName] of Object.entries(packageMappings)) {
+      if (absolutePath.includes(path)) {
+        // usesPackageName = true
+        // Use string slicing instead of regex to avoid ReDoS and ensure correct behavior
+        const pathIndex = absolutePath.indexOf(path)
+        filePath = packageName + absolutePath.slice(pathIndex + path.length)
+        break
+      }
+    }
+  }
+
+  // if (usesPackageName) {
+  //   return filePath.replace('.ts', '')
+  // }
+  return filePath.replace('.ts', '.js')
+}

package/src/utils/file-imports-serializer.ts

@@ -0,0 +1,25 @@
+import { getFileImportRelativePath } from './file-import-path.js'
+
+export const serializeFileImports = (
+  importType: string,
+  outputPath: string,
+  files: Set<string>,
+  packageMappings: Record<string, string> = {}
+) => {
+  const serializedOutput: string[] = [
+    `/* The files with an ${importType} function call */`,
+  ]
+
+  Array.from(files)
+    .sort()
+    .forEach((path) => {
+      const filePath = getFileImportRelativePath(
+        outputPath,
+        path,
+        packageMappings
+      )
+      serializedOutput.push(`import '${filePath}'`)
+    })
+
+  return serializedOutput.join('\n')
+}

package/src/utils/file-writer.ts

@@ -0,0 +1,56 @@
+import { dirname } from 'path'
+import { mkdir, readFile, writeFile } from 'fs/promises'
+import { CLILogger } from '../services/cli-logger.service.js'
+
+// TODO: add version back in once the ESM dust settles
+export const DO_NOT_MODIFY_COMMENT = `/**
+ * This file was generated by the @pikku/cli
+ */
+`
+
+export const writeFileInDir = async (
+  logger: CLILogger,
+  path: string,
+  content: string,
+  {
+    ignoreModifyComment = false,
+    logWrite = true,
+  }: { ignoreModifyComment?: boolean; logWrite?: boolean } = {}
+) => {
+  if (path.includes('.json')) {
+    ignoreModifyComment = true
+  }
+
+  if (content.includes('server-only')) {
+    content = content.replace(
+      "'server-only'",
+      `'server-only'\n\n${ignoreModifyComment ? '' : DO_NOT_MODIFY_COMMENT}`
+    )
+  } else {
+    content = `${ignoreModifyComment ? '' : DO_NOT_MODIFY_COMMENT}${content}`
+  }
+
+  // Try to read existing file content
+  let existingContent: string | undefined
+  try {
+    existingContent = await readFile(path, 'utf-8')
+  } catch (error) {
+    // Only suppress ENOENT (file not found) errors
+    // Rethrow permission, I/O, encoding, or other errors
+    const nodeError = error as NodeJS.ErrnoException
+    if (nodeError.code !== 'ENOENT') {
+      throw error
+    }
+    // File doesn't exist, so we need to write it
+  }
+
+  // Only write if content has changed or file doesn't exist
+  if (existingContent !== content) {
+    await mkdir(dirname(path), { recursive: true })
+    await writeFile(path, content, 'utf-8')
+
+    if (logWrite) {
+      logger.info({ message: `✓ File written to ${path}`, type: 'success' })
+    }
+  }
+}

package/src/utils/generate-bootstrap-file.ts

@@ -0,0 +1,43 @@
+import { Config } from '../../types/application-types.js'
+import { CLILogger } from '../services/cli-logger.service.js'
+import { getFileImportRelativePath } from './file-import-path.js'
+import { writeFileInDir } from './file-writer.js'
+
+export const generateBootstrapFile = async (
+  logger: CLILogger,
+  config: Config,
+  bootstrapFile: string,
+  specificImports: string[],
+  schemas?: boolean,
+  hasMiddleware?: boolean
+) => {
+  // Common imports that every bootstrap file needs
+  const commonImports: string[] = []
+
+  // Add middleware first (must be registered before functions meta)
+  if (hasMiddleware) {
+    commonImports.push(config.middlewareFile)
+  }
+
+  commonImports.push(config.functionsMetaMinFile, config.functionsFile)
+
+  // Add schema if it exists
+  if (schemas) {
+    commonImports.push(`${config.schemaDirectory}/register.gen.ts`)
+  }
+
+  // Combine common imports with specific imports
+  const allImports = [...commonImports, ...specificImports]
+
+  await writeFileInDir(
+    logger,
+    bootstrapFile,
+    allImports
+      .map(
+        (to) =>
+          `import '${getFileImportRelativePath(bootstrapFile, to, config.packageMappings)}'`
+      )
+      .sort((to) => (to.includes('meta') ? -1 : 1)) // Ensure meta files are at the top
+      .join('\n')
+  )
+}

package/src/utils/pikku-cli-config.ts

@@ -0,0 +1,356 @@
+import { join, dirname, resolve, isAbsolute } from 'path'
+import { readdir, readFile } from 'fs/promises'
+import { PikkuCLIConfig } from '../../types/config.js'
+import { InspectorFilters } from '@pikku/inspector'
+import { PikkuWiringTypes } from '@pikku/core'
+import { CLILogger } from '../services/cli-logger.service.js'
+
+const CONFIG_DIR_FILES = [
+  'nextBackendFile',
+  'nextHTTPFile',
+  'fetchFile',
+  'websocketFile',
+  'rpcWiringsFile',
+  'queueWiringsFile',
+  'mcpJsonFile',
+]
+
+export const getPikkuCLIConfig = async (
+  logger: CLILogger,
+  configFile: string | undefined = undefined,
+  requiredFields: Array<keyof PikkuCLIConfig>,
+  filters: InspectorFilters = {},
+  exitProcess: boolean = false
+): Promise<PikkuCLIConfig> => {
+  const config = await _getPikkuCLIConfig(
+    logger,
+    configFile,
+    requiredFields,
+    filters,
+    exitProcess
+  )
+  return config
+}
+
+const _getPikkuCLIConfig = async (
+  logger: CLILogger,
+  configFile: string | undefined = undefined,
+  requiredFields: Array<keyof PikkuCLIConfig>,
+  filters: InspectorFilters = {},
+  exitProcess: boolean = false
+): Promise<PikkuCLIConfig> => {
+  if (!configFile) {
+    let execDirectory = process.cwd()
+    const files = await readdir(execDirectory)
+    const file = files.find((file) => /pikku\.config\.(ts|js|json)$/.test(file))
+    if (!file) {
+      throw new Error('Config file pikku.config.json not found')
+    }
+    configFile = join(execDirectory, file)
+  }
+
+  try {
+    let result: PikkuCLIConfig
+    const file = await readFile(configFile, 'utf-8')
+    const configDir = dirname(configFile)
+    const config: PikkuCLIConfig = JSON.parse(file)
+    if (config.extends) {
+      const extendedConfig = await getPikkuCLIConfig(
+        logger,
+        resolve(configDir, config.extends),
+        [],
+        filters,
+        exitProcess
+      )
+      result = {
+        ...extendedConfig,
+        ...config,
+        configDir,
+        packageMappings: {
+          ...extendedConfig.packageMappings,
+          ...config.packageMappings,
+        },
+      }
+    } else {
+      result = {
+        ...config,
+        configDir,
+        packageMappings: config.packageMappings || {},
+        rootDir: config.rootDir
+          ? resolve(configDir, config.rootDir)
+          : configDir,
+      }
+    }
+
+    // Create transport/event directories
+    const functionDir = join(result.outDir, 'function')
+    const httpDir = join(result.outDir, 'http')
+    const channelDir = join(result.outDir, 'channel')
+    const rpcDir = join(result.outDir, 'rpc')
+    const schedulerDir = join(result.outDir, 'scheduler')
+    const queueDir = join(result.outDir, 'queue')
+    const mcpDir = join(result.outDir, 'mcp')
+    const cliDir = join(result.outDir, 'cli')
+    const middlewareDir = join(result.outDir, 'middleware')
+
+    // Create directories if they don't exist (will be done lazily when files are written)
+
+    if (!result.schemaDirectory) {
+      result.schemaDirectory = join(result.outDir, 'schemas')
+    }
+
+    // Functions
+    if (!result.functionsFile) {
+      result.functionsFile = join(functionDir, 'pikku-functions.gen.ts')
+    }
+    if (!result.functionsMetaFile) {
+      result.functionsMetaFile = join(
+        functionDir,
+        'pikku-functions-meta.gen.ts'
+      )
+    }
+    if (!result.functionsMetaMinFile) {
+      result.functionsMetaMinFile = join(
+        functionDir,
+        'pikku-functions-meta.min.gen.ts'
+      )
+    }
+    if (!result.functionTypesFile) {
+      result.functionTypesFile = join(
+        functionDir,
+        'pikku-function-types.gen.ts'
+      )
+    }
+    if (!result.typesDeclarationFile) {
+      result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.ts')
+    }
+
+    // HTTP
+    if (!result.httpWiringsFile) {
+      result.httpWiringsFile = join(httpDir, 'pikku-http-wirings.gen.ts')
+    }
+    if (!result.httpWiringMetaFile) {
+      result.httpWiringMetaFile = join(
+        httpDir,
+        'pikku-http-wirings-meta.gen.ts'
+      )
+    }
+    if (!result.httpMapDeclarationFile) {
+      result.httpMapDeclarationFile = join(
+        httpDir,
+        'pikku-http-wirings-map.gen.d.ts'
+      )
+    }
+    if (!result.httpTypesFile) {
+      result.httpTypesFile = join(httpDir, 'pikku-http-types.gen.ts')
+    }
+
+    // Channels/WebSocket
+    if (!result.channelsWiringFile) {
+      result.channelsWiringFile = join(channelDir, 'pikku-channels.gen.ts')
+    }
+    if (!result.channelsWiringMetaFile) {
+      result.channelsWiringMetaFile = join(
+        channelDir,
+        'pikku-channels-meta.gen.ts'
+      )
+    }
+    if (!result.channelsMapDeclarationFile) {
+      result.channelsMapDeclarationFile = join(
+        channelDir,
+        'pikku-channels-map.gen.d.ts'
+      )
+    }
+    if (!result.channelsTypesFile) {
+      result.channelsTypesFile = join(channelDir, 'pikku-channel-types.gen.ts')
+    }
+
+    // RPC (internal and external)
+    if (!result.rpcInternalWiringMetaFile) {
+      result.rpcInternalWiringMetaFile = join(
+        rpcDir,
+        'pikku-rpc-wirings-meta.internal.gen.ts'
+      )
+    }
+
+    if (!result.rpcInternalMapDeclarationFile) {
+      result.rpcInternalMapDeclarationFile = join(
+        rpcDir,
+        'pikku-rpc-wirings-map.internal.gen.d.ts'
+      )
+    }
+
+    if (!result.rpcMapDeclarationFile) {
+      result.rpcMapDeclarationFile = join(
+        rpcDir,
+        'pikku-rpc-wirings-map.gen.d.ts'
+      )
+    }
+
+    // Scheduler
+    if (!result.schedulersWiringFile) {
+      result.schedulersWiringFile = join(
+        schedulerDir,
+        'pikku-schedulers-wirings.gen.ts'
+      )
+    }
+    if (!result.schedulersWiringMetaFile) {
+      result.schedulersWiringMetaFile = join(
+        schedulerDir,
+        'pikku-schedulers-wirings-meta.gen.ts'
+      )
+    }
+    if (!result.schedulersTypesFile) {
+      result.schedulersTypesFile = join(
+        schedulerDir,
+        'pikku-scheduler-types.gen.ts'
+      )
+    }
+
+    // Queue
+    if (!result.queueWorkersWiringFile) {
+      result.queueWorkersWiringFile = join(
+        queueDir,
+        'pikku-queue-workers-wirings.gen.ts'
+      )
+    }
+    if (!result.queueWorkersWiringMetaFile) {
+      result.queueWorkersWiringMetaFile = join(
+        queueDir,
+        'pikku-queue-workers-wirings-meta.gen.ts'
+      )
+    }
+    if (!result.queueMapDeclarationFile) {
+      result.queueMapDeclarationFile = join(
+        queueDir,
+        'pikku-queue-workers-wirings-map.gen.d.ts'
+      )
+    }
+    if (!result.queueTypesFile) {
+      result.queueTypesFile = join(queueDir, 'pikku-queue-types.gen.ts')
+    }
+
+    // Services
+    if (!result.servicesFile) {
+      result.servicesFile = join(result.outDir, 'pikku-services.gen.ts')
+    }
+
+    // Middleware
+    if (!result.middlewareFile) {
+      result.middlewareFile = join(middlewareDir, 'pikku-middleware.gen.ts')
+    }
+    if (!result.middlewareGroupsMetaFile) {
+      result.middlewareGroupsMetaFile = join(
+        middlewareDir,
+        'pikku-middleware-groups-meta.gen.ts'
+      )
+    }
+
+    // Bootstrap files
+    if (!result.bootstrapFile) {
+      result.bootstrapFile = join(result.outDir, 'pikku-bootstrap.gen.ts')
+    }
+
+    // MCP
+    if (!result.mcpWiringsMetaFile) {
+      result.mcpWiringsMetaFile = join(mcpDir, 'pikku-mcp-wirings-meta.gen.ts')
+    }
+    if (!result.mcpWiringsFile) {
+      result.mcpWiringsFile = join(mcpDir, 'pikku-mcp-wirings.gen.ts')
+    }
+    if (!result.mcpJsonFile) {
+      result.mcpJsonFile = join(mcpDir, 'pikku-mcp.gen.json')
+    }
+    if (!result.mcpTypesFile) {
+      result.mcpTypesFile = join(mcpDir, 'pikku-mcp-types.gen.ts')
+    }
+
+    // CLI
+    if (!result.cliWiringsFile) {
+      result.cliWiringsFile = join(cliDir, 'pikku-cli-wirings.gen.ts')
+    }
+    if (!result.cliWiringMetaFile) {
+      result.cliWiringMetaFile = join(cliDir, 'pikku-cli-wirings-meta.gen.ts')
+    }
+    if (!result.cliBootstrapFile) {
+      result.cliBootstrapFile = join(cliDir, 'pikku-cli-bootstrap.gen.ts')
+    }
+    if (!result.cliTypesFile) {
+      result.cliTypesFile = join(cliDir, 'pikku-cli-types.gen.ts')
+    }
+
+    result.bootstrapFiles = result.bootstrapFiles || {}
+    for (const key of Object.keys(PikkuWiringTypes)) {
+      const eventDir = join(result.outDir, key.toLowerCase())
+      result.bootstrapFiles[key] = join(
+        eventDir,
+        `pikku-bootstrap-${key}.gen.ts`
+      )
+    }
+
+    if (requiredFields.length > 0) {
+      validateCLIConfig(result, requiredFields)
+    }
+
+    for (const objectKey of Object.keys(result)) {
+      if (objectKey.endsWith('File') || objectKey.endsWith('Directory')) {
+        const relativeTo = CONFIG_DIR_FILES.includes(objectKey)
+          ? result.configDir
+          : result.rootDir
+        // Only normalize string values to avoid corrupting nested objects
+        if (result[objectKey] && typeof result[objectKey] === 'string') {
+          if (!isAbsolute(result[objectKey])) {
+            result[objectKey] = join(relativeTo, result[objectKey])
+          }
+        }
+      }
+    }
+
+    // Separately normalize bootstrapFiles (Record<string, string>)
+    if (result.bootstrapFiles && typeof result.bootstrapFiles === 'object') {
+      for (const [key, value] of Object.entries(result.bootstrapFiles)) {
+        if (typeof value === 'string' && !isAbsolute(value)) {
+          result.bootstrapFiles[key] = join(result.rootDir, value)
+        }
+      }
+    }
+
+    result.filters = result.filters || {}
+    if (filters.tags && filters.tags.length > 0) {
+      result.filters.tags = filters.tags
+    }
+    if (filters.types && filters.types.length > 0) {
+      result.filters.types = filters.types
+    }
+    if (filters.directories && filters.directories.length > 0) {
+      result.filters.directories = filters.directories
+    }
+
+    if (!isAbsolute(result.tsconfig)) {
+      result.tsconfig = join(result.rootDir, result.tsconfig)
+    }
+
+    return result
+  } catch (e: any) {
+    logger.error(e)
+    throw new Error(`Config file not found: ${configFile}`)
+  }
+}
+
+export const validateCLIConfig = (
+  cliConfig: PikkuCLIConfig,
+  required: Array<keyof PikkuCLIConfig>
+) => {
+  let errors: string[] = []
+  for (const key of required) {
+    if (!cliConfig[key]) {
+      errors.push(key)
+    }
+  }
+
+  if (errors.length > 0) {
+    throw new Error(
+      `${errors.join(', ')} ${errors.length === 1 ? 'is' : 'are'} required in pikku.config.json`
+    )
+  }
+}