@pikku/cli 0.6.6

package/dist/bin/pikku-nextjs.js

@@ -0,0 +1,40 @@
+import { serializeNextJsWrapper } from '../src/nextjs/serialize-nextjs-wrapper.js';
+import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { inspectorGlob } from '../src/inspector-glob.js';
+export const pikkuNext = async ({ nextJSfile, routesFile, routesMapDeclarationFile, schemaDirectory, packageMappings, }, visitState, options) => {
+    return await logCommandInfoAndTime('Generating nextjs wrapper', 'Generated nextjs wrapper', [nextJSfile === undefined, 'nextjs outfile is not defined'], async () => {
+        if (!nextJSfile) {
+            throw new Error('nextJSfile is required in pikku config');
+        }
+        const { pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory, } = await getPikkuFilesAndMethods(visitState, packageMappings, nextJSfile, options, {
+            config: true,
+            singletonServicesFactory: true,
+            sessionServicesFactory: true,
+        });
+        const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextJSfile, pikkuConfigFactory.file, packageMappings)}'`;
+        const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextJSfile, singletonServicesFactory.file, packageMappings)}'`;
+        const sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextJSfile, sessionServicesFactory.file, packageMappings)}'`;
+        const routesPath = getFileImportRelativePath(nextJSfile, routesFile, packageMappings);
+        const routesMapDeclarationPath = getFileImportRelativePath(nextJSfile, routesMapDeclarationFile, packageMappings);
+        const schemasPath = getFileImportRelativePath(nextJSfile, `${schemaDirectory}/register.gen.ts`, packageMappings);
+        const content = serializeNextJsWrapper(routesPath, routesMapDeclarationPath, schemasPath, pikkuConfigImport, singletonServicesImport, sessionServicesImport);
+        await writeFileInDir(nextJSfile, content);
+    });
+};
+export const action = async (options) => {
+    logPikkuLogo();
+    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'nextJSfile'], true);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    await pikkuNext(cliConfig, visitState, options);
+};
+export const nextjs = (program) => {
+    program
+        .command('nextjs')
+        .description('generate nextjs wrapper')
+        .option('-ct | --pikku-config-type', 'The type of your pikku config object')
+        .option('-ss | --singleton-services-factory-type', 'The type of your singleton services factory')
+        .option('-se | --session-services-factory-type', 'The type of your session services factory')
+        .option('-c | --config <string>', 'The path to pikku cli config file')
+        .action(action);
+};

package/dist/bin/pikku-openapi.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { InspectorState } from '@pikku/inspector';
+export declare const pikkuOpenAPI: ({ tsconfig, openAPI }: PikkuCLIConfig, { http }: InspectorState) => Promise<void>;
+export declare const openapi: (program: Command) => void;

package/dist/bin/pikku-openapi.js

@@ -0,0 +1,41 @@
+import { logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+import { generateSchemas } from '../src/schema/schema-generator.js';
+import { generateOpenAPISpec } from '../src/openapi/openapi-spec-generator.js';
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { stringify } from 'yaml';
+import { inspectorGlob } from '../src/inspector-glob.js';
+export const pikkuOpenAPI = async ({ tsconfig, openAPI }, { http }) => {
+    await logCommandInfoAndTime('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(tsconfig, http.typesMap, http.meta);
+        const openAPISpec = await generateOpenAPISpec(http.meta, schemas, openAPI.additionalInfo);
+        if (openAPI.outputFile.endsWith('.json')) {
+            await writeFileInDir(openAPI.outputFile, JSON.stringify(openAPISpec, null, 2), true);
+        }
+        else if (openAPI.outputFile.endsWith('.yaml') ||
+            openAPI.outputFile.endsWith('.yml')) {
+            await writeFileInDir(openAPI.outputFile, stringify(openAPISpec), true);
+        }
+    });
+};
+async function action({ config }) {
+    logPikkuLogo();
+    const cliConfig = await getPikkuCLIConfig(config, [
+        'rootDir',
+        'routesFile',
+        'openAPI',
+        'schemaDirectory',
+        'tsconfig',
+    ]);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    await pikkuOpenAPI(cliConfig, visitState);
+}
+export const openapi = (program) => {
+    program
+        .command('openapi')
+        .description('Generate an openapi spec')
+        .option('-c | --config <string>', 'The path to pikku cli config file')
+        .action(action);
+};

package/dist/bin/pikku-routes-map.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { InspectorState } from '@pikku/inspector';
+export declare const pikkuHTTPMap: ({ routesMapDeclarationFile, packageMappings }: PikkuCLIConfig, { http }: InspectorState) => Promise<boolean>;
+export declare const routesMap: (program: Command) => void;

package/dist/bin/pikku-routes-map.js

@@ -0,0 +1,27 @@
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+import { serializeTypedRoutesMap } from '../src/http/serialize-typed-route-map.js';
+import { inspectorGlob } from '../src/inspector-glob.js';
+export const pikkuHTTPMap = async ({ routesMapDeclarationFile, packageMappings }, { http }) => {
+    return await logCommandInfoAndTime('Creating routes map', 'Created routes map', [http.files.size === 0], async () => {
+        const content = serializeTypedRoutesMap(routesMapDeclarationFile, packageMappings, http.typesMap, http.meta, http.metaInputTypes);
+        await writeFileInDir(routesMapDeclarationFile, content);
+    });
+};
+async function action(cliOptions) {
+    logPikkuLogo();
+    const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
+        'rootDir',
+        'routeDirectories',
+        'routesFile',
+    ]);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    await pikkuHTTPMap(cliConfig, visitState);
+}
+export const routesMap = (program) => {
+    program
+        .command('map')
+        .description('Generate a map of all routes to aid in type checking')
+        .option('-c | --config <string>', 'The path to pikku cli config file')
+        .action(action);
+};

package/dist/bin/pikku-routes.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { InspectorState } from '@pikku/inspector';
+export declare const pikkuRoutes: (cliConfig: PikkuCLIConfig, visitState: InspectorState) => Promise<boolean>;
+export declare const routes: (program: Command) => void;

package/dist/bin/pikku-routes.js

@@ -0,0 +1,33 @@
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { serializeHTTPRoutesMeta } from '../src/http/serialize-route-meta.js';
+import { logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+import { serializeRoutes } from '../src/http/serialize-route-imports.js';
+import { inspectorGlob } from '../src/inspector-glob.js';
+export const pikkuRoutes = async (cliConfig, visitState) => {
+    return await logCommandInfoAndTime('Finding routes', 'Found routes', [visitState.http.files.size === 0], async () => {
+        const { routesFile, packageMappings } = cliConfig;
+        const { http } = visitState;
+        const content = [
+            serializeRoutes(routesFile, http.files, packageMappings),
+            serializeHTTPRoutesMeta(http.meta),
+        ];
+        await writeFileInDir(routesFile, content.join('\n\n'));
+    });
+};
+async function action(cliOptions) {
+    logPikkuLogo();
+    const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
+        'rootDir',
+        'routeDirectories',
+        'routesFile',
+    ]);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    await pikkuRoutes(cliConfig, visitState);
+}
+export const routes = (program) => {
+    program
+        .command('routes')
+        .description('Find all routes to import')
+        .option('-c | --config <string>', 'The path to pikku cli config file')
+        .action(action);
+};

package/dist/bin/pikku-scheduler.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { InspectorState } from '@pikku/inspector';
+export declare const pikkuScheduler: (cliConfig: PikkuCLIConfig, visitState: InspectorState) => Promise<boolean>;
+export declare const schedules: (program: Command) => void;

package/dist/bin/pikku-scheduler.js

@@ -0,0 +1,32 @@
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+import { serializeSchedulerMeta, serializeSchedulers, } from '../src/scheduler/serialize-schedulers.js';
+import { inspectorGlob } from '../src/inspector-glob.js';
+export const pikkuScheduler = async (cliConfig, visitState) => {
+    return await logCommandInfoAndTime('Finding scheduled tasks', 'Found scheduled tasks', [visitState.scheduledTasks.files.size === 0], async () => {
+        const { schedulersFile, packageMappings } = cliConfig;
+        const { scheduledTasks } = visitState;
+        const content = [
+            serializeSchedulers(schedulersFile, scheduledTasks.files, packageMappings),
+            serializeSchedulerMeta(scheduledTasks.meta),
+        ];
+        await writeFileInDir(schedulersFile, content.join('\n\n'));
+    });
+};
+async function action(cliOptions) {
+    logPikkuLogo();
+    const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
+        'rootDir',
+        'routeDirectories',
+        'routesFile',
+    ]);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    await pikkuScheduler(cliConfig, visitState);
+}
+export const schedules = (program) => {
+    program
+        .command('scheduler')
+        .description('Find all scheduled tasks to import')
+        .option('-c | --config <string>', 'The path to pikku cli config file')
+        .action(action);
+};

package/dist/bin/pikku-schemas.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { InspectorState } from '@pikku/inspector';
+export declare const pikkuSchemas: ({ tsconfig, schemaDirectory, supportsImportAttributes }: PikkuCLIConfig, { http }: InspectorState) => Promise<boolean>;
+export declare const schemas: (program: Command) => void;

package/dist/bin/pikku-schemas.js

@@ -0,0 +1,27 @@
+import { saveSchemas, generateSchemas } from '../src/schema/schema-generator.js';
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { logCommandInfoAndTime, logPikkuLogo } from '../src/utils.js';
+import { inspectorGlob } from '../src/inspector-glob.js';
+export const pikkuSchemas = async ({ tsconfig, schemaDirectory, supportsImportAttributes }, { http }) => {
+    return await logCommandInfoAndTime('Creating schemas', 'Created schemas', [false], async () => {
+        const schemas = await generateSchemas(tsconfig, http.typesMap, http.meta);
+        await saveSchemas(schemaDirectory, schemas, http.typesMap, http.meta, supportsImportAttributes);
+    });
+};
+async function action({ config }) {
+    logPikkuLogo();
+    const cliConfig = await getPikkuCLIConfig(config, [
+        'routeDirectories',
+        'schemaDirectory',
+        'tsconfig',
+    ]);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    await pikkuSchemas(cliConfig, visitState);
+}
+export const schemas = (program) => {
+    program
+        .command('schemas')
+        .description('Generate schemas for all the expected function input types')
+        .option('-c | --config <string>', 'The path to pikku cli config file')
+        .action(action);
+};

package/dist/bin/pikku-websocket.d.ts

@@ -0,0 +1,6 @@
+import { Command } from 'commander';
+import { PikkuCLIOptions } from '../src/utils.js';
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
+export declare const pikkuWebSocket: ({ websocketFile, channelsMapDeclarationFile, packageMappings, }: PikkuCLIConfig) => Promise<void>;
+export declare const action: (options: PikkuCLIOptions) => Promise<void>;
+export declare const websocket: (program: Command) => void;

package/dist/bin/pikku-websocket.js

@@ -0,0 +1,25 @@
+import { getFileImportRelativePath, logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { serializeWebsocketWrapper } from '../src/channels/serialize-websocket-wrapper.js';
+export const pikkuWebSocket = async ({ websocketFile, channelsMapDeclarationFile, packageMappings, }) => {
+    await logCommandInfoAndTime('Generating websocket wrapper', 'Generated websocket wrapper', [websocketFile === undefined, 'websocketFile is required in pikku config'], async () => {
+        if (!websocketFile) {
+            throw new Error('fetchFile is required in pikku config');
+        }
+        const channelsMapDeclarationPath = getFileImportRelativePath(websocketFile, channelsMapDeclarationFile, packageMappings);
+        const content = [serializeWebsocketWrapper(channelsMapDeclarationPath)];
+        await writeFileInDir(websocketFile, content.join('\n'));
+    });
+};
+export const action = async (options) => {
+    logPikkuLogo();
+    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'], true);
+    await pikkuWebSocket(cliConfig);
+};
+export const websocket = (program) => {
+    program
+        .command('websocket')
+        .description('generate websocket wrapper')
+        .option('-c | --config <string>', 'The path to pikku cli config file')
+        .action(action);
+};

package/dist/bin/pikku.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/pikku.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { schemas } from './pikku-schemas.js';
+import { routes } from './pikku-routes.js';
+import { nextjs } from './pikku-nextjs.js';
+import { all } from './pikku-all.js';
+import { functionTypes } from './pikku-function-types.js';
+import { routesMap } from './pikku-routes-map.js';
+import { fetch } from './pikku-fetch.js';
+import { channels } from './pikku-channels.js';
+import { schedules } from './pikku-scheduler.js';
+const program = new Command('pikku');
+program.usage('[command]');
+all(program);
+routes(program);
+routesMap(program);
+functionTypes(program);
+schemas(program);
+nextjs(program);
+fetch(program);
+channels(program);
+schedules(program);
+program.parse(process.argv);

package/dist/src/channels/serialize-channels.d.ts

@@ -0,0 +1,3 @@
+import { ChannelsMeta } from '@pikku/core/channel';
+export declare const serializeChannels: (outputPath: string, filesWithChannels: Set<string>, packageMappings?: Record<string, string>) => string;
+export declare const serializeChannelMeta: (channelsMeta: ChannelsMeta) => string;

package/dist/src/channels/serialize-channels.js

@@ -0,0 +1,19 @@
+import { getFileImportRelativePath } from '../utils.js';
+export const serializeChannels = (outputPath, filesWithChannels, packageMappings = {}) => {
+    const serializedOutput = [
+        '/* The files with an addChannel function call */',
+    ];
+    Array.from(filesWithChannels)
+        .sort()
+        .forEach((path) => {
+        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
+        serializedOutput.push(`import '${filePath}'`);
+    });
+    return serializedOutput.join('\n');
+};
+export const serializeChannelMeta = (channelsMeta) => {
+    const serializedOutput = [];
+    serializedOutput.push("import { setChannelsMeta } from '@pikku/core/channel'");
+    serializedOutput.push(`setChannelsMeta(${JSON.stringify(channelsMeta, null, 2)})`);
+    return serializedOutput.join('\n');
+};

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

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

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

@@ -0,0 +1,87 @@
+import { serializeImportMap } from '../core/serialize-import-map.js';
+export const serializeTypedChannelsMap = (relativeToPath, packageMappings, typesMap, channelsMeta) => {
+    const { channels, requiredTypes } = generateChannels(channelsMeta);
+    typesMap.customTypes.forEach(({ references }) => {
+        for (const reference of references) {
+            requiredTypes.add(reference);
+        }
+    });
+    const imports = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    return `/**
+ * This provides the structure needed for TypeScript to be aware of channels
+ */
+    
+${imports}
+
+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(channelsMeta) {
+    const requiredTypes = new Set();
+    const channelsObject = {};
+    for (const meta of channelsMeta) {
+        const { name, messageRoutes, message } = meta;
+        if (!channelsObject[name]) {
+            channelsObject[name] = { message, routes: {} };
+        }
+        for (const [key, route] of Object.entries(messageRoutes)) {
+            if (!channelsObject[name].routes[key]) {
+                channelsObject[name].routes[key] = {};
+            }
+            for (const [method, { inputs, outputs }] of Object.entries(route)) {
+                const inputTypes = inputs || null;
+                const outputTypes = 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)}, ${formatTypeArray(handler.outputTypes)}>,\n`;
+            }
+            routesStr += '      },\n';
+        }
+        routesStr += '    },\n';
+        // Add `defaultMessage` outside `routes`
+        if (message) {
+            routesStr += `    readonly defaultMessage: ChannelHandler<${formatTypeArray(message.inputs)}, ${formatTypeArray(message.outputs)}>,\n`;
+        }
+        routesStr += '  },\n';
+    }
+    routesStr += '};';
+    return { channels: routesStr, requiredTypes };
+}
+// Utility to format type arrays
+function formatTypeArray(types) {
+    return types ? types.join(' | ') : 'null';
+}

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

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

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

@@ -0,0 +1,61 @@
+export const serializeWebsocketWrapper = (channelsMapPath) => {
+    return `import { AbstractPikkuWebsocket, AbstractPikkuRouteHandler } from '@pikku/websocket'
+import { ChannelDefaultHandlerOf, ChannelRouteHandlerOf, ChannelsMap } from '${channelsMapPath}';
+
+class PikkuWebSocketRoute<Channel extends keyof ChannelsMap, Route extends keyof ChannelsMap[Channel]['routes']> extends AbstractPikkuRouteHandler {
+    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 AbstractPikkuWebsocket {
+    /**
+     * 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/core/serialize-import-map.d.ts

@@ -0,0 +1,2 @@
+import { TypesMap } from '@pikku/inspector';
+export declare const serializeImportMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, requiredTypes: Set<string>) => string;

package/dist/src/core/serialize-import-map.js

@@ -0,0 +1,23 @@
+import { getFileImportRelativePath } from '../utils.js';
+export const serializeImportMap = (relativeToPath, packageMappings, typesMap, requiredTypes) => {
+    const paths = new Map();
+    Array.from(requiredTypes).forEach((requiredType) => {
+        const { originalName, uniqueName, path } = typesMap.getTypeMeta(requiredType);
+        if (!path) {
+            return;
+        }
+        const variables = paths.get(path) || [];
+        if (originalName === uniqueName) {
+            variables.push(originalName);
+        }
+        else {
+            variables.push(`${originalName} as ${uniqueName}`);
+        }
+        paths.set(path, variables);
+    });
+    const imports = [];
+    for (const [path, variables] of paths.entries()) {
+        imports.push(`import type { ${variables.join(', ')} } from '${getFileImportRelativePath(relativeToPath, path, packageMappings)}'`);
+    }
+    return imports.join('\n');
+};

package/dist/src/core/serialize-pikku-types.d.ts

@@ -0,0 +1,4 @@
+/**
+ *
+ */
+export declare const serializePikkuTypes: (userSessionTypeImport: string, userSessionTypeName: string, sessionServicesTypeImport: string, servicesTypeName: string) => string;

package/dist/src/core/serialize-pikku-types.js

@@ -0,0 +1,48 @@
+/**
+ *
+ */
+export const serializePikkuTypes = (userSessionTypeImport, userSessionTypeName, sessionServicesTypeImport, servicesTypeName) => {
+    return `/**
+* This is used to provide the application types in the typescript project
+*/
+  
+import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission, MakeRequired } from '@pikku/core'
+import { CoreHTTPFunctionRoute, AssertRouteParams } from '@pikku/core/http'
+import { CoreScheduledTask } from '@pikku/core/scheduler'
+import { CoreAPIChannel, CoreChannelConnection, CoreChannelDisconnection, CoreChannelMessage, PikkuChannel } from '@pikku/core/channel'
+
+${userSessionTypeImport}
+${sessionServicesTypeImport}
+
+export type APIPermission<In = unknown, RequiredServices = ${servicesTypeName}> = CoreAPIPermission<In, RequiredServices, ${userSessionTypeName}>
+
+export type APIFunctionSessionless<In = unknown, Out = never, RequiredServices = ${servicesTypeName}> = CoreAPIFunctionSessionless<In, Out, RequiredServices, ${userSessionTypeName}>
+export type APIFunction<In = unknown, Out = never, RequiredServices = ${servicesTypeName}> = CoreAPIFunction<In, Out, RequiredServices, ${userSessionTypeName}>
+type APIRoute<In, Out, Route extends string> = CoreHTTPFunctionRoute<In, Out, Route, APIFunction<In, Out>, APIFunctionSessionless<In, Out>, APIPermission<In>>
+
+export type ChannelConnection<Out = never, ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: MakeRequired<Services, 'eventHub'>, channel: PikkuChannel<${userSessionTypeName}, ChannelData, Out>) => Promise<void>
+export type ChannelDisconnection<ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: MakeRequired<Services, 'eventHub'>, channel: PikkuChannel<${userSessionTypeName}, ChannelData, never>) => Promise<void>
+export type ChannelMessage<In, Out = never, ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: MakeRequired<Services, 'eventHub'>, channel: PikkuChannel<${userSessionTypeName}, ChannelData, Out>, data: In) => Promise<Out | void>
+type APIChannel<ChannelData, Channel extends string, In extends unknown, Out extends unknown> = CoreAPIChannel<ChannelData, Channel, ChannelConnection, ChannelDisconnection, ChannelMessage<In, Out, ChannelData>>
+
+type ScheduledTask = CoreScheduledTask<APIFunctionSessionless<void, void>, ${userSessionTypeName}>
+
+declare module "@pikku/core" {
+  // type APIPermission<In = unknown, RequiredServices = ${servicesTypeName}> = CoreAPIPermission<In, RequiredServices, ${userSessionTypeName}>
+  // type APIFunction = <In = unknown, Out = never, RequiredServices = ${servicesTypeName}> = CoreAPIFunction<In, Out, RequiredServices, ${userSessionTypeName}>
+  // type APIFunctionSessionless = <In = unknown, Out = never, RequiredServices = ${servicesTypeName}> = CoreAPIFunctionSessionless<In, Out, RequiredServices, ${userSessionTypeName}>
+
+  function addChannel<ChannelData, Channel extends string>(
+    channel: APIChannel<ChannelData, Channel> & AssertRouteParams<ChannelData, Channel>
+  ): void;
+
+  function addRoute<In, Out, Route extends string>(
+    route: APIRoute<In, Out, Route> & AssertRouteParams<In, Route>
+  ): void;
+
+  function addScheduledTask(
+    task: ScheduledTask
+  ): void;
+}
+`;
+};

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

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

package/dist/src/http/serialize-fetch-wrapper.js

@@ -0,0 +1,57 @@
+export const serializeFetchWrapper = (routesMapPath) => {
+    return `
+import { CorePikkuFetch, HTTPMethod } from '@pikku/fetch'
+import type { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPath}'
+
+export class PikkuFetch extends AbstractPikkuFetch {
+    public async post<Route extends RoutesWithMethod<'POST'>>(
+        route: Route,
+        data: RouteHandlerOf<Route, 'POST'>['input'] = null,
+        options?: Omit<RequestInit, 'body'>
+    ): Promise<RouteHandlerOf<Route, 'POST'>['output']> {
+        return super.api(route, 'POST', data, options);
+    }
+
+    public async get<Route extends RoutesWithMethod<'GET'>>(
+        route: Route,
+        data: RouteHandlerOf<Route, 'GET'>['input'] = null,
+        options?: Omit<RequestInit, 'body'>
+    ): Promise<RouteHandlerOf<Route, 'GET'>['output']> {
+        return super.api(route, 'GET', data, options);
+    }
+
+    public async patch<Route extends RoutesWithMethod<'PATCH'>>(
+        route: Route,
+        data: RouteHandlerOf<Route, 'PATCH'>['input'] = null,
+        options?: Omit<RequestInit, 'body'>
+    ): Promise<RouteHandlerOf<Route, 'PATCH'>['output']> {
+        return super.api(route, 'PATCH', data, options);
+    }
+
+    public async head<Route extends RoutesWithMethod<'HEAD'>>(
+        route: Route,
+        data: RouteHandlerOf<Route, 'HEAD'>['input'] = null,
+        options?: Omit<RequestInit, 'body'>
+    ): Promise<RouteHandlerOf<Route, 'HEAD'>['output']> {
+        return super.api(route, 'HEAD', data, options);
+    }
+
+    public async delete<Route extends RoutesWithMethod<'DELETE'>>(
+        route: Route,
+        data: RouteHandlerOf<Route, 'DELETE'>['input'] = null,
+        options?: Omit<RequestInit, 'body'>
+    ): Promise<RouteHandlerOf<Route, 'DELETE'>['output']> {
+        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

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