@pikku/cli 0.11.3 → 0.12.0

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

@@ -1,134 +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
-    // 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)
-
-    // 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(null, '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,51 +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, externalPackages } =
-      config
-
-    const content = serializeTypedRPCMap(
-      rpcInternalMapDeclarationFile,
-      packageMappings,
-      functions.typesMap,
-      functions.meta,
-      rpc.internalMeta,
-      externalPackages
-    )
-    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, externalPackages } = config
-
-    const content = serializeTypedRPCMap(
-      rpcMapDeclarationFile,
-      packageMappings,
-      functions.typesMap,
-      functions.meta,
-      rpc.exposedMeta,
-      externalPackages
-    )
-    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(null, '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,33 +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)
- *
- * 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 (_services, { rpcName, data }, { rpc }) => {
-    return await (rpc.invoke as any)(rpcName, data)
-  },
-  internal: true,
-})
-
-wireQueueWorker({
-  queueName: 'pikku-remote-internal-rpc',
-  func: pikkuRemoteInternalRPC,
-})
-`
-}

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: String(rpcName), data }) as any
-    }
-}
-
-export const pikkuRPC = new PikkuRPC();
-`
-}