@pikku/cli 0.11.3 → 0.12.1

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

@@ -1,194 +0,0 @@
-import { serializeImportMap } from '../../../utils/serialize-import-map.js'
-import { TypesMap } from '@pikku/inspector'
-import { FunctionsMeta } from '@pikku/core'
-import { generateCustomTypes } from '../../../utils/custom-types-generator.js'
-
-export const serializeTypedRPCMap = (
-  relativeToPath: string,
-  packageMappings: Record<string, string>,
-  typesMap: TypesMap,
-  functionsMeta: FunctionsMeta,
-  rpcMeta: Record<string, string>,
-  externalPackages?: Record<string, string>
-) => {
-  const requiredTypes = new Set<string>()
-  const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
-  const serializedRPCs = generateRPCs(
-    rpcMeta,
-    functionsMeta,
-    typesMap,
-    requiredTypes
-  )
-
-  const serializedImportMap = serializeImportMap(
-    relativeToPath,
-    packageMappings,
-    typesMap,
-    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}
-
-interface RPCHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-${serializedRPCs}
-${externalPackageImports}
-${mergedRPCMap}
-
-export type RPCInvoke = <Name extends keyof FlattenedRPCMap>(
-  name: Name,
-  data: FlattenedRPCMap[Name]['input'],
-  options?: {
-    location?: 'local' | 'remote' | 'auto'
-  }
-) => Promise<FlattenedRPCMap[Name]['output']>
-
-// Import WorkflowMap for workflow typing
-import type { WorkflowMap } from '../workflow/pikku-workflow-map.gen.js'
-
-export type TypedPikkuRPC = {
-  depth: number;
-  global: boolean;
-  invoke: RPCInvoke;
-  invokeExposed: (name: string, data: any) => Promise<any>;
-  startWorkflow: <Name extends keyof WorkflowMap>(
-    name: Name,
-    input: WorkflowMap[Name]['input']
-  ) => Promise<{ runId: string }>;
-}
-  `
-}
-
-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,
-  typesMap: TypesMap,
-  requiredTypes: Set<string>
-) {
-  // Initialize an object to collect RPCs
-  const rpcsObj: Record<string, { inputType: string; outputType: string }> = {}
-
-  // Iterate through RPC metadata
-  for (const [funcName, pikkuFuncName] of Object.entries(rpcMeta)) {
-    const functionMeta = functionsMeta[pikkuFuncName]
-    if (!functionMeta) {
-      throw new Error(
-        `Function ${funcName} not found in functionsMeta. Please check your configuration.`
-      )
-    }
-
-    const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined
-    const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
-
-    // Store the input and output types for RPCHandler
-    // 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 {
-        // Type not in typesMap - use the name directly (e.g., zod-derived types)
-        inputType = input
-      }
-    }
-
-    let outputType = 'null'
-    if (output) {
-      try {
-        outputType = typesMap.getTypeMeta(output).uniqueName
-      } catch {
-        // Type not in typesMap - use the name directly (e.g., zod-derived types)
-        outputType = output
-      }
-    }
-
-    requiredTypes.add(inputType)
-    requiredTypes.add(outputType)
-
-    // Add RPC entry
-    rpcsObj[funcName] = {
-      inputType,
-      outputType,
-    }
-  }
-
-  // Build the RPCs object as a string
-  let rpcsStr = 'export type RPCMap = {\n'
-
-  for (const [funcName, handler] of Object.entries(rpcsObj)) {
-    rpcsStr += `  readonly '${funcName}': RPCHandler<${handler.inputType}, ${handler.outputType}>,\n`
-  }
-
-  rpcsStr += '};\n'
-
-  return rpcsStr
-}

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

@@ -1,25 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { serializeSchedulerTypes } from './serialize-scheduler-types.js'
-
-export const pikkuSchedulerTypes: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config }) => {
-    const { schedulersTypesFile, functionTypesFile, packageMappings } = config
-
-    const functionTypesImportPath = getFileImportRelativePath(
-      schedulersTypesFile,
-      functionTypesFile,
-      packageMappings
-    )
-    const content = serializeSchedulerTypes(functionTypesImportPath)
-    await writeFileInDir(logger, schedulersTypesFile, content)
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Creating cheduler types',
-      commandEnd: 'Created scheduler types',
-    }),
-  ],
-})

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

@@ -1,88 +0,0 @@
-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 {
-  serializeSchedulerMeta,
-  serializeSchedulerMetaTS,
-} from './serialize-scheduler-meta.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import {
-  stripVerboseFields,
-  hasVerboseFields,
-} from '../../../utils/strip-verbose-meta.js'
-
-export const pikkuScheduler: any = pikkuSessionlessFunc<
-  void,
-  boolean | undefined
->({
-  func: async ({ logger, config, getInspectorState }) => {
-    const visitState = await getInspectorState()
-    const {
-      schedulersWiringFile,
-      schedulersWiringMetaFile,
-      schedulersWiringMetaJsonFile,
-      packageMappings,
-      schema,
-    } = config
-    const { scheduledTasks } = visitState
-
-    const fullMeta = serializeSchedulerMeta(scheduledTasks.meta)
-
-    // Write minimal JSON (runtime-only fields)
-    const minimalMeta = stripVerboseFields(fullMeta)
-    await writeFileInDir(
-      logger,
-      schedulersWiringMetaJsonFile,
-      JSON.stringify(minimalMeta, null, 2)
-    )
-
-    // Write verbose JSON only if it has additional fields
-    if (hasVerboseFields(fullMeta)) {
-      const verbosePath = schedulersWiringMetaJsonFile.replace(
-        /\.gen\.json$/,
-        '-verbose.gen.json'
-      )
-      await writeFileInDir(
-        logger,
-        verbosePath,
-        JSON.stringify(fullMeta, null, 2)
-      )
-    }
-
-    const jsonImportPath = getFileImportRelativePath(
-      schedulersWiringMetaFile,
-      schedulersWiringMetaJsonFile,
-      packageMappings
-    )
-
-    await writeFileInDir(
-      logger,
-      schedulersWiringMetaFile,
-      serializeSchedulerMetaTS(
-        scheduledTasks.meta,
-        jsonImportPath,
-        schema?.supportsImportAttributes ?? false
-      )
-    )
-
-    await writeFileInDir(
-      logger,
-      schedulersWiringFile,
-      serializeFileImports(
-        'addScheduledTasks',
-        schedulersWiringFile,
-        scheduledTasks.files,
-        packageMappings
-      )
-    )
-
-    return true
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Finding Scheduled tasks',
-      commandEnd: 'Found Scheduled tasks',
-    }),
-  ],
-})

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

@@ -1,37 +0,0 @@
-import { ScheduledTasksMeta } from '@pikku/core/scheduler'
-
-export const serializeSchedulerMeta = (
-  scheduledTasksMeta: ScheduledTasksMeta
-) => {
-  return scheduledTasksMeta
-}
-
-export const serializeSchedulerMetaTS = (
-  scheduledTasksMeta: ScheduledTasksMeta,
-  jsonImportPath: string,
-  supportsImportAttributes
-) => {
-  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 { ScheduledTasksMeta } from '@pikku/core/scheduler'"
-  )
-  serializedOutput.push(importStatement)
-  serializedOutput.push('')
-  serializedOutput.push(
-    "pikkuState(null, 'scheduler', 'meta', metaData as ScheduledTasksMeta)"
-  )
-  serializedOutput.push('')
-
-  const scheduledTasksMetaValues = Object.values(scheduledTasksMeta)
-  if (scheduledTasksMetaValues.length > 0) {
-    serializedOutput.push(
-      `export type ScheduledTaskNames = '${scheduledTasksMetaValues.map((s) => s.name).join("' | '")}'`
-    )
-  }
-  return serializedOutput.join('\n')
-}

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

@@ -1,28 +0,0 @@
-/**
- * Generates type definitions for scheduler wirings
- */
-export const serializeSchedulerTypes = (functionTypesImportPath: string) => {
-  return `/**
- * Scheduler-specific type definitions for tree-shaking optimization
- */
-
-import { CoreScheduledTask, wireScheduler as wireSchedulerCore } from '@pikku/core/scheduler'
-import type { PikkuFunctionConfig, PikkuMiddleware } from '${functionTypesImportPath}'
-
-/**
- * Type definition for scheduled tasks that run at specified intervals.
- * These are sessionless functions that execute based on cron expressions.
- */
-type SchedulerWiring = CoreScheduledTask<PikkuFunctionConfig<void, void, 'session' | 'rpc'>, PikkuMiddleware>
-
-/**
- * Registers a scheduled task with the Pikku framework.
- * Tasks run based on cron expressions and are sessionless.
- *
- * @param task - Scheduled task definition with cron expression and handler
- */
-export const wireScheduler = (task: SchedulerWiring) => {
-  wireSchedulerCore(task as any) // TODO
-}
-`
-}

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

@@ -1,25 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { writeAllServiceMetadata } from '@pikku/inspector'
-
-export const pikkuServiceMetadata: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config, getInspectorState }) => {
-    const state = await getInspectorState()
-
-    // Only write service metadata if there are services to document
-    if (state.serviceMetadata && state.serviceMetadata.length > 0) {
-      writeAllServiceMetadata(state.serviceMetadata, config.outDir)
-      logger.debug(
-        `• Wrote ${state.serviceMetadata.length} service metadata files`
-      )
-    } else {
-      logger.debug('• No service metadata to write')
-    }
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Generating service metadata',
-      commandEnd: 'Generated service metadata',
-    }),
-  ],
-})

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

@@ -1,218 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { convertDslToGraph, ErrorCode } from '@pikku/inspector'
-import type { WorkflowsMeta } from '@pikku/core/workflow'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { serializeWorkflowTypes } from './serialize-workflow-types.js'
-import { serializeWorkflowRegistration } from './serialize-workflow-registration.js'
-import { serializeWorkflowMap } from './serialize-workflow-map.js'
-import { serializeWorkflowMeta } from './serialize-workflow-meta.js'
-import { serializeWorkflowWorkers } from './serialize-workflow-workers.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import {
-  stripVerboseFields,
-  hasVerboseFields,
-} from '../../../utils/strip-verbose-meta.js'
-import { join } from 'path'
-
-export const pikkuWorkflow: any = pikkuSessionlessFunc<
-  void,
-  boolean | undefined
->({
-  func: async ({ logger, config, getInspectorState }) => {
-    const visitState = await getInspectorState()
-    const {
-      workflowsWiringFile,
-      workflowsWiringMetaFile,
-      workflowMetaDir,
-      workflowMapDeclarationFile,
-      workflowTypesFile,
-      functionTypesFile,
-      typesDeclarationFile,
-      packageMappings,
-      schema,
-    } = config
-    const { workflows, functions: functionState } = visitState
-    const { typesMap } = functionState
-
-    // Get all workflow names (both DSL and graph-based)
-    const dslWorkflowNames = Object.keys(workflows.meta)
-    const graphWorkflowNames = Object.keys(workflows.graphMeta)
-    const allWorkflowNames = [
-      ...new Set([...dslWorkflowNames, ...graphWorkflowNames]),
-    ]
-
-    const hasWorkflows = allWorkflowNames.length > 0
-
-    // Validate that workflowService is configured if workflows are defined
-    if (hasWorkflows) {
-      const hasWorkflowState =
-        visitState.serviceAggregation.allSingletonServices.includes(
-          'workflowService'
-        )
-      if (!hasWorkflowState) {
-        logger.critical(
-          ErrorCode.WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED,
-          'Workflows detected but workflowService service not configured. Please add workflowService to your singleton services'
-        )
-        throw new Error(
-          'WorkflowState service not configured but workflows are defined'
-        )
-      }
-    }
-
-    // Generate individual JSON files for each workflow (convert DSL to graph format)
-    if (hasWorkflows && workflowMetaDir) {
-      // Write individual JSON files for DSL workflows
-      const dslMeta = workflows.meta as WorkflowsMeta
-      for (const [name, meta] of Object.entries(dslMeta)) {
-        const graphMeta = convertDslToGraph(name, meta)
-
-        // Write minimal version (runtime-only fields)
-        const minimalMeta = stripVerboseFields(graphMeta)
-        const minimalPath = join(workflowMetaDir, `${name}.gen.json`)
-        await writeFileInDir(
-          logger,
-          minimalPath,
-          JSON.stringify(minimalMeta, null, 2),
-          { ignoreModifyComment: true }
-        )
-
-        // Write verbose version only if it has additional fields
-        if (hasVerboseFields(graphMeta)) {
-          const verbosePath = join(workflowMetaDir, `${name}-verbose.gen.json`)
-          await writeFileInDir(
-            logger,
-            verbosePath,
-            JSON.stringify(graphMeta, null, 2),
-            { ignoreModifyComment: true }
-          )
-        }
-      }
-
-      // Write individual JSON files for graph workflows
-      for (const [name, graphMeta] of Object.entries(workflows.graphMeta)) {
-        // Write minimal version (runtime-only fields)
-        const minimalMeta = stripVerboseFields(graphMeta)
-        const minimalPath = join(workflowMetaDir, `${name}.gen.json`)
-        await writeFileInDir(
-          logger,
-          minimalPath,
-          JSON.stringify(minimalMeta, null, 2),
-          { ignoreModifyComment: true }
-        )
-
-        // Write verbose version only if it has additional fields
-        if (hasVerboseFields(graphMeta)) {
-          const verbosePath = join(workflowMetaDir, `${name}-verbose.gen.json`)
-          await writeFileInDir(
-            logger,
-            verbosePath,
-            JSON.stringify(graphMeta, null, 2),
-            { ignoreModifyComment: true }
-          )
-        }
-      }
-    }
-
-    // Generate workflow meta aggregation file
-    if (workflowsWiringMetaFile && workflowMetaDir) {
-      await writeFileInDir(
-        logger,
-        workflowsWiringMetaFile,
-        serializeWorkflowMeta(
-          workflowsWiringMetaFile,
-          workflowMetaDir,
-          allWorkflowNames,
-          packageMappings,
-          schema?.supportsImportAttributes ?? false,
-          config.externalPackageName
-        )
-      )
-    }
-
-    // Generate workflow registration (meta + DSL workflow registrations)
-    const metaImportPath = getFileImportRelativePath(
-      workflowsWiringFile,
-      workflowsWiringMetaFile,
-      packageMappings
-    )
-
-    await writeFileInDir(
-      logger,
-      workflowsWiringFile,
-      serializeWorkflowRegistration(
-        workflowsWiringFile,
-        metaImportPath,
-        allWorkflowNames,
-        workflows.files,
-        workflows.graphFiles,
-        packageMappings,
-        config.externalPackageName
-      )
-    )
-
-    // Generate workflow types (DSL + graph helpers in one file)
-    const functionTypesImportPath = getFileImportRelativePath(
-      workflowTypesFile,
-      functionTypesFile,
-      packageMappings
-    )
-    const rpcMapImportPath = getFileImportRelativePath(
-      workflowTypesFile,
-      config.rpcInternalMapDeclarationFile,
-      packageMappings
-    )
-
-    await writeFileInDir(
-      logger,
-      workflowTypesFile,
-      serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath)
-    )
-
-    // Generate workflow map (I/O types for type-safe client)
-    // Always generate even if empty - RPC map imports WorkflowMap
-    await writeFileInDir(
-      logger,
-      workflowMapDeclarationFile,
-      serializeWorkflowMap(
-        workflowMapDeclarationFile,
-        packageMappings,
-        typesMap,
-        functionState.meta,
-        workflows.meta
-      )
-    )
-
-    // Generate workflow workers if configured
-    if (config.workflows) {
-      if (config.workflows.singleQueue) {
-        const workflowPath = join(config.rootDir, config.workflows.path)
-        const pathToPikkuTypes = getFileImportRelativePath(
-          workflowPath,
-          typesDeclarationFile,
-          packageMappings
-        )
-        await writeFileInDir(
-          logger,
-          workflowPath,
-          serializeWorkflowWorkers(pathToPikkuTypes)
-        )
-      } else if (workflows.files.size > 0) {
-        logger.critical(
-          ErrorCode.WORKFLOW_MULTI_QUEUE_NOT_SUPPORTED,
-          'Multi-queue workflows are not supported when workflows.singleQueue is false. Please enable singleQueue in your configuration.'
-        )
-        return false
-      }
-    }
-
-    return hasWorkflows
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Generating Workflows',
-      commandEnd: 'Generated Workflows',
-    }),
-  ],
-})