@pikku/cli 0.11.1 → 0.11.3

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

@@ -0,0 +1,81 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializePackageFactories } from './serialize-package.js'
+
+export const pikkuPackage: any = pikkuSessionlessFunc<
+  void,
+  boolean | undefined
+>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const { externalPackageName, packageMappings, packageFile } = config
+
+    // Only generate for external packages
+    if (!externalPackageName) {
+      logger.info({
+        message:
+          'Skipping package factories - not an external package (externalPackageName not set)',
+        type: 'skip',
+      })
+      return false
+    }
+
+    if (!packageFile) {
+      logger.info({
+        message: 'Skipping package factories - packageFile not configured',
+        type: 'skip',
+      })
+      return false
+    }
+
+    const state = await getInspectorState()
+    const { filesAndMethods } = state
+
+    const {
+      pikkuConfigFactory,
+      singletonServicesFactory,
+      wireServicesFactory,
+    } = filesAndMethods
+
+    const content = serializePackageFactories(
+      packageFile,
+      externalPackageName,
+      pikkuConfigFactory
+        ? {
+            file: pikkuConfigFactory.file,
+            variable: pikkuConfigFactory.variable,
+          }
+        : undefined,
+      singletonServicesFactory
+        ? {
+            file: singletonServicesFactory.file,
+            variable: singletonServicesFactory.variable,
+          }
+        : undefined,
+      wireServicesFactory
+        ? {
+            file: wireServicesFactory.file,
+            variable: wireServicesFactory.variable,
+          }
+        : undefined,
+      packageMappings
+    )
+
+    if (!content) {
+      logger.info({
+        message: 'Skipping package factories - no service factories found',
+        type: 'skip',
+      })
+      return false
+    }
+
+    await writeFileInDir(logger, packageFile, content)
+    return true
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Generating package service factories',
+      commandEnd: 'Generated package service factories',
+    }),
+  ],
+})

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

@@ -0,0 +1,69 @@
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+
+export interface PackageFactoryInfo {
+  file: string
+  variable: string
+}
+
+export const serializePackageFactories = (
+  outputPath: string,
+  packageName: string,
+  configFactory: PackageFactoryInfo | undefined,
+  singletonServicesFactory: PackageFactoryInfo | undefined,
+  wireServicesFactory: PackageFactoryInfo | undefined,
+  packageMappings: Record<string, string> = {}
+) => {
+  const imports: string[] = [
+    `import { addPackageServiceFactories } from '@pikku/core'`,
+  ]
+
+  const factoryEntries: string[] = []
+
+  if (configFactory) {
+    const filePath = getFileImportRelativePath(
+      outputPath,
+      configFactory.file,
+      packageMappings
+    )
+    imports.push(
+      `import { ${configFactory.variable} as createConfig } from '${filePath}'`
+    )
+    factoryEntries.push(`  createConfig,`)
+  }
+
+  if (singletonServicesFactory) {
+    const filePath = getFileImportRelativePath(
+      outputPath,
+      singletonServicesFactory.file,
+      packageMappings
+    )
+    imports.push(
+      `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${filePath}'`
+    )
+    factoryEntries.push(`  createSingletonServices,`)
+  }
+
+  if (wireServicesFactory) {
+    const filePath = getFileImportRelativePath(
+      outputPath,
+      wireServicesFactory.file,
+      packageMappings
+    )
+    imports.push(
+      `import { ${wireServicesFactory.variable} as createWireServices } from '${filePath}'`
+    )
+    factoryEntries.push(`  createWireServices,`)
+  }
+
+  // Only generate if at least one factory is defined
+  if (factoryEntries.length === 0) {
+    return null
+  }
+
+  return `${imports.join('\n')}
+
+addPackageServiceFactories('${packageName}', {
+${factoryEntries.join('\n')}
+})
+`
+}

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

@@ -17,10 +17,10 @@ export const pikkuPermissions: any = pikkuSessionlessFunc<
     // Check if there are any permission group factories
     const hasHTTPFactories = Array.from(
       state.http.routePermissions.values()
-    ).some((meta) => meta.exportName && meta.isFactory)
+    ).some((meta: any) => meta.exportName && meta.isFactory)
     const hasTagFactories = Array.from(
       state.permissions.tagPermissions.values()
-    ).some((meta) => meta.exportName && meta.isFactory)
+    ).some((meta: any) => meta.exportName && meta.isFactory)
     const hasFactories = hasHTTPFactories || hasTagFactories
 
     // Generate permissions imports file if there are factories

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

@@ -2,7 +2,15 @@ import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js'
 import { writeFileInDir } from '../../../utils/file-writer.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { serializeQueueMeta } from './serialize-queue-meta.js'
+import {
+  serializeQueueMeta,
+  serializeQueueMetaTS,
+} from './serialize-queue-meta.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import {
+  stripVerboseFields,
+  hasVerboseFields,
+} from '../../../utils/strip-verbose-meta.js'
 
 export const pikkuQueue: any = pikkuSessionlessFunc<void, boolean | undefined>({
   func: async ({ logger, config, getInspectorState }) => {
@@ -10,15 +18,52 @@ export const pikkuQueue: any = pikkuSessionlessFunc<void, boolean | undefined>({
     const {
       queueWorkersWiringFile,
       queueWorkersWiringMetaFile,
+      queueWorkersWiringMetaJsonFile,
       packageMappings,
+      schema,
     } = config
     const { queueWorkers } = visitState
 
+    const fullMeta = serializeQueueMeta(queueWorkers.meta)
+
+    // Write minimal JSON file (runtime-only fields)
+    const minimalMeta = stripVerboseFields(fullMeta)
     await writeFileInDir(
       logger,
+      queueWorkersWiringMetaJsonFile,
+      JSON.stringify(minimalMeta, null, 2)
+    )
+
+    // Write verbose JSON only if it has additional fields
+    if (hasVerboseFields(fullMeta)) {
+      const verbosePath = queueWorkersWiringMetaJsonFile.replace(
+        /\.gen\.json$/,
+        '-verbose.gen.json'
+      )
+      await writeFileInDir(
+        logger,
+        verbosePath,
+        JSON.stringify(fullMeta, null, 2)
+      )
+    }
+
+    // Calculate relative path from TS file to JSON file
+    const jsonImportPath = getFileImportRelativePath(
       queueWorkersWiringMetaFile,
-      serializeQueueMeta(queueWorkers.meta)
+      queueWorkersWiringMetaJsonFile,
+      packageMappings
     )
+
+    // Write TypeScript file that imports JSON
+    await writeFileInDir(
+      logger,
+      queueWorkersWiringMetaFile,
+      serializeQueueMetaTS(
+        jsonImportPath,
+        schema?.supportsImportAttributes ?? false
+      )
+    )
+
     await writeFileInDir(
       logger,
       queueWorkersWiringFile,

package/src/functions/wirings/queue/pikku-queue.ts

@@ -2,7 +2,11 @@ import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js'
 import { writeFileInDir } from '../../../utils/file-writer.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { serializeQueueMeta } from './serialize-queue-meta.js'
+import {
+  serializeQueueMeta,
+  serializeQueueMetaTS,
+} from './serialize-queue-meta.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 
 export const pikkuQueue: any = pikkuSessionlessFunc<void, boolean>({
   func: async ({ logger, config, getInspectorState }) => {
@@ -10,24 +14,36 @@ export const pikkuQueue: any = pikkuSessionlessFunc<void, boolean>({
     const {
       queueWorkersWiringFile,
       queueWorkersWiringMetaFile,
+      queueWorkersWiringMetaJsonFile,
       packageMappings,
+      schema,
     } = config
     const { queueWorkers } = visitState
 
-    // Add remote RPC worker to queue metadata if it exists
-    const queueMeta = { ...queueWorkers.meta }
-    if (config.rpc?.remoteRpcWorkersPath) {
-      queueMeta['pikku-remote-internal-rpc'] = {
-        pikkuFuncName: 'pikkuRemoteInternalRPC',
-        queueName: 'pikku-remote-internal-rpc',
-      }
-    }
+    // Write JSON file
+    await writeFileInDir(
+      logger,
+      queueWorkersWiringMetaJsonFile,
+      JSON.stringify(serializeQueueMeta(queueWorkers.meta), null, 2)
+    )
+
+    // Calculate relative path from TS file to JSON file
+    const jsonImportPath = getFileImportRelativePath(
+      queueWorkersWiringMetaFile,
+      queueWorkersWiringMetaJsonFile,
+      packageMappings
+    )
 
+    // Write TypeScript file that imports JSON
     await writeFileInDir(
       logger,
       queueWorkersWiringMetaFile,
-      serializeQueueMeta(queueMeta)
+      serializeQueueMetaTS(
+        jsonImportPath,
+        schema?.supportsImportAttributes ?? false
+      )
     )
+
     await writeFileInDir(
       logger,
       queueWorkersWiringFile,

package/src/functions/wirings/queue/serialize-queue-map.ts

@@ -30,7 +30,7 @@ export const serializeQueueMap = (
   return `/**
  * This provides the structure needed for typescript to be aware of Queue workers and their input/output types
  */
-    
+
 ${serializedImportMap}
 ${serializedCustomTypes}
 
@@ -93,8 +93,23 @@ function generateQueues(
     const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
 
     // Store the input and output types for QueueHandler
-    const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null'
-    const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null'
+    // For zod-derived schemas, the type might not be in typesMap, so use the schema name directly
+    let inputType = 'null'
+    if (input) {
+      try {
+        inputType = typesMap.getTypeMeta(input).uniqueName
+      } catch {
+        inputType = input
+      }
+    }
+    let outputType = 'null'
+    if (output) {
+      try {
+        outputType = typesMap.getTypeMeta(output).uniqueName
+      } catch {
+        outputType = output
+      }
+    }
 
     requiredTypes.add(inputType)
     requiredTypes.add(outputType)

package/src/functions/wirings/queue/serialize-queue-meta.ts

@@ -1,10 +1,24 @@
 import { QueueWorkersMeta } from '@pikku/core/queue'
 
 export const serializeQueueMeta = (queueWorkersMeta: QueueWorkersMeta) => {
+  return queueWorkersMeta
+}
+
+export const serializeQueueMetaTS = (
+  jsonImportPath: string,
+  supportsImportAttributes: boolean
+) => {
+  const importStatement = supportsImportAttributes
+    ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+    : `import metaData from '${jsonImportPath}'`
+
   const serializedOutput: string[] = []
   serializedOutput.push("import { pikkuState } from '@pikku/core'")
+  serializedOutput.push("import { QueueWorkersMeta } from '@pikku/core/queue'")
+  serializedOutput.push(importStatement)
+  serializedOutput.push('')
   serializedOutput.push(
-    `pikkuState('queue', 'meta', ${JSON.stringify(queueWorkersMeta, null, 2)})`
+    "pikkuState(null, 'queue', 'meta', metaData as QueueWorkersMeta)"
   )
   return serializedOutput.join('\n')
 }

package/src/functions/wirings/queue/serialize-queue-types.ts

@@ -15,7 +15,7 @@ import type { PikkuFunctionConfig } from '${functionTypesImportPath}'
  * @template In - Input type for the queue job
  * @template Out - Output type for the queue job
  */
-type QueueWiring<In, Out> = CoreQueueWorker<PikkuFunctionConfig<In, Out>>
+type QueueWiring<In, Out> = CoreQueueWorker<PikkuFunctionConfig<In, Out, 'session' | 'rpc'>>
 
 /**
  * Registers a queue worker with the Pikku framework.

package/src/functions/wirings/rpc/pikku-command-rpc-map.ts

@@ -6,14 +6,16 @@ import { serializeTypedRPCMap } from './serialize-typed-rpc-map.js'
 export const pikkuRPCInternalMap: any = pikkuSessionlessFunc<void, void>({
   func: async ({ logger, config, getInspectorState }) => {
     const { functions, rpc } = await getInspectorState()
-    const { rpcInternalMapDeclarationFile, packageMappings } = config
+    const { rpcInternalMapDeclarationFile, packageMappings, externalPackages } =
+      config
 
     const content = serializeTypedRPCMap(
       rpcInternalMapDeclarationFile,
       packageMappings,
       functions.typesMap,
       functions.meta,
-      rpc.internalMeta
+      rpc.internalMeta,
+      externalPackages
     )
     await writeFileInDir(logger, rpcInternalMapDeclarationFile, content)
   },
@@ -28,14 +30,15 @@ export const pikkuRPCInternalMap: any = pikkuSessionlessFunc<void, void>({
 export const pikkuRPCExposedMap: any = pikkuSessionlessFunc<void, void>({
   func: async ({ logger, config, getInspectorState }) => {
     const { functions, rpc } = await getInspectorState()
-    const { rpcMapDeclarationFile, packageMappings } = config
+    const { rpcMapDeclarationFile, packageMappings, externalPackages } = config
 
     const content = serializeTypedRPCMap(
       rpcMapDeclarationFile,
       packageMappings,
       functions.typesMap,
       functions.meta,
-      rpc.exposedMeta
+      rpc.exposedMeta,
+      externalPackages
     )
     await writeFileInDir(logger, rpcMapDeclarationFile, content)
   },

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

@@ -1,17 +1,40 @@
 import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
 import { writeFileInDir } from '../../../utils/file-writer.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 
 export const pikkuRPC: any = pikkuSessionlessFunc<void, boolean>({
   func: async ({ logger, config, getInspectorState }) => {
     const { rpc } = await getInspectorState()
-    const { rpcInternalWiringMetaFile } = config
+    const {
+      rpcInternalWiringMetaFile,
+      rpcInternalWiringMetaJsonFile,
+      packageMappings,
+      schema,
+    } = config
 
     if (rpc.internalFiles.size > 0) {
+      await writeFileInDir(
+        logger,
+        rpcInternalWiringMetaJsonFile,
+        JSON.stringify(rpc.internalMeta, null, 2)
+      )
+
+      const jsonImportPath = getFileImportRelativePath(
+        rpcInternalWiringMetaFile,
+        rpcInternalWiringMetaJsonFile,
+        packageMappings
+      )
+
+      const supportsImportAttributes = schema?.supportsImportAttributes ?? false
+      const importStatement = supportsImportAttributes
+        ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+        : `import metaData from '${jsonImportPath}'`
+
       await writeFileInDir(
         logger,
         rpcInternalWiringMetaFile,
-        `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.internalMeta, null, 2)})`
+        `import { pikkuState } from '@pikku/core'\n${importStatement}\npikkuState(null, 'rpc', 'meta', metaData as Record<string, string>)`
       )
       return true
     }

package/src/functions/wirings/rpc/serialize-public-rpc.ts

@@ -13,16 +13,23 @@ import { pikkuSessionlessFunc, wireHTTP } from '${pathToPikkuTypes}'
  * This is used for public HTTP access to exposed server functions
  */
 export const rpcCaller = pikkuSessionlessFunc<
-  { name: string, data?: any },
+  { rpcName: string, data?: any },
   any
 >({
-  func: async ({ rpc }, { name, data }) => {
-    return await (rpc.invokeExposed as any)(name, data)
+  func: async (services, { rpcName, data }, { rpc }) => {
+    return await (rpc.invokeExposed as any)(rpcName, data)
   },
 })
 
 wireHTTP({
-  route: '/rpc',
+  route: "/rpc/:rpcName",
+  method: "options",
+  auth: false,
+  func: pikkuSessionlessFunc<{ rpcName: string }>(async () => void 0),
+});
+
+wireHTTP({
+  route: '/rpc/:rpcName',
   method: 'post',
   func: rpcCaller,
 })

package/src/functions/wirings/rpc/serialize-remote-rpc.ts

@@ -11,12 +11,15 @@ import { pikkuSessionlessFunc, wireQueueWorker } from '${pathToPikkuTypes}'
 /**
  * Generic remote RPC worker that invokes any internal RPC by name
  * This is used for executing internal RPCs via a queue or HTTP (e.g., scheduled tasks, background jobs, internal services)
+ *
+ * TODO: Security risk - this allows any RPC to be invoked by name. Should validate
+ * that rpcName is in an allowlist of permitted internal RPCs to prevent unauthorized access.
  */
 export const pikkuRemoteInternalRPC = pikkuSessionlessFunc<
   { rpcName: string, data?: any },
   any
 >({
-  func: async ({ rpc }, { rpcName, data }) => {
+  func: async (_services, { rpcName, data }, { rpc }) => {
     return await (rpc.invoke as any)(rpcName, data)
   },
   internal: true,

package/src/functions/wirings/rpc/serialize-rpc-wrapper.ts

@@ -54,12 +54,12 @@ export class PikkuRPC {
      * This is a generic method that routes to the appropriate server function
      * based on the function name and passes the provided data.
      *
-     * @param name - The name of the server function to invoke
+     * @param rpcName - The name of the server function to invoke
      * @param data - The data to pass to the server function
      * @returns A promise that resolves with the function's return value
      */
-    invoke: RPCInvoke = async (name, data) => {
-       return await this.pikkuFetch.post('/rpc' as any, { name, data }) as any
+    invoke: RPCInvoke = async (rpcName, data) => {
+       return await this.pikkuFetch.post(\`/rpc/\${rpcName}\` as any, { rpcName: String(rpcName), data }) as any
     }
 }
 

package/src/functions/wirings/rpc/serialize-typed-rpc-map.ts

@@ -8,7 +8,8 @@ export const serializeTypedRPCMap = (
   packageMappings: Record<string, string>,
   typesMap: TypesMap,
   functionsMeta: FunctionsMeta,
-  rpcMeta: Record<string, string>
+  rpcMeta: Record<string, string>,
+  externalPackages?: Record<string, string>
 ) => {
   const requiredTypes = new Set<string>()
   const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
@@ -26,10 +27,17 @@ export const serializeTypedRPCMap = (
     requiredTypes
   )
 
+  const externalPackageImports = generateExternalPackageImports(
+    externalPackages,
+    relativeToPath
+  )
+
+  const mergedRPCMap = generateMergedRPCMap(externalPackages)
+
   return `/**
  * This provides the structure needed for typescript to be aware of RPCs and their return types
  */
-    
+
 ${serializedImportMap}
 ${serializedCustomTypes}
 
@@ -39,14 +47,16 @@ interface RPCHandler<I, O> {
 }
 
 ${serializedRPCs}
+${externalPackageImports}
+${mergedRPCMap}
 
-export type RPCInvoke = <Name extends keyof RPCMap>(
+export type RPCInvoke = <Name extends keyof FlattenedRPCMap>(
   name: Name,
-  data: RPCMap[Name]['input'],
+  data: FlattenedRPCMap[Name]['input'],
   options?: {
     location?: 'local' | 'remote' | 'auto'
   }
-) => Promise<RPCMap[Name]['output']>
+) => Promise<FlattenedRPCMap[Name]['output']>
 
 // Import WorkflowMap for workflow typing
 import type { WorkflowMap } from '../workflow/pikku-workflow-map.gen.js'
@@ -64,6 +74,60 @@ export type TypedPikkuRPC = {
   `
 }
 
+function generateExternalPackageImports(
+  externalPackages: Record<string, string> | undefined,
+  relativeToPath: string
+): string {
+  if (!externalPackages || Object.keys(externalPackages).length === 0) {
+    return ''
+  }
+
+  let imports = '\n// External package RPC maps\n'
+  for (const [namespace, packageName] of Object.entries(externalPackages)) {
+    // Import the RPCMap from each external package's internal RPC map
+    // Use .js extension - package.json exports will resolve to .d.ts for types
+    imports += `import type { RPCMap as ${toPascalCase(namespace)}RPCMap } from '${packageName}/.pikku/rpc/pikku-rpc-wirings-map.internal.gen.js'\n`
+  }
+  return imports
+}
+
+function generateMergedRPCMap(
+  externalPackages: Record<string, string> | undefined
+): string {
+  if (!externalPackages || Object.keys(externalPackages).length === 0) {
+    return `
+// No external packages, use RPCMap directly
+export type FlattenedRPCMap = RPCMap
+`
+  }
+
+  // TypeScript utility to flatten namespaced RPC maps
+  const utilityTypes = `
+// Utility type to prefix keys with namespace
+type PrefixKeys<T, Prefix extends string> = {
+  [K in keyof T as \`\${Prefix}:\${string & K}\`]: T[K]
+}
+
+// Merge all RPC maps with namespace prefixes
+export type FlattenedRPCMap =
+  RPCMap${Object.keys(externalPackages)
+    .map(
+      (namespace) =>
+        ` & PrefixKeys<${toPascalCase(namespace)}RPCMap, '${namespace}'>`
+    )
+    .join('')}
+`
+
+  return utilityTypes
+}
+
+function toPascalCase(str: string): string {
+  return str
+    .split(/[-_]/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('')
+}
+
 function generateRPCs(
   rpcMeta: Record<string, string>,
   functionsMeta: FunctionsMeta,
@@ -86,13 +150,14 @@ function generateRPCs(
     const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
 
     // Store the input and output types for RPCHandler
-    // Use 'any' for types not in typesMap (e.g., inline types in generated workflow workers)
+    // For zod-derived schemas, the type might not be in typesMap, so use the schema name directly
     let inputType = 'null'
     if (input) {
       try {
         inputType = typesMap.getTypeMeta(input).uniqueName
       } catch {
-        inputType = 'any'
+        // Type not in typesMap - use the name directly (e.g., zod-derived types)
+        inputType = input
       }
     }
 
@@ -101,7 +166,8 @@ function generateRPCs(
       try {
         outputType = typesMap.getTypeMeta(output).uniqueName
       } catch {
-        outputType = 'any'
+        // Type not in typesMap - use the name directly (e.g., zod-derived types)
+        outputType = output
       }
     }