@pikku/cli 0.6.6

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

@@ -0,0 +1,22 @@
+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 { setScheduledTasksMeta } from '@pikku/core/scheduler'");
+    serializedOutput.push(`setScheduledTasksMeta(${JSON.stringify(scheduledTasksMeta, null, 2)})`);
+    if (scheduledTasksMeta.length > 0) {
+        serializedOutput.push(`export type ScheduledTaskNames = '${scheduledTasksMeta.map((s) => s.name).join("' | '")}'`);
+    }
+    return serializedOutput.join('\n');
+};

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

@@ -0,0 +1,5 @@
+import { JSONValue } from '@pikku/core';
+import { HTTPRoutesMeta } from '@pikku/core/http';
+import { TypesMap } from '@pikku/inspector';
+export declare function generateSchemas(tsconfig: string, typesMap: TypesMap, routesMeta: 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

@@ -0,0 +1,79 @@
+import { createGenerator, RootlessError } from 'ts-json-schema-generator';
+import { writeFileInDir } from '../utils.js';
+import { mkdir, writeFile } from 'fs/promises';
+export async function generateSchemas(tsconfig, typesMap, routesMeta) {
+    const schemasSet = new Set(typesMap.customTypes.keys());
+    for (const { input, output, inputTypes } of routesMeta) {
+        if (input) {
+            schemasSet.add(typesMap.getTypeMeta(input).uniqueName);
+        }
+        if (output) {
+            schemasSet.add(typesMap.getTypeMeta(output).uniqueName);
+        }
+        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.log('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) {
+        console.log(`\x1b[34m• 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})
+// addSchema('${schema}', require('./schemas/${schema}.schema.json'))
+`)
+        .join('\n');
+    await writeFileInDir(`${schemaParentDir}/register.gen.ts`, `import { addSchema } from '@pikku/core/schema'
+// import { createRequire } from "module"
+// const require = createRequire(import.meta.url)
+${schemaImports}`);
+}

package/dist/src/utils.d.ts

@@ -0,0 +1,34 @@
+import { InspectorState } from '@pikku/inspector';
+export declare const getFileImportRelativePath: (from: string, to: string, packageMappings: Record<string, string>) => string;
+interface Meta {
+    file: string;
+    variable: string;
+    type: string;
+    typePath: string;
+}
+export type FilesAndMethods = {
+    userSessionType: Meta;
+    sessionServicesType: Meta;
+    pikkuConfigFactory: Meta;
+    singletonServicesFactory: Meta;
+    sessionServicesFactory: Meta;
+};
+export interface PikkuCLIOptions {
+    config?: string;
+    configFileType?: string;
+    userSessionType?: string;
+    singletonServicesFactoryType?: string;
+    sessionServicesFactoryType?: string;
+}
+export declare const getPikkuFilesAndMethods: ({ sessionServicesTypeImportMap: httpSessionServicesTypeImportMap, userSessionTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }: InspectorState, packageMappings: Record<string, string>, outputFile: string, { configFileType, singletonServicesFactoryType, sessionServicesFactoryType, }: PikkuCLIOptions, requires?: Partial<{
+    config: boolean;
+    sessionServiceType: boolean;
+    userSessionType: boolean;
+    singletonServicesFactory: boolean;
+    sessionServicesFactory: boolean;
+}>) => Promise<FilesAndMethods>;
+export declare const writeFileInDir: (path: string, content: string, ignoreModifyComment?: boolean) => Promise<void>;
+export declare const logCommandInfoAndTime: (commandStart: string, commandEnd: string, [skipCondition, skipMessage]: [boolean] | [boolean, string], callback: (...args: any[]) => Promise<unknown>) => Promise<boolean>;
+export declare const logPikkuLogo: () => void;
+export declare const DO_NOT_MODIFY_COMMENT = "/**\n * This file was generated by the @pikku/cli\n */\n";
+export {};

package/dist/src/utils.js

@@ -0,0 +1,109 @@
+// import packageInfo from '../package.json'
+import { relative, dirname } from 'path';
+import { mkdir, writeFile } from 'fs/promises';
+export const getFileImportRelativePath = (from, to, packageMappings) => {
+    let filePath = relative(dirname(from), to);
+    if (!/^\.+\//.test(filePath)) {
+        filePath = `./${filePath}`;
+    }
+    let usesPackageName = false;
+    for (const [path, packageName] of Object.entries(packageMappings)) {
+        if (filePath.includes(path)) {
+            usesPackageName = true;
+            filePath = filePath.replace(new RegExp(`.*${path}`), packageName);
+            break;
+        }
+    }
+    if (usesPackageName) {
+        return filePath.replace('.ts', '');
+    }
+    return filePath.replace('.ts', '.js');
+};
+const getMetaTypes = (type, errors, map, desiredType) => {
+    if (desiredType) {
+        const entries = Object.entries(map);
+        for (const [file, meta] of entries) {
+            for (const { type, variable, typePath } of meta) {
+                if (type === desiredType) {
+                    return { file, variable, type, typePath };
+                }
+            }
+        }
+        errors.set(`No ${desiredType} found that extends ${type}`, map);
+        return undefined;
+    }
+    const totalValues = Object.values(map).flat();
+    if (totalValues.length === 0) {
+        errors.set(`No ${type} found`, map);
+    }
+    else if (totalValues.length > 1) {
+        errors.set(`More than one ${type} found`, map);
+    }
+    else {
+        const entry = Object.entries(map)[0];
+        if (entry) {
+            const [file, [{ type, variable, typePath }]] = entry;
+            return { file, type, variable, typePath };
+        }
+    }
+    return undefined;
+};
+export const getPikkuFilesAndMethods = async ({ sessionServicesTypeImportMap: httpSessionServicesTypeImportMap, userSessionTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }, packageMappings, outputFile, { configFileType, singletonServicesFactoryType, sessionServicesFactoryType, }, requires = {
+    config: false,
+    sessionServiceType: false,
+    userSessionType: false,
+    singletonServicesFactory: false,
+    sessionServicesFactory: false,
+}) => {
+    let errors = new Map();
+    const result = {
+        userSessionType: getMetaTypes('CoreUserSession', requires.userSessionType ? errors : new Map(), userSessionTypeImportMap, configFileType),
+        sessionServicesType: getMetaTypes('CoreServices', requires.sessionServiceType ? errors : new Map(), httpSessionServicesTypeImportMap),
+        pikkuConfigFactory: getMetaTypes('CoreConfig', requires.config ? errors : new Map(), configFactories, configFileType),
+        singletonServicesFactory: getMetaTypes('CreateSingletonServices', requires.singletonServicesFactory ? errors : new Map(), singletonServicesFactories, singletonServicesFactoryType),
+        sessionServicesFactory: getMetaTypes('CreateSessionServices', requires.sessionServicesFactory ? errors : new Map(), sessionServicesFactories, sessionServicesFactoryType),
+    };
+    if (errors.size > 0) {
+        const result = ['Found errors:'];
+        errors.forEach((filesAndMethods, message) => {
+            result.push(`- ${message}`);
+            for (const [file, methods] of Object.entries(filesAndMethods)) {
+                result.push(`\t* file: ${getFileImportRelativePath(outputFile, file, packageMappings)}`);
+                result.push(`\t* methods: ${methods.map(({ variable, type }) => `${variable}: ${type}`).join(', ')}`);
+            }
+        });
+        console.error(result.join('\n'));
+        process.exit(1);
+    }
+    return result;
+};
+export const writeFileInDir = async (path, content, ignoreModifyComment = false) => {
+    if (content.includes('server-only')) {
+        content = content.replace("'server-only'", `'server-only'\n\n${ignoreModifyComment ? '' : DO_NOT_MODIFY_COMMENT}`);
+    }
+    else {
+        content = `${ignoreModifyComment ? '' : DO_NOT_MODIFY_COMMENT}${content}`;
+    }
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, content, 'utf-8');
+    console.log(`\x1b[32m✓ File written to ${path}\x1b[0m`);
+};
+export const logCommandInfoAndTime = async (commandStart, commandEnd, [skipCondition, skipMessage = 'none found'], callback) => {
+    if (skipCondition === true) {
+        console.log(`\x1b[34m• Skipping ${commandStart} since ${skipMessage}.\x1b[0m`);
+        return false;
+    }
+    const start = Date.now();
+    console.log(`\x1b[34m• ${commandStart}...\x1b[0m`);
+    await callback();
+    console.log(`\x1b[32m✓ ${commandEnd} in ${Date.now() - start}ms.\x1b[0m`);
+    return true;
+};
+export const logPikkuLogo = () => {
+    console.log(`\x1b[33m⚙️ PIKKU CLI ⚙️\n-------------------\x1b[0m`);
+};
+// TODO: add version back in once the ESM dust settles
+export const DO_NOT_MODIFY_COMMENT = `/**
+ * This file was generated by the @pikku/cli
+ */
+`;

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../bin/pikku-all.ts","../bin/pikku-channels-map.ts","../bin/pikku-channels.ts","../bin/pikku-fetch.ts","../bin/pikku-function-types.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-routes-map.ts","../bin/pikku-routes.ts","../bin/pikku-scheduler.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/pikku-cli-config.ts","../src/utils.ts","../src/channels/serialize-channels.ts","../src/channels/serialize-typed-channel-map.ts","../src/channels/serialize-websocket-wrapper.ts","../src/core/serialize-import-map.ts","../src/core/serialize-pikku-types.ts","../src/http/serialize-fetch-wrapper.ts","../src/http/serialize-route-imports.ts","../src/http/serialize-route-meta.ts","../src/http/serialize-typed-route-map.ts","../src/nextjs/serialize-nextjs-wrapper.ts","../src/openapi/openapi-spec-generator.ts","../src/scheduler/serialize-schedulers.ts","../src/schema/schema-generator.ts"],"version":"5.7.3"}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@pikku/cli",
+  "version": "0.6.6",
+  "author": "yasser.fadl@gmail.com",
+  "license": "MIT",
+  "bin": {
+    "pikku": "dist/bin/pikku.js"
+  },
+  "type": "module",
+  "main": "dist/bin/pikku.js",
+  "module": "dist/bin/pikku.js",
+  "scripts": {
+    "tsc": "tsc",
+    "build:esm": "tsc -b",
+    "schema": "ts-json-schema-generator -o cli.schema.json --path 'src/pikku-cli-config.ts' --type 'PikkuCLIConfig'",
+    "build": "yarn build:esm && yarn schema",
+    "ncu": "ncu -x '/.*glob.*/'",
+    "release": "yarn build && npm test",
+    "test": "bash run-tests.sh",
+    "test:watch": "bash run-tests.sh --watch",
+    "test:coverage": "bash run-tests.sh --coverage"
+  },
+  "dependencies": {
+    "@openapi-contrib/json-schema-to-openapi-schema": "^3.0.2",
+    "@pikku/core": "^0.6.7",
+    "@pikku/inspector": "^0.6.2",
+    "@types/cookie": "^0.6.0",
+    "@types/uuid": "^10.0.0",
+    "commander": "^12",
+    "glob": "^10",
+    "path-to-regexp": "^8.2.0",
+    "ts-json-schema-generator": "^2.3.0",
+    "typescript": "^5.6",
+    "yaml": "^2.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.7.8"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/run-tests.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+
+# Enable nullglob to handle cases where no files match the pattern
+shopt -s nullglob
+
+# Initialize variables for options
+watch_mode=false
+coverage_mode=false
+
+# Parse command-line options
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --watch)
+      watch_mode=true
+      shift
+      ;;
+    --coverage)
+      coverage_mode=true
+      shift
+      ;;
+    *)
+      echo "Unknown option: $1"
+      exit 1
+      ;;
+  esac
+done
+
+# Define the pattern to match your test files
+pattern="src/*.test.ts"
+
+# Expand the pattern into an array of files
+files=($(find src -type f -name "*.test.ts"))
+
+# Check if any files matched the pattern
+if [ ${#files[@]} -eq 0 ]; then
+  echo "No test files found matching pattern: $pattern"
+  exit 0
+fi
+
+# Construct the node command
+node_cmd="node --import tsx --test"
+
+# Append options based on flags
+if [ "$watch_mode" = true ]; then
+  node_cmd="$node_cmd --watch"
+fi
+
+if [ "$coverage_mode" = true ]; then
+  node_cmd="$node_cmd --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info"
+fi
+
+# Execute the node command with the expanded list of files
+$node_cmd "${files[@]}"

package/src/channels/serialize-channels.ts

@@ -0,0 +1,34 @@
+import { ChannelsMeta } from '@pikku/core/channel'
+import { getFileImportRelativePath } from '../utils.js'
+
+export const serializeChannels = (
+  outputPath: string,
+  filesWithChannels: Set<string>,
+  packageMappings: Record<string, string> = {}
+) => {
+  const serializedOutput: string[] = [
+    '/* 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: ChannelsMeta) => {
+  const serializedOutput: string[] = []
+  serializedOutput.push("import { setChannelsMeta } from '@pikku/core/channel'")
+  serializedOutput.push(
+    `setChannelsMeta(${JSON.stringify(channelsMeta, null, 2)})`
+  )
+  return serializedOutput.join('\n')
+}

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

@@ -0,0 +1,133 @@
+import { ChannelsMeta } from '@pikku/core/channel'
+import { serializeImportMap } from '../core/serialize-import-map.js'
+import { TypesMap } from '@pikku/inspector'
+
+export const serializeTypedChannelsMap = (
+  relativeToPath: string,
+  packageMappings: Record<string, string>,
+  typesMap: TypesMap,
+  channelsMeta: ChannelsMeta
+): string => {
+  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: ChannelsMeta) {
+  const requiredTypes = new Set<string>()
+  const channelsObject: Record<
+    string,
+    {
+      message: { inputs: string[] | null; outputs: string[] | null } | null
+      routes: Record<
+        string,
+        Record<
+          string,
+          {
+            inputTypes: string[] | null
+            outputTypes: string[] | null
+          }
+        >
+      >
+    }
+  > = {}
+
+  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: string[] | null): string {
+  return types ? types.join(' | ') : 'null'
+}

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

@@ -0,0 +1,61 @@
+export const serializeWebsocketWrapper = (channelsMapPath: string) => {
+  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/src/core/serialize-import-map.ts

@@ -0,0 +1,33 @@
+import { TypesMap } from '@pikku/inspector'
+import { getFileImportRelativePath } from '../utils.js'
+
+export const serializeImportMap = (
+  relativeToPath: string,
+  packageMappings: Record<string, string>,
+  typesMap: TypesMap,
+  requiredTypes: Set<string>
+) => {
+  const paths = new Map<string, string[]>()
+  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: string[] = []
+  for (const [path, variables] of paths.entries()) {
+    imports.push(
+      `import type { ${variables.join(', ')} } from '${getFileImportRelativePath(relativeToPath, path, packageMappings)}'`
+    )
+  }
+  return imports.join('\n')
+}

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

@@ -0,0 +1,53 @@
+/**
+ *
+ */
+export const serializePikkuTypes = (
+  userSessionTypeImport: string,
+  userSessionTypeName: string,
+  sessionServicesTypeImport: string,
+  servicesTypeName: string
+) => {
+  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;
+}
+`
+}