@pikku/cli 0.11.1 → 0.11.3

package/src/functions/wirings/functions/pikku-command-services.ts

@@ -6,11 +6,11 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 
 export const serializeServicesMap = (
   allSingletonServices: string[],
-  allSessionServices: string[],
+  allWireServices: string[],
   requiredServices: Set<string>,
   forceRequiredServices: string[] = [],
   servicesImport: string,
-  sessionServicesImport: string
+  wireServicesImport: string
 ): string => {
   // Use pre-aggregated services from inspector state
   // This includes services from:
@@ -20,7 +20,7 @@ export const serializeServicesMap = (
   // - Session factories
   const usedServices = new Set(requiredServices)
 
-  // Internal services that are created internally by the framework (PikkuInteraction)
+  // Internal services that are created internally by the framework (PikkuWire)
   // These should not appear in the services maps
   const internalServices = new Set([
     'rpc',
@@ -41,7 +41,7 @@ export const serializeServicesMap = (
   })
 
   // Services that are always required internally by the framework
-  const defaultServices = ['config', 'logger', 'variables', 'schema']
+  const defaultServices = ['config', 'logger', 'variables', 'schema', 'secrets']
   defaultServices.forEach((service) => usedServices.add(service))
 
   // Create singleton services map: all singleton services with true/false based on usage
@@ -50,12 +50,12 @@ export const serializeServicesMap = (
     singletonServicesMap[service] = usedServices.has(service)
   })
 
-  // Create session services map: all session services with true/false based on usage
-  // Exclude internal framework services (PikkuInteraction)
-  const sessionServicesMap: Record<string, boolean> = {}
-  allSessionServices.forEach((service) => {
+  // Create wire services map: all wire services with true/false based on usage
+  // Exclude internal framework services (PikkuWire)
+  const wireServicesMap: Record<string, boolean> = {}
+  allWireServices.forEach((service) => {
     if (!internalServices.has(service)) {
-      sessionServicesMap[service] = usedServices.has(service)
+      wireServicesMap[service] = usedServices.has(service)
     }
   })
 
@@ -63,13 +63,13 @@ export const serializeServicesMap = (
   const requiredSingletonServiceNames = Object.keys(singletonServicesMap)
     .filter((key) => singletonServicesMap[key])
     .sort()
-  const requiredSessionServiceNames = Object.keys(sessionServicesMap)
-    .filter((key) => sessionServicesMap[key])
+  const requiredWireServiceNames = Object.keys(wireServicesMap)
+    .filter((key) => wireServicesMap[key])
     .sort()
 
   const code = [
     servicesImport,
-    sessionServicesImport,
+    wireServicesImport,
     '',
     '// Singleton services map: true if required, false if available but unused',
     'export const requiredSingletonServices = {',
@@ -78,11 +78,11 @@ export const serializeServicesMap = (
       .map((service) => `  '${service}': ${singletonServicesMap[service]},`),
     '} as const',
     '',
-    '// Session services map: true if required, false if available but unused',
-    'export const requiredSessionServices = {',
-    ...Object.keys(sessionServicesMap)
+    '// Wire services map: true if required, false if available but unused',
+    'export const requiredWireServices = {',
+    ...Object.keys(wireServicesMap)
       .sort()
-      .map((service) => `  '${service}': ${sessionServicesMap[service]},`),
+      .map((service) => `  '${service}': ${wireServicesMap[service]},`),
     '} as const',
     '',
     '// Type exports',
@@ -90,9 +90,9 @@ export const serializeServicesMap = (
       ? `export type RequiredSingletonServices = Pick<SingletonServices, ${requiredSingletonServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<SingletonServices, ${requiredSingletonServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
       : 'export type RequiredSingletonServices = Partial<SingletonServices>',
     '',
-    requiredSessionServiceNames.length > 0
-      ? `export type RequiredSessionServices = Pick<Services, ${requiredSessionServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<Services, ${requiredSessionServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
-      : 'export type RequiredSessionServices = Partial<Services>',
+    requiredWireServiceNames.length > 0
+      ? `export type RequiredWireServices = Pick<Services, ${requiredWireServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<Services, ${requiredWireServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
+      : 'export type RequiredWireServices = Partial<Services>',
     '',
   ].join('\n')
 
@@ -105,29 +105,29 @@ export const pikkuServices: any = pikkuSessionlessFunc<void, void>({
 
     // Check for required types
     checkRequiredTypes(visitState.filesAndMethodsErrors, {
-      sessionServiceType: true,
+      wireServiceType: true,
       singletonServicesType: true,
     })
 
-    const { sessionServicesType, singletonServicesType } =
+    const { wireServicesType, singletonServicesType } =
       visitState.filesAndMethods
 
-    if (!sessionServicesType || !singletonServicesType) {
+    if (!wireServicesType || !singletonServicesType) {
       throw new Error(
-        'Required types not found: sessionServicesType or singletonServicesType'
+        'Required types not found: wireServicesType or singletonServicesType'
       )
     }
 
     const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, singletonServicesType.typePath, config.packageMappings)}'`
-    const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, sessionServicesType.typePath, config.packageMappings)}'`
+    const wireServicesImport = `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, wireServicesType.typePath, config.packageMappings)}'`
 
     const servicesCode = serializeServicesMap(
       visitState.serviceAggregation.allSingletonServices,
-      visitState.serviceAggregation.allSessionServices,
+      visitState.serviceAggregation.allWireServices,
       visitState.serviceAggregation.requiredServices,
       config.forceRequiredServices,
       servicesImport,
-      sessionServicesImport
+      wireServicesImport
     )
     await writeFileInDir(logger, config.servicesFile, servicesCode)
   },

package/src/functions/wirings/functions/pikku-function-types.ts

@@ -16,6 +16,7 @@ export const pikkuFunctionTypes: any = pikkuSessionlessFunc<void, void>({
       queueTypesFile,
       mcpTypesFile,
       cliTypesFile,
+      forgeTypesFile,
     } = config
 
     const content = serializePikkuTypesHub(
@@ -29,7 +30,8 @@ export const pikkuFunctionTypes: any = pikkuSessionlessFunc<void, void>({
       ),
       getFileImportRelativePath(typesFile, queueTypesFile, packageMappings),
       getFileImportRelativePath(typesFile, mcpTypesFile, packageMappings),
-      getFileImportRelativePath(typesFile, cliTypesFile, packageMappings)
+      getFileImportRelativePath(typesFile, cliTypesFile, packageMappings),
+      getFileImportRelativePath(typesFile, forgeTypesFile, packageMappings)
     )
 
     await writeFileInDir(logger, typesFile, content)

package/src/functions/wirings/functions/schemas.ts

@@ -2,11 +2,12 @@ import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
 import {
   saveSchemas,
   generateSchemas,
+  generateZodSchemas,
 } from '../../../utils/schema-generator.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
 
 /**
- * Generate JSON schemas from TypeScript types
+ * Generate JSON schemas from TypeScript types and Zod schemas
  */
 export const pikkuSchemas: any = pikkuSessionlessFunc<
   void,
@@ -22,17 +23,26 @@ export const pikkuSchemas: any = pikkuSessionlessFunc<
       visitState.functions.meta,
       visitState.http.meta,
       config.schemasFromTypes,
-      config.schema?.additionalProperties
+      config.schema?.additionalProperties,
+      visitState.zodLookup
+    )
+
+    const zodSchemas = await generateZodSchemas(
+      logger,
+      visitState.zodLookup,
+      visitState.functions.typesMap
     )
 
     await saveSchemas(
       logger,
       config.schemaDirectory,
-      schemas,
+      { ...schemas, ...zodSchemas},
       visitState.functions.typesMap,
       visitState.functions.meta,
+      config.schema?.supportsImportAttributes || true,
       config.schemasFromTypes,
-      config.schema?.supportsImportAttributes
+      visitState.zodLookup,
+      config.externalPackageName || null
     )
 
     return true

package/src/functions/wirings/functions/serialize-function-imports.ts

@@ -5,7 +5,9 @@ export const serializeFunctionImports = (
   outputPath: string,
   functionsMap: Map<string, { path: string; exportedName: string }>,
   functionsMeta: FunctionsMeta,
-  packageMappings: Record<string, string> = {}
+  packageMappings: Record<string, string> = {},
+  /** Package name for external packages (e.g., '@pikku/templates-function-external') */
+  externalPackageName?: string
 ) => {
   const serializedImports: string[] = [
     `/* Import and register functions used by RPCs */`,
@@ -19,6 +21,9 @@ export const serializeFunctionImports = (
     a[0].localeCompare(b[0])
   )
 
+  // Third argument to addFunction is the package name (null for main package)
+  const packageArg = externalPackageName ? `, '${externalPackageName}'` : ''
+
   for (const [name, { path, exportedName }] of sortedEntries) {
     const filePath = getFileImportRelativePath(
       outputPath,
@@ -30,14 +35,18 @@ export const serializeFunctionImports = (
     // For directly exported functions, we can just import and register them
     if (name === exportedName) {
       serializedImports.push(`import { ${exportedName} } from '${filePath}'`)
-      serializedRegistrations.push(`addFunction('${name}', ${exportedName})`)
+      serializedRegistrations.push(
+        `addFunction('${name}', ${exportedName}${packageArg})`
+      )
     }
     // For renamed functions, we need to import and alias them
     else {
       serializedImports.push(
         `import { ${exportedName} as ${name} } from '${filePath}'`
       )
-      serializedRegistrations.push(`addFunction('${name}', ${name})`)
+      serializedRegistrations.push(
+        `addFunction('${name}', ${name}${packageArg})`
+      )
     }
   }