@pikku/cli 0.11.2 → 0.12.0

package/dist/src/functions/commands/versions-init.d.ts

@@ -0,0 +1,7 @@
+export declare const pikkuVersionsInit: import("#pikku").PikkuFunctionConfig<{
+    force?: boolean;
+}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+    force?: boolean;
+}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    force?: boolean;
+}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/versions-init.js

@@ -0,0 +1,15 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { pikkuSessionlessFunc } from '#pikku';
+import { createEmptyManifest, saveManifest, } from '../../utils/contract-versions.js';
+export const pikkuVersionsInit = pikkuSessionlessFunc({
+    func: async ({ logger, config }, { force }) => {
+        const manifestPath = join(config.outDir, 'versions.json');
+        if (existsSync(manifestPath) && !force) {
+            logger.error(`Version manifest already exists at ${manifestPath}. Use --force to overwrite.`);
+            process.exit(1);
+        }
+        await saveManifest(manifestPath, createEmptyManifest());
+        logger.info(`Version manifest created at ${manifestPath}`);
+    },
+});

package/dist/src/functions/commands/versions-update.d.ts

@@ -0,0 +1 @@
+export declare const pikkuVersionsUpdate: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/versions-update.js

@@ -0,0 +1,20 @@
+import { join } from 'path';
+import { pikkuSessionlessFunc } from '#pikku';
+import { ErrorCode } from '@pikku/inspector';
+import { saveManifest } from '../../utils/contract-versions.js';
+export const pikkuVersionsUpdate = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const manifestPath = join(config.outDir, 'versions.json');
+        const visitState = await getInspectorState();
+        if (!visitState.manifest.initial) {
+            throw new Error(`Version manifest not found at ${manifestPath}. Run 'pikku init' to create one.`);
+        }
+        const immutabilityErrors = visitState.manifest.errors.filter((e) => e.code === ErrorCode.FUNCTION_VERSION_MODIFIED);
+        if (immutabilityErrors.length > 0) {
+            const messages = immutabilityErrors.map((e) => `[${e.code}] ${e.message}`);
+            throw new Error(messages.join('\n'));
+        }
+        await saveManifest(manifestPath, visitState.manifest.current);
+        logger.debug(`Version manifest updated at ${manifestPath}`);
+    },
+});

package/dist/src/functions/commands/watch.d.ts

@@ -1 +1 @@
-export declare const watch: any;
+export declare const watch: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/watch.js

@@ -1,9 +1,8 @@
-import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js';
+import { pikkuVoidFunc } from '#pikku';
 import chokidar from 'chokidar';
-import { all } from './all.js';
 export const watch = pikkuVoidFunc({
-    func: async ({ logger, config, getInspectorState }) => {
-        const services = { logger, config, getInspectorState };
+    remote: true,
+    func: async ({ logger, config }, _data, { rpc }) => {
         const configWatcher = chokidar.watch(config.srcDirectories, {
             ignoreInitial: true,
             ignored: /.*\.gen\.tsx?/,
@@ -20,7 +19,7 @@ export const watch = pikkuVoidFunc({
                 const handle = async () => {
                     try {
                         const start = Date.now();
-                        await all.func(services, null, {});
+                        await rpc.invoke('all', null);
                         logger.info({
                             message: `✓ Generated in ${Date.now() - start}ms`,
                             type: 'timing',

package/dist/src/functions/runtimes/fetch/index.d.ts

@@ -0,0 +1 @@
+export declare const pikkuFetch: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/{wirings → runtimes}/fetch/index.js

@@ -1,5 +1,5 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
-import { serializeFetchWrapper } from '../http/serialize-fetch-wrapper.js';
+import { pikkuSessionlessFunc } from '#pikku';
+import { serializeFetchWrapper } from '../../wirings/http/serialize-fetch-wrapper.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';
@@ -8,7 +8,7 @@ export const pikkuFetch = pikkuSessionlessFunc({
         const { fetchFile, httpMapDeclarationFile, packageMappings } = config;
         // If fetchFile is not set, clean up any existing file and return
         if (!fetchFile) {
-            logger.info({
+            logger.debug({
                 message: "Skipping generating fetch wrapper since fetchFile isn't set in the pikku config.",
                 type: 'skip',
             });

package/dist/src/functions/runtimes/nextjs/pikku-command-nextjs.d.ts

@@ -1 +1 @@
-export declare const pikkuNext: any;
+export declare const pikkuNext: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/runtimes/nextjs/pikku-command-nextjs.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { checkRequiredTypes } from '../../../utils/check-required-types.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
@@ -10,7 +10,7 @@ export const pikkuNext = pikkuSessionlessFunc({
         const { nextBackendFile, nextHTTPFile, httpMapDeclarationFile, rpcMapDeclarationFile, packageMappings, fetchFile, } = config;
         // If both files are undefined, clean up any existing files and return
         if (!nextBackendFile && !nextHTTPFile) {
-            logger.info({
+            logger.debug({
                 message: 'Skipping generating nextjs wrapper since nextjs outfile is not defined.',
                 type: 'skip',
             });
@@ -24,21 +24,19 @@ export const pikkuNext = pikkuSessionlessFunc({
             throw new Error('rpcMapDeclarationFile is required in pikku config in order for nextJS wrapper to work');
         }
         if (nextBackendFile) {
-            // Check for required types
             checkRequiredTypes(visitState.filesAndMethodsErrors, {
                 config: true,
                 singletonServicesFactory: true,
-                wireServicesFactory: true,
             });
             const { pikkuConfigFactory, singletonServicesFactory, wireServicesFactory, } = visitState.filesAndMethods;
-            if (!pikkuConfigFactory ||
-                !singletonServicesFactory ||
-                !wireServicesFactory) {
+            if (!pikkuConfigFactory || !singletonServicesFactory) {
                 throw new Error('Required types not found');
             }
             const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextBackendFile, pikkuConfigFactory.file, packageMappings)}'`;
             const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextBackendFile, singletonServicesFactory.file, packageMappings)}'`;
-            const wireServicesImport = `import { ${wireServicesFactory.variable} as createWireServices } from '${getFileImportRelativePath(nextBackendFile, wireServicesFactory.file, packageMappings)}'`;
+            const wireServicesImport = wireServicesFactory
+                ? `import { ${wireServicesFactory.variable} as createWireServices } from '${getFileImportRelativePath(nextBackendFile, wireServicesFactory.file, packageMappings)}'`
+                : '';
             const bootstrapPath = getFileImportRelativePath(nextBackendFile, config.bootstrapFile, packageMappings);
             const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpMapDeclarationFile, packageMappings);
             const rpcMapDeclarationPath = getFileImportRelativePath(nextBackendFile, rpcMapDeclarationFile, packageMappings);

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

@@ -1 +1 @@
-export declare const serializeNextJsBackendWrapper: (bootstrapPath: string, routesMapPath: string, rpcMapPath: string, configImport: string, singleServicesFactoryImport: string, wireServicesImport: string) => string;
+export declare const serializeNextJsBackendWrapper: (bootstrapPath: string, routesMapPath: string, rpcMapPath: string, configImport: string, singleServicesFactoryImport: string, wireServicesImport: string | undefined) => string;

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

@@ -1,4 +1,5 @@
 export const serializeNextJsBackendWrapper = (bootstrapPath, routesMapPath, rpcMapPath, configImport, singleServicesFactoryImport, wireServicesImport) => {
+    const hasWireServices = !!wireServicesImport;
     return `'server-only'
 
 /**
@@ -8,13 +9,13 @@ export const serializeNextJsBackendWrapper = (bootstrapPath, routesMapPath, rpcM
 import { PikkuNextJS } from '@pikku/next'
 import { NextRequest } from 'next/server.js'
 import type { HTTPWiringsMap, HTTPWiringHandlerOf, HTTPWiringsWithMethod } from '${routesMapPath}'
-import type { RPCMap } from '${rpcMapPath}'
+import type { FlattenedRPCMap } from '${rpcMapPath}'
 
 type RouteContext = { params: Promise<Record<string, string | string[]>> }
 
 ${configImport}
 ${singleServicesFactoryImport}
-${wireServicesImport}
+${wireServicesImport ? wireServicesImport : ''}
 
 import '${bootstrapPath}'
 
@@ -25,17 +26,12 @@ export const removeAPIPrefix = (enable: boolean) => {
   _removeAPIPrefix = enable
 }
 
-/**
- * Initializes and returns an instance of PikkuNextJS with helper methods for handling route requests.
- *
- * @returns An object containing methods for making dynamic and static action requests, as well as session retrieval.
- */
 export const pikku = (_options?: any) => {
   if (!_pikku) {
     _pikku = new PikkuNextJS(
       createConfig as any,
       createSingletonServices as any,
-      createWireServices
+      ${hasWireServices ? 'createWireServices' : 'undefined'}
     )
   }
 
@@ -88,14 +84,16 @@ export const pikku = (_options?: any) => {
    *
    * @template Route - The route key with the POST method.
    * @param route - The route identifier.
-   * @param data - The input data for the POST request, defaults to null.
+   * @param data - The input data for the POST request (required if input type is defined).
    * @returns A promise that resolves to the output of the POST handler.
    */
   const dynamicPost = <Route extends HTTPWiringsWithMethod<'POST'>>(
     route: Route,
-    data: HTTPWiringHandlerOf<Route, 'POST'>['input'] = null
+    ...args: HTTPWiringHandlerOf<Route, 'POST'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'POST'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'POST'>['input']>]
   ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> => {
-    return dynamicActionRequest(route, 'POST', data)
+    return dynamicActionRequest(route, 'POST', args[0] ?? null)
   }
 
   /**
@@ -103,14 +101,16 @@ export const pikku = (_options?: any) => {
    *
    * @template Route - The route key with the GET method.
    * @param route - The route identifier.
-   * @param data - The input data for the GET request, defaults to null.
+   * @param data - The input data for the GET request (required if input type is defined).
    * @returns A promise that resolves to the output of the GET handler.
    */
   const dynamicGet = <Route extends HTTPWiringsWithMethod<'GET'>>(
     route: Route,
-    data: HTTPWiringHandlerOf<Route, 'GET'>['input'] = null
+    ...args: HTTPWiringHandlerOf<Route, 'GET'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'GET'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'GET'>['input']>]
   ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> => {
-    return dynamicActionRequest(route, 'GET', data)
+    return dynamicActionRequest(route, 'GET', args[0] ?? null)
   }
 
   /**
@@ -118,14 +118,16 @@ export const pikku = (_options?: any) => {
    *
    * @template Route - The route key with the PATCH method.
    * @param route - The route identifier.
-   * @param data - The input data for the PATCH request, defaults to null.
+   * @param data - The input data for the PATCH request (required if input type is defined).
    * @returns A promise that resolves to the output of the PATCH handler.
    */
   const dynamicPatch = <Route extends HTTPWiringsWithMethod<'PATCH'>>(
     route: Route,
-    data: HTTPWiringHandlerOf<Route, 'PATCH'>['input'] = null
+    ...args: HTTPWiringHandlerOf<Route, 'PATCH'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'PATCH'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'PATCH'>['input']>]
   ): Promise<HTTPWiringHandlerOf<Route, 'PATCH'>['output']> => {
-    return dynamicActionRequest(route, 'PATCH', data)
+    return dynamicActionRequest(route, 'PATCH', args[0] ?? null)
   }
 
   /**
@@ -133,14 +135,16 @@ export const pikku = (_options?: any) => {
    *
    * @template Route - The route key with the DELETE method.
    * @param route - The route identifier.
-   * @param data - The input data for the DELETE request, defaults to null.
+   * @param data - The input data for the DELETE request (required if input type is defined).
    * @returns A promise that resolves to the output of the DELETE handler.
    */
   const dynamicDel = <Route extends HTTPWiringsWithMethod<'DELETE'>>(
     route: Route,
-    data: HTTPWiringHandlerOf<Route, 'DELETE'>['input'] = null
+    ...args: HTTPWiringHandlerOf<Route, 'DELETE'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'DELETE'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'DELETE'>['input']>]
   ): Promise<HTTPWiringHandlerOf<Route, 'DELETE'>['output']> => {
-    return dynamicActionRequest(route, 'DELETE', data)
+    return dynamicActionRequest(route, 'DELETE', args[0] ?? null)
   }
 
   // Static Requests
@@ -150,14 +154,16 @@ export const pikku = (_options?: any) => {
    *
    * @template Route - The route key with the POST method.
    * @param route - The route identifier.
-   * @param data - The input data for the POST request, defaults to null.
+   * @param data - The input data for the POST request (required if input type is defined).
    * @returns A promise that resolves to the output of the POST handler.
    */
   const staticPost = <Route extends HTTPWiringsWithMethod<'POST'>>(
     route: Route,
-    data: HTTPWiringHandlerOf<Route, 'POST'>['input'] = null
+    ...args: HTTPWiringHandlerOf<Route, 'POST'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'POST'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'POST'>['input']>]
   ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> => {
-    return staticActionRequest(route, 'POST', data)
+    return staticActionRequest(route, 'POST', args[0] ?? null)
   }
 
   /**
@@ -165,49 +171,49 @@ export const pikku = (_options?: any) => {
    *
    * @template Route - The route key with the GET method.
    * @param route - The route identifier.
-   * @param data - The input data for the GET request, defaults to null.
+   * @param data - The input data for the GET request (required if input type is defined).
    * @returns A promise that resolves to the output of the GET handler.
    */
   const staticGet = <Route extends HTTPWiringsWithMethod<'GET'>>(
     route: Route,
-    data: HTTPWiringHandlerOf<Route, 'GET'>['input'] = null
+    ...args: HTTPWiringHandlerOf<Route, 'GET'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'GET'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'GET'>['input']>]
   ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> => {
-    return staticActionRequest(route, 'GET', data)
+    return staticActionRequest(route, 'GET', args[0] ?? null)
   }
 
   // RPC Requests
 
-  /**
-   * Type definition for RPC invocation with dynamic context.
-   */
-  type RPCInvoke = <Name extends keyof RPCMap>(
-    name: Name,
-    data: RPCMap[Name]['input']
-  ) => Promise<RPCMap[Name]['output']>
-
   /**
    * Makes a dynamic RPC request.
    *
-   * @template Name - The RPC function name from the RPCMap.
+   * @template Name - The RPC function name from the FlattenedRPCMap.
    * @param name - The RPC function identifier.
-   * @param data - The input data for the RPC request.
+   * @param data - The input data for the RPC request (required if input type is defined).
    * @returns A promise that resolves to the output of the RPC handler.
    */
-  const rpc: RPCInvoke = async (name, data) => {
-    return dynamicActionRequest(\`/rpc/\${name}\` as any, 'POST', { data }) as any
+  const rpc = async <Name extends keyof FlattenedRPCMap>(
+    rpcName: Name,
+    data: FlattenedRPCMap[Name]['input']
+  ): Promise<FlattenedRPCMap[Name]['output']> => {
+    return dynamicActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: data ?? null }) as unknown as FlattenedRPCMap[Name]['output']
   }
 
   /**
    * Makes a static RPC request.
    * Note: In HTTP wrapper context, both rpc and staticRPC behave the same way.
    *
-   * @template Name - The RPC function name from the RPCMap.
+   * @template Name - The RPC function name from the FlattenedRPCMap.
    * @param name - The RPC function identifier.
-   * @param data - The input data for the RPC request.
+   * @param data - The input data for the RPC request (required if input type is defined).
    * @returns A promise that resolves to the output of the RPC handler.
    */
-  const staticRPC: RPCInvoke = async (name, data) => {
-    return staticActionRequest(\`/rpc/\${name}\` as any, 'POST', { data }) as any
+  const staticRPC = async <Name extends keyof FlattenedRPCMap>(
+    rpcName: Name,
+    data: FlattenedRPCMap[Name]['input']
+  ): Promise<FlattenedRPCMap[Name]['output']> => {
+    return staticActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: data ?? null }) as unknown as FlattenedRPCMap[Name]['output']
   }
 
   return {
@@ -242,7 +248,7 @@ export const pikkuAPIRequest = (
     _pikku = new PikkuNextJS(
       createConfig as any,
       createSingletonServices as any,
-      createWireServices
+      ${hasWireServices ? 'createWireServices' : 'undefined'}
     )
   }
   if (_removeAPIPrefix) {

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

@@ -7,7 +7,7 @@ export const serializeNextJsHTTPWrapper = (routesMapPath, rpcMapPath, pikkuFetch
  */
 import { CorePikkuFetchOptions } from '@pikku/fetch'
 import type { HTTPWiringsMap, HTTPWiringHandlerOf, HTTPWiringsWithMethod } from '${routesMapPath}'
-import type { RPCMap } from '${rpcMapPath}'
+import type { FlattenedRPCMap } from '${rpcMapPath}'
 import { PikkuFetch } from '${pikkuFetchImport}'
 
 let _pikku: PikkuFetch | undefined
@@ -60,14 +60,16 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
    *
    * @template Route - The route key with the POST method.
    * @param route - The route identifier.
-   * @param data - The input data for the POST request, defaults to null.
+   * @param data - The input data for the POST request (required if input type is defined).
    * @returns A promise that resolves to the output of the POST handler.
    */
   const dynamicPost = <Route extends HTTPWiringsWithMethod<'POST'>>(
     route: Route,
-    data: HTTPWiringHandlerOf<Route, 'POST'>['input'] = null
+    ...args: HTTPWiringHandlerOf<Route, 'POST'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'POST'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'POST'>['input']>]
   ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> => {
-    return dynamicActionRequest(route, 'POST', data)
+    return dynamicActionRequest(route, 'POST', args[0] ?? null)
   }
 
   /**
@@ -75,14 +77,16 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
    *
    * @template Route - The route key with the GET method.
    * @param route - The route identifier.
-   * @param data - The input data for the GET request, defaults to null.
+   * @param data - The input data for the GET request (required if input type is defined).
    * @returns A promise that resolves to the output of the GET handler.
    */
   const dynamicGet = <Route extends HTTPWiringsWithMethod<'GET'>>(
     route: Route,
-    data: HTTPWiringHandlerOf<Route, 'GET'>['input'] = null
+    ...args: HTTPWiringHandlerOf<Route, 'GET'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'GET'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'GET'>['input']>]
   ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> => {
-    return dynamicActionRequest(route, 'GET', data)
+    return dynamicActionRequest(route, 'GET', args[0] ?? null)
   }
 
   /**
@@ -90,14 +94,16 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
    *
    * @template Route - The route key with the PATCH method.
    * @param route - The route identifier.
-   * @param data - The input data for the PATCH request, defaults to null.
+   * @param data - The input data for the PATCH request (required if input type is defined).
    * @returns A promise that resolves to the output of the PATCH handler.
    */
   const dynamicPatch = <Route extends HTTPWiringsWithMethod<'PATCH'>>(
     route: Route,
-    data: HTTPWiringHandlerOf<Route, 'PATCH'>['input'] = null
+    ...args: HTTPWiringHandlerOf<Route, 'PATCH'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'PATCH'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'PATCH'>['input']>]
   ): Promise<HTTPWiringHandlerOf<Route, 'PATCH'>['output']> => {
-    return dynamicActionRequest(route, 'PATCH', data)
+    return dynamicActionRequest(route, 'PATCH', args[0] ?? null)
   }
 
   /**
@@ -105,14 +111,16 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
    *
    * @template Route - The route key with the DELETE method.
    * @param route - The route identifier.
-   * @param data - The input data for the DELETE request, defaults to null.
+   * @param data - The input data for the DELETE request (required if input type is defined).
    * @returns A promise that resolves to the output of the DELETE handler.
    */
   const dynamicDel = <Route extends HTTPWiringsWithMethod<'DELETE'>>(
     route: Route,
-    data: HTTPWiringHandlerOf<Route, 'DELETE'>['input'] = null
+    ...args: HTTPWiringHandlerOf<Route, 'DELETE'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'DELETE'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'DELETE'>['input']>]
   ): Promise<HTTPWiringHandlerOf<Route, 'DELETE'>['output']> => {
-    return dynamicActionRequest(route, 'DELETE', data)
+    return dynamicActionRequest(route, 'DELETE', args[0] ?? null)
   }
 
   // Static Requests
@@ -122,14 +130,16 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
    *
    * @template Route - The route key with the POST method.
    * @param route - The route identifier.
-   * @param data - The input data for the POST request, defaults to null.
+   * @param data - The input data for the POST request (required if input type is defined).
    * @returns A promise that resolves to the output of the POST handler.
    */
   const staticPost = <Route extends HTTPWiringsWithMethod<'POST'>>(
     route: Route,
-    data: HTTPWiringHandlerOf<Route, 'POST'>['input'] = null
+    ...args: HTTPWiringHandlerOf<Route, 'POST'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'POST'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'POST'>['input']>]
   ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> => {
-    return staticActionRequest(route, 'POST', data)
+    return staticActionRequest(route, 'POST', args[0] ?? null)
   }
 
   /**
@@ -137,49 +147,49 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
    *
    * @template Route - The route key with the GET method.
    * @param route - The route identifier.
-   * @param data - The input data for the GET request, defaults to null.
+   * @param data - The input data for the GET request (required if input type is defined).
    * @returns A promise that resolves to the output of the GET handler.
    */
   const staticGet = <Route extends HTTPWiringsWithMethod<'GET'>>(
     route: Route,
-    data: HTTPWiringHandlerOf<Route, 'GET'>['input'] = null
+    ...args: HTTPWiringHandlerOf<Route, 'GET'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'GET'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'GET'>['input']>]
   ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> => {
-    return staticActionRequest(route, 'GET', data)
+    return staticActionRequest(route, 'GET', args[0] ?? null)
   }
 
   // RPC Requests
 
-  /**
-   * Type definition for RPC invocation.
-   */
-  type RPCInvoke = <Name extends keyof RPCMap>(
-    name: Name,
-    data: RPCMap[Name]['input']
-  ) => Promise<RPCMap[Name]['output']>
-
   /**
    * Makes a dynamic RPC request.
    *
-   * @template Name - The RPC function name from the RPCMap.
+   * @template Name - The RPC function name from the FlattenedRPCMap.
    * @param name - The RPC function identifier.
-   * @param data - The input data for the RPC request.
+   * @param data - The input data for the RPC request (required if input type is defined).
    * @returns A promise that resolves to the output of the RPC handler.
    */
-  const rpc: RPCInvoke = async (rpcName, data) => {
-    return dynamicActionRequest(\`/rpc/\${rpcName}\` as any, 'POST', { data }) as any
+  const rpc = async <Name extends keyof FlattenedRPCMap>(
+    rpcName: Name,
+    data: FlattenedRPCMap[Name]['input']
+  ): Promise<FlattenedRPCMap[Name]['output']> => {
+    return dynamicActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: data ?? null }) as unknown as FlattenedRPCMap[Name]['output']
   }
 
   /**
    * Makes a static RPC request.
    * Note: In HTTP wrapper context, both rpc and rpcStatic behave the same way.
    *
-   * @template Name - The RPC function name from the RPCMap.
+   * @template Name - The RPC function name from the FlattenedRPCMap.
    * @param name - The RPC function identifier.
-   * @param data - The input data for the RPC request.
+   * @param data - The input data for the RPC request (required if input type is defined).
    * @returns A promise that resolves to the output of the RPC handler.
    */
-  const staticRPC: RPCInvoke = async (rpcName, data) => {
-    return staticActionRequest(\`/rpc/\${rpcName}\` as any, 'POST', { data }) as any
+  const staticRPC = async <Name extends keyof FlattenedRPCMap>(
+    rpcName: Name,
+    data: FlattenedRPCMap[Name]['input']
+  ): Promise<FlattenedRPCMap[Name]['output']> => {
+    return staticActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: data ?? null }) as unknown as FlattenedRPCMap[Name]['output']
   }
 
   return {

package/dist/src/functions/runtimes/websocket/pikku-command-websocket-typed.d.ts

@@ -0,0 +1 @@
+export declare const pikkuWebSocketTyped: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/{wirings/channels → runtimes/websocket}/pikku-command-websocket-typed.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 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';
@@ -8,7 +8,7 @@ export const pikkuWebSocketTyped = pikkuSessionlessFunc({
         const { websocketFile, channelsMapDeclarationFile, packageMappings } = config;
         // If websocketFile is not set, clean up any existing file and return
         if (!websocketFile) {
-            logger.info({
+            logger.debug({
                 message: "Skipping generating websocket wrapper since websocketFile isn't set in the pikku config.",
                 type: 'skip',
             });

package/dist/src/functions/wirings/ai-agent/pikku-command-ai-agent-types.d.ts

@@ -0,0 +1 @@
+export declare const pikkuAIAgentTypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/ai-agent/pikku-command-ai-agent-types.js

@@ -0,0 +1,19 @@
+import { pikkuSessionlessFunc } from '#pikku';
+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 { serializeAIAgentTypes } from './serialize-ai-agent-types.js';
+export const pikkuAIAgentTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { agentTypesFile, functionTypesFile, packageMappings } = config;
+        const functionTypesImportPath = getFileImportRelativePath(agentTypesFile, functionTypesFile, packageMappings);
+        const content = serializeAIAgentTypes(functionTypesImportPath);
+        await writeFileInDir(logger, agentTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating AI agent types',
+            commandEnd: 'Created AI agent types',
+        }),
+    ],
+});

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

@@ -0,0 +1 @@
+export declare const pikkuAIAgent: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;