@pikku/cli 0.8.3 → 0.9.1

package/src/{events → wirings}/rpc/pikku-command-rpc.ts

@@ -3,7 +3,7 @@ import { PikkuCommand } from '../../types.js'
 
 export const pikkuRPC: PikkuCommand = async (
   logger,
-  { rpcMetaFile },
+  { rpcWiringMetaFile },
   { rpc }
 ) => {
   return await logCommandInfoAndTime(
@@ -14,7 +14,7 @@ export const pikkuRPC: PikkuCommand = async (
     async () => {
       await writeFileInDir(
         logger,
-        rpcMetaFile,
+        rpcWiringMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`
       )
     }

package/src/{events → wirings}/rpc/pikku-rpc.ts

@@ -3,7 +3,7 @@ import { PikkuCommand } from '../../types.js'
 
 export const pikkuRPC: PikkuCommand = async (
   logger,
-  { rpcMetaFile },
+  { rpcWiringMetaFile },
   { rpc }
 ) => {
   return await logCommandInfoAndTime(
@@ -14,7 +14,7 @@ export const pikkuRPC: PikkuCommand = async (
     async () => {
       await writeFileInDir(
         logger,
-        rpcMetaFile,
+        rpcWiringMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`
       )
     }

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

@@ -0,0 +1,68 @@
+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 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 })
+    }
+}
+
+export const pikkuRPC = new PikkuRPC();
+`
+}

package/src/{events → wirings}/scheduler/pikku-command-scheduler.ts

@@ -17,19 +17,23 @@ export const pikkuScheduler: PikkuCommand = async (
     'Found scheduled tasks',
     [visitState.scheduledTasks.files.size === 0],
     async () => {
-      const { schedulersFile, schedulersMetaFile, packageMappings } = cliConfig
+      const {
+        schedulersWiringFile,
+        schedulersWiringMetaFile,
+        packageMappings,
+      } = cliConfig
       const { scheduledTasks } = visitState
       await writeFileInDir(
         logger,
-        schedulersMetaFile,
+        schedulersWiringMetaFile,
         serializeSchedulerMeta(scheduledTasks.meta)
       )
       await writeFileInDir(
         logger,
-        schedulersFile,
+        schedulersWiringFile,
         serializeFileImports(
           'addScheduledTasks',
-          schedulersFile,
+          schedulersWiringFile,
           scheduledTasks.files,
           packageMappings
         )

package/dist/src/events/channels/pikku-channels.js

@@ -1,9 +0,0 @@
-import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
-export const pikkuChannels = async (logger, cliConfig, visitState) => {
-    return await logCommandInfoAndTime(logger, 'Finding Channels', 'Found channels', [visitState.channels.files.size === 0], async () => {
-        const { channelsFile, channelsMetaFile, packageMappings } = cliConfig;
-        const { channels } = visitState;
-        await writeFileInDir(logger, channelsFile, serializeFileImports('addChannel', channelsFile, channels.files, packageMappings));
-        await writeFileInDir(logger, channelsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`);
-    });
-};

package/dist/src/events/channels/pikku-command-channels.js

@@ -1,9 +0,0 @@
-import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
-export const pikkuChannels = async (logger, cliConfig, visitState) => {
-    return await logCommandInfoAndTime(logger, 'Finding Channels', 'Found channels', [visitState.channels.files.size === 0], async () => {
-        const { channelsFile, channelsMetaFile, packageMappings } = cliConfig;
-        const { channels } = visitState;
-        await writeFileInDir(logger, channelsFile, serializeFileImports('addChannel', channelsFile, channels.files, packageMappings));
-        await writeFileInDir(logger, channelsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`);
-    });
-};

package/dist/src/events/http/pikku-command-http-map.js

@@ -1,8 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
-import { serializeTypedRoutesMap } from './serialize-typed-http-map.js';
-export const pikkuHTTPMap = async (logger, { httpRoutesMapDeclarationFile, packageMappings }, { http, functions }) => {
-    return await logCommandInfoAndTime(logger, 'Creating HTTP map', 'Created HTTP map', [http.files.size === 0], async () => {
-        const content = serializeTypedRoutesMap(httpRoutesMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, http.meta, http.metaInputTypes);
-        await writeFileInDir(logger, httpRoutesMapDeclarationFile, content);
-    });
-};

package/dist/src/events/http/serialize-fetch-wrapper.js

@@ -1,67 +0,0 @@
-export const serializeFetchWrapper = (routesMapPath) => {
-    return `
-import { CorePikkuFetch, HTTPMethod } from '@pikku/fetch'
-import type { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPath}'
-
-export class PikkuFetch extends CorePikkuFetch {
-    public async post<Route extends RoutesWithMethod<'POST'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'POST'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'POST'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'POST'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'POST'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'POST', data, options);
-    }
-
-    public async get<Route extends RoutesWithMethod<'GET'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'GET'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'GET'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'GET'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'GET'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'GET', data, options);
-    }
-
-    public async patch<Route extends RoutesWithMethod<'PATCH'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'PATCH'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'PATCH'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'PATCH'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'PATCH'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'PATCH', data, options);
-    }
-
-    public async head<Route extends RoutesWithMethod<'HEAD'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'HEAD'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'HEAD'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'HEAD'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'HEAD'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'HEAD', data, options);
-    }
-
-    public async delete<Route extends RoutesWithMethod<'DELETE'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'DELETE'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'DELETE'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'DELETE'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'DELETE'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'DELETE', data, options);
-    }
-
-    public async fetch<
-        Route extends keyof RoutesMap,
-        Method extends keyof RoutesMap[Route]
-    >(route: Route, method: Method, data: RouteHandlerOf<Route, Method>['input'], options?: Omit<RequestInit, 'body'>): Promise<Response> {
-        return await super.fetch(route, method as HTTPMethod, data, options);
-    }
-}
-
-export const pikkuFetch = new PikkuFetch();
-`;
-};

package/dist/src/events/http/serialize-typed-http-map.d.ts

@@ -1,4 +0,0 @@
-import { HTTPRoutesMeta } from '@pikku/core/http';
-import { MetaInputTypes, TypesMap } from '@pikku/inspector';
-import { FunctionsMeta } from '@pikku/core';
-export declare const serializeTypedRoutesMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, routesMeta: HTTPRoutesMeta, metaTypes: MetaInputTypes) => string;

package/dist/src/events/queue/pikku-command-queue-service.js

@@ -1,12 +0,0 @@
-import { serializeQueueWrapper } from './serialize-queue-wrapper.js';
-import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-export const pikkuQueueService = async (logger, { queueFile, queueMapDeclarationFile, packageMappings }) => {
-    return await logCommandInfoAndTime(logger, 'Generating queue service wrapper', 'Generated queue service wrapper', [queueFile === undefined, "queueFile isn't set in the pikku config"], async () => {
-        if (!queueFile) {
-            throw new Error("queueFile is isn't set in the pikku config");
-        }
-        const queueMapDeclarationPath = getFileImportRelativePath(queueFile, queueMapDeclarationFile, packageMappings);
-        const content = [serializeQueueWrapper(queueMapDeclarationPath)];
-        await writeFileInDir(logger, queueFile, content.join('\n'));
-    });
-};

package/dist/src/events/rpc/pikku-command-rpc-client.js

@@ -1,12 +0,0 @@
-import { serializeRPCWrapper } from './serialize-rpc-wrapper.js';
-import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-export const pikkuRPCClient = async (logger, { rpcFile, rpcMapDeclarationFile, packageMappings }) => {
-    return await logCommandInfoAndTime(logger, 'Generating RPC wrapper', 'Generated RPC wrapper', [rpcFile === undefined, "rpcFile isn't set in the pikku config"], async () => {
-        if (!rpcFile) {
-            throw new Error("rpcFile isn't set in the pikku config");
-        }
-        const rpcMapDeclarationPath = getFileImportRelativePath(rpcFile, rpcMapDeclarationFile, packageMappings);
-        const content = [serializeRPCWrapper(rpcMapDeclarationPath)];
-        await writeFileInDir(logger, rpcFile, content.join('\n'));
-    });
-};

package/dist/src/events/rpc/pikku-command-rpc.js

@@ -1,6 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
-export const pikkuRPC = async (logger, { rpcMetaFile }, { rpc }) => {
-    return await logCommandInfoAndTime(logger, 'Finding RPCs tasks', 'Found RPCs', [false], async () => {
-        await writeFileInDir(logger, rpcMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`);
-    });
-};

package/dist/src/events/rpc/pikku-rpc.js

@@ -1,6 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
-export const pikkuRPC = async (logger, { rpcMetaFile }, { rpc }) => {
-    return await logCommandInfoAndTime(logger, 'Finding RPCs tasks', 'Found RPCs', [false], async () => {
-        await writeFileInDir(logger, rpcMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`);
-    });
-};

package/dist/src/events/rpc/serialize-rpc-wrapper.js

@@ -1,29 +0,0 @@
-export const serializeRPCWrapper = (rpcMapPath) => {
-    return `
-import { PikkuFetch } from "./pikku-fetch.gen.js"
-import type { RPCInvoke } from '${rpcMapPath}'
-
-export class PikkuRPC {
-    pikkuFetch = new PikkuFetch()
-
-    setPikkuFetch(pikkuFetch: PikkuFetch): void {
-        this.pikkuFetch = pikkuFetch
-    }
-
-    setServerUrl(serverUrl: string): void {
-        this.pikkuFetch.setServerUrl(serverUrl)
-    }
-
-    setAuthorizationJWT(jwt: string | null): void {
-        this.pikkuFetch.setAuthorizationJWT(jwt)
-    }
-
-    // Generic RPC invoke method
-    invoke: RPCInvoke = async (name, data) => {
-       return await this.pikkuFetch.post('/rpc', { name, data })
-    }
-}
-
-export const pikkuRPC = new PikkuRPC();
-`;
-};

package/src/events/http/serialize-fetch-wrapper.ts

@@ -1,67 +0,0 @@
-export const serializeFetchWrapper = (routesMapPath: string) => {
-  return `
-import { CorePikkuFetch, HTTPMethod } from '@pikku/fetch'
-import type { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPath}'
-
-export class PikkuFetch extends CorePikkuFetch {
-    public async post<Route extends RoutesWithMethod<'POST'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'POST'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'POST'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'POST'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'POST'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'POST', data, options);
-    }
-
-    public async get<Route extends RoutesWithMethod<'GET'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'GET'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'GET'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'GET'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'GET'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'GET', data, options);
-    }
-
-    public async patch<Route extends RoutesWithMethod<'PATCH'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'PATCH'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'PATCH'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'PATCH'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'PATCH'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'PATCH', data, options);
-    }
-
-    public async head<Route extends RoutesWithMethod<'HEAD'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'HEAD'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'HEAD'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'HEAD'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'HEAD'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'HEAD', data, options);
-    }
-
-    public async delete<Route extends RoutesWithMethod<'DELETE'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'DELETE'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'DELETE'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'DELETE'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'DELETE'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'DELETE', data, options);
-    }
-
-    public async fetch<
-        Route extends keyof RoutesMap,
-        Method extends keyof RoutesMap[Route]
-    >(route: Route, method: Method, data: RouteHandlerOf<Route, Method>['input'], options?: Omit<RequestInit, 'body'>): Promise<Response> {
-        return await super.fetch(route, method as HTTPMethod, data, options);
-    }
-}
-
-export const pikkuFetch = new PikkuFetch();
-`
-}

package/src/events/rpc/serialize-rpc-wrapper.ts

@@ -1,29 +0,0 @@
-export const serializeRPCWrapper = (rpcMapPath: string) => {
-  return `
-import { PikkuFetch } from "./pikku-fetch.gen.js"
-import type { RPCInvoke } from '${rpcMapPath}'
-
-export class PikkuRPC {
-    pikkuFetch = new PikkuFetch()
-
-    setPikkuFetch(pikkuFetch: PikkuFetch): void {
-        this.pikkuFetch = pikkuFetch
-    }
-
-    setServerUrl(serverUrl: string): void {
-        this.pikkuFetch.setServerUrl(serverUrl)
-    }
-
-    setAuthorizationJWT(jwt: string | null): void {
-        this.pikkuFetch.setAuthorizationJWT(jwt)
-    }
-
-    // Generic RPC invoke method
-    invoke: RPCInvoke = async (name, data) => {
-       return await this.pikkuFetch.post('/rpc', { name, data })
-    }
-}
-
-export const pikkuRPC = new PikkuRPC();
-`
-}