@pikku/cli 0.11.2 → 0.12.0

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

@@ -1,66 +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 {
-  serializeQueueMeta,
-  serializeQueueMetaTS,
-} from './serialize-queue-meta.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-
-export const pikkuQueue: any = pikkuSessionlessFunc<void, boolean | undefined>({
-  func: async ({ logger, config, getInspectorState }) => {
-    const visitState = await getInspectorState()
-    const {
-      queueWorkersWiringFile,
-      queueWorkersWiringMetaFile,
-      queueWorkersWiringMetaJsonFile,
-      packageMappings,
-      schema,
-    } = config
-    const { queueWorkers } = visitState
-
-    // 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,
-      serializeQueueMetaTS(
-        jsonImportPath,
-        schema?.supportsImportAttributes ?? false
-      )
-    )
-
-    await writeFileInDir(
-      logger,
-      queueWorkersWiringFile,
-      serializeFileImports(
-        'addQueueWorkers',
-        queueWorkersWiringFile,
-        queueWorkers.files,
-        packageMappings
-      )
-    )
-
-    return true
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Finding Queues',
-      commandEnd: 'Found Queues',
-    }),
-  ],
-})

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

@@ -1,26 +0,0 @@
-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 { serializeQueueMap } from './serialize-queue-map.js'
-
-export const pikkuQueueMap: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config, getInspectorState }) => {
-    const { queueWorkers, functions } = await getInspectorState()
-    const { queueMapDeclarationFile, packageMappings } = config
-
-    const content = serializeQueueMap(
-      queueMapDeclarationFile,
-      packageMappings,
-      functions.typesMap,
-      functions.meta,
-      queueWorkers.meta
-    )
-    await writeFileInDir(logger, queueMapDeclarationFile, content)
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Creating Queue map',
-      commandEnd: 'Created Queue map',
-    }),
-  ],
-})

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

@@ -1,75 +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 {
-  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 }) => {
-    const visitState = await getInspectorState()
-    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(queueMeta), 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,
-      serializeQueueMetaTS(
-        jsonImportPath,
-        schema?.supportsImportAttributes ?? false
-      )
-    )
-
-    await writeFileInDir(
-      logger,
-      queueWorkersWiringFile,
-      serializeFileImports(
-        'addQueueWorkers',
-        queueWorkersWiringFile,
-        queueWorkers.files,
-        packageMappings
-      )
-    )
-
-    return true
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Finding queues',
-      commandEnd: 'Found queue',
-    }),
-  ],
-})

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

@@ -1,119 +0,0 @@
-import type { QueueWorkersMeta } from '@pikku/core/queue'
-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 serializeQueueMap = (
-  relativeToPath: string,
-  packageMappings: Record<string, string>,
-  typesMap: TypesMap,
-  functionsMeta: FunctionsMeta,
-  queueWorkersMeta: QueueWorkersMeta
-) => {
-  const requiredTypes = new Set<string>()
-  const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
-  const serializedQueues = generateQueues(
-    queueWorkersMeta,
-    functionsMeta,
-    typesMap,
-    requiredTypes
-  )
-
-  const serializedImportMap = serializeImportMap(
-    relativeToPath,
-    packageMappings,
-    typesMap,
-    requiredTypes
-  )
-
-  return `/**
- * This provides the structure needed for typescript to be aware of Queue workers and their input/output types
- */
-    
-${serializedImportMap}
-${serializedCustomTypes}
-
-import type { QueueJob } from '@pikku/core/queue'
-
-interface QueueHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-${serializedQueues}
-
-type QueueAdd = <Name extends keyof QueueMap>(
-  name: Name,
-  data: QueueMap[Name]['input'],
-  options?: {
-    priority?: number
-    delay?: number
-    attempts?: number
-    removeOnComplete?: number
-    removeOnFail?: number
-    jobId?: string
-  }
-) => Promise<string>
-
-type QueueGetJob = <Name extends keyof QueueMap>(
-  name: Name,
-  jobId: string
-) => Promise<QueueJob<QueueMap[Name]['input'], QueueMap[Name]['output']> | null>
-
-export type TypedPikkuQueue = {
-  add: QueueAdd;
-  getJob: QueueGetJob;
-}
-  `
-}
-
-function generateQueues(
-  queueWorkersMeta: QueueWorkersMeta,
-  functionsMeta: FunctionsMeta,
-  typesMap: TypesMap,
-  requiredTypes: Set<string>
-) {
-  // Initialize an object to collect queues
-  const queuesObj: Record<string, { inputType: string; outputType: string }> =
-    {}
-
-  // Iterate through Queue metadata
-  for (const [queueName, { pikkuFuncName }] of Object.entries(
-    queueWorkersMeta
-  )) {
-    const functionMeta = functionsMeta[pikkuFuncName]
-    if (!functionMeta) {
-      throw new Error(
-        `Function ${queueName} 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 QueueHandler
-    const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null'
-    const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null'
-
-    requiredTypes.add(inputType)
-    requiredTypes.add(outputType)
-
-    // Add Queue entry
-    queuesObj[queueName] = {
-      inputType,
-      outputType,
-    }
-  }
-
-  // Build the Queues object as a string
-  let queuesStr = 'export type QueueMap = {\n'
-
-  for (const [queueName, handler] of Object.entries(queuesObj)) {
-    queuesStr += `  readonly '${queueName}': QueueHandler<${handler.inputType}, ${handler.outputType}>,\n`
-  }
-
-  queuesStr += '};\n'
-
-  return queuesStr
-}

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

@@ -1,24 +0,0 @@
-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', metaData as QueueWorkersMeta)"
-  )
-  return serializedOutput.join('\n')
-}

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

@@ -1,30 +0,0 @@
-/**
- * Generates type definitions for queue wirings
- */
-export const serializeQueueTypes = (functionTypesImportPath: string) => {
-  return `/**
- * Queue-specific type definitions for tree-shaking optimization
- */
-
-import { CoreQueueWorker, wireQueueWorker as wireQueueWorkerCore } from '@pikku/core/queue'
-import type { PikkuFunctionConfig } from '${functionTypesImportPath}'
-
-/**
- * Type definition for queue workers that process background jobs.
- *
- * @template In - Input type for the queue job
- * @template Out - Output type for the queue job
- */
-type QueueWiring<In, Out> = CoreQueueWorker<PikkuFunctionConfig<In, Out, 'session' | 'rpc'>>
-
-/**
- * Registers a queue worker with the Pikku framework.
- * Workers process background jobs from queues.
- *
- * @param queueWorker - Queue worker definition with job handler
- */
-export const wireQueueWorker = (queueWorker: QueueWiring<any, any>) => {
-  wireQueueWorkerCore(queueWorker as any) // TODO
-}
-`
-}

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

@@ -1,35 +0,0 @@
-export const serializeQueueWrapper = (queueMapPath: string) => {
-  return `
-import type { QueueService, QueueJob } from '@pikku/core/queue'
-import type { QueueMap, TypedPikkuQueue } from '${queueMapPath}'
-
-export class PikkuQueue implements TypedPikkuQueue {
-    constructor(private queueService: QueueService) {}
-
-    public async add<Name extends keyof QueueMap>(
-        queueName: Name,
-        data: QueueMap[Name]['input'],
-        options?: {
-            priority?: number
-            delay?: number
-            attempts?: number
-            removeOnComplete?: number
-            removeOnFail?: number
-            jobId?: string
-        }
-    ): Promise<string> {
-        return this.queueService.add(queueName as string, data, options);
-    }
-
-    public async getJob<Name extends keyof QueueMap>(
-        queueName: Name,
-        jobId: string
-    ): Promise<QueueJob<QueueMap[Name]['input'], QueueMap[Name]['output']> | null> {
-        return this.queueService.getJob<QueueMap[Name]['input'], QueueMap[Name]['output']>(
-            queueName as string,
-            jobId
-        );
-    }
-}
-`
-}

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

@@ -1,32 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { serializePublicRPC } from './serialize-public-rpc.js'
-import { join } from 'path'
-
-export const pikkuPublicRPC: any = pikkuSessionlessFunc<void, boolean>({
-  func: async ({ logger, config }) => {
-    if (config.rpc?.publicRpcPath) {
-      const publicRpcPath = join(config.rootDir, config.rpc.publicRpcPath)
-      const pathToPikkuTypes = getFileImportRelativePath(
-        publicRpcPath,
-        config.typesDeclarationFile,
-        config.packageMappings
-      )
-      await writeFileInDir(
-        logger,
-        publicRpcPath,
-        serializePublicRPC(pathToPikkuTypes)
-      )
-      return true
-    }
-    return false
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Generating Public RPC Endpoint',
-      commandEnd: 'Generated Public RPC Endpoint',
-    }),
-  ],
-})

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

@@ -1,35 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { serializeRemoteRPC } from './serialize-remote-rpc.js'
-import { join } from 'path'
-
-export const pikkuRemoteRPC: any = pikkuSessionlessFunc<void, boolean>({
-  func: async ({ logger, config }) => {
-    if (config.rpc?.remoteRpcWorkersPath) {
-      const remoteRpcPath = join(
-        config.rootDir,
-        config.rpc.remoteRpcWorkersPath
-      )
-      const pathToPikkuTypes = getFileImportRelativePath(
-        remoteRpcPath,
-        config.typesDeclarationFile,
-        config.packageMappings
-      )
-      await writeFileInDir(
-        logger,
-        remoteRpcPath,
-        serializeRemoteRPC(pathToPikkuTypes)
-      )
-      return true
-    }
-    return false
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Generating Remote RPC Workers',
-      commandEnd: 'Generated Remote RPC Workers',
-    }),
-  ],
-})

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

@@ -1,35 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { serializeRPCWrapper } from './serialize-rpc-wrapper.js'
-
-export const pikkuRPCClient: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config }) => {
-    const { rpcWiringsFile, rpcMapDeclarationFile, packageMappings } = config
-
-    // If rpcWiringsFile is not set, clean up any existing file and return
-    if (!rpcWiringsFile) {
-      logger.info({
-        message:
-          "Skipping generating RPC wrappers since rpcWiringsFile isn't set in the pikku config.",
-        type: 'skip',
-      })
-      return
-    }
-
-    const rpcMapDeclarationPath = getFileImportRelativePath(
-      rpcWiringsFile,
-      rpcMapDeclarationFile,
-      packageMappings
-    )
-    const content = [serializeRPCWrapper(rpcMapDeclarationPath)]
-    await writeFileInDir(logger, rpcWiringsFile, content.join('\n'))
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Generating RPC wrappers',
-      commandEnd: 'Generated RPC wrappers',
-    }),
-  ],
-})

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

@@ -1,48 +0,0 @@
-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 { 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 content = serializeTypedRPCMap(
-      rpcInternalMapDeclarationFile,
-      packageMappings,
-      functions.typesMap,
-      functions.meta,
-      rpc.internalMeta
-    )
-    await writeFileInDir(logger, rpcInternalMapDeclarationFile, content)
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Creating RPC internal map',
-      commandEnd: 'Created RPC internal map',
-    }),
-  ],
-})
-
-export const pikkuRPCExposedMap: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config, getInspectorState }) => {
-    const { functions, rpc } = await getInspectorState()
-    const { rpcMapDeclarationFile, packageMappings } = config
-
-    const content = serializeTypedRPCMap(
-      rpcMapDeclarationFile,
-      packageMappings,
-      functions.typesMap,
-      functions.meta,
-      rpc.exposedMeta
-    )
-    await writeFileInDir(logger, rpcMapDeclarationFile, content)
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Creating RPC external map',
-      commandEnd: 'Created RPC external map',
-    }),
-  ],
-})

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

@@ -1,49 +0,0 @@
-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,
-      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'\n${importStatement}\npikkuState('rpc', 'meta', metaData as Record<string, string>)`
-      )
-      return true
-    }
-    return false
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Finding RPCs tasks',
-      commandEnd: 'Found RPCs',
-    }),
-  ],
-})

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

@@ -1,37 +0,0 @@
-/**
- * Generate public RPC HTTP endpoint
- */
-export const serializePublicRPC = (pathToPikkuTypes: string) => {
-  return `/**
- * Auto-generated public RPC HTTP endpoint
- * Do not edit manually - regenerate with 'npx pikku'
- */
-import { pikkuSessionlessFunc, wireHTTP } from '${pathToPikkuTypes}'
-
-/**
- * Public RPC endpoint that invokes any exposed RPC by name
- * This is used for public HTTP access to exposed server functions
- */
-export const rpcCaller = pikkuSessionlessFunc<
-  { rpcName: string, data?: any },
-  any
->({
-  func: async (services, { rpcName, data }, { rpc }) => {
-    return await (rpc.invokeExposed as any)(rpcName, data)
-  },
-})
-
-wireHTTP({
-  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

@@ -1,30 +0,0 @@
-/**
- * Generate remote internal RPC queue worker and HTTP endpoint
- */
-export const serializeRemoteRPC = (pathToPikkuTypes: string) => {
-  return `/**
- * Auto-generated remote internal RPC queue worker and HTTP endpoint
- * Do not edit manually - regenerate with 'npx pikku'
- */
-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)
- */
-export const pikkuRemoteInternalRPC = pikkuSessionlessFunc<
-  { rpcName: string, data?: any },
-  any
->({
-  func: async (_services, { rpcName, data }, { rpc }) => {
-    return await (rpc.invoke as any)(rpcName, data)
-  },
-  internal: true,
-})
-
-wireQueueWorker({
-  queueName: 'pikku-remote-internal-rpc',
-  func: pikkuRemoteInternalRPC,
-})
-`
-}