@pikku/cli 0.9.0 → 0.9.1

package/dist/src/events/mcp/pikku-command-mcp-json.d.ts

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

package/dist/src/events/mcp/pikku-command-mcp-json.js

@@ -1,13 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
-import { serializeMCPJson } from './serialize-mcp-json.js';
-export const pikkuMCPJSON = async (logger, { mcpJsonFile, schemaDirectory }, { mcpEndpoints, functions }) => {
-    return await logCommandInfoAndTime(logger, 'Generating MCP JSON', 'Generated MCP JSON', [mcpEndpoints.files.size === 0 || !mcpJsonFile], async () => {
-        // Generate MCP JSON file
-        if (mcpJsonFile) {
-            const mcpJson = await serializeMCPJson(logger, schemaDirectory, functions.meta, functions.typesMap, mcpEndpoints.resourcesMeta, mcpEndpoints.toolsMeta, mcpEndpoints.promptsMeta);
-            await writeFileInDir(logger, mcpJsonFile, mcpJson, {
-                ignoreModifyComment: true,
-            });
-        }
-    });
-};

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

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

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

@@ -1,54 +0,0 @@
-import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
-import { readFile } from 'fs/promises';
-import { join } from 'path';
-// Helper function to generate arguments from schema
-const generateArgumentsFromSchema = async (inputSchema, schemaDirectory, typesMap, logger) => {
-    if (!inputSchema)
-        return [];
-    if (['boolean', 'string', 'number', 'null', 'undefined', 'void'].includes(inputSchema)) {
-        return [];
-    }
-    const uniqueName = typesMap.getUniqueName(inputSchema);
-    if (!uniqueName)
-        return [];
-    try {
-        const schemaPath = join(schemaDirectory, 'schemas', `${uniqueName}.schema.json`);
-        const schemaContent = await readFile(schemaPath, 'utf-8');
-        const schema = JSON.parse(schemaContent);
-        const argumentsArray = [];
-        if (schema && typeof schema === 'object' && schema.properties) {
-            const properties = schema.properties;
-            const required = schema.required || [];
-            for (const [propName, propSchema] of Object.entries(properties)) {
-                argumentsArray.push({
-                    name: propName,
-                    description: propSchema.description || `${propName} parameter`,
-                    required: required.includes(propName),
-                });
-            }
-        }
-        return argumentsArray;
-    }
-    catch (e) {
-        logger.warn(`Could not load schema for type: ${uniqueName}`);
-        return [];
-    }
-};
-export const pikkuMCP = async (logger, { mcpWiringsFile, mcpWiringsMetaFile, packageMappings, schemaDirectory }, { mcpEndpoints, functions }) => {
-    return await logCommandInfoAndTime(logger, 'Finding MCP endpoints', 'Found MCP endpoints', [mcpEndpoints.files.size === 0], async () => {
-        await writeFileInDir(logger, mcpWiringsFile, serializeFileImports('wireMCPResource or wireMCPTool', mcpWiringsFile, mcpEndpoints.files, packageMappings));
-        // Populate arguments for prompts meta before serializing
-        const promptsMetaWithArguments = { ...mcpEndpoints.promptsMeta };
-        for (const promptMeta of Object.values(promptsMetaWithArguments)) {
-            const functionMeta = functions.meta[promptMeta.pikkuFuncName];
-            if (functionMeta) {
-                const inputType = functionMeta.inputs?.[0];
-                promptMeta.arguments = await generateArgumentsFromSchema(inputType || null, schemaDirectory || '', functions.typesMap, logger);
-            }
-        }
-        await writeFileInDir(logger, mcpWiringsMetaFile, `import { pikkuState } from '@pikku/core'
-pikkuState('mcp', 'resourcesMeta', ${JSON.stringify(mcpEndpoints.resourcesMeta, null, 2)})
-pikkuState('mcp', 'toolsMeta', ${JSON.stringify(mcpEndpoints.toolsMeta, null, 2)})
-pikkuState('mcp', 'promptsMeta', ${JSON.stringify(promptsMetaWithArguments, null, 2)})`);
-    });
-};

package/dist/src/events/mcp/serialize-mcp-json.d.ts

@@ -1,5 +0,0 @@
-import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core';
-import { FunctionsMeta } from '@pikku/core';
-import { TypesMap } from '@pikku/inspector';
-import { CLILogger } from '../../utils.js';
-export declare const serializeMCPJson: (logger: CLILogger, schemaDirectory: string, functionsMeta: FunctionsMeta, typesMap: TypesMap, mcpResourceMeta: MCPResourceMeta, mcpToolMeta: MCPToolMeta, mcpPromptMeta: MCPPromptMeta) => Promise<string>;

package/dist/src/events/mcp/serialize-mcp-json.js

@@ -1,101 +0,0 @@
-import { readFile } from 'fs/promises';
-import { join } from 'path';
-export const serializeMCPJson = async (logger, schemaDirectory, functionsMeta, typesMap, mcpResourceMeta, mcpToolMeta, mcpPromptMeta) => {
-    const tools = [];
-    const resources = [];
-    const prompts = [];
-    // Helper function to load schema from file
-    const loadSchema = async (typeName) => {
-        if (!typeName ||
-            ['boolean', 'string', 'number', 'null', 'undefined', 'void'].includes(typeName)) {
-            return undefined;
-        }
-        const uniqueName = typesMap.getUniqueName(typeName);
-        if (!uniqueName) {
-            return undefined;
-        }
-        try {
-            const schemaPath = join(schemaDirectory, 'schemas', `${uniqueName}.schema.json`);
-            const schemaContent = await readFile(schemaPath, 'utf-8');
-            return JSON.parse(schemaContent);
-        }
-        catch (e) {
-            logger.warn(`Could not load schema for type: ${uniqueName}`);
-            return undefined;
-        }
-    };
-    // Process MCP resources
-    for (const [name, endpointMeta] of Object.entries(mcpResourceMeta)) {
-        const functionMeta = functionsMeta[endpointMeta.pikkuFuncName];
-        if (!functionMeta) {
-            logger.warn(`Function ${endpointMeta.pikkuFuncName} not found in functionsMeta. Skipping resource ${name}.`);
-            continue;
-        }
-        const inputType = functionMeta.inputs?.[0];
-        const outputType = functionMeta.outputs?.[0];
-        const parameters = await loadSchema(inputType);
-        const returns = await loadSchema(outputType);
-        const endpoint = {
-            uri: name,
-            name,
-            description: endpointMeta.description,
-            ...(parameters && { parameters }),
-            ...(returns && { returns }),
-            ...(endpointMeta.streaming && { streaming: true }),
-        };
-        resources.push(endpoint);
-    }
-    // Process MCP tools
-    for (const [name, endpointMeta] of Object.entries(mcpToolMeta)) {
-        const functionMeta = functionsMeta[endpointMeta.pikkuFuncName];
-        if (!functionMeta) {
-            logger.warn(`Function ${endpointMeta.pikkuFuncName} not found in functionsMeta. Skipping tool ${name}.`);
-            continue;
-        }
-        const inputType = functionMeta.inputs?.[0];
-        const outputType = functionMeta.outputs?.[0];
-        const parameters = await loadSchema(inputType);
-        const returns = await loadSchema(outputType);
-        const endpoint = {
-            name,
-            description: endpointMeta.description,
-            ...(parameters && { parameters }),
-            ...(returns && { returns }),
-            ...(endpointMeta.streaming && { streaming: true }),
-        };
-        tools.push(endpoint);
-    }
-    // Process MCP prompts
-    for (const [name, endpointMeta] of Object.entries(mcpPromptMeta)) {
-        const functionMeta = functionsMeta[endpointMeta.pikkuFuncName];
-        if (!functionMeta) {
-            logger.warn(`Function ${endpointMeta.pikkuFuncName} not found in functionsMeta. Skipping prompt ${name}.`);
-            continue;
-        }
-        const inputType = functionMeta.inputs?.[0];
-        // TODO: this needs to be a json schema type, not any
-        const inputSchema = await loadSchema(inputType);
-        // Generate arguments from input schema
-        const argumentsArray = [];
-        if (inputSchema &&
-            typeof inputSchema === 'object' &&
-            inputSchema.properties) {
-            const properties = inputSchema.properties;
-            const required = inputSchema.required || [];
-            for (const [propName, propSchema] of Object.entries(properties)) {
-                argumentsArray.push({
-                    name: propName,
-                    description: propSchema.description || `${propName} parameter`,
-                    required: required.includes(propName),
-                });
-            }
-        }
-        const prompt = {
-            name,
-            description: endpointMeta.description,
-            arguments: argumentsArray,
-        };
-        prompts.push(prompt);
-    }
-    return JSON.stringify({ tools, resources, prompts }, null, 2);
-};

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

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

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

@@ -1,8 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
-import { serializeQueueMap } from './serialize-queue-map.js';
-export const pikkuQueueMap = async (logger, { queueMapDeclarationFile, packageMappings }, { queueWorkers, functions }) => {
-    return await logCommandInfoAndTime(logger, 'Creating Queue map', 'Created Queue map', [queueWorkers.files.size === 0], async () => {
-        const content = serializeQueueMap(queueMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, queueWorkers.meta);
-        await writeFileInDir(logger, queueMapDeclarationFile, content);
-    });
-};

package/dist/src/events/queue/pikku-command-queue-service.d.ts

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

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

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

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

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

@@ -1,10 +0,0 @@
-import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
-import { serializeQueueMeta } from './serialize-queue-meta.js';
-export const pikkuQueue = async (logger, cliConfig, visitState) => {
-    return await logCommandInfoAndTime(logger, 'Finding queues', 'Found queue', [visitState.queueWorkers.files.size === 0], async () => {
-        const { queueWorkersWiringFile, queueWorkersWiringMetaFile, packageMappings } = cliConfig;
-        const { queueWorkers } = visitState;
-        await writeFileInDir(logger, queueWorkersWiringMetaFile, serializeQueueMeta(queueWorkers.meta));
-        await writeFileInDir(logger, queueWorkersWiringFile, serializeFileImports('addQueueWorkers', queueWorkersWiringFile, queueWorkers.files, packageMappings));
-    });
-};

package/dist/src/events/queue/pikku-queue-map.d.ts

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

package/dist/src/events/queue/pikku-queue-map.js

@@ -1,8 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
-import { serializeQueueMap } from './serialize-queue-map.js';
-export const pikkuQueueMap = async (logger, { queueMapDeclarationFile, packageMappings }, { queueWorkers, functions }) => {
-    return await logCommandInfoAndTime(logger, 'Creating Queue map', 'Created Queue map', [queueWorkers.files.size === 0], async () => {
-        const content = serializeQueueMap(queueMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, queueWorkers.meta);
-        await writeFileInDir(logger, queueMapDeclarationFile, content);
-    });
-};

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

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

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

@@ -1,10 +0,0 @@
-import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
-import { serializeQueueMeta } from './serialize-queue-meta.js';
-export const pikkuQueue = async (logger, cliConfig, visitState) => {
-    return await logCommandInfoAndTime(logger, 'Finding queues', 'Found queue', [visitState.queueWorkers.files.size === 0], async () => {
-        const { queueWorkersWiringFile, queueWorkersWiringMetaFile, packageMappings } = cliConfig;
-        const { queueWorkers } = visitState;
-        await writeFileInDir(logger, queueWorkersWiringMetaFile, serializeQueueMeta(queueWorkers.meta));
-        await writeFileInDir(logger, queueWorkersWiringFile, serializeFileImports('addQueueWorkers', queueWorkersWiringFile, queueWorkers.files, packageMappings));
-    });
-};

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

@@ -1,4 +0,0 @@
-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;

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

@@ -1,77 +0,0 @@
-import { serializeImportMap } from '../../serialize-import-map.js';
-import { generateCustomTypes } from '../../utils.js';
-export const serializeQueueMap = (relativeToPath, packageMappings, typesMap, functionsMeta, queueWorkersMeta) => {
-    const requiredTypes = new Set();
-    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
-    const serializedQueues = generateQueues(queueWorkersMeta, functionsMeta, typesMap, requiredTypes);
-    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
-    return `/**
- * This provides the structure needed for typescript to be aware of Queue workers and their input/output types
- */
-    
-${serializedImportMap}
-${serializedCustomTypes}
-
-import type { QueueJob } from '@pikku/core/queue'
-
-interface QueueHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-${serializedQueues}
-
-type QueueAdd = <Name extends keyof QueueMap>(
-  name: Name,
-  data: QueueMap[Name]['input'],
-  options?: {
-    priority?: number
-    delay?: number
-    attempts?: number
-    removeOnComplete?: number
-    removeOnFail?: number
-    jobId?: string
-  }
-) => Promise<string>
-
-type QueueGetJob = <Name extends keyof QueueMap>(
-  name: Name,
-  jobId: string
-) => Promise<QueueJob<QueueMap[Name]['input'], QueueMap[Name]['output']> | null>
-
-export type TypedPikkuQueue = {
-  add: QueueAdd;
-  getJob: QueueGetJob;
-}
-  `;
-};
-function generateQueues(queueWorkersMeta, functionsMeta, typesMap, requiredTypes) {
-    // Initialize an object to collect queues
-    const queuesObj = {};
-    // Iterate through Queue metadata
-    for (const [queueName, { pikkuFuncName }] of Object.entries(queueWorkersMeta)) {
-        const functionMeta = functionsMeta[pikkuFuncName];
-        if (!functionMeta) {
-            throw new Error(`Function ${queueName} not found in functionsMeta. Please check your configuration.`);
-        }
-        const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
-        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
-        // Store the input and output types for QueueHandler
-        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
-        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null';
-        requiredTypes.add(inputType);
-        requiredTypes.add(outputType);
-        // Add Queue entry
-        queuesObj[queueName] = {
-            inputType,
-            outputType,
-        };
-    }
-    // Build the Queues object as a string
-    let queuesStr = 'export type QueueMap = {\n';
-    for (const [queueName, handler] of Object.entries(queuesObj)) {
-        queuesStr += `  readonly '${queueName}': QueueHandler<${handler.inputType}, ${handler.outputType}>,\n`;
-    }
-    queuesStr += '};\n';
-    return queuesStr;
-}

package/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;