@pikku/cli 0.9.0 → 0.9.2

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

@@ -1,15 +0,0 @@
-import { logCommandInfoAndTime, getFileImportRelativePath, writeFileInDir, } from '../../utils.js';
-import { serializeWebsocketWrapper } from './serialize-websocket-wrapper.js';
-export const pikkuWebSocketTyped = async (logger, { websocketFile, channelsMapDeclarationFile, packageMappings }) => {
-    return await logCommandInfoAndTime(logger, 'Generating websocket wrapper', 'Generated websocket wrapper', [
-        websocketFile === undefined,
-        "websocketFile isn't set in the pikku config",
-    ], async () => {
-        if (!websocketFile) {
-            throw new Error("fetchFile is isn't set in the pikku config");
-        }
-        const channelsMapDeclarationPath = getFileImportRelativePath(websocketFile, channelsMapDeclarationFile, packageMappings);
-        const content = [serializeWebsocketWrapper(channelsMapDeclarationPath)];
-        await writeFileInDir(logger, websocketFile, content.join('\n'));
-    });
-};

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

@@ -1,4 +0,0 @@
-import { ChannelsMeta } from '@pikku/core/channel';
-import { TypesMap } from '@pikku/inspector';
-import { FunctionsMeta } from '@pikku/core';
-export declare const serializeTypedChannelsMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, channelsMeta: ChannelsMeta) => string;

package/dist/src/events/channels/serialize-typed-channel-map.js

@@ -1,111 +0,0 @@
-import { serializeImportMap } from '../../serialize-import-map.js';
-import { generateCustomTypes } from '../../utils.js';
-export const serializeTypedChannelsMap = (relativeToPath, packageMappings, typesMap, functionsMeta, channelsMeta) => {
-    const { channels, requiredTypes } = generateChannels(functionsMeta, channelsMeta);
-    typesMap.customTypes.forEach(({ references }) => {
-        for (const reference of references) {
-            requiredTypes.add(reference);
-        }
-    });
-    const imports = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
-    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
-    return `/**
- * This provides the structure needed for TypeScript to be aware of channels
- */
-    
-${imports}
-${serializedCustomTypes}
-
-interface ChannelHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-${channels}
-
-export type ChannelDefaultHandlerOf<Channel extends keyof ChannelsMap> =
-    ChannelsMap[Channel]['defaultMessage'] extends { input: infer I; output: infer O }
-        ? ChannelHandler<I, O>
-        : never;
-
-export type ChannelRouteHandlerOf<
-    Channel extends keyof ChannelsMap, 
-    Route extends keyof ChannelsMap[Channel]['routes'], 
-    Method extends keyof ChannelsMap[Channel]['routes'][Route],
-> =
-    ChannelsMap[Channel]['routes'][Route][Method] extends { input: infer I; output: infer O }
-        ? ChannelHandler<I, O>
-        : never;
-`;
-};
-function generateChannels(functionsMeta, channelsMeta) {
-    const requiredTypes = new Set();
-    const channelsObject = {};
-    for (const meta of Object.values(channelsMeta)) {
-        const { name, messageWirings, message } = meta;
-        if (!channelsObject[name]) {
-            channelsObject[name] = { message: null, routes: {} };
-        }
-        if (message) {
-            const func = functionsMeta[message.pikkuFuncName];
-            if (!func) {
-                throw new Error(`Function ${message.pikkuFuncName} not found in functionsMeta for channel ${name}`);
-            }
-            const inputTypes = func.inputs || null;
-            const outputTypes = func.outputs || null;
-            channelsObject[name].message = {
-                inputs: inputTypes,
-                outputs: outputTypes,
-            };
-            inputTypes?.forEach((type) => requiredTypes.add(type));
-            outputTypes?.forEach((type) => requiredTypes.add(type));
-        }
-        for (const [key, route] of Object.entries(messageWirings)) {
-            if (!channelsObject[name].routes[key]) {
-                channelsObject[name].routes[key] = {};
-            }
-            for (const [method, { pikkuFuncName }] of Object.entries(route)) {
-                const func = functionsMeta[pikkuFuncName];
-                if (!func) {
-                    throw new Error(`Function ${pikkuFuncName} not found in functionsMeta for channel ${name}, route ${key}, method ${method}`);
-                }
-                const inputTypes = func.inputs || null;
-                const outputTypes = func.outputs || null;
-                channelsObject[name].routes[key][method] = {
-                    inputTypes,
-                    outputTypes,
-                };
-                inputTypes?.forEach((type) => requiredTypes.add(type));
-                outputTypes?.forEach((type) => requiredTypes.add(type));
-            }
-        }
-    }
-    let routesStr = 'export type ChannelsMap = {\n';
-    for (const [channelPath, { routes, message }] of Object.entries(channelsObject)) {
-        routesStr += `  readonly '${channelPath}': {\n`;
-        // Add `routes` object
-        routesStr += `    readonly routes: {\n`;
-        for (const [key, methods] of Object.entries(routes)) {
-            routesStr += `      readonly ${key}: {\n`;
-            for (const [method, handler] of Object.entries(methods)) {
-                routesStr += `        readonly ${method}: ChannelHandler<${formatTypeArray(handler.inputTypes) || 'void'}, ${formatTypeArray(handler.outputTypes) || 'never'}>,\n`;
-            }
-            routesStr += '      },\n';
-        }
-        routesStr += '    },\n';
-        // Add `defaultMessage` outside `routes`
-        if (message) {
-            routesStr += `    readonly defaultMessage: ChannelHandler<${formatTypeArray(message.inputs)}, ${formatTypeArray(message.outputs)}>,\n`;
-        }
-        else {
-            routesStr += `    readonly defaultMessage: never,\n`;
-        }
-        routesStr += '  },\n';
-    }
-    routesStr += '};';
-    return { channels: routesStr, requiredTypes };
-}
-// Utility to format type arrays
-function formatTypeArray(types) {
-    return types ? types.join(' | ') : 'null';
-}

package/dist/src/events/channels/serialize-websocket-wrapper.d.ts

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

package/dist/src/events/channels/serialize-websocket-wrapper.js

@@ -1,75 +0,0 @@
-export const serializeWebsocketWrapper = (channelsMapPath) => {
-    return `import { CorePikkuWebsocket, CorePikkuRouteHandler } from '@pikku/websocket'
-import { ChannelDefaultHandlerOf, ChannelRouteHandlerOf, ChannelsMap } from '${channelsMapPath}';
-
-class PikkuWebSocketRoute<Channel extends keyof ChannelsMap, Route extends keyof ChannelsMap[Channel]['routes']> extends CorePikkuRouteHandler {
-    public subscribe<
-        Method extends keyof ChannelsMap[Channel]['routes'][Route],
-        Data extends ChannelRouteHandlerOf<Channel, Route, Method>['output']
-    >(method: Method, callback: (data: Data) => void
-    ) {
-        super.subscribe(method.toString(), callback)
-    }
-
-    public unsubscribe<
-        Method extends keyof ChannelsMap[Channel]['routes'][Route],
-        Data extends ChannelRouteHandlerOf<Channel, Route, Method>['output']
-    >(method: Method, callback?: (data: Data) => void) {
-        super.unsubscribe(method.toString(), callback)
-    }
-
-    public send<
-        Method extends keyof ChannelsMap[Channel]['routes'][Route],
-        Data extends ChannelRouteHandlerOf<Channel, Route, Method>['input']
-    >(method: Method, data: Data) {
-        super.send(method.toString(), data)
-    }
-}
-
-export class PikkuWebSocket<Channel extends keyof ChannelsMap, Topics extends Record<string, any> = {}> extends CorePikkuWebsocket {
-    /**
-     * Send a message to a specific route and method.
-     * Validates the input data type.
-     */
-    public getRoute<Route extends keyof ChannelsMap[Channel]['routes']>(route: Route): PikkuWebSocketRoute<Channel, Route> {
-        return super.getRoute(route)
-    }
-
-    /**
-     * Subscribe to a specific route and method.
-     */
-    public subscribe<Data extends ChannelDefaultHandlerOf<Channel>['output']>(
-        callback: (data: Data) => void
-    ) {
-        super.subscribe(callback)
-    }
-
-    /**
-     * Subscribe to a specific route and method.
-     */
-    public unsubscribe<Data extends ChannelDefaultHandlerOf<Channel>['output']>(
-        callback?: (data: Data) => void
-    ) {
-        super.unsubscribe(callback)
-    }
-
-    public send(data: ChannelDefaultHandlerOf<Channel>['input']) {
-        super.send(data)
-    }
-
-    /**
-     * Subscribe to a topic from the EventHub system with strong typing.
-     */
-    public subscribeToEventHub<Topic extends keyof EventHubTopics>(
-        topic: Topic,
-        callback: (data: EventHubTopics[Topic]) => void
-    ) {
-        super.subscribe((data) => {
-            if (data.topic === topic) {
-                callback(data as EventHubTopics[Topic])
-            }
-        })
-    }
-}
-  `;
-};

package/dist/src/events/fetch/index.d.ts

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

package/dist/src/events/fetch/index.js

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

package/dist/src/events/functions/pikku-command-function-types.d.ts

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

package/dist/src/events/functions/pikku-command-function-types.js

@@ -1,13 +0,0 @@
-import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-import { serializePikkuTypes } from '../../serialize-pikku-types.js';
-export const pikkuFunctionTypes = async (logger, { typesDeclarationFile: typesFile, packageMappings, rpcMapDeclarationFile }, visitState, options = {}) => {
-    return await logCommandInfoAndTime(logger, 'Creating api types', 'Created api types', [false], async () => {
-        const { userSessionType, sessionServicesType, singletonServicesType } = await getPikkuFilesAndMethods(logger, visitState, packageMappings, typesFile, options, {
-            userSessionType: true,
-            sessionServiceType: true,
-            singletonServicesType: true,
-        });
-        const content = serializePikkuTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcMapDeclarationFile, packageMappings)}'`);
-        await writeFileInDir(logger, typesFile, content);
-    });
-};

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

@@ -1,6 +0,0 @@
-import { PikkuCommand } from '../../types.js';
-export declare const serializeFunctionImports: (outputPath: string, functionsMap: Map<string, {
-    path: string;
-    exportedName: string;
-}>, packageMappings?: Record<string, string>) => string;
-export declare const pikkuFunctions: PikkuCommand;

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

@@ -1,35 +0,0 @@
-import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-export const serializeFunctionImports = (outputPath, functionsMap, packageMappings = {}) => {
-    const serializedImports = [
-        `/* Import and register RPCs */`,
-        `import { addFunction } from '@pikku/core'`,
-    ];
-    const serializedRegistrations = [];
-    // Sort by function name for consistent output
-    const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) => a[0].localeCompare(b[0]));
-    for (const [name, { path, exportedName }] of sortedEntries) {
-        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
-        // For directly exported functions, we can just import and register them
-        if (name === exportedName) {
-            serializedImports.push(`import { ${exportedName} } from '${filePath}'`);
-            serializedRegistrations.push(`addFunction('${name}', { func: ${exportedName} })`);
-        }
-        // For renamed functions, we need to import and alias them
-        else {
-            serializedImports.push(`import { ${exportedName} as ${name} } from '${filePath}'`);
-            serializedRegistrations.push(`addFunction('${name}', ${name})`);
-        }
-    }
-    // Add a blank line between imports and registrations
-    if (serializedImports.length > 0 && serializedRegistrations.length > 0) {
-        serializedImports.push('');
-    }
-    // Combine the imports and registrations
-    return [...serializedImports, ...serializedRegistrations].join('\n');
-};
-export const pikkuFunctions = async (logger, { functionsMetaFile, functionsFile, packageMappings }, { functions }) => {
-    return await logCommandInfoAndTime(logger, 'Serializing Pikku functions', 'Serialized Pikku functions', [false], async () => {
-        await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, functions.files, packageMappings));
-        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`);
-    });
-};

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

@@ -1,3 +0,0 @@
-import { PikkuCommand } from '../../types.js';
-export declare const serializeServicesMap: (functionsMetaData: Record<string, any>, middlewareServices: string[] | undefined, servicesImport: string, sessionServicesImport: string) => string;
-export declare const pikkuServices: PikkuCommand;

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

@@ -1,73 +0,0 @@
-import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-export const serializeServicesMap = (functionsMetaData, middlewareServices = [], servicesImport, sessionServicesImport) => {
-    // Extract all unique services from all functions
-    const usedServices = new Set();
-    // Internal services that are created internally and not via the create service script
-    const internalServices = new Set(['rpc', 'mcp', 'channel', 'userSession']);
-    for (const funcMeta of Object.values(functionsMetaData)) {
-        if (funcMeta.services && Array.isArray(funcMeta.services.services)) {
-            funcMeta.services.services.forEach((service) => {
-                // Only include services that are not internal
-                if (!internalServices.has(service)) {
-                    usedServices.add(service);
-                }
-            });
-        }
-    }
-    // Add middleware services that might not be detected from function inspection
-    middlewareServices.forEach((service) => {
-        if (!internalServices.has(service)) {
-            usedServices.add(service);
-        }
-    });
-    // Create a map of services with true for all needed services
-    const servicesMap = Object.fromEntries(Array.from(usedServices)
-        .sort()
-        .map((service) => [service, true]));
-    // Generate the TypeScript code
-    const serviceKeys = Object.keys(servicesMap).sort();
-    // Services that are always required internally by the framework
-    const defaultServices = ['config', 'logger', 'variables', 'schema'];
-    // Combine default services with detected services
-    const allRequiredServices = [
-        ...new Set([...defaultServices, ...serviceKeys]),
-    ].sort();
-    // For RequiredSingletonServices, we need to pick from the actual SingletonServices interface
-    // This will be resolved at compile time based on what's actually in the SingletonServices interface
-    // We don't need to hardcode which services are singletons beyond the core framework ones
-    const code = [
-        '/**',
-        ' * This file was generated by the @pikku/cli',
-        ' */',
-        '',
-        servicesImport,
-        sessionServicesImport,
-        "import type { PikkuInteraction } from '@pikku/core'",
-        '',
-        'export const singletonServices = {',
-        ...Object.keys(servicesMap).map((service) => `    '${service}': true,`),
-        '} as const',
-        '',
-        '// Singleton services (created once at startup)',
-        '// Only includes services that are both required and available in SingletonServices',
-        `export type RequiredSingletonServices = Pick<SingletonServices, Extract<keyof SingletonServices, ${allRequiredServices.map((key) => `'${key}'`).join(' | ')}>> & Partial<Omit<SingletonServices, ${allRequiredServices.map((key) => `'${key}'`).join(' | ')}>>`,
-        '',
-        '// Session services (created per request, can access singleton services)',
-        '// Omits singleton services and PikkuInteraction (mcp, rpc, http, channel)',
-        `export type RequiredSessionServices = Omit<Services, keyof SingletonServices | keyof PikkuInteraction>`,
-        '',
-    ].join('\n');
-    return code;
-};
-export const pikkuServices = async (logger, cliConfig, visitState) => {
-    return await logCommandInfoAndTime(logger, 'Generating Pikku services map', 'Generated Pikku services map', [visitState.functions.files.size === 0], async () => {
-        const { sessionServicesType, singletonServicesType } = await getPikkuFilesAndMethods(logger, visitState, cliConfig.packageMappings, cliConfig.typesDeclarationFile, {}, {
-            sessionServiceType: true,
-            singletonServicesType: true,
-        });
-        const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(cliConfig.typesDeclarationFile, singletonServicesType.typePath, cliConfig.packageMappings)}'`;
-        const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(cliConfig.typesDeclarationFile, sessionServicesType.typePath, cliConfig.packageMappings)}'`;
-        const servicesCode = serializeServicesMap(visitState.functions.meta, cliConfig.middlewareServices, servicesImport, sessionServicesImport);
-        await writeFileInDir(logger, cliConfig.servicesFile, servicesCode);
-    });
-};

package/dist/src/events/functions/pikku-function-types.d.ts

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

package/dist/src/events/functions/pikku-function-types.js

@@ -1,13 +0,0 @@
-import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-import { serializePikkuTypes } from '../../serialize-pikku-types.js';
-export const pikkuFunctionTypes = async (logger, { typesDeclarationFile: typesFile, packageMappings, rpcMapDeclarationFile }, visitState, options = {}) => {
-    return await logCommandInfoAndTime(logger, 'Creating api types', 'Created api types', [false], async () => {
-        const { userSessionType, sessionServicesType, singletonServicesType } = await getPikkuFilesAndMethods(logger, visitState, packageMappings, typesFile, options, {
-            userSessionType: true,
-            sessionServiceType: true,
-            singletonServicesType: true,
-        });
-        const content = serializePikkuTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcMapDeclarationFile, packageMappings)}'`);
-        await writeFileInDir(logger, typesFile, content);
-    });
-};

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

@@ -1,6 +0,0 @@
-import { PikkuCommand } from '../../types.js';
-export declare const serializeFunctionImports: (outputPath: string, functionsMap: Map<string, {
-    path: string;
-    exportedName: string;
-}>, packageMappings?: Record<string, string>) => string;
-export declare const pikkuFunctions: PikkuCommand;

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

@@ -1,35 +0,0 @@
-import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-export const serializeFunctionImports = (outputPath, functionsMap, packageMappings = {}) => {
-    const serializedImports = [
-        `/* Import and register RPCs */`,
-        `import { addFunction } from '@pikku/core'`,
-    ];
-    const serializedRegistrations = [];
-    // Sort by function name for consistent output
-    const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) => a[0].localeCompare(b[0]));
-    for (const [name, { path, exportedName }] of sortedEntries) {
-        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
-        // For directly exported functions, we can just import and register them
-        if (name === exportedName) {
-            serializedImports.push(`import { ${exportedName} } from '${filePath}'`);
-            serializedRegistrations.push(`addFunction('${name}', { func: ${exportedName} })`);
-        }
-        // For renamed functions, we need to import and alias them
-        else {
-            serializedImports.push(`import { ${exportedName} as ${name} } from '${filePath}'`);
-            serializedRegistrations.push(`addFunction('${name}', ${name})`);
-        }
-    }
-    // Add a blank line between imports and registrations
-    if (serializedImports.length > 0 && serializedRegistrations.length > 0) {
-        serializedImports.push('');
-    }
-    // Combine the imports and registrations
-    return [...serializedImports, ...serializedRegistrations].join('\n');
-};
-export const pikkuFunctions = async (logger, { functionsMetaFile, functionsFile, packageMappings }, { functions }) => {
-    return await logCommandInfoAndTime(logger, 'Serializing Pikku functions', 'Serialized Pikku functions', [false], async () => {
-        await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, functions.files, packageMappings));
-        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`);
-    });
-};

package/dist/src/events/http/openapi-spec-generator.d.ts

@@ -1,79 +0,0 @@
-import { FunctionsMeta, HTTPWiringsMeta } from '@pikku/core';
-interface OpenAPISpec {
-    openapi: string;
-    info: {
-        title: string;
-        version: string;
-        description?: string;
-        termsOfService?: string;
-        contact?: {
-            name?: string;
-            url?: string;
-            email?: string;
-        };
-        license?: {
-            name: string;
-            url?: string;
-        };
-    };
-    servers: {
-        url: string;
-        description?: string;
-    }[];
-    paths: Record<string, any>;
-    components: {
-        schemas: Record<string, any>;
-        responses?: Record<string, any>;
-        parameters?: Record<string, any>;
-        examples?: Record<string, any>;
-        requestBodies?: Record<string, any>;
-        headers?: Record<string, any>;
-        securitySchemes?: Record<string, any>;
-    };
-    security?: {
-        [key: string]: any[];
-    }[];
-    tags?: {
-        name: string;
-        description?: string;
-    }[];
-    externalDocs?: {
-        description?: string;
-        url: string;
-    };
-}
-export interface OpenAPISpecInfo {
-    info: {
-        title: string;
-        version: string;
-        description: string;
-        termsOfService?: string;
-        contact?: {
-            name?: string;
-            url?: string;
-            email?: string;
-        };
-        license?: {
-            name: string;
-            url?: string;
-        };
-    };
-    servers: {
-        url: string;
-        description?: string;
-    }[];
-    tags?: {
-        name: string;
-        description?: string;
-    }[];
-    externalDocs?: {
-        description?: string;
-        url: string;
-    };
-    securitySchemes?: Record<string, any>;
-    security?: {
-        [key: string]: any[];
-    }[];
-}
-export declare function generateOpenAPISpec(functionsMeta: FunctionsMeta, routeMeta: HTTPWiringsMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
-export {};

package/dist/src/events/http/openapi-spec-generator.js

@@ -1,145 +0,0 @@
-import { pikkuState } from '@pikku/core';
-import _convertSchema from '@openapi-contrib/json-schema-to-openapi-schema';
-const convertSchema = 'default' in _convertSchema ? _convertSchema.default : _convertSchema;
-const getErrorResponseForConstructorName = (constructorName) => {
-    const errors = Array.from(pikkuState('misc', 'errors').entries());
-    const foundError = errors.find(([e]) => e.name === constructorName);
-    if (foundError) {
-        return foundError[1];
-    }
-    return undefined;
-};
-const convertSchemasToBodyPayloads = async (functionsMeta, routesMeta, schemas) => {
-    const requiredSchemas = new Set(routesMeta
-        .map(({ inputTypes, pikkuFuncName }) => {
-        const output = functionsMeta[pikkuFuncName]?.outputs?.[0];
-        return [inputTypes?.body, output];
-    })
-        .flat()
-        .filter((schema) => !!schema));
-    const convertedEntries = await Promise.all(Object.entries(schemas).map(async ([key, schema]) => {
-        if (requiredSchemas.has(key)) {
-            const convertedSchema = await convertSchema(schema, {
-                convertUnreferencedDefinitions: false,
-                dereference: { circular: 'ignore' },
-            });
-            return [key, convertedSchema];
-        }
-        return;
-    }));
-    return Object.fromEntries(convertedEntries.filter((s) => !!s));
-};
-export async function generateOpenAPISpec(functionsMeta, routeMeta, schemas, additionalInfo) {
-    const paths = {};
-    routeMeta.forEach((meta) => {
-        const { route, method, inputTypes, pikkuFuncName, params, query, docs } = meta;
-        const functionMeta = functionsMeta[pikkuFuncName];
-        if (!functionMeta) {
-            console.error(`• No function metadata found for '${pikkuFuncName}' in route '${route}'.`);
-            return;
-        }
-        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
-        const path = route.replace(/:(\w+)/g, '{$1}'); // Convert ":param" to "{param}"
-        if (!paths[path]) {
-            paths[path] = {};
-        }
-        const responses = {};
-        docs?.errors?.forEach((error) => {
-            const errorResponse = getErrorResponseForConstructorName(error);
-            if (errorResponse) {
-                responses[errorResponse.status] = {
-                    description: errorResponse.message,
-                };
-            }
-        });
-        const operation = {
-            description: docs?.description ||
-                `This endpoint handles the ${method.toUpperCase()} request for the route ${route}.`,
-            tags: docs?.tags || [route.split('/')[1] || 'default'],
-            parameters: [],
-            responses: {
-                ...responses,
-                '200': {
-                    description: 'Successful response',
-                    content: output
-                        ? {
-                            'application/json': {
-                                schema: typeof output === 'string' &&
-                                    ['boolean', 'string', 'number'].includes(output)
-                                    ? { type: output }
-                                    : { $ref: `#/components/schemas/${output}` },
-                            },
-                        }
-                        : undefined,
-                },
-            },
-        };
-        const bodyType = inputTypes?.body;
-        if (bodyType) {
-            operation.requestBody = {
-                required: true,
-                content: {
-                    'application/json': {
-                        schema: typeof bodyType === 'string' &&
-                            ['boolean', 'string', 'number'].includes(bodyType)
-                            ? { type: bodyType }
-                            : { $ref: `#/components/schemas/${bodyType}` },
-                    },
-                },
-            };
-        }
-        if (params) {
-            operation.parameters = params.map((param) => ({
-                name: param,
-                in: 'path',
-                required: true,
-                schema: { type: 'string' },
-            }));
-        }
-        if (query) {
-            operation.parameters.push(...query.map((query) => ({
-                name: query,
-                in: 'query',
-                required: false,
-                schema: { type: 'string' },
-            })));
-        }
-        paths[path][method] = operation;
-    });
-    return {
-        openapi: '3.1.0',
-        info: additionalInfo.info,
-        servers: additionalInfo.servers,
-        paths,
-        components: {
-            schemas: await convertSchemasToBodyPayloads(functionsMeta, routeMeta, schemas),
-            responses: {},
-            parameters: {},
-            examples: {},
-            requestBodies: {},
-            headers: {},
-            securitySchemes: additionalInfo.securitySchemes || {
-                ApiKeyAuth: {
-                    type: 'apiKey',
-                    in: 'header',
-                    name: 'x-api-key',
-                },
-                BearerAuth: {
-                    type: 'http',
-                    scheme: 'bearer',
-                },
-            },
-        },
-        security: additionalInfo.security || [
-            {
-                ApiKeyAuth: [],
-            },
-            {
-                BearerAuth: [],
-            },
-        ],
-        tags: additionalInfo.tags,
-        externalDocs: additionalInfo.externalDocs,
-        // definitions
-    };
-}