@pikku/cli 0.7.7 → 0.8.1

package/dist/src/events/queue/serialize-queue-map.js

@@ -0,0 +1,77 @@
+import { serializeImportMap } from '../../serialize-import-map.js';
+import { generateCustomTypes } from '../../utils.js';
+export const serializeQueueMap = (relativeToPath, packageMappings, typesMap, functionsMeta, queueWorkersMeta) => {
+    const requiredTypes = new Set();
+    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
+    const serializedQueues = generateQueues(queueWorkersMeta, functionsMeta, typesMap, requiredTypes);
+    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    return `/**
+ * This provides the structure needed for typescript to be aware of Queue workers and their input/output types
+ */
+    
+${serializedImportMap}
+${serializedCustomTypes}
+
+import type { QueueJob } from '@pikku/core/queue'
+
+interface QueueHandler<I, O> {
+    input: I;
+    output: O;
+}
+
+${serializedQueues}
+
+type QueueAdd = <Name extends keyof QueueMap>(
+  name: Name,
+  data: QueueMap[Name]['input'],
+  options?: {
+    priority?: number
+    delay?: number
+    attempts?: number
+    removeOnComplete?: number
+    removeOnFail?: number
+    jobId?: string
+  }
+) => Promise<string>
+
+type QueueGetJob = <Name extends keyof QueueMap>(
+  name: Name,
+  jobId: string
+) => Promise<QueueJob<QueueMap[Name]['input'], QueueMap[Name]['output']> | null>
+
+export type TypedPikkuQueue = {
+  add: QueueAdd;
+  getJob: QueueGetJob;
+}
+  `;
+};
+function generateQueues(queueWorkersMeta, functionsMeta, typesMap, requiredTypes) {
+    // Initialize an object to collect queues
+    const queuesObj = {};
+    // Iterate through Queue metadata
+    for (const [queueName, { pikkuFuncName }] of Object.entries(queueWorkersMeta)) {
+        const functionMeta = functionsMeta[pikkuFuncName];
+        if (!functionMeta) {
+            throw new Error(`Function ${queueName} not found in functionsMeta. Please check your configuration.`);
+        }
+        const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
+        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
+        // Store the input and output types for QueueHandler
+        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
+        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null';
+        requiredTypes.add(inputType);
+        requiredTypes.add(outputType);
+        // Add Queue entry
+        queuesObj[queueName] = {
+            inputType,
+            outputType,
+        };
+    }
+    // Build the Queues object as a string
+    let queuesStr = 'export type QueueMap = {\n';
+    for (const [queueName, handler] of Object.entries(queuesObj)) {
+        queuesStr += `  readonly '${queueName}': QueueHandler<${handler.inputType}, ${handler.outputType}>,\n`;
+    }
+    queuesStr += '};\n';
+    return queuesStr;
+}

package/dist/src/events/queue/serialize-queue-meta.d.ts

@@ -0,0 +1,2 @@
+import { queueWorkersMeta } from '@pikku/core';
+export declare const serializeQueueMeta: (queueWorkersMeta: queueWorkersMeta) => string;

package/dist/src/events/queue/serialize-queue-meta.js

@@ -0,0 +1,6 @@
+export const serializeQueueMeta = (queueWorkersMeta) => {
+    const serializedOutput = [];
+    serializedOutput.push("import { pikkuState } from '@pikku/core'");
+    serializedOutput.push(`pikkuState('queue', 'meta', ${JSON.stringify(queueWorkersMeta, null, 2)})`);
+    return serializedOutput.join('\n');
+};

package/dist/src/events/queue/serialize-queue-wrapper.d.ts

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

package/dist/src/events/queue/serialize-queue-wrapper.js

@@ -0,0 +1,35 @@
+export const serializeQueueWrapper = (queueMapPath) => {
+    return `
+import type { QueueService, QueueJob } from '@pikku/core/queue'
+import type { QueueMap, TypedPikkuQueue } from '${queueMapPath}'
+
+export class PikkuQueue implements TypedPikkuQueue {
+    constructor(private queueService: QueueService) {}
+
+    public async add<Name extends keyof QueueMap>(
+        queueName: Name,
+        data: QueueMap[Name]['input'],
+        options?: {
+            priority?: number
+            delay?: number
+            attempts?: number
+            removeOnComplete?: number
+            removeOnFail?: number
+            jobId?: string
+        }
+    ): Promise<string> {
+        return this.queueService.add(queueName as string, data, options);
+    }
+
+    public async getJob<Name extends keyof QueueMap>(
+        queueName: Name,
+        jobId: string
+    ): Promise<QueueJob<QueueMap[Name]['input'], QueueMap[Name]['output']> | null> {
+        return this.queueService.getJob<QueueMap[Name]['input'], QueueMap[Name]['output']>(
+            queueName as string,
+            jobId
+        );
+    }
+}
+`;
+};

package/dist/src/events/rpc/pikku-command-rpc-client.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommandWithoutState } from '../../types.js';
+export declare const pikkuRPCClient: PikkuCommandWithoutState;

package/dist/src/events/rpc/pikku-command-rpc-client.js

@@ -0,0 +1,12 @@
+import { serializeRPCWrapper } from './serialize-rpc-wrapper.js';
+import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
+export const pikkuRPCClient = async (logger, { rpcFile, rpcMapDeclarationFile, packageMappings }) => {
+    return await logCommandInfoAndTime(logger, 'Generating RPC wrapper', 'Generated RPC wrapper', [rpcFile === undefined, "rpcFile isn't set in the pikku config"], async () => {
+        if (!rpcFile) {
+            throw new Error("rpcFile isn't set in the pikku config");
+        }
+        const rpcMapDeclarationPath = getFileImportRelativePath(rpcFile, rpcMapDeclarationFile, packageMappings);
+        const content = [serializeRPCWrapper(rpcMapDeclarationPath)];
+        await writeFileInDir(logger, rpcFile, content.join('\n'));
+    });
+};

package/dist/src/events/rpc/pikku-command-rpc-map.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommand } from '../../types.js';
+export declare const pikkuRPCMap: PikkuCommand;

package/dist/src/events/rpc/pikku-command-rpc-map.js

@@ -0,0 +1,8 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
+import { serializeTypedRPCMap } from './serialize-typed-rpc-map.js';
+export const pikkuRPCMap = async (logger, { rpcMapDeclarationFile, packageMappings }, { functions, rpc }) => {
+    return await logCommandInfoAndTime(logger, 'Creating RPC map', 'Created RPC map', [false], async () => {
+        const content = serializeTypedRPCMap(rpcMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.meta);
+        await writeFileInDir(logger, rpcMapDeclarationFile, content);
+    });
+};

package/dist/src/events/rpc/pikku-command-rpc.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommand } from '../../types.js';
+export declare const pikkuRPC: PikkuCommand;

package/dist/src/events/rpc/pikku-command-rpc.js

@@ -0,0 +1,6 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
+export const pikkuRPC = async (logger, { rpcMetaFile }, { rpc }) => {
+    return await logCommandInfoAndTime(logger, 'Finding RPCs tasks', 'Found RPCs', [false], async () => {
+        await writeFileInDir(logger, rpcMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`);
+    });
+};

package/dist/src/events/rpc/pikku-rpc.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommand } from '../../types.js';
+export declare const pikkuRPC: PikkuCommand;

package/dist/src/events/rpc/pikku-rpc.js

@@ -0,0 +1,6 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
+export const pikkuRPC = async (logger, { rpcMetaFile }, { rpc }) => {
+    return await logCommandInfoAndTime(logger, 'Finding RPCs tasks', 'Found RPCs', [false], async () => {
+        await writeFileInDir(logger, rpcMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`);
+    });
+};

package/dist/src/events/rpc/serialize-rpc-wrapper.d.ts

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

package/dist/src/events/rpc/serialize-rpc-wrapper.js

@@ -0,0 +1,29 @@
+export const serializeRPCWrapper = (rpcMapPath) => {
+    return `
+import { PikkuFetch } from "./pikku-fetch.gen.js"
+import type { RPCInvoke } from '${rpcMapPath}'
+
+export class PikkuRPC {
+    pikkuFetch = new PikkuFetch()
+
+    setPikkuFetch(pikkuFetch: PikkuFetch): void {
+        this.pikkuFetch = pikkuFetch
+    }
+
+    setServerUrl(serverUrl: string): void {
+        this.pikkuFetch.setServerUrl(serverUrl)
+    }
+
+    setAuthorizationJWT(jwt: string | null): void {
+        this.pikkuFetch.setAuthorizationJWT(jwt)
+    }
+
+    // Generic RPC invoke method
+    invoke: RPCInvoke = async (name, data) => {
+       return await this.pikkuFetch.post('/rpc', { name, data })
+    }
+}
+
+export const pikkuRPC = new PikkuRPC();
+`;
+};

package/dist/src/{serialize-typed-rpc-map.d.ts → events/rpc/serialize-typed-rpc-map.d.ts}

@@ -1,4 +1,4 @@
+import type { RPCMeta } from '@pikku/core/rpc';
 import { TypesMap } from '@pikku/inspector';
 import { FunctionsMeta } from '@pikku/core';
-import { RPCMeta } from '../../core/src/rpc/rpc-types.js';
 export declare const serializeTypedRPCMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, rpcMeta: Record<string, RPCMeta>) => string;

package/dist/src/{serialize-typed-rpc-map.js → events/rpc/serialize-typed-rpc-map.js}

@@ -1,5 +1,5 @@
-import { serializeImportMap } from './utils/serialize-import-map.js';
-import { generateCustomTypes } from './utils/utils.js';
+import { serializeImportMap } from '../../serialize-import-map.js';
+import { generateCustomTypes } from '../../utils.js';
 export const serializeTypedRPCMap = (relativeToPath, packageMappings, typesMap, functionsMeta, rpcMeta) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
@@ -19,7 +19,7 @@ interface RPCHandler<I, O> {
 
 ${serializedRPCs}
 
-type RPCInvoke = <Name extends keyof RPCMap>(
+export type RPCInvoke = <Name extends keyof RPCMap>(
   name: Name,
   data: RPCMap[Name]['input'],
   options?: {

package/dist/src/events/scheduler/pikku-command-scheduler.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommand } from '../../types.js';
+export declare const pikkuScheduler: PikkuCommand;

package/dist/src/events/scheduler/pikku-command-scheduler.js

@@ -0,0 +1,10 @@
+import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
+import { serializeSchedulerMeta } from './serialize-scheduler-meta.js';
+export const pikkuScheduler = async (logger, cliConfig, visitState) => {
+    return await logCommandInfoAndTime(logger, 'Finding scheduled tasks', 'Found scheduled tasks', [visitState.scheduledTasks.files.size === 0], async () => {
+        const { schedulersFile, schedulersMetaFile, packageMappings } = cliConfig;
+        const { scheduledTasks } = visitState;
+        await writeFileInDir(logger, schedulersMetaFile, serializeSchedulerMeta(scheduledTasks.meta));
+        await writeFileInDir(logger, schedulersFile, serializeFileImports('addScheduledTasks', schedulersFile, scheduledTasks.files, packageMappings));
+    });
+};

package/dist/src/inspector-glob.d.ts

@@ -1,2 +1,2 @@
 import { InspectorFilters, InspectorState } from '@pikku/inspector';
-export declare const inspectorGlob: (rootDir: string, srcDirectories: string[], filters: InspectorFilters) => Promise<InspectorState>;
+export declare const inspectorGlob: (logger: any, rootDir: string, srcDirectories: string[], filters: InspectorFilters) => Promise<InspectorState>;

package/dist/src/inspector-glob.js

@@ -1,12 +1,12 @@
 import * as path from 'path';
 import { glob } from 'tinyglobby';
 import { inspect } from '@pikku/inspector';
-import { logCommandInfoAndTime } from './utils/utils.js';
-export const inspectorGlob = async (rootDir, srcDirectories, filters) => {
+import { logCommandInfoAndTime } from './utils.js';
+export const inspectorGlob = async (logger, rootDir, srcDirectories, filters) => {
     let result;
-    await logCommandInfoAndTime('Inspecting codebase', 'Inspected codebase', [false], async () => {
+    await logCommandInfoAndTime(logger, 'Inspecting codebase', 'Inspected codebase', [false], async () => {
         const routeFiles = (await Promise.all(srcDirectories.map((dir) => glob(`${path.join(rootDir, dir)}/**/*.ts`)))).flat();
-        result = await inspect(routeFiles, filters);
+        result = await inspect(logger, routeFiles, filters);
     });
     return result;
 };

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

@@ -1,4 +1,4 @@
-import { OpenAPISpecInfo } from './openapi-spec-generator.js';
+import { OpenAPISpecInfo } from './events/http/openapi-spec-generator.js';
 import { InspectorFilters } from '@pikku/inspector';
 import { PikkuEventTypes } from '@pikku/core';
 export interface PikkuCLICoreOutputFiles {
@@ -17,6 +17,12 @@ export interface PikkuCLICoreOutputFiles {
     rpcMapDeclarationFile: string;
     schedulersFile: string;
     schedulersMetaFile: string;
+    queueWorkersFile: string;
+    queueWorkersMetaFile: string;
+    queueMapDeclarationFile: string;
+    mcpEndpointsFile: string;
+    mcpEndpointsMetaFile: string;
+    servicesFile: string;
     bootstrapFile: string;
     bootstrapFiles: Record<PikkuEventTypes, string>;
 }
@@ -33,11 +39,15 @@ export type PikkuCLIConfig = {
     nextHTTPFile?: string;
     fetchFile?: string;
     websocketFile?: string;
+    rpcFile?: string;
+    queueFile?: string;
+    mcpJsonFile?: string;
     openAPI?: {
         outputFile: string;
         additionalInfo: OpenAPISpecInfo;
     };
+    middlewareServices?: string[];
     filters: InspectorFilters;
 } & PikkuCLICoreOutputFiles;
-export declare const getPikkuCLIConfig: (configFile: string | undefined, requiredFields: Array<keyof PikkuCLIConfig>, tags?: string[], exitProcess?: boolean) => Promise<PikkuCLIConfig>;
+export declare const getPikkuCLIConfig: (configFile: string | undefined, requiredFields: Array<keyof PikkuCLIConfig>, filters?: InspectorFilters, exitProcess?: boolean) => Promise<PikkuCLIConfig>;
 export declare const validateCLIConfig: (cliConfig: PikkuCLIConfig, required: Array<keyof PikkuCLIConfig>) => void;

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

@@ -6,12 +6,15 @@ const CONFIG_DIR_FILES = [
     'nextHTTPFile',
     'fetchFile',
     'websocketFile',
+    'rpcFile',
+    'queueFile',
+    'mcpJsonFile',
 ];
-export const getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags = [], exitProcess = false) => {
-    const config = await _getPikkuCLIConfig(configFile, requiredFields, tags, exitProcess);
+export const getPikkuCLIConfig = async (configFile = undefined, requiredFields, filters = {}, exitProcess = false) => {
+    const config = await _getPikkuCLIConfig(configFile, requiredFields, filters, exitProcess);
     return config;
 };
-const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags = [], exitProcess = false) => {
+const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, filters = {}, exitProcess = false) => {
     if (!configFile) {
         let execDirectory = process.cwd();
         const files = await readdir(execDirectory);
@@ -32,7 +35,7 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
         const configDir = dirname(configFile);
         const config = JSON.parse(file);
         if (config.extends) {
-            const extendedConfig = await getPikkuCLIConfig(resolve(configDir, config.extends), [], tags, exitProcess);
+            const extendedConfig = await getPikkuCLIConfig(resolve(configDir, config.extends), [], filters, exitProcess);
             result = {
                 ...extendedConfig,
                 ...config,
@@ -54,54 +57,94 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
             };
         }
         if (result.outDir) {
+            // Create transport/event directories
+            const functionDir = join(result.outDir, 'function');
+            const httpDir = join(result.outDir, 'http');
+            const channelDir = join(result.outDir, 'channel');
+            const rpcDir = join(result.outDir, 'rpc');
+            const schedulerDir = join(result.outDir, 'scheduler');
+            const queueDir = join(result.outDir, 'queue');
+            const mcpDir = join(result.outDir, 'mcp');
+            // Create directories if they don't exist (will be done lazily when files are written)
             if (!result.schemaDirectory) {
-                result.schemaDirectory = join(result.outDir, 'pikku-schemas');
+                result.schemaDirectory = join(result.outDir, 'schemas');
             }
+            // Functions
             if (!result.functionsFile) {
-                result.functionsFile = join(result.outDir, 'pikku-functions.gen.ts');
+                result.functionsFile = join(functionDir, 'pikku-functions.gen.ts');
             }
             if (!result.functionsMetaFile) {
-                result.functionsMetaFile = join(result.outDir, 'pikku-functions-meta.gen.ts');
+                result.functionsMetaFile = join(functionDir, 'pikku-functions-meta.gen.ts');
             }
-            if (!result.rpcMetaFile) {
-                result.rpcMetaFile = join(result.outDir, 'pikku-rpc-meta.gen.ts');
-            }
-            if (!result.rpcMapDeclarationFile) {
-                result.rpcMapDeclarationFile = join(result.outDir, 'pikku-rpc-map.gen.ts');
+            if (!result.typesDeclarationFile) {
+                result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.ts');
             }
+            // HTTP
             if (!result.httpRoutesFile) {
-                result.httpRoutesFile = join(result.outDir, 'pikku-http-routes.gen.ts');
+                result.httpRoutesFile = join(httpDir, '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');
+                result.httpRoutesMetaFile = join(httpDir, 'pikku-http-routes-meta.gen.ts');
             }
-            if (!result.schedulersMetaFile) {
-                result.schedulersMetaFile = join(result.outDir, 'pikku-schedules-meta.gen.ts');
+            if (!result.httpRoutesMapDeclarationFile) {
+                result.httpRoutesMapDeclarationFile = join(httpDir, 'pikku-http-routes-map.gen.d.ts');
             }
+            // Channels/WebSocket
             if (!result.channelsFile) {
-                result.channelsFile = join(result.outDir, 'pikku-channels.gen.ts');
+                result.channelsFile = join(channelDir, 'pikku-channels.gen.ts');
             }
             if (!result.channelsMetaFile) {
-                result.channelsMetaFile = join(result.outDir, 'pikku-channels-meta.gen.ts');
+                result.channelsMetaFile = join(channelDir, 'pikku-channels-meta.gen.ts');
             }
-            if (!result.typesDeclarationFile) {
-                result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.ts');
+            if (!result.channelsMapDeclarationFile) {
+                result.channelsMapDeclarationFile = join(channelDir, 'pikku-channels-map.gen.d.ts');
             }
-            if (!result.httpRoutesMapDeclarationFile) {
-                result.httpRoutesMapDeclarationFile = join(result.outDir, 'pikku-http-routes-map.gen.d.ts');
+            // RPC
+            if (!result.rpcMetaFile) {
+                result.rpcMetaFile = join(rpcDir, 'pikku-rpc-meta.gen.ts');
             }
-            if (!result.channelsMapDeclarationFile) {
-                result.channelsMapDeclarationFile = join(result.outDir, 'pikku-channels-map.gen.d.ts');
+            if (!result.rpcMapDeclarationFile) {
+                result.rpcMapDeclarationFile = join(rpcDir, 'pikku-rpc-map.gen.ts');
+            }
+            // Scheduler
+            if (!result.schedulersFile) {
+                result.schedulersFile = join(schedulerDir, 'pikku-scheduler.gen.ts');
+            }
+            if (!result.schedulersMetaFile) {
+                result.schedulersMetaFile = join(schedulerDir, 'pikku-scheduler-meta.gen.ts');
+            }
+            // Queue
+            if (!result.queueWorkersFile) {
+                result.queueWorkersFile = join(queueDir, 'pikku-queue-workers.gen.ts');
+            }
+            if (!result.queueWorkersMetaFile) {
+                result.queueWorkersMetaFile = join(queueDir, 'pikku-queue-workers-meta.gen.ts');
             }
+            if (!result.queueMapDeclarationFile) {
+                result.queueMapDeclarationFile = join(queueDir, 'pikku-queue-map.gen.ts');
+            }
+            // Services
+            if (!result.servicesFile) {
+                result.servicesFile = join(result.outDir, 'pikku-services.gen.ts');
+            }
+            // Bootstrap files
             if (!result.bootstrapFile) {
                 result.bootstrapFile = join(result.outDir, 'pikku-bootstrap.gen.ts');
             }
+            // MCP
+            if (!result.mcpEndpointsMetaFile) {
+                result.mcpEndpointsMetaFile = join(mcpDir, 'mcp-endpoints-meta.gen.ts');
+            }
+            if (!result.mcpEndpointsFile) {
+                result.mcpEndpointsFile = join(mcpDir, 'mcp-endpoints.gen.ts');
+            }
+            if (!result.mcpJsonFile) {
+                result.mcpJsonFile = join(mcpDir, 'mcp.gen.json');
+            }
             result.bootstrapFiles = result.bootstrapFiles || {};
             for (const key of Object.keys(PikkuEventTypes)) {
-                result.bootstrapFiles[key] = join(result.outDir, `pikku-bootstrap-${key}.gen.ts`);
+                const eventDir = join(result.outDir, key.toLowerCase());
+                result.bootstrapFiles[key] = join(eventDir, `pikku-bootstrap-${key}.gen.ts`);
             }
         }
         if (requiredFields.length > 0) {
@@ -120,8 +163,14 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
             }
         }
         result.filters = result.filters || {};
-        if (tags.length > 0) {
-            result.filters.tags = tags;
+        if (filters.tags && filters.tags.length > 0) {
+            result.filters.tags = filters.tags;
+        }
+        if (filters.types && filters.types.length > 0) {
+            result.filters.types = filters.types;
+        }
+        if (filters.directories && filters.directories.length > 0) {
+            result.filters.directories = filters.directories;
         }
         if (!isAbsolute(result.tsconfig)) {
             result.tsconfig = join(result.rootDir, result.tsconfig);

package/dist/src/pikku-command-schemas.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommand } from './types.js';
+export declare const pikkuSchemas: PikkuCommand;

package/dist/src/pikku-command-schemas.js

@@ -0,0 +1,8 @@
+import { generateSchemas, saveSchemas } from './schema-generator.js';
+import { logCommandInfoAndTime } from './utils.js';
+export const pikkuSchemas = async (logger, { tsconfig, schemaDirectory, supportsImportAttributes }, { functions, http }) => {
+    return await logCommandInfoAndTime(logger, 'Creating schemas', 'Created schemas', [false], async () => {
+        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta);
+        await saveSchemas(logger, schemaDirectory, schemas, functions.typesMap, functions.meta, supportsImportAttributes);
+    });
+};

package/dist/src/runtimes/nextjs/pikku-command-nextjs.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommand } from '../../types.js';
+export declare const pikkuNext: PikkuCommand;

package/dist/src/runtimes/nextjs/pikku-command-nextjs.js

@@ -0,0 +1,36 @@
+import { logCommandInfoAndTime, getPikkuFilesAndMethods, getFileImportRelativePath, writeFileInDir, } from '../../utils.js';
+import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from './serialize-nextjs-backend-wrapper.js';
+import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from './serialize-nextjs-http-wrapper.js';
+export const pikkuNext = async (logger, { nextBackendFile, nextHTTPFile, httpRoutesMapDeclarationFile, packageMappings, fetchFile, bootstrapFiles, }, visitState, options = {}) => {
+    return await logCommandInfoAndTime(logger, 'Generating nextjs wrapper', 'Generated nextjs wrapper', [
+        nextBackendFile === undefined && nextHTTPFile === undefined,
+        'nextjs outfile is not defined',
+    ], async () => {
+        if (!nextBackendFile && !nextHTTPFile) {
+            throw new Error('nextBackendFile or nextHTTPFile is required in pikku config for nextJS');
+        }
+        if (nextHTTPFile && !fetchFile) {
+            throw new Error('fetchFile is required in pikku config in order for nextJS http wrapper to work');
+        }
+        if (nextBackendFile) {
+            const { pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory, } = await getPikkuFilesAndMethods(logger, visitState, packageMappings, nextBackendFile, options, {
+                config: true,
+                singletonServicesFactory: true,
+                sessionServicesFactory: true,
+            });
+            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 httpBootstrapPath = getFileImportRelativePath(nextBackendFile, bootstrapFiles.http, packageMappings);
+            const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpRoutesMapDeclarationFile, packageMappings);
+            const content = serializeNextBackendWrapper(httpBootstrapPath, routesMapDeclarationPath, pikkuConfigImport, singletonServicesImport, sessionServicesImport);
+            await writeFileInDir(logger, nextBackendFile, content);
+        }
+        if (nextHTTPFile && fetchFile) {
+            const routesMapDeclarationPath = getFileImportRelativePath(nextHTTPFile, httpRoutesMapDeclarationFile, packageMappings);
+            const fetchPath = getFileImportRelativePath(nextHTTPFile, fetchFile, packageMappings);
+            const content = serializeNextHTTPWrapper(routesMapDeclarationPath, fetchPath);
+            await writeFileInDir(logger, nextHTTPFile, content);
+        }
+    });
+};

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

@@ -1,5 +1,6 @@
+import { CLILogger } from './utils.js';
 import { FunctionsMeta, JSONValue } from '@pikku/core';
 import { HTTPRoutesMeta } from '@pikku/core/http';
 import { TypesMap } from '@pikku/inspector';
-export declare function generateSchemas(tsconfig: string, typesMap: TypesMap, functionMeta: FunctionsMeta, httpRoutesMeta: HTTPRoutesMeta): Promise<Record<string, JSONValue>>;
-export declare function saveSchemas(schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, functionsMeta: FunctionsMeta, supportsImportAttributes: boolean): Promise<void>;
+export declare function generateSchemas(logger: CLILogger, tsconfig: string, typesMap: TypesMap, functionMeta: FunctionsMeta, httpRoutesMeta: HTTPRoutesMeta): Promise<Record<string, JSONValue>>;
+export declare function saveSchemas(logger: CLILogger, schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, functionsMeta: FunctionsMeta, supportsImportAttributes: boolean): Promise<void>;

package/dist/src/schema-generator.js

@@ -1,7 +1,7 @@
 import { createGenerator, RootlessError } from 'ts-json-schema-generator';
-import { logInfo, writeFileInDir } from './utils/utils.js';
+import { writeFileInDir } from './utils.js';
 import { mkdir, writeFile } from 'fs/promises';
-export async function generateSchemas(tsconfig, typesMap, functionMeta, httpRoutesMeta) {
+export async function generateSchemas(logger, tsconfig, typesMap, functionMeta, httpRoutesMeta) {
     const schemasSet = new Set(typesMap.customTypes.keys());
     for (const { inputs, outputs } of Object.values(functionMeta)) {
         const types = [...(inputs || []), ...(outputs || [])];
@@ -43,16 +43,16 @@ export async function generateSchemas(tsconfig, typesMap, functionMeta, httpRout
         catch (e) {
             // Ignore rootless errors
             if (e instanceof RootlessError) {
-                console.error('Error generating schema since it has no root:', schema);
+                logger.error(`Error generating schema since it has no root: ${schema}`);
                 return;
             }
-            throw e;
+            logger.error(`Error generating schema: ${schema}`);
         }
     });
     return schemas;
 }
-export async function saveSchemas(schemaParentDir, schemas, typesMap, functionsMeta, supportsImportAttributes) {
-    await writeFileInDir(`${schemaParentDir}/register.gen.ts`, 'export const empty = null;');
+export async function saveSchemas(logger, schemaParentDir, schemas, typesMap, functionsMeta, supportsImportAttributes) {
+    await writeFileInDir(logger, `${schemaParentDir}/register.gen.ts`, 'export const empty = null;');
     const desiredSchemas = new Set([
         ...Object.values(functionsMeta)
             .map(({ inputs, outputs }) => [
@@ -65,7 +65,7 @@ export async function saveSchemas(schemaParentDir, schemas, typesMap, functionsM
         ...typesMap.customTypes.keys(),
     ]);
     if (desiredSchemas.size === 0) {
-        logInfo(`• Skipping schemas since none found.\x1b[0m`);
+        logger.info(`• Skipping schemas since none found.\x1b[0m`);
         return;
     }
     await mkdir(`${schemaParentDir}/schemas`, { recursive: true });
@@ -80,6 +80,6 @@ import * as ${schema} from './schemas/${schema}.schema.json' ${supportsImportAtt
 addSchema('${schema}', ${schema})
 `)
         .join('\n');
-    await writeFileInDir(`${schemaParentDir}/register.gen.ts`, `import { addSchema } from '@pikku/core/schema'
-${schemaImports}`);
+    await writeFileInDir(logger, `${schemaParentDir}/register.gen.ts`, `import { addSchema } from '@pikku/core/schema'
+${schemaImports}`, { logWrite: true });
 }

package/dist/src/schemas.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommand } from './types.js';
+export declare const pikkuSchemas: PikkuCommand;

package/dist/src/schemas.js

@@ -0,0 +1,8 @@
+import { saveSchemas, generateSchemas } from './schema-generator.js';
+import { logCommandInfoAndTime } from './utils.js';
+export const pikkuSchemas = async (logger, { tsconfig, schemaDirectory, supportsImportAttributes }, { functions, http }) => {
+    return await logCommandInfoAndTime(logger, 'Creating schemas', 'Created schemas', [false], async () => {
+        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta);
+        await saveSchemas(logger, schemaDirectory, schemas, functions.typesMap, functions.meta, supportsImportAttributes);
+    });
+};

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

@@ -8,6 +8,9 @@ export const serializeImportMap = (relativeToPath, packageMappings, typesMap, re
             return;
         }
         const variables = paths.get(path) || [];
+        if (uniqueName === '__object') {
+            return;
+        }
         if (originalName === uniqueName) {
             variables.push(originalName);
         }