@pikku/cli 0.7.0 → 0.7.1

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

@@ -1,61 +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> 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)
-    }
-}
-  `;
-};

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-route-imports.d.ts

@@ -1 +0,0 @@
-export declare const serializeRoutes: (outputPath: string, filesWithRoutes: Set<string>, packageMappings?: Record<string, string>) => string;

package/dist/src/events/http/serialize-route-imports.js

@@ -1,13 +0,0 @@
-import { getFileImportRelativePath } from '../utils.js';
-export const serializeRoutes = (outputPath, filesWithRoutes, packageMappings = {}) => {
-    const serializedOutput = [
-        '/* The files with an addRoute function call */',
-    ];
-    Array.from(filesWithRoutes)
-        .sort()
-        .forEach((path) => {
-        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
-        serializedOutput.push(`import '${filePath}'`);
-    });
-    return serializedOutput.join('\n');
-};

package/dist/src/events/http/serialize-route-meta.d.ts

@@ -1,2 +0,0 @@
-import type { HTTPRoutesMeta } from '@pikku/core/http';
-export declare const serializeHTTPRoutesMeta: (routesMeta: HTTPRoutesMeta) => string;

package/dist/src/events/http/serialize-route-meta.js

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

package/dist/src/events/http/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/events/http/serialize-typed-route-map.js

@@ -1,107 +0,0 @@
-import { serializeImportMap } from '../core/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')}`;
-};

package/dist/src/events/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/events/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/http/serialize-fetch-wrapper.d.ts

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

package/dist/src/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/http/serialize-route-imports.d.ts

@@ -1 +0,0 @@
-export declare const serializeRoutes: (outputPath: string, filesWithRoutes: Set<string>, packageMappings?: Record<string, string>) => string;

package/dist/src/http/serialize-route-imports.js

@@ -1,13 +0,0 @@
-import { getFileImportRelativePath } from '../utils.js';
-export const serializeRoutes = (outputPath, filesWithRoutes, packageMappings = {}) => {
-    const serializedOutput = [
-        '/* The files with an addRoute function call */',
-    ];
-    Array.from(filesWithRoutes)
-        .sort()
-        .forEach((path) => {
-        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
-        serializedOutput.push(`import '${filePath}'`);
-    });
-    return serializedOutput.join('\n');
-};

package/dist/src/http/serialize-route-meta.d.ts

@@ -1,2 +0,0 @@
-import type { HTTPRoutesMeta } from '@pikku/core/http';
-export declare const serializeHTTPRoutesMeta: (routesMeta: HTTPRoutesMeta) => string;

package/dist/src/http/serialize-route-meta.js

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

package/dist/src/http/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/http/serialize-typed-route-map.js

@@ -1,107 +0,0 @@
-import { serializeImportMap } from '../core/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')}`;
-};

package/dist/src/nextjs/serialize-nextjs-backend-wrapper.d.ts

@@ -1 +0,0 @@
-export declare const serializeNextJsBackendWrapper: (routesPath: string, routesMapPath: string, schemasPath: string, configImport: string, singleServicesFactoryImport: string, sessionServicesImport: string) => string;

package/dist/src/nextjs/serialize-nextjs-http-wrapper.d.ts

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

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

@@ -1,79 +0,0 @@
-import { HTTPRoutesMeta } 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(routeMeta: HTTPRoutesMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
-export {};