@pikku/cli 0.7.7 → 0.8.0

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-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/{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);

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,10 +1,10 @@
 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);
     });

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,11 @@ export interface PikkuCLICoreOutputFiles {
     rpcMapDeclarationFile: string;
     schedulersFile: string;
     schedulersMetaFile: string;
+    queueWorkersFile: string;
+    queueWorkersMetaFile: string;
+    queueMapDeclarationFile: string;
+    mcpEndpointsFile: string;
+    mcpEndpointsMetaFile: string;
     bootstrapFile: string;
     bootstrapFiles: Record<PikkuEventTypes, string>;
 }
@@ -33,6 +38,8 @@ export type PikkuCLIConfig = {
     nextHTTPFile?: string;
     fetchFile?: string;
     websocketFile?: string;
+    queueFile?: string;
+    mcpJsonFile?: string;
     openAPI?: {
         outputFile: string;
         additionalInfo: OpenAPISpecInfo;

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

@@ -6,6 +6,8 @@ const CONFIG_DIR_FILES = [
     'nextHTTPFile',
     'fetchFile',
     'websocketFile',
+    'queueFile',
+    'mcpJsonFile',
 ];
 export const getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags = [], exitProcess = false) => {
     const config = await _getPikkuCLIConfig(configFile, requiredFields, tags, exitProcess);
@@ -54,54 +56,89 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
             };
         }
         if (result.outDir) {
+            // Create transport/event directories
+            const httpDir = join(result.outDir, 'http');
+            const channelsDir = join(result.outDir, 'channels');
+            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');
             }
             if (!result.functionsMetaFile) {
                 result.functionsMetaFile = join(result.outDir, '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(channelsDir, 'pikku-channels.gen.ts');
             }
             if (!result.channelsMetaFile) {
-                result.channelsMetaFile = join(result.outDir, 'pikku-channels-meta.gen.ts');
+                result.channelsMetaFile = join(channelsDir, 'pikku-channels-meta.gen.ts');
             }
-            if (!result.typesDeclarationFile) {
-                result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.ts');
+            if (!result.channelsMapDeclarationFile) {
+                result.channelsMapDeclarationFile = join(channelsDir, '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-schedules.gen.ts');
+            }
+            if (!result.schedulersMetaFile) {
+                result.schedulersMetaFile = join(schedulerDir, 'pikku-schedules-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');
+            }
+            // 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) {

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 || [])];
@@ -51,8 +51,8 @@ export async function generateSchemas(tsconfig, typesMap, functionMeta, httpRout
     });
     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);
         }