@pikku/cli 0.6.19 → 0.7.0

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/serialize-typed-channel-map.d.ts

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

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

@@ -0,0 +1,93 @@
+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 }) => {
+        for (const reference of references) {
+            requiredTypes.add(reference);
+        }
+    });
+    const imports = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
+    return `/**
+ * This provides the structure needed for TypeScript to be aware of channels
+ */
+    
+${imports}
+${serializedCustomTypes}
+
+interface ChannelHandler<I, O> {
+    input: I;
+    output: O;
+}
+
+${channels}
+
+export type ChannelDefaultHandlerOf<Channel extends keyof ChannelsMap> =
+    ChannelsMap[Channel]['defaultMessage'] extends { input: infer I; output: infer O }
+        ? ChannelHandler<I, O>
+        : never;
+
+export type ChannelRouteHandlerOf<
+    Channel extends keyof ChannelsMap, 
+    Route extends keyof ChannelsMap[Channel]['routes'], 
+    Method extends keyof ChannelsMap[Channel]['routes'][Route],
+> =
+    ChannelsMap[Channel]['routes'][Route][Method] extends { input: infer I; output: infer O }
+        ? ChannelHandler<I, O>
+        : never;
+`;
+};
+function generateChannels(channelsMeta) {
+    const requiredTypes = new Set();
+    const channelsObject = {};
+    for (const meta of Object.values(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) || 'void'}, ${formatTypeArray(handler.outputTypes) || 'never'}>,\n`;
+            }
+            routesStr += '      },\n';
+        }
+        routesStr += '    },\n';
+        // Add `defaultMessage` outside `routes`
+        if (message) {
+            routesStr += `    readonly defaultMessage: ChannelHandler<${formatTypeArray(message.inputs)}, ${formatTypeArray(message.outputs)}>,\n`;
+        }
+        else {
+            routesStr += `    readonly defaultMessage: never,\n`;
+        }
+        routesStr += '  },\n';
+    }
+    routesStr += '};';
+    return { channels: routesStr, requiredTypes };
+}
+// Utility to format type arrays
+function formatTypeArray(types) {
+    return types ? types.join(' | ') : 'null';
+}

package/dist/src/serialize-typed-function-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-function-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/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/serialize-typed-route-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-route-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/serialize-websocket-wrapper.d.ts

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

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

@@ -0,0 +1,61 @@
+export const serializeWebsocketWrapper = (channelsMapPath) => {
+    return `import { CorePikkuWebsocket, CorePikkuRouteHandler } from '@pikku/websocket'
+import { ChannelDefaultHandlerOf, ChannelRouteHandlerOf, ChannelsMap } from '${channelsMapPath}';
+
+class PikkuWebSocketRoute<Channel extends keyof ChannelsMap, Route extends keyof ChannelsMap[Channel]['routes']> extends CorePikkuRouteHandler {
+    public subscribe<
+        Method extends keyof ChannelsMap[Channel]['routes'][Route],
+        Data extends ChannelRouteHandlerOf<Channel, Route, Method>['output']
+    >(method: Method, callback: (data: Data) => void
+    ) {
+        super.subscribe(method.toString(), callback)
+    }
+
+    public unsubscribe<
+        Method extends keyof ChannelsMap[Channel]['routes'][Route],
+        Data extends ChannelRouteHandlerOf<Channel, Route, Method>['output']
+    >(method: Method, callback?: (data: Data) => void) {
+        super.unsubscribe(method.toString(), callback)
+    }
+
+    public send<
+        Method extends keyof ChannelsMap[Channel]['routes'][Route],
+        Data extends ChannelRouteHandlerOf<Channel, Route, Method>['input']
+    >(method: Method, data: Data) {
+        super.send(method.toString(), data)
+    }
+}
+
+export class PikkuWebSocket<Channel extends keyof ChannelsMap> extends CorePikkuWebsocket {
+    /**
+     * Send a message to a specific route and method.
+     * Validates the input data type.
+     */
+    public getRoute<Route extends keyof ChannelsMap[Channel]['routes']>(route: Route): PikkuWebSocketRoute<Channel, Route> {
+        return super.getRoute(route)
+    }
+
+    /**
+     * Subscribe to a specific route and method.
+     */
+    public subscribe<Data extends ChannelDefaultHandlerOf<Channel>['output']>(
+        callback: (data: Data) => void
+    ) {
+        super.subscribe(callback)
+    }
+
+    /**
+     * Subscribe to a specific route and method.
+     */
+    public unsubscribe<Data extends ChannelDefaultHandlerOf<Channel>['output']>(
+        callback?: (data: Data) => void
+    ) {
+        super.unsubscribe(callback)
+    }
+
+    public send(data: ChannelDefaultHandlerOf<Channel>['input']) {
+        super.send(data)
+    }
+}
+  `;
+};

package/dist/src/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.6.19",
+  "version": "0.7.0",
   "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.23",
-    "@pikku/inspector": "^0.6.4",
+    "@pikku/core": "^0.7.0",
+    "@pikku/inspector": "^0.7.0",
     "@types/cookie": "^0.6.0",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.4.1",