@pikku/cli 0.10.1 → 0.11.0

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-backend-wrapper.js

@@ -1,13 +1,16 @@
 export const serializeNextJsBackendWrapper = (bootstrapPath, routesMapPath, configImport, singleServicesFactoryImport, sessionServicesImport) => {
     return `'server-only'
-  
+
 /**
  * This file provides a wrapper around the PikkuNextJS class to allow for methods to be type checked against your routes.
  * It ensures type safety for route handling methods when integrating with the @pikku/core framework.
  */
 import { PikkuNextJS } from '@pikku/next'
+import { NextRequest } from 'next/server.js'
 import type { HTTPWiringsMap, HTTPWiringHandlerOf, HTTPWiringsWithMethod } from '${routesMapPath}'
 
+type RouteContext = { params: Promise<Record<string, string | string[]>> }
+
 ${configImport}
 ${singleServicesFactoryImport}
 ${sessionServicesImport}
@@ -15,6 +18,11 @@ ${sessionServicesImport}
 import '${bootstrapPath}'
 
 let _pikku: PikkuNextJS | undefined
+let _removeAPIPrefix = true
+
+export const removeAPIPrefix = (enable: boolean) => {
+  _removeAPIPrefix = enable
+}
 
 /**
  * Initializes and returns an instance of PikkuNextJS with helper methods for handling route requests.
@@ -172,8 +180,44 @@ export const pikku = (_options?: any) => {
     patch: dynamicPatch,
     del: dynamicDel,
     staticGet,
-    staticPost
+    staticPost,
+  }
+}
+
+/**
+ * Pre-bound API request handler for Next.js App Router route handlers.
+ * Use this to directly export route handlers without losing context.
+ *
+ * @param req - The Next.js request object.
+ * @param context - Next.js route context (unused by Pikku, but required by Next.js signature).
+ * @returns A promise that resolves to a Next.js Response object.
+ *
+ * @example
+ * export const GET = pikkuAPIRequest
+ * export const POST = pikkuAPIRequest
+ */
+export const pikkuAPIRequest = (
+  req: NextRequest,
+  context: RouteContext
+): Promise<Response> => {
+  if (!_pikku) {
+    _pikku = new PikkuNextJS(
+      createConfig as any,
+      createSingletonServices as any,
+      createSessionServices
+    )
+  }
+  if (_removeAPIPrefix) {
+    const url = new URL(req.url)
+    url.pathname = url.pathname.replace(/^\\/api/, '') || '/'
+    req = new NextRequest(url.toString(), {
+      method: req.method,
+      headers: req.headers,
+      body: req.body,
+      duplex: 'half',
+    } as any)
   }
+  return _pikku.apiRequest(req)
 }
 `;
 };

package/dist/src/functions/wirings/channels/serialize-channel-types.js

@@ -10,11 +10,12 @@ export const serializeChannelTypes = (functionTypesImportPath) => {
 import { CoreChannel, wireChannel as wireChannelCore } from '@pikku/core/channel'
 import { CorePikkuFunctionConfig } from '@pikku/core'
 import { AssertHTTPWiringParams } from '@pikku/core/http'
-import type { PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
+import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
 
 /**
  * Type definition for WebSocket channels with typed data exchange.
  * Supports connection, disconnection, and message handling.
+ * Accepts both session-based (PikkuFunction) and sessionless (PikkuFunctionSessionless) functions.
  *
  * @template ChannelData - Type of data exchanged through the channel
  * @template Channel - String literal type for the channel name
@@ -24,7 +25,7 @@ type ChannelWiring<ChannelData, Channel extends string> = CoreChannel<
   Channel,
   CorePikkuFunctionConfig<PikkuFunctionSessionless<void, any, ChannelData>, PikkuPermission<void>, PikkuMiddleware>,
   CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void, ChannelData>, PikkuPermission<void>, PikkuMiddleware>,
-  CorePikkuFunctionConfig<PikkuFunctionSessionless<any, any, ChannelData>, PikkuPermission<any>, PikkuMiddleware>,
+  CorePikkuFunctionConfig<PikkuFunctionSessionless<any, any, ChannelData> | PikkuFunction<any, any, ChannelData>, PikkuPermission<any>, PikkuMiddleware>,
   PikkuPermission,
   PikkuMiddleware
 >

package/dist/src/functions/wirings/channels/serialize-websocket-wrapper.js

@@ -26,6 +26,20 @@ class PikkuWebSocketRoute<Channel extends keyof ChannelsMap, Route extends keyof
     }
 }
 
+/**
+ * Type-safe WebSocket wrapper for Pikku channels.
+ *
+ * @example
+ * // Browser usage
+ * const ws = new WebSocket('ws://localhost:3000')
+ * const pikkuWS = new PikkuWebSocket<'events'>(ws)
+ *
+ * @example
+ * // Node.js usage
+ * import WebSocket from 'ws'
+ * const ws = new WebSocket('ws://localhost:3000')
+ * const pikkuWS = new PikkuWebSocket<'events'>(ws)
+ */
 export class PikkuWebSocket<Channel extends keyof ChannelsMap, EventHubTopics extends Record<string, any> = {}> extends CorePikkuWebsocket {
     /**
      * Send a message to a specific route and method.

package/dist/src/functions/wirings/cli/pikku-command-cli-entry.js

@@ -35,8 +35,8 @@ export const pikkuCLIEntry = pikkuSessionlessFunc({
             for (const entrypointConfig of configs) {
                 // Normalize entrypoint config to get type
                 const entrypointType = typeof entrypointConfig === 'string'
-                    ? 'cli'
-                    : entrypointConfig.type || 'cli';
+                    ? 'local'
+                    : entrypointConfig.type || 'local';
                 // Handle channel type entrypoint
                 if (entrypointType === 'channel') {
                     if (typeof entrypointConfig === 'string' ||
@@ -85,10 +85,10 @@ export const pikkuCLIEntry = pikkuSessionlessFunc({
                     }
                     continue;
                 }
-                // Handle CLI type entrypoint (default)
+                // Handle local CLI type entrypoint (default)
                 const entrypointPath = typeof entrypointConfig === 'string'
                     ? entrypointConfig
-                    : entrypointConfig.type === 'cli'
+                    : entrypointConfig.type === 'local'
                         ? entrypointConfig.path
                         : undefined;
                 if (!entrypointPath) {

package/dist/src/functions/wirings/cli/serialize-channel-cli-client.js

@@ -99,11 +99,11 @@ ${rendererImports}
  * Executes CLI commands over a WebSocket connection
  */
 export async function ${capitalizedName}CLIClient(
-  url: string,
+  ws: WebSocket,
   args?: string[]
 ): Promise<void> {
-  // Create WebSocket connection
-  const pikkuWS = new CorePikkuWebsocket(url)
+  // Create Pikku WebSocket wrapper
+  const pikkuWS = new CorePikkuWebsocket(ws)
 
   // Register renderers for CLI commands
   const renderers = ${renderersMap}
@@ -121,10 +121,23 @@ export default ${capitalizedName}CLIClient
 
 // For direct execution (if this file is run directly)
 if (import.meta.url === \`file://\${process.argv[1]}\`) {
-  const url = process.env.PIKKU_WS_URL || 'ws://localhost:3000${finalChannelRoute}'
-  ${capitalizedName}CLIClient(url, process.argv.slice(2)).catch(error => {
-    console.error('Fatal error:', error.message)
-    process.exit(1)
+  const url = process.env.PIKKU_WS_URL || 'ws://localhost:4002${finalChannelRoute}'
+
+  // Create WebSocket instance
+  let WebSocketImpl: any
+  if (typeof WebSocket !== 'undefined') {
+    WebSocketImpl = WebSocket
+  } else {
+    // Node.js environment - dynamically import 'ws'
+    const wsModule = await import('ws')
+    WebSocketImpl = wsModule.default
+  }
+
+  const ws = new WebSocketImpl(url) as WebSocket
+  ${capitalizedName}CLIClient(ws, process.argv.slice(2)).catch(error => {
+    console.error('Fatal channel CLI error:', error)
+    // TODO: We get an error code even when it exists cleanly, investigate
+    // process.exit(1)
   })
 }
 `;

package/dist/src/functions/wirings/cli/serialize-channel-cli.js

@@ -24,12 +24,6 @@ export function serializeChannelCLI(programName, programMeta, channelFile, funct
         }
     };
     collectCommands(programMeta.commands);
-    // Generate the wireChannel call
-    const commandEntries = Object.entries(commandMap)
-        .map(([commandKey, { pikkuFuncName }]) => {
-        return `      '${commandKey}': ${pikkuFuncName}`;
-    })
-        .join(',\n');
     // Generate imports from function file locations
     const funcNames = [
         ...new Set(Object.values(commandMap).map((v) => v.pikkuFuncName)),
@@ -46,19 +40,50 @@ export function serializeChannelCLI(programName, programMeta, channelFile, funct
         .join('\n');
     // Get relative path to channel types file
     const channelTypesPath = getFileImportRelativePath(channelFile, channelTypesFile, packageMappings);
+    // Get relative path to function types file
+    const functionTypesPath = getFileImportRelativePath(channelFile, functionTypesFile, packageMappings);
     return `/**
  * WebSocket channel backend for '${programName}' CLI commands
  */
 import { wireChannel } from '${channelTypesPath}'
+import { pikkuMiddleware } from '${functionTypesPath}'
 ${imports}
 
+// Middleware to close the channel after CLI command completes
+const cliCloseOnComplete = pikkuMiddleware(async (services, { channel }, next) => {
+  const closeChannel = () => {
+    setTimeout(async () => {
+      try {
+        // This gives time for the response to be sent before closing
+        await channel?.close()
+      } catch (err) {
+        // Ignore errors on close
+      }
+    }, 200)
+  }
+  
+  try {
+    const result = await next()
+    closeChannel()
+    return result
+  } catch (error) {
+    closeChannel()
+    throw error
+  }
+})
+
 wireChannel({
   name: '${finalChannelName}',
   route: '${finalChannelRoute}',
   auth: false,
   onMessageWiring: {
     command: {
-${commandEntries}
+${Object.entries(commandMap)
+        .map(([commandKey, { pikkuFuncName }]) => `      '${commandKey}': {
+        func: ${pikkuFuncName},
+        middleware: [cliCloseOnComplete],
+      }`)
+        .join(',\n')}
     }
   },
   tags: ['cli', '${programName}']

package/dist/src/functions/wirings/cli/serialize-cli-types.js

@@ -24,6 +24,28 @@ ${userSessionTypeName !== 'Session' ? `type Session = ${userSessionTypeName}` :
  */
 type PikkuCLIRender<Data, RequiredServices extends SingletonServices = SingletonServices> = CorePikkuCLIRender<Data, RequiredServices, Session>
 
+/**
+ * Creates a type-safe CLI renderer with access to your application's singleton services.
+ * The renderer receives the full singleton services and output data to format and display results.
+ *
+ * @template Data - The output data type from the CLI command
+ * @template RequiredServices - The minimum services required for type checking (defaults to SingletonServices)
+ * @param render - Function that receives singleton services and data to render output
+ * @returns A CLI renderer configuration
+ *
+ * @example
+ * \`\`\`typescript
+ * const myRenderer = pikkuCLIRender<MyData>(({ logger }, data) => {
+ *   logger.info(data.message)
+ * })
+ * \`\`\`
+ */
+export const pikkuCLIRender = <Data, RequiredServices extends SingletonServices = SingletonServices>(
+  render: (services: SingletonServices, data: Data) => void | Promise<void>
+): PikkuCLIRender<Data, RequiredServices> => {
+  return render as any
+}
+
 /**
  * CLI command configuration with project-specific types.
  * Uses CoreCLICommandConfig from @pikku/core with local middleware and render types.

package/dist/src/functions/wirings/functions/pikku-command-services.d.ts

@@ -1,2 +1,2 @@
-export declare const serializeServicesMap: (requiredServices: Set<string>, forceRequiredServices: string[] | undefined, servicesImport: string, sessionServicesImport: string) => string;
+export declare const serializeServicesMap: (allSingletonServices: string[], allSessionServices: string[], requiredServices: Set<string>, forceRequiredServices: string[] | undefined, servicesImport: string, sessionServicesImport: string) => string;
 export declare const pikkuServices: any;

package/dist/src/functions/wirings/functions/pikku-command-services.js

@@ -3,7 +3,7 @@ import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { checkRequiredTypes } from '../../../utils/check-required-types.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-export const serializeServicesMap = (requiredServices, forceRequiredServices = [], servicesImport, sessionServicesImport) => {
+export const serializeServicesMap = (allSingletonServices, allSessionServices, requiredServices, forceRequiredServices = [], servicesImport, sessionServicesImport) => {
     // Use pre-aggregated services from inspector state
     // This includes services from:
     // - Wired functions (HTTP, channels, queues, schedulers, MCP, CLI, RPC)
@@ -11,45 +11,73 @@ export const serializeServicesMap = (requiredServices, forceRequiredServices = [
     // - Permissions used by wired functions
     // - Session factories
     const usedServices = new Set(requiredServices);
-    // Internal services that are created internally and not via the create service script
-    const internalServices = new Set(['rpc', 'mcp', 'channel', 'userSession']);
+    // Internal services that are created internally by the framework (PikkuInteraction)
+    // These should not appear in the services maps
+    const internalServices = new Set([
+        'rpc',
+        'mcp',
+        'channel',
+        'userSession',
+        'cli',
+        'http',
+        'queue',
+        'scheduledTask',
+    ]);
     // Add force-required services that might not be detected from function inspection
     forceRequiredServices.forEach((service) => {
         if (!internalServices.has(service)) {
             usedServices.add(service);
         }
     });
-    // Create a map of services with true for all needed services
-    const servicesMap = Object.fromEntries(Array.from(usedServices)
-        .sort()
-        .map((service) => [service, true]));
-    // Generate the TypeScript code
-    const serviceKeys = Object.keys(servicesMap).sort();
     // Services that are always required internally by the framework
     const defaultServices = ['config', 'logger', 'variables', 'schema'];
-    // Combine default services with detected services
-    const allRequiredServices = [
-        ...new Set([...defaultServices, ...serviceKeys]),
-    ].sort();
-    // For RequiredSingletonServices, we need to pick from the actual SingletonServices interface
-    // This will be resolved at compile time based on what's actually in the SingletonServices interface
-    // We don't need to hardcode which services are singletons beyond the core framework ones
+    defaultServices.forEach((service) => usedServices.add(service));
+    // Create singleton services map: all singleton services with true/false based on usage
+    const singletonServicesMap = {};
+    allSingletonServices.forEach((service) => {
+        singletonServicesMap[service] = usedServices.has(service);
+    });
+    // Create session services map: all session services with true/false based on usage
+    // Exclude internal framework services (PikkuInteraction)
+    const sessionServicesMap = {};
+    allSessionServices.forEach((service) => {
+        if (!internalServices.has(service)) {
+            sessionServicesMap[service] = usedServices.has(service);
+        }
+    });
+    // Get all required service names (those marked as true)
+    const requiredSingletonServiceNames = Object.keys(singletonServicesMap)
+        .filter((key) => singletonServicesMap[key])
+        .sort();
+    const requiredSessionServiceNames = Object.keys(sessionServicesMap)
+        .filter((key) => sessionServicesMap[key])
+        .sort();
     const code = [
         servicesImport,
         sessionServicesImport,
-        "import type { PikkuInteraction } from '@pikku/core'",
         '',
-        'export const singletonServices = {',
-        ...Object.keys(servicesMap).map((service) => `    '${service}': true,`),
+        '// Singleton services map: true if required, false if available but unused',
+        'export const requiredSingletonServices = {',
+        ...Object.keys(singletonServicesMap)
+            .sort()
+            .map((service) => `  '${service}': ${singletonServicesMap[service]},`),
+        '} as const',
+        '',
+        '// Session services map: true if required, false if available but unused',
+        'export const requiredSessionServices = {',
+        ...Object.keys(sessionServicesMap)
+            .sort()
+            .map((service) => `  '${service}': ${sessionServicesMap[service]},`),
         '} as const',
         '',
-        '// Singleton services (created once at startup)',
-        '// Only includes services that are both required and available in SingletonServices',
-        `export type RequiredSingletonServices = Pick<SingletonServices, Extract<keyof SingletonServices, ${allRequiredServices.map((key) => `'${key}'`).join(' | ')}>> & Partial<Omit<SingletonServices, ${allRequiredServices.map((key) => `'${key}'`).join(' | ')}>>`,
+        '// Type exports',
+        requiredSingletonServiceNames.length > 0
+            ? `export type RequiredSingletonServices = Pick<SingletonServices, ${requiredSingletonServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<SingletonServices, ${requiredSingletonServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
+            : 'export type RequiredSingletonServices = Partial<SingletonServices>',
         '',
-        '// Session services (created per request, can access singleton services)',
-        '// Omits singleton services and PikkuInteraction (mcp, rpc, http, channel)',
-        `export type RequiredSessionServices = Omit<Services, keyof SingletonServices | keyof PikkuInteraction>`,
+        requiredSessionServiceNames.length > 0
+            ? `export type RequiredSessionServices = Pick<Services, ${requiredSessionServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<Services, ${requiredSessionServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
+            : 'export type RequiredSessionServices = Partial<Services>',
         '',
     ].join('\n');
     return code;
@@ -68,7 +96,7 @@ export const pikkuServices = pikkuSessionlessFunc({
         }
         const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, singletonServicesType.typePath, config.packageMappings)}'`;
         const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, sessionServicesType.typePath, config.packageMappings)}'`;
-        const servicesCode = serializeServicesMap(visitState.serviceAggregation.requiredServices, config.forceRequiredServices, servicesImport, sessionServicesImport);
+        const servicesCode = serializeServicesMap(visitState.serviceAggregation.allSingletonServices, visitState.serviceAggregation.allSessionServices, visitState.serviceAggregation.requiredServices, config.forceRequiredServices, servicesImport, sessionServicesImport);
         await writeFileInDir(logger, config.servicesFile, servicesCode);
     },
     middleware: [

package/dist/src/functions/wirings/functions/schemas.js

@@ -7,8 +7,8 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 export const pikkuSchemas = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const schemas = await generateSchemas(logger, config.tsconfig, visitState.functions.typesMap, visitState.functions.meta, visitState.http.meta, config.schemasFromTypes);
-        await saveSchemas(logger, config.schemaDirectory, schemas, visitState.functions.typesMap, visitState.functions.meta, config.supportsImportAttributes, config.schemasFromTypes);
+        const schemas = await generateSchemas(logger, config.tsconfig, visitState.functions.typesMap, visitState.functions.meta, visitState.http.meta, config.schemasFromTypes, config.schema?.additionalProperties);
+        await saveSchemas(logger, config.schemaDirectory, schemas, visitState.functions.typesMap, visitState.functions.meta, config.schemasFromTypes, config.schema?.supportsImportAttributes);
         return true;
     },
     middleware: [

package/dist/src/functions/wirings/http/pikku-command-openapi.js

@@ -16,7 +16,7 @@ export const pikkuOpenAPI = pikkuSessionlessFunc({
             return;
         }
         const { http, functions } = await getInspectorState();
-        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta, schemasFromTypes);
+        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta, schemasFromTypes, config.schema?.additionalProperties);
         const openAPISpec = await generateOpenAPISpec(logger, functions.meta, http.meta, schemas, openAPI.additionalInfo);
         if (openAPI.outputFile.endsWith('.json')) {
             await writeFileInDir(logger, openAPI.outputFile, JSON.stringify(openAPISpec, null, 2), { ignoreModifyComment: true });

package/dist/src/functions/wirings/middleware/pikku-command-middleware.js

@@ -9,20 +9,13 @@ export const pikkuMiddleware = pikkuSessionlessFunc({
         const { middleware } = state;
         const { middlewareFile, packageMappings } = config;
         let filesGenerated = false;
-        // Check if there are any middleware group factories
-        const hasHTTPFactories = Array.from(state.http.routeMiddleware.values()).some((meta) => meta.exportName && meta.isFactory);
-        const hasTagFactories = Array.from(state.middleware.tagMiddleware.values()).some((meta) => meta.exportName && meta.isFactory);
-        const hasFactories = hasHTTPFactories || hasTagFactories;
-        // Generate middleware imports file if there are factories
-        if (hasFactories) {
-            await writeFileInDir(logger, middlewareFile, serializeMiddlewareImports(middlewareFile, middleware, state.http, packageMappings));
-            filesGenerated = true;
-        }
-        // Generate middleware groups metadata file
+        // Check if there are any middleware groups
         const hasHTTPGroups = state.http.routeMiddleware.size > 0;
         const hasTagGroups = state.middleware.tagMiddleware.size > 0;
         if (hasHTTPGroups || hasTagGroups) {
             await writeFileInDir(logger, config.middlewareGroupsMetaFile, serializeMiddlewareGroupsMeta(state));
+            // Always generate middleware imports file when groups exist (even if empty)
+            await writeFileInDir(logger, middlewareFile, serializeMiddlewareImports(middlewareFile, middleware, state.http, packageMappings));
             filesGenerated = true;
         }
         return filesGenerated;

package/dist/src/functions/wirings/queue/pikku-queue.js

@@ -8,7 +8,15 @@ export const pikkuQueue = pikkuSessionlessFunc({
         const visitState = await getInspectorState();
         const { queueWorkersWiringFile, queueWorkersWiringMetaFile, packageMappings, } = config;
         const { queueWorkers } = visitState;
-        await writeFileInDir(logger, queueWorkersWiringMetaFile, serializeQueueMeta(queueWorkers.meta));
+        // 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',
+            };
+        }
+        await writeFileInDir(logger, queueWorkersWiringMetaFile, serializeQueueMeta(queueMeta));
         await writeFileInDir(logger, queueWorkersWiringFile, serializeFileImports('addQueueWorkers', queueWorkersWiringFile, queueWorkers.files, packageMappings));
         return true;
     },

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

@@ -1,4 +1,4 @@
-import type { queueWorkersMeta } from '@pikku/core/queue';
+import type { QueueWorkersMeta } from '@pikku/core/queue';
 import { TypesMap } from '@pikku/inspector';
 import { FunctionsMeta } from '@pikku/core';
-export declare const serializeQueueMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, queueWorkersMeta: queueWorkersMeta) => string;
+export declare const serializeQueueMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, queueWorkersMeta: QueueWorkersMeta) => string;

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

@@ -1,2 +1,2 @@
-import { queueWorkersMeta } from '@pikku/core/queue';
-export declare const serializeQueueMeta: (queueWorkersMeta: queueWorkersMeta) => string;
+import { QueueWorkersMeta } from '@pikku/core/queue';
+export declare const serializeQueueMeta: (queueWorkersMeta: QueueWorkersMeta) => string;

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

@@ -0,0 +1 @@
+export declare const pikkuPublicRPC: any;

package/dist/src/functions/wirings/rpc/pikku-command-public-rpc.js

@@ -0,0 +1,23 @@
+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 = pikkuSessionlessFunc({
+    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/dist/src/functions/wirings/rpc/pikku-command-remote-rpc.d.ts

@@ -0,0 +1 @@
+export declare const pikkuRemoteRPC: any;

package/dist/src/functions/wirings/rpc/pikku-command-remote-rpc.js

@@ -0,0 +1,23 @@
+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 = pikkuSessionlessFunc({
+    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/dist/src/functions/wirings/rpc/serialize-public-rpc.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generate public RPC HTTP endpoint
+ */
+export declare const serializePublicRPC: (pathToPikkuTypes: string) => string;

package/dist/src/functions/wirings/rpc/serialize-public-rpc.js

@@ -0,0 +1,30 @@
+/**
+ * Generate public RPC HTTP endpoint
+ */
+export const serializePublicRPC = (pathToPikkuTypes) => {
+    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<
+  { name: string, data?: any },
+  any
+>({
+  func: async ({ rpc }, { name, data }) => {
+    return await (rpc.invokeExposed as any)(name, data)
+  },
+})
+
+wireHTTP({
+  route: '/rpc',
+  method: 'post',
+  func: rpcCaller,
+})
+`;
+};

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

@@ -0,0 +1,4 @@
+/**
+ * Generate remote internal RPC queue worker and HTTP endpoint
+ */
+export declare const serializeRemoteRPC: (pathToPikkuTypes: string) => string;

package/dist/src/functions/wirings/rpc/serialize-remote-rpc.js

@@ -0,0 +1,30 @@
+/**
+ * Generate remote internal RPC queue worker and HTTP endpoint
+ */
+export const serializeRemoteRPC = (pathToPikkuTypes) => {
+    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 ({ rpc }, { rpcName, data }) => {
+    return await (rpc.invoke as any)(rpcName, data)
+  },
+  internal: true,
+})
+
+wireQueueWorker({
+  queueName: 'pikku-remote-internal-rpc',
+  func: pikkuRemoteInternalRPC,
+})
+`;
+};

package/dist/src/functions/wirings/rpc/serialize-rpc-wrapper.js

@@ -53,13 +53,13 @@ export class PikkuRPC {
      * 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 name - 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', { name, data })
+       return await this.pikkuFetch.post('/rpc' as any, { name, data }) as any
     }
 }