@pikku/cli 0.11.2 → 0.12.0

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

@@ -1,68 +0,0 @@
-export const serializeRPCWrapper = (rpcMapPath: string) => {
-  return `
-import { PikkuFetch } from "./pikku-fetch.gen.js"
-import type { RPCInvoke } from '${rpcMapPath}'
-
-/**
- * PikkuRPC provides a type-safe client for making Remote Procedure Calls (RPC) 
- * to your Pikku server. It wraps the underlying HTTP client and provides a 
- * simple interface for invoking server-side functions.
- */
-export class PikkuRPC {
-    /** The underlying HTTP client used for making RPC calls */
-    pikkuFetch = new PikkuFetch()
-
-    /**
-     * Sets a custom PikkuFetch instance to use for RPC calls.
-     * This allows you to configure custom settings or use a shared client instance.
-     * 
-     * @param pikkuFetch - The PikkuFetch instance to use
-     */
-    setPikkuFetch(pikkuFetch: PikkuFetch): void {
-        this.pikkuFetch = pikkuFetch
-    }
-
-    /**
-     * Sets the base server URL for all RPC calls.
-     * 
-     * @param serverUrl - The base URL of your Pikku server (e.g., 'https://api.example.com')
-     */
-    setServerUrl(serverUrl: string): void {
-        this.pikkuFetch.setServerUrl(serverUrl)
-    }
-
-    /**
-     * Sets the JWT token for authorization on all RPC calls.
-     * 
-     * @param jwt - The JWT token to use for authorization, or null to remove authorization
-     */
-    setAuthorizationJWT(jwt: string | null): void {
-        this.pikkuFetch.setAuthorizationJWT(jwt)
-    }
-
-    /**
-     * Sets the API key for authorization on all RPC calls.
-     * 
-     * @param apiKey - The API key to use for authorization, or null to remove the API key
-     */
-    setAPIKey(apiKey: string | null): void {
-        this.pikkuFetch.setAPIKey(apiKey)
-    }
-
-    /**
-     * Invokes a remote procedure call on the server.
-     * This is a generic method that routes to the appropriate server function
-     * based on the function name and passes the provided data.
-     *
-     * @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 (rpcName, data) => {
-       return await this.pikkuFetch.post(\`/rpc/\${rpcName}\` as any, { rpcName, data }) as any
-    }
-}
-
-export const pikkuRPC = new PikkuRPC();
-`
-}

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

@@ -1,128 +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>
-) => {
-  const requiredTypes = new Set<string>()
-  const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
-  const serializedRPCs = generateRPCs(
-    rpcMeta,
-    functionsMeta,
-    typesMap,
-    requiredTypes
-  )
-
-  const serializedImportMap = serializeImportMap(
-    relativeToPath,
-    packageMappings,
-    typesMap,
-    requiredTypes
-  )
-
-  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}
-
-export type RPCInvoke = <Name extends keyof RPCMap>(
-  name: Name,
-  data: RPCMap[Name]['input'],
-  options?: {
-    location?: 'local' | 'remote' | 'auto'
-  }
-) => Promise<RPCMap[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 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
-    // Use 'any' for types not in typesMap (e.g., inline types in generated workflow workers)
-    let inputType = 'null'
-    if (input) {
-      try {
-        inputType = typesMap.getTypeMeta(input).uniqueName
-      } catch {
-        inputType = 'any'
-      }
-    }
-
-    let outputType = 'null'
-    if (output) {
-      try {
-        outputType = typesMap.getTypeMeta(output).uniqueName
-      } catch {
-        outputType = 'any'
-      }
-    }
-
-    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,67 +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'
-
-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
-
-    await writeFileInDir(
-      logger,
-      schedulersWiringMetaJsonFile,
-      JSON.stringify(serializeSchedulerMeta(scheduledTasks.meta), 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('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-map.ts

@@ -1,24 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { serializeWorkflowMap } from './serialize-workflow-map.js'
-
-export const pikkuWorkflowMap: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config, getInspectorState }) => {
-    const visitState = await getInspectorState()
-    const { workflowMapDeclarationFile, packageMappings } = config
-    const { workflows, functions: functionState } = visitState
-    const { typesMap } = functionState
-
-    await writeFileInDir(
-      logger,
-      workflowMapDeclarationFile,
-      serializeWorkflowMap(
-        workflowMapDeclarationFile,
-        packageMappings,
-        typesMap,
-        functionState.meta,
-        workflows.meta
-      )
-    )
-  },
-})

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

@@ -1,29 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { serializeWorkflowTypes } from './serialize-workflow-types.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-
-export const pikkuWorkflowTypes: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config }) => {
-    const { workflowTypesFile, functionTypesFile, packageMappings } = config
-
-    const functionTypesImportPath = getFileImportRelativePath(
-      workflowTypesFile,
-      functionTypesFile,
-      packageMappings
-    )
-
-    // Get RPC map import path
-    const rpcMapImportPath = getFileImportRelativePath(
-      workflowTypesFile,
-      config.rpcInternalMapDeclarationFile,
-      packageMappings
-    )
-
-    await writeFileInDir(
-      logger,
-      workflowTypesFile,
-      serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath)
-    )
-  },
-})

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

@@ -1,151 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { ErrorCode } from '@pikku/inspector'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import {
-  serializeWorkflowMeta,
-  serializeWorkflowMetaTS,
-} from './serialize-workflow-meta.js'
-import { serializeWorkflowTypes } from './serialize-workflow-types.js'
-import { serializeWorkflowMap } from './serialize-workflow-map.js'
-import { serializeWorkflowWorkers } from './serialize-workflow-workers.js'
-import { serializeWorkflowWirings } from './serialize-workflow-wirings.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.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,
-      workflowsWiringMetaJsonFile,
-      workflowMapDeclarationFile,
-      workflowTypesFile,
-      functionTypesFile,
-      typesDeclarationFile,
-      packageMappings,
-      schema,
-    } = config
-    const { workflows, functions: functionState } = visitState
-    const { typesMap } = functionState
-
-    // Validate that workflowService service is configured if workflows are defined
-    const hasWorkflows = Object.keys(workflows.meta).length > 0
-    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'
-        )
-      }
-    }
-
-    await writeFileInDir(
-      logger,
-      workflowsWiringMetaJsonFile,
-      JSON.stringify(serializeWorkflowMeta(workflows.meta), null, 2)
-    )
-
-    const jsonImportPath = getFileImportRelativePath(
-      workflowsWiringMetaFile,
-      workflowsWiringMetaJsonFile,
-      packageMappings
-    )
-
-    // Write workflow metadata TypeScript file that imports JSON
-    await writeFileInDir(
-      logger,
-      workflowsWiringMetaFile,
-      serializeWorkflowMetaTS(
-        workflows.meta,
-        jsonImportPath,
-        schema?.supportsImportAttributes ?? false
-      )
-    )
-
-    // Write workflow wirings (imports and addWorkflow calls)
-    await writeFileInDir(
-      logger,
-      workflowsWiringFile,
-      serializeWorkflowWirings(
-        workflowsWiringFile,
-        workflows.files,
-        packageMappings
-      )
-    )
-
-    // Write workflow types
-    const functionTypesImportPath = getFileImportRelativePath(
-      workflowTypesFile,
-      functionTypesFile,
-      packageMappings
-    )
-
-    // Get RPC map import path
-    const rpcMapImportPath = getFileImportRelativePath(
-      workflowTypesFile,
-      config.rpcInternalMapDeclarationFile,
-      packageMappings
-    )
-
-    await writeFileInDir(
-      logger,
-      workflowTypesFile,
-      serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath)
-    )
-
-    // Write workflow map (type-safe client API)
-    await writeFileInDir(
-      logger,
-      workflowMapDeclarationFile,
-      serializeWorkflowMap(
-        workflowMapDeclarationFile,
-        packageMappings,
-        typesMap,
-        functionState.meta,
-        workflows.meta
-      )
-    )
-
-    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 true
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Finding Workflows',
-      commandEnd: 'Found Workflows',
-    }),
-  ],
-})