@pikku/cli 0.9.0 → 0.9.1

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
-    };
-}

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

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

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

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

package/dist/src/events/http/pikku-command-http-routes.d.ts

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

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

@@ -1,9 +0,0 @@
-import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
-export const pikkuHTTP = async (logger, cliConfig, visitState) => {
-    return await logCommandInfoAndTime(logger, 'Finding HTTP routes', 'Found HTTP routes', [visitState.http.files.size === 0], async () => {
-        const { httpWiringsFile, httpWiringMetaFile, packageMappings } = cliConfig;
-        const { http } = visitState;
-        await writeFileInDir(logger, httpWiringsFile, serializeFileImports('wireHTTP', httpWiringsFile, http.files, packageMappings));
-        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`);
-    });
-};

package/dist/src/events/http/pikku-command-nextjs.d.ts

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

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

@@ -1,36 +0,0 @@
-import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from '../../runtimes/nextjs/serialize-nextjs-backend-wrapper.js';
-import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from '../../runtimes/nextjs/serialize-nextjs-http-wrapper.js';
-import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-export const pikkuNext = async (logger, { nextBackendFile, nextHTTPFile, httpRoutesMapDeclarationFile, packageMappings, fetchFile, bootstrapFiles, }, visitState, options = {}) => {
-    return await logCommandInfoAndTime(logger, 'Generating nextjs wrapper', 'Generated nextjs wrapper', [
-        nextBackendFile === undefined && nextHTTPFile === undefined,
-        'nextjs outfile is not defined',
-    ], async () => {
-        if (!nextBackendFile && !nextHTTPFile) {
-            throw new Error('nextBackendFile or nextHTTPFile is required in pikku config for nextJS');
-        }
-        if (nextHTTPFile && !fetchFile) {
-            throw new Error('fetchFile is required in pikku config in order for nextJS http wrapper to work');
-        }
-        if (nextBackendFile) {
-            const { pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory, } = await getPikkuFilesAndMethods(logger, visitState, packageMappings, nextBackendFile, options, {
-                config: true,
-                singletonServicesFactory: true,
-                sessionServicesFactory: true,
-            });
-            const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextBackendFile, pikkuConfigFactory.file, packageMappings)}'`;
-            const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextBackendFile, singletonServicesFactory.file, packageMappings)}'`;
-            const sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextBackendFile, sessionServicesFactory.file, packageMappings)}'`;
-            const httpBootstrapPath = getFileImportRelativePath(nextBackendFile, bootstrapFiles.http, packageMappings);
-            const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpRoutesMapDeclarationFile, packageMappings);
-            const content = serializeNextBackendWrapper(httpBootstrapPath, routesMapDeclarationPath, pikkuConfigImport, singletonServicesImport, sessionServicesImport);
-            await writeFileInDir(logger, nextBackendFile, content);
-        }
-        if (nextHTTPFile && fetchFile) {
-            const routesMapDeclarationPath = getFileImportRelativePath(nextHTTPFile, httpRoutesMapDeclarationFile, packageMappings);
-            const fetchPath = getFileImportRelativePath(nextHTTPFile, fetchFile, packageMappings);
-            const content = serializeNextHTTPWrapper(routesMapDeclarationPath, fetchPath);
-            await writeFileInDir(logger, nextHTTPFile, content);
-        }
-    });
-};

package/dist/src/events/http/pikku-command-openapi.d.ts

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

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

@@ -1,20 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
-import { generateSchemas } from '../../schema-generator.js';
-import { generateOpenAPISpec } from './openapi-spec-generator.js';
-import { stringify } from 'yaml';
-export const pikkuOpenAPI = async (logger, { tsconfig, openAPI }, { http, functions }) => {
-    return await logCommandInfoAndTime(logger, 'Creating OpenAPI spec', 'Created OpenAPI spec', [openAPI?.outputFile === undefined, 'openAPI outfile is not defined'], async () => {
-        if (!openAPI?.outputFile) {
-            throw new Error('openAPI is required');
-        }
-        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta);
-        const openAPISpec = await generateOpenAPISpec(functions.meta, http.meta, schemas, openAPI.additionalInfo);
-        if (openAPI.outputFile.endsWith('.json')) {
-            await writeFileInDir(logger, openAPI.outputFile, JSON.stringify(openAPISpec, null, 2), { ignoreModifyComment: true });
-        }
-        else if (openAPI.outputFile.endsWith('.yaml') ||
-            openAPI.outputFile.endsWith('.yml')) {
-            await writeFileInDir(logger, openAPI.outputFile, stringify(openAPISpec), { ignoreModifyComment: true });
-        }
-    });
-};

package/dist/src/events/http/pikku-http-routes.d.ts

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

package/dist/src/events/http/pikku-http-routes.js

@@ -1,9 +0,0 @@
-import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
-export const pikkuHTTP = async (logger, cliConfig, visitState) => {
-    return await logCommandInfoAndTime(logger, 'Finding HTTP routes', 'Found HTTP routes', [visitState.http.files.size === 0], async () => {
-        const { httpWiringsFile, httpWiringMetaFile, packageMappings } = cliConfig;
-        const { http } = visitState;
-        await writeFileInDir(logger, httpWiringsFile, serializeFileImports('wireHTTP', httpWiringsFile, http.files, packageMappings));
-        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`);
-    });
-};

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

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

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 { HTTPWiringsMeta } from '@pikku/core/http';
-import { MetaInputTypes, TypesMap } from '@pikku/inspector';
-import { FunctionsMeta } from '@pikku/core';
-export declare const serializeTypedHTTPWiringsMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, wiringsMeta: HTTPWiringsMeta, metaTypes: MetaInputTypes) => string;

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

@@ -1,100 +0,0 @@
-import { serializeImportMap } from '../../serialize-import-map.js';
-import { generateCustomTypes } from '../../utils.js';
-export const serializeTypedHTTPWiringsMap = (relativeToPath, packageMappings, typesMap, functionsMeta, wiringsMeta, metaTypes) => {
-    const requiredTypes = new Set();
-    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
-    const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap);
-    const serializedHTTPWirings = generateHTTPWirings(wiringsMeta, functionsMeta, typesMap, requiredTypes);
-    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
-    return `/**
- * This provides the structure needed for typescript to be aware of routes and their return types
- */
-    
-${serializedImportMap}
-${serializedCustomTypes}
-${serializedMetaTypes}
-
-interface HTTPWiringHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-${serializedHTTPWirings}
-
-export type HTTPWiringHandlerOf<HTTPWiring extends keyof HTTPWiringsMap, Method extends keyof HTTPWiringsMap[HTTPWiring]> =
-    HTTPWiringsMap[HTTPWiring][Method] extends { input: infer I; output: infer O }
-        ? HTTPWiringHandler<I, O>
-        : never;
-
-export type HTTPWiringsWithMethod<Method extends string> = {
-  [HTTPWiring in keyof HTTPWiringsMap]: Method extends keyof HTTPWiringsMap[HTTPWiring] ? HTTPWiring : never;
-}[keyof HTTPWiringsMap];
-  `;
-};
-function generateHTTPWirings(routesMeta, functionsMeta, typesMap, requiredTypes) {
-    // Initialize an object to collect routes
-    const routesObj = {};
-    for (const meta of routesMeta) {
-        const { route, method, pikkuFuncName } = meta;
-        const functionMeta = functionsMeta[pikkuFuncName];
-        if (!functionMeta) {
-            throw new Error(`Function ${pikkuFuncName} not found in functionsMeta. Please check your configuration.`);
-        }
-        const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
-        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
-        // Initialize the route entry if it doesn't exist
-        if (!routesObj[route]) {
-            routesObj[route] = {};
-        }
-        // Store the input and output types separately for RouteHandler
-        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
-        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null';
-        requiredTypes.add(inputType);
-        requiredTypes.add(outputType);
-        // Add method entry
-        routesObj[route][method] = {
-            inputType,
-            outputType,
-        };
-    }
-    // Build the routes object as a string
-    let routesStr = 'export type RoutesMap = {\n';
-    for (const [routePath, methods] of Object.entries(routesObj)) {
-        routesStr += `  readonly '${routePath}': {\n`;
-        for (const [method, handler] of Object.entries(methods)) {
-            routesStr += `    readonly ${method.toUpperCase()}: RouteHandler<${handler.inputType}, ${handler.outputType}>,\n`;
-        }
-        routesStr += '  },\n';
-    }
-    routesStr += '};';
-    return routesStr;
-}
-const generateMetaTypes = (metaTypes, typesMap) => {
-    const nameToTypeMap = Array.from(metaTypes.entries()).reduce((result, [_name, { query, body, params }]) => {
-        const { uniqueName } = typesMap.getTypeMeta(_name);
-        const queryType = query && query.length > 0
-            ? `Pick<${uniqueName}, '${query?.join("' | '")}'>`
-            : undefined;
-        if (queryType) {
-            result.set(`${uniqueName}Query`, queryType);
-        }
-        const paramsType = params && params.length > 0
-            ? `Pick<${uniqueName}, '${params.join("' | '")}'>`
-            : undefined;
-        if (paramsType) {
-            result.set(`${uniqueName}Params`, paramsType);
-        }
-        const bodyType = (body && body.length > 0) || (params && params.length > 0)
-            ? `Omit<${uniqueName}, '${[...new Set([...(query || []), ...(params || [])])].join("' | '")}'>`
-            : uniqueName;
-        if (bodyType) {
-            result.set(`${uniqueName}Body`, bodyType);
-        }
-        return result;
-    }, new Map());
-    return `
-// The '& {}' is a workaround for not directly refering to a type since it confuses typescript
-${Array.from(nameToTypeMap.entries())
-        .map(([name, type]) => `export type ${name} = ${type} & {}`)
-        .join('\n')}`;
-};