@pikku/cli 0.11.1 → 0.11.3

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

@@ -1,32 +1,35 @@
 import { TypesMap } from '@pikku/inspector'
 
+// Sanitize a type name to be a valid TypeScript identifier
+function sanitizeTypeName(name: string): string {
+  // Replace hyphens with underscores
+  return name.replace(/-/g, '_')
+}
+
 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 }]) => {
+  .filter(([_name, { type }]) => {
+    const hasUndefinedGeneric =
+      /\b(Name|In|Out|Key)\b/.test(type) && /\[.*\]/.test(type)
+    return !hasUndefinedGeneric
+  })
+  .map(([originalName, { type, references }]) => {
+    const name = sanitizeTypeName(originalName)
     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(
@@ -36,16 +39,13 @@ ${Array.from(typesMap.customTypes.entries())
         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
+      } catch {
+        // Type not found in map (ambient/builtin type)
       }
     })
 

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

@@ -19,7 +19,7 @@ export const generateBootstrapFile = async (
     commonImports.push(config.middlewareFile)
   }
 
-  commonImports.push(config.functionsMetaMinFile, config.functionsFile)
+  commonImports.push(config.functionsMetaFile, config.functionsFile)
 
   // Add schema if it exists
   if (schemas) {

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

@@ -64,6 +64,10 @@ const _getPikkuCLIConfig = async (
           ...extendedConfig.packageMappings,
           ...config.packageMappings,
         },
+        externalPackages: {
+          ...extendedConfig.externalPackages,
+          ...config.externalPackages,
+        },
         ignoreFiles: config.ignoreFiles ??
           extendedConfig.ignoreFiles ?? [
             '**/*.test.ts',
@@ -73,7 +77,7 @@ const _getPikkuCLIConfig = async (
           ],
         schema: {
           additionalProperties: false,
-          supportsImportAttributes: false,
+          supportsImportAttributes: true,
           ...extendedConfig.schema,
           ...config.schema,
         },
@@ -83,6 +87,7 @@ const _getPikkuCLIConfig = async (
         ...config,
         configDir,
         packageMappings: config.packageMappings || {},
+        externalPackages: config.externalPackages || {},
         rootDir: config.rootDir
           ? resolve(configDir, config.rootDir)
           : configDir,
@@ -94,7 +99,7 @@ const _getPikkuCLIConfig = async (
         ],
         schema: {
           additionalProperties: false,
-          supportsImportAttributes: false,
+          supportsImportAttributes: true,
           ...config.schema,
         },
       }
@@ -128,10 +133,10 @@ const _getPikkuCLIConfig = async (
         'pikku-functions-meta.gen.ts'
       )
     }
-    if (!result.functionsMetaMinFile) {
-      result.functionsMetaMinFile = join(
+    if (!result.functionsMetaJsonFile) {
+      result.functionsMetaJsonFile = join(
         functionDir,
-        'pikku-functions-meta.min.gen.ts'
+        'pikku-functions-meta.gen.json'
       )
     }
     if (!result.functionTypesFile) {
@@ -154,6 +159,12 @@ const _getPikkuCLIConfig = async (
         'pikku-http-wirings-meta.gen.ts'
       )
     }
+    if (!result.httpWiringMetaJsonFile) {
+      result.httpWiringMetaJsonFile = join(
+        httpDir,
+        'pikku-http-wirings-meta.gen.json'
+      )
+    }
     if (!result.httpMapDeclarationFile) {
       result.httpMapDeclarationFile = join(
         httpDir,
@@ -174,6 +185,12 @@ const _getPikkuCLIConfig = async (
         'pikku-channels-meta.gen.ts'
       )
     }
+    if (!result.channelsWiringMetaJsonFile) {
+      result.channelsWiringMetaJsonFile = join(
+        channelDir,
+        'pikku-channels-meta.gen.json'
+      )
+    }
     if (!result.channelsMapDeclarationFile) {
       result.channelsMapDeclarationFile = join(
         channelDir,
@@ -192,6 +209,13 @@ const _getPikkuCLIConfig = async (
       )
     }
 
+    if (!result.rpcInternalWiringMetaJsonFile) {
+      result.rpcInternalWiringMetaJsonFile = join(
+        rpcDir,
+        'pikku-rpc-wirings-meta.internal.gen.json'
+      )
+    }
+
     if (!result.rpcInternalMapDeclarationFile) {
       result.rpcInternalMapDeclarationFile = join(
         rpcDir,
@@ -230,6 +254,12 @@ const _getPikkuCLIConfig = async (
         'pikku-schedulers-wirings-meta.gen.ts'
       )
     }
+    if (!result.schedulersWiringMetaJsonFile) {
+      result.schedulersWiringMetaJsonFile = join(
+        schedulerDir,
+        'pikku-schedulers-wirings-meta.gen.json'
+      )
+    }
     if (!result.schedulersTypesFile) {
       result.schedulersTypesFile = join(
         schedulerDir,
@@ -250,6 +280,12 @@ const _getPikkuCLIConfig = async (
         'pikku-queue-workers-wirings-meta.gen.ts'
       )
     }
+    if (!result.queueWorkersWiringMetaJsonFile) {
+      result.queueWorkersWiringMetaJsonFile = join(
+        queueDir,
+        'pikku-queue-workers-wirings-meta.gen.json'
+      )
+    }
     if (!result.queueMapDeclarationFile) {
       result.queueMapDeclarationFile = join(
         queueDir,
@@ -292,6 +328,11 @@ const _getPikkuCLIConfig = async (
       )
     }
 
+    // Workflow meta directory (individual JSON files for each workflow)
+    if (!result.workflowMetaDir) {
+      result.workflowMetaDir = join(workflowDir, 'meta')
+    }
+
     // Services
     if (!result.servicesFile) {
       result.servicesFile = join(result.outDir, 'pikku-services.gen.ts')
@@ -307,6 +348,12 @@ const _getPikkuCLIConfig = async (
         'pikku-middleware-groups-meta.gen.ts'
       )
     }
+    if (!result.middlewareGroupsMetaJsonFile) {
+      result.middlewareGroupsMetaJsonFile = join(
+        middlewareDir,
+        'pikku-middleware-groups-meta.gen.json'
+      )
+    }
 
     // Permissions
     const permissionsDir = join(result.outDir, 'permissions')
@@ -319,10 +366,21 @@ const _getPikkuCLIConfig = async (
       result.bootstrapFile = join(result.outDir, 'pikku-bootstrap.gen.ts')
     }
 
+    // Package service factories (for external packages)
+    if (!result.packageFile) {
+      result.packageFile = join(result.outDir, 'pikku-package.gen.ts')
+    }
+
     // MCP
     if (!result.mcpWiringsMetaFile) {
       result.mcpWiringsMetaFile = join(mcpDir, 'pikku-mcp-wirings-meta.gen.ts')
     }
+    if (!result.mcpWiringsMetaJsonFile) {
+      result.mcpWiringsMetaJsonFile = join(
+        mcpDir,
+        'pikku-mcp-wirings-meta.gen.json'
+      )
+    }
     if (!result.mcpWiringsFile) {
       result.mcpWiringsFile = join(mcpDir, 'pikku-mcp-wirings.gen.ts')
     }
@@ -340,6 +398,12 @@ const _getPikkuCLIConfig = async (
     if (!result.cliWiringMetaFile) {
       result.cliWiringMetaFile = join(cliDir, 'pikku-cli-wirings-meta.gen.ts')
     }
+    if (!result.cliWiringMetaJsonFile) {
+      result.cliWiringMetaJsonFile = join(
+        cliDir,
+        'pikku-cli-wirings-meta.gen.json'
+      )
+    }
     if (!result.cliBootstrapFile) {
       result.cliBootstrapFile = join(cliDir, 'pikku-cli-bootstrap.gen.ts')
     }
@@ -347,6 +411,18 @@ const _getPikkuCLIConfig = async (
       result.cliTypesFile = join(cliDir, 'pikku-cli-types.gen.ts')
     }
 
+    // Forge
+    const forgeDir = join(result.outDir, 'forge')
+    if (!result.forgeNodesMetaJsonFile) {
+      result.forgeNodesMetaJsonFile = join(
+        forgeDir,
+        'pikku-forge-nodes-meta.gen.json'
+      )
+    }
+    if (!result.forgeTypesFile) {
+      result.forgeTypesFile = join(forgeDir, 'pikku-forge-types.gen.ts')
+    }
+
     if (requiredFields.length > 0) {
       validateCLIConfig(result, requiredFields)
     }
@@ -369,6 +445,30 @@ const _getPikkuCLIConfig = async (
       result.tsconfig = join(result.rootDir, result.tsconfig)
     }
 
+    if (result.externalPackage) {
+      const packageJsonPath = join(result.rootDir, 'package.json')
+      try {
+        const packageJsonContent = await readFile(packageJsonPath, 'utf-8')
+        const packageJson = JSON.parse(packageJsonContent)
+
+        if (
+          !packageJson.name ||
+          typeof packageJson.name !== 'string' ||
+          packageJson.name.trim() === ''
+        ) {
+          throw new Error(
+            `package.json at ${packageJsonPath} is missing a valid "name" field`
+          )
+        }
+
+        result.externalPackageName = packageJson.name
+      } catch (e: any) {
+        throw new Error(
+          `externalPackage is true but could not read or parse package.json at ${packageJsonPath}: ${e.message}`
+        )
+      }
+    }
+
     return result
   } catch (e: any) {
     logger.error(e)

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

@@ -14,11 +14,11 @@ interface Meta {
 
 export type FilesAndMethods = {
   userSessionType: Meta
-  sessionServicesType: Meta
+  wireServicesType: Meta
   singletonServicesType: Meta
   pikkuConfigFactory: Meta
   singletonServicesFactory: Meta
-  sessionServicesFactory: Meta
+  wireServicesFactory: Meta
 }
 
 const getMetaTypes = (
@@ -85,9 +85,9 @@ export const getPikkuFilesAndMethods = async (
 ): Promise<FilesAndMethods> => {
   const {
     singletonServicesTypeImportMap,
-    sessionServicesTypeImportMap,
+    wireServicesTypeImportMap,
     userSessionTypeImportMap,
-    sessionServicesFactories,
+    wireServicesFactories,
     singletonServicesFactories,
     configFactories,
   } = state
@@ -96,7 +96,7 @@ export const getPikkuFilesAndMethods = async (
     configFileType,
     userSessionType,
     singletonServicesFactoryType,
-    sessionServicesFactoryType,
+    wireServicesFactoryType,
   } = options
   let errors = new Map<string, PathToNameAndType>()
 
@@ -110,10 +110,7 @@ export const getPikkuFilesAndMethods = async (
       'CoreSingletonServices',
       singletonServicesTypeImportMap
     ),
-    sessionServicesType: getMetaTypes(
-      'CoreServices',
-      sessionServicesTypeImportMap
-    ),
+    wireServicesType: getMetaTypes('CoreServices', wireServicesTypeImportMap),
     pikkuConfigFactory: getMetaTypes(
       'CoreConfig',
       configFactories,
@@ -124,10 +121,10 @@ export const getPikkuFilesAndMethods = async (
       singletonServicesFactories,
       singletonServicesFactoryType
     ),
-    sessionServicesFactory: getMetaTypes(
-      'CreateSessionServices',
-      sessionServicesFactories,
-      sessionServicesFactoryType
+    wireServicesFactory: getMetaTypes(
+      'CreateWireServices',
+      wireServicesFactories,
+      wireServicesFactoryType
     ),
   }
 

package/src/utils/schema-generator.ts

@@ -3,8 +3,88 @@ 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 { TypesMap, ErrorCode, ZodSchemaRef } from '@pikku/inspector'
 import { CLILogger } from '../services/cli-logger.service.js'
+import { tsImport } from 'tsx/esm/api'
+import * as z from 'zod'
+import { zodToTs, createAuxiliaryTypeStore } from 'zod-to-ts'
+import {
+  createPrinter,
+  createSourceFile,
+  EmitHint,
+  ScriptKind,
+  ScriptTarget,
+} from 'typescript'
+
+/**
+ * Convert a name to a valid JavaScript identifier.
+ * Replaces hyphens and other invalid characters with underscores.
+ */
+function toValidIdentifier(name: string): string {
+  let result = name.replace(/[-./]/g, '_')
+  if (/^\d/.test(result)) {
+    result = '_' + result
+  }
+  return result
+}
+
+const PRIMITIVE_TYPES = new Set([
+  'boolean',
+  'string',
+  'number',
+  'null',
+  'undefined',
+  'void',
+  'any',
+  'unknown',
+  'never',
+])
+
+/** Map TypeScript type strings to JSON Schema. Returns null if no schema should be generated. */
+function primitiveTypeToSchema(typeStr: string): JSONValue | null {
+  const normalized = typeStr.trim()
+
+  // void/undefined/never mean no data - don't generate a schema
+  if (
+    normalized === 'void' ||
+    normalized === 'undefined' ||
+    normalized === 'never'
+  ) {
+    return null
+  }
+
+  // Handle boolean literals
+  if (
+    normalized === 'boolean' ||
+    normalized === 'false | true' ||
+    normalized === 'true | false'
+  ) {
+    return { type: 'boolean' }
+  }
+  if (normalized === 'true') {
+    return { const: true }
+  }
+  if (normalized === 'false') {
+    return { const: false }
+  }
+
+  // Handle string
+  if (normalized === 'string') {
+    return { type: 'string' }
+  }
+
+  // Handle number
+  if (normalized === 'number') {
+    return { type: 'number' }
+  }
+
+  // Handle null
+  if (normalized === 'null') {
+    return { type: 'null' }
+  }
+
+  return null
+}
 
 export async function generateSchemas(
   logger: CLILogger,
@@ -13,7 +93,8 @@ export async function generateSchemas(
   functionMeta: FunctionsMeta,
   httpWiringsMeta: HTTPWiringsMeta,
   additionalTypes?: string[],
-  additionalProperties: boolean = false
+  additionalProperties: boolean = false,
+  zodLookup?: Map<string, ZodSchemaRef>
 ): Promise<Record<string, JSONValue>> {
   const schemasSet = new Set(typesMap.customTypes.keys())
   for (const { inputs, outputs } of Object.values(functionMeta)) {
@@ -44,7 +125,6 @@ export async function generateSchemas(
     }
   }
 
-  // Add additional types from schemasFromTypes config
   if (additionalTypes) {
     for (const type of additionalTypes) {
       schemasSet.add(type)
@@ -66,18 +146,28 @@ export async function generateSchemas(
   const schemas: Record<string, JSONValue> = {}
 
   schemasSet.forEach((schema) => {
+    if (PRIMITIVE_TYPES.has(schema)) {
+      return
+    }
+    if (zodLookup?.has(schema)) {
+      return
+    }
     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}`
-        )
+        const customType = typesMap.customTypes.get(schema)
+        if (customType) {
+          const primitiveSchema = primitiveTypeToSchema(customType.type)
+          if (primitiveSchema) {
+            schemas[schema] = primitiveSchema
+          }
+        }
         return
       }
+      const customType = typesMap.customTypes.get(schema)
       logger.error(
-        `[${ErrorCode.SCHEMA_GENERATION_ERROR}] Error generating schema: ${schema}. Message: ${e.message}`
+        `[${ErrorCode.SCHEMA_GENERATION_ERROR}] Error generating schema: ${schema}. Message: ${e.message}. Type info: ${customType ? `type=${customType.type}` : 'not in typesMap'}`
       )
     }
   })
@@ -85,14 +175,78 @@ export async function generateSchemas(
   return schemas
 }
 
+export async function generateZodSchemas(
+  logger: CLILogger,
+  zodLookup: Map<string, ZodSchemaRef>,
+  typesMap: TypesMap
+): Promise<Record<string, JSONValue>> {
+  const schemas: Record<string, JSONValue> = {}
+  const auxiliaryTypeStore = createAuxiliaryTypeStore()
+  const printer = createPrinter()
+  const fakeSourceFile = createSourceFile(
+    'zod-types.ts',
+    '',
+    ScriptTarget.ESNext,
+    false,
+    ScriptKind.TS
+  )
+
+  for (const [schemaName, ref] of zodLookup.entries()) {
+    try {
+      const module = await tsImport(ref.sourceFile, import.meta.url)
+      const zodSchema = module[ref.variableName]
+      if (!zodSchema) {
+        logger.warn(
+          `Could not find exported schema '${ref.variableName}' in ${ref.sourceFile} for ${schemaName}. Available exports: ${Object.keys(module).join(', ')}`
+        )
+        continue
+      }
+
+      const schema = z.toJSONSchema(zodSchema) as any
+
+      // Remove fields with defaults from the required array
+      // Fields with defaults are semantically optional in input validation
+      if (schema.required && schema.properties) {
+        schema.required = schema.required.filter((fieldName: string) => {
+          const prop = schema.properties[fieldName]
+          return prop && prop.default === undefined
+        })
+        if (schema.required.length === 0) {
+          delete schema.required
+        }
+      }
+
+      schemas[schemaName] = schema
+      const { node: tsType } = zodToTs(zodSchema, { auxiliaryTypeStore })
+
+      const typeText = printer.printNode(
+        EmitHint.Unspecified,
+        tsType,
+        fakeSourceFile
+      )
+
+      typesMap.addCustomType(schemaName, typeText, [])
+      logger.info(`• Generated schema from Zod: ${schemaName}`)
+    } catch (e) {
+      logger.warn(
+        `Could not convert Zod schema '${schemaName}': ${e instanceof Error ? e.message : e}`
+      )
+    }
+  }
+
+  return schemas
+}
+
 export async function saveSchemas(
   logger: CLILogger,
   schemaParentDir: string,
   schemas: Record<string, JSONValue>,
   typesMap: TypesMap,
   functionsMeta: FunctionsMeta,
+  supportsImportAttributes: boolean,
   additionalTypes?: string[],
-  supportsImportAttributes: boolean = false
+  zodLookup?: Map<string, ZodSchemaRef>,
+  packageName?: string | null
 ) {
   await writeFileInDir(
     logger,
@@ -108,26 +262,25 @@ export async function saveSchemas(
           try {
             types.push(typesMap.getUniqueName(inputs[0]))
           } catch {
-            // Skip types not in typesMap (e.g., inline types in generated workflow workers)
+            // Skip types not in typesMap - might be a zod schema name
+            types.push(inputs[0])
           }
         }
         if (outputs?.[0]) {
           try {
             types.push(typesMap.getUniqueName(outputs[0]))
           } catch {
-            // Skip types not in typesMap (e.g., inline types in generated workflow workers)
+            // Skip types not in typesMap - might be a zod schema name
+            types.push(outputs[0])
           }
         }
         return types
       })
       .flat()
-      .filter(
-        (s): s is string =>
-          !!s &&
-          !['boolean', 'string', 'number', 'null', 'undefined'].includes(s)
-      ),
+      .filter((s): s is string => !!s && !PRIMITIVE_TYPES.has(s)),
     ...typesMap.customTypes.keys(),
     ...(additionalTypes || []),
+    ...(zodLookup ? Array.from(zodLookup.keys()) : []),
   ])
 
   if (desiredSchemas.size === 0) {
@@ -153,19 +306,29 @@ export async function saveSchemas(
     (schema) => schemas[schema]
   )
 
+  // Generate the packageName argument for addSchema calls
+  const packageNameArg = packageName ? `, '${packageName}'` : ''
+
   const schemaImports = availableSchemas
-    .map(
-      (schema) => `
-import * as ${schema} from './schemas/${schema}.schema.json' ${supportsImportAttributes ? `with { type: 'json' }` : ''}
-addSchema('${schema}', ${schema})
+    .map((schema) => {
+      const identifier = toValidIdentifier(schema)
+      return `
+import * as ${identifier} from './schemas/${schema}.schema.json' ${supportsImportAttributes ? `with { type: 'json' }` : ''}
+addSchema('${schema}', ${identifier}${packageNameArg})
 `
-    )
+    })
     .join('\n')
 
+  // Only import addSchema if there are schemas to register
+  const importStatement =
+    availableSchemas.length > 0
+      ? `import { addSchema } from '@pikku/core/schema'`
+      : '// No schemas to register'
+
   await writeFileInDir(
     logger,
     `${schemaParentDir}/register.gen.ts`,
-    `import { addSchema } from '@pikku/core/schema'
+    `${importStatement}
 ${schemaImports}`,
     { logWrite: true }
   )