@pikku/cli 0.9.15 → 0.10.0

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

@@ -0,0 +1,55 @@
+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((refName) => {
+      // Skip __object types (including those with suffixes like __object_abc123)
+      // These are placeholder types created by the inspector for invalid/broken functions
+      // (e.g., functions with type errors or missing return statements). Attempting to
+      // import these would fail since the source files don't actually export __object.
+      if (refName !== '__object' && !refName.startsWith('__object_')) {
+        requiredTypes.add(refName)
+      }
+    })
+
+    // 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,72 @@
+import { dirname } from 'path'
+import { mkdir, readFile, writeFile, rm } from 'fs/promises'
+import { existsSync } from 'fs'
+import { CLILogger } from '../services/cli-logger.service.js'
+import { getCLIVersion } from './get-cli-version.js'
+
+export const DO_NOT_MODIFY_COMMENT = `/**
+ * This file was generated by @pikku/cli@${getCLIVersion()}
+ */
+`
+
+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' })
+    }
+  }
+}
+
+export const removeFileInDir = async (
+  logger: CLILogger,
+  path: string,
+  { logRemove = true }: { logRemove?: boolean } = {}
+) => {
+  // Check if file exists before attempting removal
+  if (existsSync(path)) {
+    await rm(path, { force: true })
+
+    if (logRemove) {
+      logger.info({ message: `✓ File removed at ${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/get-cli-version.ts

@@ -0,0 +1,28 @@
+import { dirname, join } from 'path'
+import { readFile } from 'fs/promises'
+import { fileURLToPath } from 'url'
+
+// Get package version for generated file comments
+const __dirname = dirname(fileURLToPath(import.meta.url))
+let version = 'unknown'
+
+try {
+  // Try from src/ first (development), then from dist/src/ (built)
+  const pkgPath = join(__dirname, '..', '..', 'package.json')
+  const pkgJson = JSON.parse(await readFile(pkgPath, 'utf-8'))
+  version = pkgJson.version
+} catch {
+  try {
+    const pkgPath = join(__dirname, '..', '..', '..', 'package.json')
+    const pkgJson = JSON.parse(await readFile(pkgPath, 'utf-8'))
+    version = pkgJson.version
+  } catch {
+    // Fallback to unknown if package.json can't be found
+  }
+}
+
+/**
+ * Returns the CLI version string
+ * Works from both src/ and dist/src/ locations
+ */
+export const getCLIVersion = () => version

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

@@ -0,0 +1,327 @@
+import { join, dirname, resolve, isAbsolute } from 'path'
+import { readdir, readFile } from 'fs/promises'
+import { PikkuCLIConfig } from '../../types/config.js'
+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>,
+  exitProcess: boolean = false
+): Promise<PikkuCLIConfig> => {
+  const config = await _getPikkuCLIConfig(
+    logger,
+    configFile,
+    requiredFields,
+    exitProcess
+  )
+  return config
+}
+
+const _getPikkuCLIConfig = async (
+  logger: CLILogger,
+  configFile: string | undefined = undefined,
+  requiredFields: Array<keyof PikkuCLIConfig>,
+  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),
+        [],
+        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'
+      )
+    }
+
+    // Permissions
+    const permissionsDir = join(result.outDir, 'permissions')
+    if (!result.permissionsFile) {
+      result.permissionsFile = join(permissionsDir, 'pikku-permissions.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')
+    }
+
+    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])
+          }
+        }
+      }
+    }
+
+    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`
+    )
+  }
+}