@pikku/cli 0.7.0 → 0.7.1

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

@@ -1,136 +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 (routesMeta, schemas) => {
-    const requiredSchemas = new Set(routesMeta
-        .map(({ inputTypes, output }) => [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(routeMeta, schemas, additionalInfo) {
-    const paths = {};
-    routeMeta.forEach((meta) => {
-        const { route, method, inputTypes, output, params, query, docs } = meta;
-        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(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/scheduler/serialize-schedulers.d.ts

@@ -1,3 +0,0 @@
-import { ScheduledTasksMeta } from '@pikku/core/scheduler';
-export declare const serializeSchedulers: (outputPath: string, filesWithScheduledTasks: Set<string>, packageMappings?: Record<string, string>) => string;
-export declare const serializeSchedulerMeta: (scheduledTasksMeta: ScheduledTasksMeta) => string;

package/dist/src/scheduler/serialize-schedulers.js

@@ -1,23 +0,0 @@
-import { getFileImportRelativePath } from '../utils.js';
-export const serializeSchedulers = (outputPath, filesWithScheduledTasks, packageMappings = {}) => {
-    const serializedOutput = [
-        '/* The files with an addSerializedTasks function call */',
-    ];
-    Array.from(filesWithScheduledTasks)
-        .sort()
-        .forEach((path) => {
-        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
-        serializedOutput.push(`import '${filePath}'`);
-    });
-    return serializedOutput.join('\n');
-};
-export const serializeSchedulerMeta = (scheduledTasksMeta) => {
-    const serializedOutput = [];
-    serializedOutput.push("import { pikkuState } from '@pikku/core'");
-    serializedOutput.push(`pikkuState('scheduler', 'meta', ${JSON.stringify(scheduledTasksMeta, null, 2)})`);
-    const scheduledTasksMetaValues = Object.values(scheduledTasksMeta);
-    if (scheduledTasksMetaValues.length > 0) {
-        serializedOutput.push(`export type ScheduledTaskNames = '${scheduledTasksMetaValues.map((s) => s.name).join("' | '")}'`);
-    }
-    return serializedOutput.join('\n');
-};

package/dist/src/schema/schema-generator.d.ts

@@ -1,5 +0,0 @@
-import { JSONValue } from '@pikku/core';
-import { HTTPRoutesMeta } from '@pikku/core/http';
-import { TypesMap } from '@pikku/inspector';
-export declare function generateSchemas(tsconfig: string, typesMaps: TypesMap[], httpRoutesMeta: HTTPRoutesMeta): Promise<Record<string, JSONValue>>;
-export declare function saveSchemas(schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, routesMeta: HTTPRoutesMeta, supportsImportAttributes: boolean): Promise<void>;

package/dist/src/schema/schema-generator.js

@@ -1,89 +0,0 @@
-import { createGenerator, RootlessError } from 'ts-json-schema-generator';
-import { logInfo, writeFileInDir } from '../utils.js';
-import { mkdir, writeFile } from 'fs/promises';
-export async function generateSchemas(tsconfig, typesMaps, httpRoutesMeta) {
-    const schemasSet = new Set(typesMaps.flatMap((tm) => [...tm.customTypes.keys()]));
-    for (const { input, inputTypes } of httpRoutesMeta) {
-        if (input) {
-            for (const typesMap of typesMaps) {
-                const uniqueName = typesMap.getUniqueName(input);
-                if (uniqueName) {
-                    schemasSet.add(uniqueName);
-                    break;
-                }
-            }
-        }
-        // if (output) {
-        //   for (const typesMap of typesMaps) {
-        //     const uniqueName = typesMap.getUniqueName(output)
-        //     if (uniqueName) {
-        //       console.log('Adding output schema:', uniqueName)
-        //       schemasSet.add(uniqueName)
-        //       break
-        //     }
-        //   }
-        // }
-        if (inputTypes?.body) {
-            schemasSet.add(inputTypes.body);
-        }
-        if (inputTypes?.query) {
-            schemasSet.add(inputTypes.query);
-        }
-        if (inputTypes?.params) {
-            schemasSet.add(inputTypes.params);
-        }
-    }
-    const generator = createGenerator({
-        tsconfig,
-        skipTypeCheck: true,
-        topRef: false,
-        discriminatorType: 'open-api',
-    });
-    const schemas = {};
-    schemasSet.forEach((schema) => {
-        try {
-            schemas[schema] = generator.createSchema(schema);
-        }
-        catch (e) {
-            // Ignore rootless errors
-            if (e instanceof RootlessError) {
-                console.error('Error generating schema since it has no root:', schema);
-                return;
-            }
-            throw e;
-        }
-    });
-    return schemas;
-}
-export async function saveSchemas(schemaParentDir, schemas, typesMap, routesMeta, supportsImportAttributes) {
-    await writeFileInDir(`${schemaParentDir}/register.gen.ts`, 'export const empty = null;');
-    const desiredSchemas = new Set([
-        ...routesMeta
-            .map(({ input, output }) => [
-            input ? typesMap.getUniqueName(input) : undefined,
-            output ? typesMap.getUniqueName(output) : undefined,
-        ])
-            .flat()
-            .filter((s) => !!s &&
-            !['boolean', 'string', 'number', 'null', 'undefined'].includes(s)),
-        ...typesMap.customTypes.keys(),
-    ]);
-    if (desiredSchemas.size === 0) {
-        logInfo(`• Skipping schemas since none found.\x1b[0m`);
-        return;
-    }
-    await mkdir(`${schemaParentDir}/schemas`, { recursive: true });
-    await Promise.all(Object.entries(schemas).map(async ([schemaName, schema]) => {
-        if (desiredSchemas.has(schemaName)) {
-            await writeFile(`${schemaParentDir}/schemas/${schemaName}.schema.json`, JSON.stringify(schema), 'utf-8');
-        }
-    }));
-    const schemaImports = Array.from(desiredSchemas)
-        .map((schema) => `
-import * as ${schema} from './schemas/${schema}.schema.json' ${supportsImportAttributes ? `with { type: 'json' }` : ''}
-addSchema('${schema}', ${schema})
-`)
-        .join('\n');
-    await writeFileInDir(`${schemaParentDir}/register.gen.ts`, `import { addSchema } from '@pikku/core/schema'
-${schemaImports}`);
-}

package/dist/src/serialize-typed-route-map.d.ts

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

package/dist/src/serialize-typed-route-map.js

@@ -1,107 +0,0 @@
-import { serializeImportMap } from './serialize-import-map.js';
-export const serializeTypedRoutesMap = (relativeToPath, packageMappings, typesMap, routesMeta, metaTypes) => {
-    const requiredTypes = new Set();
-    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
-    const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap);
-    const serializedRoutes = generateRoutes(routesMeta, 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 RouteHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-${serializedRoutes}
-
-export type RouteHandlerOf<Route extends keyof RoutesMap, Method extends keyof RoutesMap[Route]> =
-    RoutesMap[Route][Method] extends { input: infer I; output: infer O }
-        ? RouteHandler<I, O>
-        : never;
-
-export type RoutesWithMethod<Method extends string> = {
-  [Route in keyof RoutesMap]: Method extends keyof RoutesMap[Route] ? Route : never;
-}[keyof RoutesMap];
-  `;
-};
-export function generateCustomTypes(typesMap, requiredTypes) {
-    return `
-// Custom types are those that are defined directly within generics
-// or are broken into simpler types
-${Array.from(typesMap.customTypes.entries())
-        .map(([name, { type, references }]) => {
-        references.forEach((name) => {
-            const originalName = typesMap.getTypeMeta(name).originalName;
-            requiredTypes.add(originalName);
-        });
-        return `export type ${name} = ${type}`;
-    })
-        .join('\n')}`;
-}
-function generateRoutes(routesMeta, typesMap, requiredTypes) {
-    // Initialize an object to collect routes
-    const routesObj = {};
-    for (const meta of routesMeta) {
-        const { route, method, input, output } = meta;
-        // 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')}`;
-};