@pikku/cli 0.6.20 → 0.7.1

package/dist/src/pikku-cli-config.d.ts

@@ -1,13 +1,19 @@
-import { OpenAPISpecInfo } from './openapi/openapi-spec-generator.js';
+import { OpenAPISpecInfo } from './openapi-spec-generator.js';
 import { InspectorFilters } from '@pikku/inspector';
 export interface PikkuCLICoreOutputFiles {
     outDir?: string;
-    routesFile: string;
+    functionsFile: string;
+    functionsMetaFile: string;
+    httpRoutesFile: string;
+    httpRoutesMetaFile: string;
     channelsFile: string;
+    channelsMetaFile: string;
     schedulersFile: string;
+    schedulersMetaFile: string;
+    rpcFile: string;
     schemaDirectory: string;
     typesDeclarationFile: string;
-    routesMapDeclarationFile: string;
+    httpRoutesMapDeclarationFile: string;
     channelsMapDeclarationFile: string;
     bootstrapFile: string;
 }
@@ -15,7 +21,7 @@ export type PikkuCLIConfig = {
     $schema?: string;
     extends?: string;
     rootDir: string;
-    routeDirectories: string[];
+    srcDirectories: string[];
     packageMappings: Record<string, string>;
     supportsImportAttributes: boolean;
     configDir: string;

package/dist/src/pikku-cli-config.js

@@ -56,20 +56,38 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
             if (!result.schemaDirectory) {
                 result.schemaDirectory = join(result.outDir, 'pikku-schemas');
             }
-            if (!result.routesFile) {
-                result.routesFile = join(result.outDir, 'pikku-routes.gen.ts');
+            if (!result.functionsFile) {
+                result.functionsFile = join(result.outDir, 'pikku-functions.gen.ts');
+            }
+            if (!result.functionsMetaFile) {
+                result.functionsMetaFile = join(result.outDir, 'pikku-functions-meta.gen.ts');
+            }
+            if (!result.rpcFile) {
+                result.rpcFile = join(result.outDir, 'pikku-rpc.gen.ts');
+            }
+            if (!result.httpRoutesFile) {
+                result.httpRoutesFile = join(result.outDir, 'pikku-http-routes.gen.ts');
+            }
+            if (!result.httpRoutesMetaFile) {
+                result.httpRoutesMetaFile = join(result.outDir, 'pikku-http-routes-meta.gen.ts');
             }
             if (!result.schedulersFile) {
                 result.schedulersFile = join(result.outDir, 'pikku-schedules.gen.ts');
             }
+            if (!result.schedulersMetaFile) {
+                result.schedulersMetaFile = join(result.outDir, 'pikku-schedules-meta.gen.ts');
+            }
             if (!result.channelsFile) {
                 result.channelsFile = join(result.outDir, 'pikku-channels.gen.ts');
             }
+            if (!result.channelsMetaFile) {
+                result.channelsMetaFile = join(result.outDir, 'pikku-channels-meta.gen.ts');
+            }
             if (!result.typesDeclarationFile) {
                 result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.ts');
             }
-            if (!result.routesMapDeclarationFile) {
-                result.routesMapDeclarationFile = join(result.outDir, 'pikku-routes-map.gen.d.ts');
+            if (!result.httpRoutesMapDeclarationFile) {
+                result.httpRoutesMapDeclarationFile = join(result.outDir, 'pikku-routes-map.gen.d.ts');
             }
             if (!result.channelsMapDeclarationFile) {
                 result.channelsMapDeclarationFile = join(result.outDir, 'pikku-channels-map.gen.d.ts');

package/dist/src/{schema/schema-generator.d.ts → schema-generator.d.ts}

@@ -1,5 +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 generateSchemas(tsconfig: string, typesMaps: TypesMap[], httpRoutesMeta: HTTPRoutesMeta): Promise<Record<string, JSONValue>>;
 export declare function saveSchemas(schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, routesMeta: HTTPRoutesMeta, supportsImportAttributes: boolean): Promise<void>;

package/dist/src/{schema/schema-generator.js → schema-generator.js}

@@ -1,15 +1,36 @@
 import { createGenerator, RootlessError } from 'ts-json-schema-generator';
-import { logInfo, writeFileInDir } from '../utils.js';
+import { logInfo, 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) {
+export async function generateSchemas(tsconfig, typesMaps, httpRoutesMeta) {
+    const schemasSet = new Set(typesMaps.flatMap((tm) => [...tm.customTypes.keys()]));
+    for (const { input, inputTypes } of httpRoutesMeta) {
         if (input) {
-            schemasSet.add(typesMap.getTypeMeta(input).uniqueName);
-        }
-        if (output) {
-            schemasSet.add(typesMap.getTypeMeta(output).uniqueName);
+            let found = false;
+            for (const typesMap of typesMaps) {
+                try {
+                    const uniqueName = typesMap.getUniqueName(input);
+                    if (uniqueName) {
+                        found = true;
+                        schemasSet.add(uniqueName);
+                        break;
+                    }
+                }
+                catch (e) { }
+            }
+            if (!found) {
+                console.error('Input type not found in any types map:', input);
+            }
         }
+        // if (output) {
+        //   for (const typesMap of typesMaps) {
+        //     const uniqueName = typesMap.getUniqueName(output)
+        //     if (uniqueName) {
+        //       console.log('Adding output schema:', uniqueName)
+        //       schemasSet.add(uniqueName)
+        //       break
+        //     }
+        //   }
+        // }
         if (inputTypes?.body) {
             schemasSet.add(inputTypes.body);
         }

package/dist/src/{core/serialize-import-map.js → serialize-import-map.js}

@@ -1,9 +1,10 @@
-import { getFileImportRelativePath } from '../utils.js';
+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) {
+            // This is a custom type that exists in file, so we don't need to import it
             return;
         }
         const variables = paths.get(path) || [];

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

@@ -0,0 +1,136 @@
+/**
+ *
+ */
+export const serializePikkuTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, sessionServicesTypeImport, servicesTypeName) => {
+    return `/**
+* This is used to provide the application types in the typescript project
+*/
+  
+import { CoreAPIPermission, PikkuMiddleware } from '@pikku/core'
+import { CoreAPIFunction, CoreAPIFunctionSessionless } from '@pikku/core/function'
+import { CoreHTTPFunctionRoute, AssertRouteParams, addHTTPRoute as addCoreHTTPRoute } from '@pikku/core/http'
+import { CoreScheduledTask, addScheduledTask as addCoreScheduledTask } from '@pikku/core/scheduler'
+import { CoreAPIChannel, PikkuChannel, addChannel as addCoreChannel } from '@pikku/core/channel'
+
+${userSessionTypeImport}
+${singletonServicesTypeImport}
+${sessionServicesTypeImport}
+
+export type APIPermission<In = unknown, RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = CoreAPIPermission<In, RequiredServices, ${userSessionTypeName}>
+export type APIMiddleware<RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = PikkuMiddleware<RequiredServices, ${userSessionTypeName}>
+
+type APIFunctionSessionless<
+  In = unknown, 
+  Out = never, 
+  ChannelData = null,  // null means optional channel
+  RequiredServices extends Services = Services & (
+    [ChannelData] extends [null] 
+      ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
+      : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
+  )
+> = CoreAPIFunctionSessionless<In, Out, ChannelData, RequiredServices, ${userSessionTypeName}>
+
+type APIFunction<
+  In = unknown, 
+  Out = never, 
+  ChannelData = null,  // null means optional channel
+  RequiredServices extends Services = Services & (
+    [ChannelData] extends [null] 
+      ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
+      : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
+  )
+> = CoreAPIFunction<In, Out, ChannelData, RequiredServices, ${userSessionTypeName}>
+
+type APIRoute<In, Out, Route extends string> = CoreHTTPFunctionRoute<In, Out, Route, APIFunction<In, Out>, APIFunctionSessionless<In, Out>, APIPermission<In>, APIMiddleware>
+type APIChannel<ChannelData, Channel extends string> = CoreAPIChannel<ChannelData, Channel, APIFunction<void, unknown> | APIFunction<void, unknown, ChannelData>, APIFunction<void, void> | APIFunction<void, void, ChannelData>, APIFunction<any, any> | APIFunction<any, any, ChannelData>, APIPermission>
+type ScheduledTask = CoreScheduledTask<APIFunctionSessionless<void, void>, ${userSessionTypeName}>
+
+export const pikkuFunc = <In, Out = unknown>(
+  func:
+    | APIFunction<In, Out>
+    | {
+        func: APIFunction<In, Out>
+        auth?: true
+        name?: string
+      }
+    | {
+        func: APIFunctionSessionless<In, Out>
+        auth: false
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuSessionlessFunc = <In, Out = unknown>(
+  func:
+    | APIFunctionSessionless<In, Out>
+    | {
+        func: APIFunctionSessionless<In, Out>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuChannelConnectionFunc = <Out = unknown, ChannelData = unknown>(
+  func:
+    | APIFunctionSessionless<void, Out, ChannelData>
+    | {
+        func: APIFunctionSessionless<void, Out, ChannelData>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuChannelDisconnectionFunc = <ChannelData = unknown>(
+  func:
+    | APIFunctionSessionless<void, void, ChannelData>
+    | {
+        func: APIFunction<void, void, ChannelData>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuChannelFunc = <In = unknown, Out = unknown, ChannelData = unknown>(
+  func:
+    | APIFunctionSessionless<In, Out, ChannelData>
+    | {
+        func: APIFunctionSessionless<In, Out, ChannelData>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuVoidFunc = (
+  func:
+    | APIFunctionSessionless<void, void>
+    | {
+        func: APIFunctionSessionless<void, void>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+   
+export const addChannel = <ChannelData, Channel extends string>(
+  channel: APIChannel<ChannelData, Channel> & AssertRouteParams<ChannelData, Channel>
+) => {
+  addCoreChannel(channel as any) // TODO
+}
+
+export const addHTTPRoute = <In, Out, Route extends string>(
+  route: APIRoute<In, Out, Route> & AssertRouteParams<In, Route>
+) => {
+  addCoreHTTPRoute(route)
+}
+
+export const addScheduledTask = (task: ScheduledTask) => {
+  addCoreScheduledTask(task as any) // TODO
+}
+`;
+};

package/dist/src/{scheduler/serialize-schedulers.d.ts → serialize-scheduler-meta.d.ts}

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

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

@@ -0,0 +1,10 @@
+export const serializeSchedulerMeta = (scheduledTasksMeta) => {
+    const serializedOutput = [];
+    serializedOutput.push("import { pikkuState } from '@pikku/core'");
+    serializedOutput.push(`pikkuState('scheduler', 'meta', ${JSON.stringify(scheduledTasksMeta, null, 2)})`);
+    const scheduledTasksMetaValues = Object.values(scheduledTasksMeta);
+    if (scheduledTasksMetaValues.length > 0) {
+        serializedOutput.push(`export type ScheduledTaskNames = '${scheduledTasksMetaValues.map((s) => s.name).join("' | '")}'`);
+    }
+    return serializedOutput.join('\n');
+};

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

@@ -1,5 +1,5 @@
-import { serializeImportMap } from '../core/serialize-import-map.js';
-import { generateCustomTypes } from '../http/serialize-typed-route-map.js';
+import { serializeImportMap } from './serialize-import-map.js';
+import { generateCustomTypes } from './serialize-typed-http-map.js';
 export const serializeTypedChannelsMap = (relativeToPath, packageMappings, typesMap, channelsMeta) => {
     const { channels, requiredTypes } = generateChannels(channelsMeta);
     typesMap.customTypes.forEach(({ references }) => {
@@ -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/{http/serialize-typed-route-map.js → serialize-typed-function-map.js}

@@ -1,10 +1,10 @@
-import { serializeImportMap } from '../core/serialize-import-map.js';
+import { serializeImportMap } from './serialize-import-map.js';
 export const serializeTypedRoutesMap = (relativeToPath, packageMappings, typesMap, routesMeta, metaTypes) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
     const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap);
-    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
     const serializedRoutes = generateRoutes(routesMeta, typesMap, requiredTypes);
+    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
     return `/**
  * This provides the structure needed for typescript to be aware of routes and their return types
  */

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

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

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

@@ -0,0 +1,107 @@
+import { serializeImportMap } from './serialize-import-map.js';
+export const serializeTypedRoutesMap = (relativeToPath, packageMappings, typesMap, routesMeta, metaTypes) => {
+    const requiredTypes = new Set();
+    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
+    const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap);
+    const serializedRoutes = generateRoutes(routesMeta, typesMap, requiredTypes);
+    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    return `/**
+ * This provides the structure needed for typescript to be aware of routes and their return types
+ */
+    
+${serializedImportMap}
+${serializedCustomTypes}
+${serializedMetaTypes}
+
+interface RouteHandler<I, O> {
+    input: I;
+    output: O;
+}
+
+${serializedRoutes}
+
+export type RouteHandlerOf<Route extends keyof RoutesMap, Method extends keyof RoutesMap[Route]> =
+    RoutesMap[Route][Method] extends { input: infer I; output: infer O }
+        ? RouteHandler<I, O>
+        : never;
+
+export type RoutesWithMethod<Method extends string> = {
+  [Route in keyof RoutesMap]: Method extends keyof RoutesMap[Route] ? Route : never;
+}[keyof RoutesMap];
+  `;
+};
+export function generateCustomTypes(typesMap, requiredTypes) {
+    return `
+// Custom types are those that are defined directly within generics
+// or are broken into simpler types
+${Array.from(typesMap.customTypes.entries())
+        .map(([name, { type, references }]) => {
+        references.forEach((name) => {
+            const originalName = typesMap.getTypeMeta(name).originalName;
+            requiredTypes.add(originalName);
+        });
+        return `export type ${name} = ${type}`;
+    })
+        .join('\n')}`;
+}
+function generateRoutes(routesMeta, typesMap, requiredTypes) {
+    // Initialize an object to collect routes
+    const routesObj = {};
+    for (const meta of routesMeta) {
+        const { route, method, input, output } = meta;
+        // Initialize the route entry if it doesn't exist
+        if (!routesObj[route]) {
+            routesObj[route] = {};
+        }
+        // Store the input and output types separately for RouteHandler
+        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
+        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null';
+        requiredTypes.add(inputType);
+        requiredTypes.add(outputType);
+        // Add method entry
+        routesObj[route][method] = {
+            inputType,
+            outputType,
+        };
+    }
+    // Build the routes object as a string
+    let routesStr = 'export type RoutesMap = {\n';
+    for (const [routePath, methods] of Object.entries(routesObj)) {
+        routesStr += `  readonly '${routePath}': {\n`;
+        for (const [method, handler] of Object.entries(methods)) {
+            routesStr += `    readonly ${method.toUpperCase()}: RouteHandler<${handler.inputType}, ${handler.outputType}>,\n`;
+        }
+        routesStr += '  },\n';
+    }
+    routesStr += '};';
+    return routesStr;
+}
+const generateMetaTypes = (metaTypes, typesMap) => {
+    const nameToTypeMap = Array.from(metaTypes.entries()).reduce((result, [_name, { query, body, params }]) => {
+        const { uniqueName } = typesMap.getTypeMeta(_name);
+        const queryType = query && query.length > 0
+            ? `Pick<${uniqueName}, '${query?.join("' | '")}'>`
+            : undefined;
+        if (queryType) {
+            result.set(`${uniqueName}Query`, queryType);
+        }
+        const paramsType = params && params.length > 0
+            ? `Pick<${uniqueName}, '${params.join("' | '")}'>`
+            : undefined;
+        if (paramsType) {
+            result.set(`${uniqueName}Params`, paramsType);
+        }
+        const bodyType = (body && body.length > 0) || (params && params.length > 0)
+            ? `Omit<${uniqueName}, '${[...new Set([...(query || []), ...(params || [])])].join("' | '")}'>`
+            : uniqueName;
+        if (bodyType) {
+            result.set(`${uniqueName}Body`, bodyType);
+        }
+        return result;
+    }, new Map());
+    return `
+// The '& {}' is a workaround for not directly refering to a type since it confuses typescript
+${Array.from(nameToTypeMap.entries())
+        .map(([name, type]) => `export type ${name} = ${type} & {}`)
+        .join('\n')}`;
+};

package/dist/src/utils.d.ts

@@ -38,4 +38,5 @@ export declare const writeFileInDir: (path: string, content: string, ignoreModif
 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 declare const serializeFileImports: (importType: string, outputPath: string, files: Set<string>, packageMappings?: Record<string, string>) => string;
 export {};

package/dist/src/utils.js

@@ -18,17 +18,17 @@ export const getFileImportRelativePath = (from, to, packageMappings) => {
     if (!/^\.+\//.test(filePath)) {
         filePath = `./${filePath}`;
     }
-    let usesPackageName = false;
+    // let usesPackageName = false
     for (const [path, packageName] of Object.entries(packageMappings)) {
         if (filePath.includes(path)) {
-            usesPackageName = true;
+            // usesPackageName = true
             filePath = filePath.replace(new RegExp(`.*${path}`), packageName);
             break;
         }
     }
-    if (usesPackageName) {
-        return filePath.replace('.ts', '');
-    }
+    // if (usesPackageName) {
+    //   return filePath.replace('.ts', '')
+    // }
     return filePath.replace('.ts', '.js');
 };
 const getMetaTypes = (type, errors, map, desiredType) => {
@@ -131,3 +131,15 @@ export const DO_NOT_MODIFY_COMMENT = `/**
  * This file was generated by the @pikku/cli
  */
 `;
+export const serializeFileImports = (importType, outputPath, files, packageMappings = {}) => {
+    const serializedOutput = [
+        `/* The files with an ${importType} function call */`,
+    ];
+    Array.from(files)
+        .sort()
+        .forEach((path) => {
+        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
+        serializedOutput.push(`import '${filePath}'`);
+    });
+    return serializedOutput.join('\n');
+};

package/dist/tsconfig.tsbuildinfo

@@ -1 +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-http.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-routes-map.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-backend-wrapper.ts","../src/nextjs/serialize-nextjs-http-wrapper.ts","../src/openapi/openapi-spec-generator.ts","../src/scheduler/serialize-schedulers.ts","../src/schema/schema-generator.ts"],"version":"5.7.3"}
+{"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-functions.ts","../bin/pikku-http-map.ts","../bin/pikku-http-routes.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-rpc.ts","../bin/pikku-scheduler.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/openapi-spec-generator.ts","../src/pikku-cli-config.ts","../src/schema-generator.ts","../src/serialize-fetch-wrapper.ts","../src/serialize-import-map.ts","../src/serialize-nextjs-backend-wrapper.ts","../src/serialize-nextjs-http-wrapper.ts","../src/serialize-pikku-types.ts","../src/serialize-scheduler-meta.ts","../src/serialize-typed-channel-map.ts","../src/serialize-typed-function-map.ts","../src/serialize-typed-http-map.ts","../src/serialize-websocket-wrapper.ts","../src/utils.ts"],"version":"5.7.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.6.20",
+  "version": "0.7.1",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "bin": {
@@ -22,8 +22,8 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^3.0.2",
-    "@pikku/core": "^0.6.24",
-    "@pikku/inspector": "^0.6.4",
+    "@pikku/core": "^0.7.3",
+    "@pikku/inspector": "^0.7.3",
     "@types/cookie": "^0.6.0",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.4.1",

package/src/inspector-glob.ts

@@ -5,7 +5,7 @@ import { logCommandInfoAndTime } from './utils.js'
 
 export const inspectorGlob = async (
   rootDir: string,
-  routeDirectories: string[],
+  srcDirectories: string[],
   filters: InspectorFilters
 ) => {
   let result: InspectorState
@@ -16,7 +16,7 @@ export const inspectorGlob = async (
     async () => {
       const routeFiles = (
         await Promise.all(
-          routeDirectories.map((dir) =>
+          srcDirectories.map((dir) =>
             glob(`${path.join(rootDir, dir)}/**/*.ts`)
           )
         )

package/src/pikku-cli-config.ts

@@ -1,16 +1,22 @@
 import { join, dirname, resolve, isAbsolute } from 'path'
 import { readdir, readFile } from 'fs/promises'
-import { OpenAPISpecInfo } from './openapi/openapi-spec-generator.js'
+import { OpenAPISpecInfo } from './openapi-spec-generator.js'
 import { InspectorFilters } from '@pikku/inspector'
 
 export interface PikkuCLICoreOutputFiles {
   outDir?: string
-  routesFile: string
+  functionsFile: string
+  functionsMetaFile: string
+  httpRoutesFile: string
+  httpRoutesMetaFile: string
   channelsFile: string
+  channelsMetaFile: string
   schedulersFile: string
+  schedulersMetaFile: string
+  rpcFile: string
   schemaDirectory: string
   typesDeclarationFile: string
-  routesMapDeclarationFile: string
+  httpRoutesMapDeclarationFile: string
   channelsMapDeclarationFile: string
   bootstrapFile: string
 }
@@ -21,7 +27,7 @@ export type PikkuCLIConfig = {
   extends?: string
 
   rootDir: string
-  routeDirectories: string[]
+  srcDirectories: string[]
   packageMappings: Record<string, string>
   supportsImportAttributes: boolean
 
@@ -121,20 +127,50 @@ const _getPikkuCLIConfig = async (
       if (!result.schemaDirectory) {
         result.schemaDirectory = join(result.outDir, 'pikku-schemas')
       }
-      if (!result.routesFile) {
-        result.routesFile = join(result.outDir, 'pikku-routes.gen.ts')
+      if (!result.functionsFile) {
+        result.functionsFile = join(result.outDir, 'pikku-functions.gen.ts')
+      }
+      if (!result.functionsMetaFile) {
+        result.functionsMetaFile = join(
+          result.outDir,
+          'pikku-functions-meta.gen.ts'
+        )
+      }
+      if (!result.rpcFile) {
+        result.rpcFile = join(result.outDir, 'pikku-rpc.gen.ts')
+      }
+      if (!result.httpRoutesFile) {
+        result.httpRoutesFile = join(result.outDir, 'pikku-http-routes.gen.ts')
+      }
+      if (!result.httpRoutesMetaFile) {
+        result.httpRoutesMetaFile = join(
+          result.outDir,
+          'pikku-http-routes-meta.gen.ts'
+        )
       }
       if (!result.schedulersFile) {
         result.schedulersFile = join(result.outDir, 'pikku-schedules.gen.ts')
       }
+      if (!result.schedulersMetaFile) {
+        result.schedulersMetaFile = join(
+          result.outDir,
+          'pikku-schedules-meta.gen.ts'
+        )
+      }
       if (!result.channelsFile) {
         result.channelsFile = join(result.outDir, 'pikku-channels.gen.ts')
       }
+      if (!result.channelsMetaFile) {
+        result.channelsMetaFile = join(
+          result.outDir,
+          'pikku-channels-meta.gen.ts'
+        )
+      }
       if (!result.typesDeclarationFile) {
         result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.ts')
       }
-      if (!result.routesMapDeclarationFile) {
-        result.routesMapDeclarationFile = join(
+      if (!result.httpRoutesMapDeclarationFile) {
+        result.httpRoutesMapDeclarationFile = join(
           result.outDir,
           'pikku-routes-map.gen.d.ts'
         )