@pikku/cli 0.6.20 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @pikku/cli
 
+## 0.7.0
+
+- Now function first. No breaking changes for end user here, just internals
+
 ## 0.6.20
 
 ### Patch Changes

package/cli.schema.json

@@ -169,7 +169,7 @@
         "rootDir": {
           "type": "string"
         },
-        "routeDirectories": {
+        "srcDirectories": {
           "items": {
             "type": "string"
           },
@@ -207,7 +207,7 @@
         "configDir",
         "packageMappings",
         "rootDir",
-        "routeDirectories",
+        "srcDirectories",
         "routesFile",
         "routesMapDeclarationFile",
         "schedulersFile",

package/dist/bin/pikku-all.js

@@ -1,8 +1,8 @@
 import { getFileImportRelativePath, logInfo, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { pikkuHTTP } from './pikku-http.js';
+import { pikkuHTTP } from './pikku-http-routes.js';
 import { pikkuFunctionTypes } from './pikku-function-types.js';
-import { pikkuHTTPMap } from './pikku-routes-map.js';
+import { pikkuHTTPMap } from './pikku-http-map.js';
 import { existsSync } from 'fs';
 import { pikkuFetch } from './pikku-fetch.js';
 import { pikkuChannelsMap } from './pikku-channels-map.js';
@@ -14,62 +14,80 @@ import { pikkuSchemas } from './pikku-schemas.js';
 import { pikkuWebSocket } from './pikku-websocket.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
 import chokidar from 'chokidar';
+import { pikkuFunctions } from './pikku-functions.js';
 const runAll = async (cliConfig, options) => {
+    const metaImports = [];
     const imports = [];
-    const addImport = (from) => {
-        imports.push(`import '${getFileImportRelativePath(cliConfig.bootstrapFile, from, cliConfig.packageMappings)}'`);
+    const addImport = (from, type) => {
+        const statement = `import '${getFileImportRelativePath(cliConfig.bootstrapFile, from, cliConfig.packageMappings)}'`;
+        if (type === 'meta') {
+            metaImports.push(statement);
+        }
+        else {
+            imports.push(statement);
+        }
     };
     let typesDeclarationFileExists = true;
-    let visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
+    let visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
     if (!existsSync(cliConfig.typesDeclarationFile)) {
         typesDeclarationFileExists = false;
     }
     await pikkuFunctionTypes(cliConfig, options, visitState);
-    // This is needed since the addRoutes function will add the routes to the visitState
+    // This is needed since the addHTTPRoute function will add the routes to the visitState
     if (!typesDeclarationFileExists) {
         logInfo(`• Type file first created, inspecting again...\x1b[0m`);
-        visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
+        visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
     }
+    const functions = pikkuFunctions(cliConfig, visitState);
+    if (!functions) {
+        logInfo(`• No functions found, skipping remaining steps...\x1b[0m`);
+        process.exit(1);
+    }
+    addImport(cliConfig.functionsMetaFile, 'meta');
+    addImport(cliConfig.functionsFile, 'events');
     const routes = await pikkuHTTP(cliConfig, visitState);
     if (routes) {
         await pikkuHTTPMap(cliConfig, visitState);
         await pikkuFetch(cliConfig);
-        addImport(cliConfig.routesFile);
+        addImport(cliConfig.httpRoutesMetaFile, 'meta');
+        addImport(cliConfig.httpRoutesFile, 'events');
     }
     const scheduled = await pikkuScheduler(cliConfig, visitState);
     if (scheduled) {
-        addImport(cliConfig.schedulersFile);
+        addImport(cliConfig.schedulersMetaFile, 'meta');
+        addImport(cliConfig.schedulersFile, 'events');
     }
     const channels = await pikkuChannels(cliConfig, visitState);
     if (channels) {
         await pikkuChannelsMap(cliConfig, visitState);
         await pikkuWebSocket(cliConfig);
-        addImport(cliConfig.channelsFile);
+        addImport(cliConfig.channelsMetaFile, 'meta');
+        addImport(cliConfig.channelsFile, 'events');
     }
     const schemas = await pikkuSchemas(cliConfig, visitState);
     if (schemas) {
-        addImport(`${cliConfig.schemaDirectory}/register.gen.ts`);
+        addImport(`${cliConfig.schemaDirectory}/register.gen.ts`, 'other');
     }
     if (cliConfig.nextBackendFile || cliConfig.nextHTTPFile) {
         await pikkuNext(cliConfig, visitState, options);
     }
     if (cliConfig.openAPI) {
         logInfo(`• OpenAPI requires a reinspection to pickup new generated types..`);
-        visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
+        visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
         await pikkuOpenAPI(cliConfig, visitState);
     }
-    await writeFileInDir(cliConfig.bootstrapFile, imports.join('\n'));
+    await writeFileInDir(cliConfig.bootstrapFile, [...metaImports, ...imports].join('\n'));
 };
 const watch = (cliConfig, options) => {
-    const configWatcher = chokidar.watch(cliConfig.routeDirectories, {
+    const configWatcher = chokidar.watch(cliConfig.srcDirectories, {
         ignoreInitial: true,
         ignored: /.*\.gen\.tsx?/,
     });
     let watcher = new chokidar.FSWatcher({});
     const generatorWatcher = () => {
         watcher.close();
-        logInfo(`• Watching directories: \n  - ${cliConfig.routeDirectories.join('\n  - ')}`);
-        watcher = chokidar.watch(cliConfig.routeDirectories, {
+        logInfo(`• Watching directories: \n  - ${cliConfig.srcDirectories.join('\n  - ')}`);
+        watcher = chokidar.watch(cliConfig.srcDirectories, {
             ignoreInitial: true,
             ignored: /.*\.gen\.ts/,
         });

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

@@ -1,17 +1,17 @@
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
-import { serializeTypedChannelsMap } from '../src/channels/serialize-typed-channel-map.js';
+import { serializeTypedChannelsMap } from '../src/serialize-typed-channel-map.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
 export const pikkuChannelsMap = async ({ channelsMapDeclarationFile, packageMappings }, state) => {
     return await logCommandInfoAndTime('Creating channels map', 'Created channels map', [state.channels.files.size === 0], async () => {
-        const content = serializeTypedChannelsMap(channelsMapDeclarationFile, packageMappings, state.channels.typesMap, state.channels.meta);
+        const content = serializeTypedChannelsMap(channelsMapDeclarationFile, packageMappings, state.functions.typesMap, state.channels.meta);
         await writeFileInDir(channelsMapDeclarationFile, content);
     });
 };
 async function action(cliOptions) {
     logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'routeDirectories', 'routesFile'], cliOptions.tags, false);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
+    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'srcDirectories', 'httpRoutesFile'], cliOptions.tags, false);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
     await pikkuChannelsMap(cliConfig, visitState);
 }
 export const channelsMap = (program) => {

package/dist/bin/pikku-channels.js

@@ -1,22 +1,18 @@
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
-import { serializeChannels, serializeChannelMeta, } from '../src/channels/serialize-channels.js';
+import { logCommandInfoAndTime, logPikkuLogo, serializeFileImports, writeFileInDir, } from '../src/utils.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
 export const pikkuChannels = async (cliConfig, visitState) => {
     return await logCommandInfoAndTime('Finding Channels', 'Found channels', [visitState.channels.files.size === 0], async () => {
-        const { channelsFile, packageMappings } = cliConfig;
+        const { channelsFile, channelsMetaFile, packageMappings } = cliConfig;
         const { channels } = visitState;
-        const content = [
-            serializeChannels(channelsFile, channels.files, packageMappings),
-            serializeChannelMeta(channels.meta),
-        ];
-        await writeFileInDir(channelsFile, content.join('\n\n'));
+        await writeFileInDir(channelsFile, serializeFileImports('addChannel', channelsFile, channels.files, packageMappings));
+        await writeFileInDir(channelsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`);
     });
 };
 async function action(cliOptions) {
     logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'routeDirectories', 'routesFile'], cliOptions.tags);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
+    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'srcDirectories', 'httpRoutesFile'], cliOptions.tags);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
     await pikkuChannels(cliConfig, visitState);
 }
 export const channels = (program) => {

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

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
 import { PikkuCLIOptions } from '../src/utils.js';
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
-export declare const pikkuFetch: ({ fetchFile, routesMapDeclarationFile, packageMappings, }: PikkuCLIConfig) => Promise<void>;
+export declare const pikkuFetch: ({ fetchFile, httpRoutesMapDeclarationFile, packageMappings, }: PikkuCLIConfig) => Promise<void>;
 export declare const action: (options: PikkuCLIOptions) => Promise<void>;
 export declare const fetch: (program: Command) => void;

package/dist/bin/pikku-fetch.js

@@ -1,12 +1,12 @@
 import { getFileImportRelativePath, logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { serializeFetchWrapper } from '../src/http/serialize-fetch-wrapper.js';
-export const pikkuFetch = async ({ fetchFile, routesMapDeclarationFile, packageMappings, }) => {
+import { serializeFetchWrapper } from '../src/serialize-fetch-wrapper.js';
+export const pikkuFetch = async ({ fetchFile, httpRoutesMapDeclarationFile, packageMappings, }) => {
     await logCommandInfoAndTime('Generating fetch wrapper', 'Generated fetch wrapper', [fetchFile === undefined, "fetchFile isn't set in the pikku config"], async () => {
         if (!fetchFile) {
             throw new Error("fetchFile is isn't set in the pikku config");
         }
-        const routesMapDeclarationPath = getFileImportRelativePath(fetchFile, routesMapDeclarationFile, packageMappings);
+        const routesMapDeclarationPath = getFileImportRelativePath(fetchFile, httpRoutesMapDeclarationFile, packageMappings);
         const content = [serializeFetchWrapper(routesMapDeclarationPath)];
         await writeFileInDir(fetchFile, content.join('\n'));
     });

package/dist/bin/pikku-function-types.js

@@ -1,8 +1,8 @@
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
-import { pikkuHTTP } from './pikku-http.js';
+import { pikkuHTTP } from './pikku-http-routes.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
-import { serializePikkuTypes } from '../src/core/serialize-pikku-types.js';
+import { serializePikkuTypes } from '../src/serialize-pikku-types.js';
 export const pikkuFunctionTypes = async ({ typesDeclarationFile: typesFile, packageMappings }, options, visitState) => {
     await logCommandInfoAndTime('Creating api types', 'Created api types', [false], async () => {
         const { userSessionType, sessionServicesType, singletonServicesType } = await getPikkuFilesAndMethods(visitState, packageMappings, typesFile, options, {
@@ -16,8 +16,8 @@ export const pikkuFunctionTypes = async ({ typesDeclarationFile: typesFile, pack
 };
 async function action(cliOptions) {
     logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'routeDirectories', 'typesDeclarationFile'], cliOptions.tags);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
+    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'srcDirectories', 'typesDeclarationFile'], cliOptions.tags);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
     await pikkuHTTP(cliConfig, visitState);
 }
 export const functionTypes = (program) => {

package/dist/bin/pikku-functions.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 pikkuFunctions: (cliConfig: PikkuCLIConfig, visitState: InspectorState) => Promise<boolean>;
+export declare const routes: (program: Command) => void;

package/dist/bin/pikku-functions.js

@@ -0,0 +1,24 @@
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { logCommandInfoAndTime, logPikkuLogo, serializeFileImports, writeFileInDir, } from '../src/utils.js';
+import { inspectorGlob } from '../src/inspector-glob.js';
+export const pikkuFunctions = async (cliConfig, visitState) => {
+    return await logCommandInfoAndTime('Finding Pikku functions', 'Found Pikku functions', [visitState.functions.files.size === 0], async () => {
+        const { functionsFile, functionsMetaFile, packageMappings } = cliConfig;
+        const { functions } = visitState;
+        await writeFileInDir(functionsFile, serializeFileImports('addFunction', functionsFile, functions.files, packageMappings));
+        await writeFileInDir(functionsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('functions', 'meta', ${JSON.stringify(functions.meta, null, 2)})`);
+    });
+};
+async function action(cliOptions) {
+    logPikkuLogo();
+    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'srcDirectories', 'functionsFile'], cliOptions.tags);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
+    await pikkuFunctions(cliConfig, visitState);
+}
+export const routes = (program) => {
+    program
+        .command('functions')
+        .description('Find all functions to import')
+        .option('-c | --config <string>', 'The path to pikku cli config file')
+        .action(action);
+};

package/dist/bin/pikku-http-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: ({ httpRoutesMapDeclarationFile, packageMappings }: PikkuCLIConfig, { http, functions }: InspectorState) => Promise<boolean>;
+export declare const routesMap: (program: Command) => void;

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

@@ -0,0 +1,23 @@
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+import { serializeTypedRoutesMap } from '../src/serialize-typed-http-map.js';
+import { inspectorGlob } from '../src/inspector-glob.js';
+export const pikkuHTTPMap = async ({ httpRoutesMapDeclarationFile, packageMappings }, { http, functions }) => {
+    return await logCommandInfoAndTime('Creating HTTP map', 'Created HTTP map', [http.files.size === 0], async () => {
+        const content = serializeTypedRoutesMap(httpRoutesMapDeclarationFile, packageMappings, functions.typesMap, http.meta, http.metaInputTypes);
+        await writeFileInDir(httpRoutesMapDeclarationFile, content);
+    });
+};
+async function action(cliOptions) {
+    logPikkuLogo();
+    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'srcDirectories', 'httpRoutesFile'], cliOptions.tags);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
+    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-http-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 pikkuHTTP: (cliConfig: PikkuCLIConfig, visitState: InspectorState) => Promise<boolean>;
+export declare const routes: (program: Command) => void;

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

@@ -0,0 +1,24 @@
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { logCommandInfoAndTime, logPikkuLogo, serializeFileImports, writeFileInDir, } from '../src/utils.js';
+import { inspectorGlob } from '../src/inspector-glob.js';
+export const pikkuHTTP = async (cliConfig, visitState) => {
+    return await logCommandInfoAndTime('Finding HTTP routes', 'Found HTTP routes', [visitState.http.files.size === 0], async () => {
+        const { httpRoutesFile, httpRoutesMetaFile, packageMappings } = cliConfig;
+        const { http } = visitState;
+        await writeFileInDir(httpRoutesFile, serializeFileImports('addHTTPRoute', httpRoutesFile, http.files, packageMappings));
+        await writeFileInDir(httpRoutesMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`);
+    });
+};
+async function action(cliOptions) {
+    logPikkuLogo();
+    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'srcDirectories', 'httpRoutesFile'], cliOptions.tags);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
+    await pikkuHTTP(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-http.js

@@ -1,15 +1,13 @@
 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 { logCommandInfoAndTime, logPikkuLogo, serializeFileImports, writeFileInDir, } from '../src/utils.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
 export const pikkuHTTP = async (cliConfig, visitState) => {
     return await logCommandInfoAndTime('Finding HTTP routes', 'Found HTTP routes', [visitState.http.files.size === 0], async () => {
         const { routesFile, packageMappings } = cliConfig;
         const { http } = visitState;
         const content = [
-            serializeRoutes(routesFile, http.files, packageMappings),
-            serializeHTTPRoutesMeta(http.meta),
+            serializeFileImports('addHTTPRoute', routesFile, http.files, packageMappings),
+            `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`
         ];
         await writeFileInDir(routesFile, content.join('\n\n'));
     });

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

@@ -2,6 +2,6 @@ import { Command } from 'commander';
 import { PikkuCLIOptions } from '../src/utils.js';
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { InspectorState } from '@pikku/inspector';
-export declare const pikkuNext: ({ nextBackendFile, nextHTTPFile, routesFile, routesMapDeclarationFile, schemaDirectory, packageMappings, fetchFile, }: PikkuCLIConfig, visitState: InspectorState, options: PikkuCLIOptions) => Promise<boolean>;
+export declare const pikkuNext: ({ nextBackendFile, nextHTTPFile, httpRoutesFile, httpRoutesMapDeclarationFile, schemaDirectory, packageMappings, fetchFile, }: PikkuCLIConfig, visitState: InspectorState, options: PikkuCLIOptions) => Promise<boolean>;
 export declare const action: (options: PikkuCLIOptions) => Promise<void>;
 export declare const nextjs: (program: Command) => void;

package/dist/bin/pikku-nextjs.js

@@ -1,9 +1,9 @@
-import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from '../src/nextjs/serialize-nextjs-backend-wrapper.js';
-import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from '../src/nextjs/serialize-nextjs-http-wrapper.js';
+import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from '../src/serialize-nextjs-backend-wrapper.js';
+import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from '../src/serialize-nextjs-http-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 ({ nextBackendFile, nextHTTPFile, routesFile, routesMapDeclarationFile, schemaDirectory, packageMappings, fetchFile, }, visitState, options) => {
+export const pikkuNext = async ({ nextBackendFile, nextHTTPFile, httpRoutesFile, httpRoutesMapDeclarationFile, schemaDirectory, packageMappings, fetchFile, }, visitState, options) => {
     return await logCommandInfoAndTime('Generating nextjs wrapper', 'Generated nextjs wrapper', [
         nextBackendFile === undefined && nextHTTPFile === undefined,
         'nextjs outfile is not defined',
@@ -23,15 +23,15 @@ export const pikkuNext = async ({ nextBackendFile, nextHTTPFile, routesFile, rou
             const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextBackendFile, pikkuConfigFactory.file, packageMappings)}'`;
             const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextBackendFile, singletonServicesFactory.file, packageMappings)}'`;
             const sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextBackendFile, sessionServicesFactory.file, packageMappings)}'`;
-            const routesPath = getFileImportRelativePath(nextBackendFile, routesFile, packageMappings);
-            const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, routesMapDeclarationFile, packageMappings);
+            const routesPath = getFileImportRelativePath(nextBackendFile, httpRoutesFile, packageMappings);
+            const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpRoutesMapDeclarationFile, packageMappings);
             const schemasPath = getFileImportRelativePath(nextBackendFile, `${schemaDirectory}/register.gen.ts`, packageMappings);
             const content = serializeNextBackendWrapper(routesPath, routesMapDeclarationPath, schemasPath, pikkuConfigImport, singletonServicesImport, sessionServicesImport);
             await writeFileInDir(nextBackendFile, content);
         }
         if (nextHTTPFile) {
-            const routesPath = getFileImportRelativePath(nextHTTPFile, routesFile, packageMappings);
-            const routesMapDeclarationPath = getFileImportRelativePath(nextHTTPFile, routesMapDeclarationFile, packageMappings);
+            const routesPath = getFileImportRelativePath(nextHTTPFile, httpRoutesFile, packageMappings);
+            const routesMapDeclarationPath = getFileImportRelativePath(nextHTTPFile, httpRoutesMapDeclarationFile, packageMappings);
             const content = serializeNextHTTPWrapper(routesPath, routesMapDeclarationPath);
             await writeFileInDir(nextHTTPFile, content);
         }
@@ -40,7 +40,7 @@ export const pikkuNext = async ({ nextBackendFile, nextHTTPFile, routesFile, rou
 export const action = async (options) => {
     logPikkuLogo();
     const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir'], options.tags, true);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
     await pikkuNext(cliConfig, visitState, options);
 };
 export const nextjs = (program) => {

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

@@ -1,5 +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 pikkuOpenAPI: ({ tsconfig, openAPI }: PikkuCLIConfig, { http, functions }: InspectorState) => Promise<void>;
 export declare const openapi: (program: Command) => void;

package/dist/bin/pikku-openapi.js

@@ -1,15 +1,15 @@
 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 { generateSchemas } from '../src/schema-generator.js';
+import { generateOpenAPISpec } from '../src/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 }) => {
+export const pikkuOpenAPI = async ({ tsconfig, openAPI }, { http, functions }) => {
     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 schemas = await generateSchemas(tsconfig, [http.typesMap, functions.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);
@@ -22,8 +22,8 @@ export const pikkuOpenAPI = async ({ tsconfig, openAPI }, { http }) => {
 };
 async function action({ config, tags }) {
     logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(config, ['rootDir', 'routesFile', 'openAPI', 'schemaDirectory', 'tsconfig'], tags);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
+    const cliConfig = await getPikkuCLIConfig(config, ['rootDir', 'httpRoutesFile', 'openAPI', 'schemaDirectory', 'tsconfig'], tags);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
     await pikkuOpenAPI(cliConfig, visitState);
 }
 export const openapi = (program) => {

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

@@ -1,5 +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 pikkuHTTPMap: ({ routesMapDeclarationFile, packageMappings }: PikkuCLIConfig, { http, functions }: InspectorState) => Promise<boolean>;
 export declare const routesMap: (program: Command) => void;

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

@@ -1,10 +1,10 @@
 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 { serializeTypedRoutesMap } from '../src/serialize-typed-route-map.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
-export const pikkuHTTPMap = async ({ routesMapDeclarationFile, packageMappings }, { http }) => {
+export const pikkuHTTPMap = async ({ routesMapDeclarationFile, packageMappings }, { http, functions }) => {
     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);
+        const content = serializeTypedRoutesMap(routesMapDeclarationFile, packageMappings, functions.typesMap, http.meta, http.metaInputTypes);
         await writeFileInDir(routesMapDeclarationFile, content);
     });
 };

package/dist/bin/pikku-scheduler.js

@@ -1,22 +1,19 @@
 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 { logCommandInfoAndTime, logPikkuLogo, serializeFileImports, writeFileInDir, } from '../src/utils.js';
+import { serializeSchedulerMeta } from '../src/serialize-scheduler-meta.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 { schedulersFile, schedulersMetaFile, packageMappings } = cliConfig;
         const { scheduledTasks } = visitState;
-        const content = [
-            serializeSchedulers(schedulersFile, scheduledTasks.files, packageMappings),
-            serializeSchedulerMeta(scheduledTasks.meta),
-        ];
-        await writeFileInDir(schedulersFile, content.join('\n\n'));
+        await writeFileInDir(schedulersMetaFile, serializeSchedulerMeta(scheduledTasks.meta));
+        await writeFileInDir(schedulersFile, serializeFileImports('addSerializedTasks', schedulersFile, scheduledTasks.files, packageMappings));
     });
 };
 async function action(options) {
     logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'routeDirectories', 'routesFile'], options.tags);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
+    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'srcDirectories', 'httpRoutesFile'], options.tags);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
     await pikkuScheduler(cliConfig, visitState);
 }
 export const schedules = (program) => {

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

@@ -1,5 +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 pikkuSchemas: ({ tsconfig, schemaDirectory, supportsImportAttributes }: PikkuCLIConfig, { functions, http, channels }: InspectorState) => Promise<boolean>;
 export declare const schemas: (program: Command) => void;

package/dist/bin/pikku-schemas.js

@@ -1,21 +1,21 @@
-import { saveSchemas, generateSchemas } from '../src/schema/schema-generator.js';
+import { saveSchemas, generateSchemas } from '../src/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 }) => {
+export const pikkuSchemas = async ({ tsconfig, schemaDirectory, supportsImportAttributes }, { functions, http, channels }) => {
     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);
+        const schemas = await generateSchemas(tsconfig, [functions.typesMap, http.typesMap, channels.typesMap], http.meta);
+        await saveSchemas(schemaDirectory, schemas, functions.typesMap, http.meta, supportsImportAttributes);
     });
 };
 async function action({ config }) {
     logPikkuLogo();
     const cliConfig = await getPikkuCLIConfig(config, [
-        'routeDirectories',
+        'srcDirectories',
         'schemaDirectory',
         'tsconfig',
     ]);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
     await pikkuSchemas(cliConfig, visitState);
 }
 export const schemas = (program) => {

package/dist/bin/pikku-websocket.js

@@ -1,6 +1,6 @@
 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';
+import { serializeWebsocketWrapper } from '../src/serialize-websocket-wrapper.js';
 export const pikkuWebSocket = async ({ websocketFile, channelsMapDeclarationFile, packageMappings, }) => {
     await logCommandInfoAndTime('Generating websocket wrapper', 'Generated websocket wrapper', [
         websocketFile === undefined,

package/dist/bin/pikku.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import { schemas } from './pikku-schemas.js';
-import { routes } from './pikku-http.js';
+import { routes } from './pikku-http-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 { routesMap } from './pikku-http-map.js';
 import { fetch } from './pikku-fetch.js';
 import { channels } from './pikku-channels.js';
 import { schedules } from './pikku-scheduler.js';

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

@@ -41,7 +41,7 @@ export type ChannelRouteHandlerOf<
 function generateChannels(channelsMeta) {
     const requiredTypes = new Set();
     const channelsObject = {};
-    for (const meta of channelsMeta) {
+    for (const meta of Object.values(channelsMeta)) {
         const { name, messageRoutes, message } = meta;
         if (!channelsObject[name]) {
             channelsObject[name] = { message, routes: {} };
@@ -70,7 +70,7 @@ function generateChannels(channelsMeta) {
         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) || 'never'}>,\n`;
+                routesStr += `        readonly ${method}: ChannelHandler<${formatTypeArray(handler.inputTypes) || 'void'}, ${formatTypeArray(handler.outputTypes) || 'never'}>,\n`;
             }
             routesStr += '      },\n';
         }
@@ -79,6 +79,9 @@ function generateChannels(channelsMeta) {
         if (message) {
             routesStr += `    readonly defaultMessage: ChannelHandler<${formatTypeArray(message.inputs)}, ${formatTypeArray(message.outputs)}>,\n`;
         }
+        else {
+            routesStr += `    readonly defaultMessage: never,\n`;
+        }
         routesStr += '  },\n';
     }
     routesStr += '};';

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

@@ -4,6 +4,7 @@ export const serializeImportMap = (relativeToPath, packageMappings, typesMap, re
     Array.from(requiredTypes).forEach((requiredType) => {
         const { originalName, uniqueName, path } = typesMap.getTypeMeta(requiredType);
         if (!path) {
+            // This is a custom type that exists in file, so we don't need to import it
             return;
         }
         const variables = paths.get(path) || [];