@pikku/cli 0.9.0 → 0.9.2

package/dist/src/events/queue/serialize-queue-meta.d.ts

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

package/dist/src/events/queue/serialize-queue-meta.js

@@ -1,6 +0,0 @@
-export const serializeQueueMeta = (queueWorkersMeta) => {
-    const serializedOutput = [];
-    serializedOutput.push("import { pikkuState } from '@pikku/core'");
-    serializedOutput.push(`pikkuState('queue', 'meta', ${JSON.stringify(queueWorkersMeta, null, 2)})`);
-    return serializedOutput.join('\n');
-};

package/dist/src/events/queue/serialize-queue-wrapper.d.ts

@@ -1 +0,0 @@
-export declare const serializeQueueWrapper: (queueMapPath: string) => string;

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

@@ -1,35 +0,0 @@
-export const serializeQueueWrapper = (queueMapPath) => {
-    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/dist/src/events/rpc/index.d.ts

@@ -1,2 +0,0 @@
-import { PikkuCommandWithoutState } from '../../types.js';
-export declare const pikkuRPCClient: PikkuCommandWithoutState;

package/dist/src/events/rpc/index.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-client.d.ts

@@ -1,2 +0,0 @@
-import { PikkuCommandWithoutState } from '../../types.js';
-export declare const pikkuRPCClient: PikkuCommandWithoutState;

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, { rpcWiringsFile, rpcMapDeclarationFile, packageMappings }) => {
-    return await logCommandInfoAndTime(logger, 'Generating RPC wrapper', 'Generated RPC wrapper', [rpcWiringsFile === undefined, "rpcWiringsFile isn't set in the pikku config"], async () => {
-        if (!rpcWiringsFile) {
-            throw new Error("rpcWiringsFile isn't set in the pikku config");
-        }
-        const rpcMapDeclarationPath = getFileImportRelativePath(rpcWiringsFile, rpcMapDeclarationFile, packageMappings);
-        const content = [serializeRPCWrapper(rpcMapDeclarationPath)];
-        await writeFileInDir(logger, rpcWiringsFile, content.join('\n'));
-    });
-};

package/dist/src/events/rpc/pikku-command-rpc-map.d.ts

@@ -1,2 +0,0 @@
-import { PikkuCommand } from '../../types.js';
-export declare const pikkuRPCMap: PikkuCommand;

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

@@ -1,8 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
-import { serializeTypedRPCMap } from './serialize-typed-rpc-map.js';
-export const pikkuRPCMap = async (logger, { rpcMapDeclarationFile, packageMappings }, { functions, rpc }) => {
-    return await logCommandInfoAndTime(logger, 'Creating RPC map', 'Created RPC map', [false], async () => {
-        const content = serializeTypedRPCMap(rpcMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.meta);
-        await writeFileInDir(logger, rpcMapDeclarationFile, content);
-    });
-};

package/dist/src/events/rpc/pikku-command-rpc.d.ts

@@ -1,2 +0,0 @@
-import { PikkuCommand } from '../../types.js';
-export declare const pikkuRPC: PikkuCommand;

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

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

package/dist/src/events/rpc/pikku-rpc.d.ts

@@ -1,2 +0,0 @@
-import { PikkuCommand } from '../../types.js';
-export declare const pikkuRPC: PikkuCommand;

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

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

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

@@ -1 +0,0 @@
-export declare const serializeRPCWrapper: (rpcMapPath: string) => string;

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

@@ -1,68 +0,0 @@
-export const serializeRPCWrapper = (rpcMapPath) => {
-    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/dist/src/events/rpc/serialize-typed-rpc-map.d.ts

@@ -1,4 +0,0 @@
-import type { RPCMeta } from '@pikku/core/rpc';
-import { TypesMap } from '@pikku/inspector';
-import { FunctionsMeta } from '@pikku/core';
-export declare const serializeTypedRPCMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, rpcMeta: Record<string, RPCMeta>) => string;

package/dist/src/events/rpc/serialize-typed-rpc-map.js

@@ -1,66 +0,0 @@
-import { serializeImportMap } from '../../serialize-import-map.js';
-import { generateCustomTypes } from '../../utils.js';
-export const serializeTypedRPCMap = (relativeToPath, packageMappings, typesMap, functionsMeta, rpcMeta) => {
-    const requiredTypes = new Set();
-    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
-    const serializedRPCs = generateRPCs(rpcMeta, functionsMeta, typesMap, requiredTypes);
-    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
-    return `/**
- * This provides the structure needed for typescript to be aware of RPCs and their return types
- */
-    
-${serializedImportMap}
-${serializedCustomTypes}
-
-interface RPCHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-${serializedRPCs}
-
-export type RPCInvoke = <Name extends keyof RPCMap>(
-  name: Name,
-  data: RPCMap[Name]['input'],
-  options?: {
-    location?: 'local' | 'remote' | 'auto'
-  }
-) => Promise<RPCMap[Name]['output']>
-
-export type TypedPikkuRPC = {
-  depth: number;
-  global: boolean;
-  invoke: RPCInvoke;
-}
-  `;
-};
-function generateRPCs(rpcMeta, functionsMeta, typesMap, requiredTypes) {
-    // Initialize an object to collect RPCs
-    const rpcsObj = {};
-    // Iterate through RPC metadata
-    for (const [funcName, { pikkuFuncName }] of Object.entries(rpcMeta)) {
-        const functionMeta = functionsMeta[pikkuFuncName];
-        if (!functionMeta) {
-            throw new Error(`Function ${funcName} 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 RPCHandler
-        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
-        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null';
-        requiredTypes.add(inputType);
-        requiredTypes.add(outputType);
-        // Add RPC entry
-        rpcsObj[funcName] = {
-            inputType,
-            outputType,
-        };
-    }
-    // Build the RPCs object as a string
-    let rpcsStr = 'export type RPCMap = {\n';
-    for (const [funcName, handler] of Object.entries(rpcsObj)) {
-        rpcsStr += `  readonly '${funcName}': RPCHandler<${handler.inputType}, ${handler.outputType}>,\n`;
-    }
-    rpcsStr += '};\n';
-    return rpcsStr;
-}

package/dist/src/events/scheduler/pikku-command-scheduler.d.ts

@@ -1,2 +0,0 @@
-import { PikkuCommand } from '../../types.js';
-export declare const pikkuScheduler: PikkuCommand;

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

@@ -1,10 +0,0 @@
-import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
-import { serializeSchedulerMeta } from './serialize-scheduler-meta.js';
-export const pikkuScheduler = async (logger, cliConfig, visitState) => {
-    return await logCommandInfoAndTime(logger, 'Finding scheduled tasks', 'Found scheduled tasks', [visitState.scheduledTasks.files.size === 0], async () => {
-        const { schedulersWiringFile, schedulersWiringMetaFile, packageMappings } = cliConfig;
-        const { scheduledTasks } = visitState;
-        await writeFileInDir(logger, schedulersWiringMetaFile, serializeSchedulerMeta(scheduledTasks.meta));
-        await writeFileInDir(logger, schedulersWiringFile, serializeFileImports('addScheduledTasks', schedulersWiringFile, scheduledTasks.files, packageMappings));
-    });
-};

package/dist/src/events/scheduler/serialize-scheduler-meta.d.ts

@@ -1,2 +0,0 @@
-import { ScheduledTasksMeta } from '@pikku/core/scheduler';
-export declare const serializeSchedulerMeta: (scheduledTasksMeta: ScheduledTasksMeta) => string;

package/dist/src/events/scheduler/serialize-scheduler-meta.js

@@ -1,10 +0,0 @@
-export const serializeSchedulerMeta = (scheduledTasksMeta) => {
-    const serializedOutput = [];
-    serializedOutput.push("import { pikkuState } from '@pikku/core'");
-    serializedOutput.push(`pikkuState('scheduler', 'meta', ${JSON.stringify(scheduledTasksMeta, null, 2)})`);
-    const scheduledTasksMetaValues = Object.values(scheduledTasksMeta);
-    if (scheduledTasksMetaValues.length > 0) {
-        serializedOutput.push(`export type ScheduledTaskNames = '${scheduledTasksMetaValues.map((s) => s.name).join("' | '")}'`);
-    }
-    return serializedOutput.join('\n');
-};