@pikku/cli 0.9.14 → 0.9.16-next.0

package/dist/src/utils/pikku-files-and-methods.js

@@ -0,0 +1,70 @@
+const getMetaTypes = (type, map, desiredType) => {
+    const errors = new Map();
+    if (desiredType) {
+        for (const [file, meta] of map.entries()) {
+            for (const { type: entryType, variable, typePath } of meta) {
+                if (entryType === desiredType) {
+                    if (entryType === null || typePath === null) {
+                        throw new Error(`Unknown state due to metaType calculation: entryType or typePath is null for ${desiredType} in ${file}`);
+                    }
+                    return { file, variable, type: entryType, typePath, errors };
+                }
+            }
+        }
+        errors.set(`No ${desiredType} found that extends ${type}`, map);
+        return;
+    }
+    const totalValues = Array.from(map.values()).flat();
+    if (totalValues.length === 0) {
+        const helpMessage = type === 'CoreConfig'
+            ? `No ${type} found. Make sure you have exported a createConfig function in your codebase:\n\n` +
+                `export const createConfig: CreateConfig<Config> = async () => {\n` +
+                `  return {}\n` +
+                `}\n\n` +
+                `Possible issues:\n` +
+                `- srcDirectories in pikku.config.json doesn't include the file with the createConfig method`
+            : `No ${type} found`;
+        errors.set(helpMessage, map);
+    }
+    else if (totalValues.length > 1) {
+        errors.set(`More than one ${type} found`, map);
+    }
+    else {
+        const entry = Array.from(map.entries())[0];
+        if (entry) {
+            const [file, [{ type: entryType, variable, typePath }]] = entry;
+            if (entryType === null || typePath === null) {
+                throw new Error(`Unknown state due to metaType calculation: entryType or typePath is null for ${type} in ${file}`);
+            }
+            return { file, type: entryType, variable, typePath, errors };
+        }
+    }
+    return;
+};
+/**
+ * @deprecated Use state.filesAndMethods from InspectorState instead
+ */
+export const getPikkuFilesAndMethods = async (state, options = {}) => {
+    const { singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, } = state;
+    const { configFileType, userSessionType, singletonServicesFactoryType, sessionServicesFactoryType, } = options;
+    let errors = new Map();
+    const result = {
+        userSessionType: getMetaTypes('CoreUserSession', userSessionTypeImportMap, userSessionType),
+        singletonServicesType: getMetaTypes('CoreSingletonServices', singletonServicesTypeImportMap),
+        sessionServicesType: getMetaTypes('CoreServices', sessionServicesTypeImportMap),
+        pikkuConfigFactory: getMetaTypes('CoreConfig', configFactories, configFileType),
+        singletonServicesFactory: getMetaTypes('CreateSingletonServices', singletonServicesFactories, singletonServicesFactoryType),
+        sessionServicesFactory: getMetaTypes('CreateSessionServices', sessionServicesFactories, sessionServicesFactoryType),
+    };
+    if (errors.size > 0) {
+        const result = ['Found errors:'];
+        errors.forEach((filesAndMethods, message) => {
+            result.push(`- ${message}`);
+            filesAndMethods.forEach((methods, file) => {
+                result.push(`\t* methods: ${methods.map(({ variable, type }) => `${variable}: ${type}`).join(', ')}`);
+            });
+        });
+        throw new Error(result.join('\n'));
+    }
+    return result;
+};

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

@@ -1,6 +1,6 @@
-import { CLILogger } from './utils.js';
 import { FunctionsMeta, JSONValue } from '@pikku/core';
 import { HTTPWiringsMeta } from '@pikku/core/http';
 import { TypesMap } from '@pikku/inspector';
+import { CLILogger } from '../services/cli-logger.service.js';
 export declare function generateSchemas(logger: CLILogger, tsconfig: string, typesMap: TypesMap, functionMeta: FunctionsMeta, httpWiringsMeta: HTTPWiringsMeta, additionalTypes?: string[]): Promise<Record<string, JSONValue>>;
 export declare function saveSchemas(logger: CLILogger, schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, functionsMeta: FunctionsMeta, supportsImportAttributes: boolean, additionalTypes?: string[]): Promise<void>;

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

@@ -1,5 +1,5 @@
 import { createGenerator, RootlessError } from 'ts-json-schema-generator';
-import { writeFileInDir } from './utils.js';
+import { writeFileInDir } from './file-writer.js';
 import { mkdir, writeFile } from 'fs/promises';
 export async function generateSchemas(logger, tsconfig, typesMap, functionMeta, httpWiringsMeta, additionalTypes) {
     const schemasSet = new Set(typesMap.customTypes.keys());

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

@@ -1,4 +1,4 @@
-import { getFileImportRelativePath } from './utils.js';
+import { getFileImportRelativePath } from './file-import-path.js';
 export const serializeImportMap = (relativeToPath, packageMappings, typesMap, requiredTypes) => {
     const paths = new Map();
     Array.from(requiredTypes).forEach((requiredType) => {

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../bin/pikku-all.ts","../bin/pikku-fetch.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-queue-service.ts","../bin/pikku-rpc.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/pikku-cli-config.ts","../src/pikku-command-schemas.ts","../src/schema-generator.ts","../src/schemas.ts","../src/serialize-import-map.ts","../src/serialize-pikku-types.ts","../src/types.ts","../src/utils.ts","../src/runtimes/nextjs/pikku-command-nextjs.ts","../src/runtimes/nextjs/serialize-nextjs-backend-wrapper.ts","../src/runtimes/nextjs/serialize-nextjs-http-wrapper.ts","../src/wirings/channels/pikku-channels.ts","../src/wirings/channels/pikku-command-channels-map.ts","../src/wirings/channels/pikku-command-channels.ts","../src/wirings/channels/pikku-command-websocket-typed.ts","../src/wirings/channels/serialize-typed-channel-map.ts","../src/wirings/channels/serialize-websocket-wrapper.ts","../src/wirings/fetch/index.ts","../src/wirings/functions/pikku-command-function-types.ts","../src/wirings/functions/pikku-command-functions.ts","../src/wirings/functions/pikku-command-services.ts","../src/wirings/functions/pikku-function-types.ts","../src/wirings/functions/serialize-function-imports.ts","../src/wirings/http/openapi-spec-generator.ts","../src/wirings/http/pikku-command-http-map.ts","../src/wirings/http/pikku-command-http-routes.ts","../src/wirings/http/pikku-command-openapi.ts","../src/wirings/http/pikku-http-routes.ts","../src/wirings/http/serialize-fetch-wrapper.ts","../src/wirings/http/serialize-typed-http-map.ts","../src/wirings/mcp/pikku-command-mcp-json.ts","../src/wirings/mcp/pikku-command-mcp.ts","../src/wirings/mcp/serialize-mcp-json.ts","../src/wirings/queue/pikku-command-queue-map.ts","../src/wirings/queue/pikku-command-queue-service.ts","../src/wirings/queue/pikku-command-queue.ts","../src/wirings/queue/pikku-queue-map.ts","../src/wirings/queue/pikku-queue.ts","../src/wirings/queue/serialize-queue-map.ts","../src/wirings/queue/serialize-queue-meta.ts","../src/wirings/queue/serialize-queue-wrapper.ts","../src/wirings/rpc/pikku-command-rpc-client.ts","../src/wirings/rpc/pikku-command-rpc-map.ts","../src/wirings/rpc/pikku-command-rpc.ts","../src/wirings/rpc/serialize-rpc-wrapper.ts","../src/wirings/rpc/serialize-typed-rpc-map.ts","../src/wirings/scheduler/pikku-command-scheduler.ts","../src/wirings/scheduler/serialize-scheduler-meta.ts"],"version":"5.9.2"}
+{"root":["../bin/pikku.ts","../src/cli.wiring.ts","../src/serialize-pikku-types.ts","../src/services.ts","../src/functions/commands/all.ts","../src/functions/commands/watch.ts","../src/functions/runtimes/nextjs/pikku-command-nextjs.ts","../src/functions/runtimes/nextjs/serialize-nextjs-backend-wrapper.ts","../src/functions/runtimes/nextjs/serialize-nextjs-http-wrapper.ts","../src/functions/wirings/channels/pikku-channels.ts","../src/functions/wirings/channels/pikku-command-channel-types.ts","../src/functions/wirings/channels/pikku-command-channels-map.ts","../src/functions/wirings/channels/pikku-command-channels.ts","../src/functions/wirings/channels/pikku-command-websocket-typed.ts","../src/functions/wirings/channels/serialize-channel-types.ts","../src/functions/wirings/channels/serialize-typed-channel-map.ts","../src/functions/wirings/channels/serialize-websocket-wrapper.ts","../src/functions/wirings/cli/pikku-command-cli-entry.ts","../src/functions/wirings/cli/pikku-command-cli-types.ts","../src/functions/wirings/cli/pikku-command-cli.ts","../src/functions/wirings/cli/serialize-channel-cli-client.ts","../src/functions/wirings/cli/serialize-channel-cli.ts","../src/functions/wirings/cli/serialize-cli-types.ts","../src/functions/wirings/cli/serialize-local-cli-bootstrap.ts","../src/functions/wirings/fetch/index.ts","../src/functions/wirings/functions/pikku-command-function-types-split.ts","../src/functions/wirings/functions/pikku-command-function-types.ts","../src/functions/wirings/functions/pikku-command-functions.ts","../src/functions/wirings/functions/pikku-command-services.ts","../src/functions/wirings/functions/pikku-function-types.ts","../src/functions/wirings/functions/schemas.ts","../src/functions/wirings/functions/serialize-function-imports.ts","../src/functions/wirings/functions/serialize-function-types.ts","../src/functions/wirings/functions/serialize-pikku-types-hub.ts","../src/functions/wirings/http/openapi-spec-generator.ts","../src/functions/wirings/http/pikku-command-http-map.ts","../src/functions/wirings/http/pikku-command-http-routes.ts","../src/functions/wirings/http/pikku-command-http-types.ts","../src/functions/wirings/http/pikku-command-openapi.ts","../src/functions/wirings/http/pikku-http-routes.ts","../src/functions/wirings/http/serialize-fetch-wrapper.ts","../src/functions/wirings/http/serialize-http-types.ts","../src/functions/wirings/http/serialize-typed-http-map.ts","../src/functions/wirings/mcp/pikku-command-mcp-json.ts","../src/functions/wirings/mcp/pikku-command-mcp-types.ts","../src/functions/wirings/mcp/pikku-command-mcp.ts","../src/functions/wirings/mcp/serialize-mcp-json.ts","../src/functions/wirings/mcp/serialize-mcp-types.ts","../src/functions/wirings/middleware/pikku-command-middleware.ts","../src/functions/wirings/middleware/serialize-middleware-groups-meta.ts","../src/functions/wirings/middleware/serialize-middleware-imports.ts","../src/functions/wirings/queue/pikku-command-queue-map.ts","../src/functions/wirings/queue/pikku-command-queue-service.ts","../src/functions/wirings/queue/pikku-command-queue-types.ts","../src/functions/wirings/queue/pikku-command-queue.ts","../src/functions/wirings/queue/pikku-queue-map.ts","../src/functions/wirings/queue/pikku-queue.ts","../src/functions/wirings/queue/serialize-queue-map.ts","../src/functions/wirings/queue/serialize-queue-meta.ts","../src/functions/wirings/queue/serialize-queue-types.ts","../src/functions/wirings/queue/serialize-queue-wrapper.ts","../src/functions/wirings/rpc/pikku-command-rpc-client.ts","../src/functions/wirings/rpc/pikku-command-rpc-map.ts","../src/functions/wirings/rpc/pikku-command-rpc.ts","../src/functions/wirings/rpc/serialize-rpc-wrapper.ts","../src/functions/wirings/rpc/serialize-typed-rpc-map.ts","../src/functions/wirings/scheduler/pikku-command-scheduler-types.ts","../src/functions/wirings/scheduler/pikku-command-scheduler.ts","../src/functions/wirings/scheduler/serialize-scheduler-meta.ts","../src/functions/wirings/scheduler/serialize-scheduler-types.ts","../src/middleware/log-command-info-and-time.ts","../src/services/cli-logger-forwarder.service.ts","../src/services/cli-logger.service.ts","../src/utils/check-required-types.ts","../src/utils/custom-types-generator.ts","../src/utils/file-import-path.ts","../src/utils/file-imports-serializer.ts","../src/utils/file-writer.ts","../src/utils/generate-bootstrap-file.ts","../src/utils/pikku-cli-config.ts","../src/utils/pikku-files-and-methods.ts","../src/utils/schema-generator.ts","../src/utils/serialize-import-map.ts","../.pikku/pikku-bootstrap.gen.ts","../.pikku/pikku-services.gen.ts","../.pikku/pikku-types.gen.ts","../.pikku/channel/pikku-channel-types.gen.ts","../.pikku/cli/pikku-cli-types.gen.ts","../.pikku/cli/pikku-cli-wirings-meta.gen.ts","../.pikku/cli/pikku-cli-wirings.gen.ts","../.pikku/function/pikku-function-types.gen.ts","../.pikku/function/pikku-functions-meta.gen.ts","../.pikku/function/pikku-functions-meta.min.gen.ts","../.pikku/function/pikku-functions.gen.ts","../.pikku/http/pikku-http-types.gen.ts","../.pikku/mcp/pikku-mcp-types.gen.ts","../.pikku/queue/pikku-queue-types.gen.ts","../.pikku/rpc/pikku-rpc-wirings-map.gen.d.ts","../.pikku/rpc/pikku-rpc-wirings-map.internal.gen.d.ts","../.pikku/rpc/pikku-rpc-wirings-meta.internal.gen.ts","../.pikku/scheduler/pikku-scheduler-types.gen.ts","../.pikku/schemas/register.gen.ts","../types/application-types.d.ts","../types/config.d.ts"],"version":"5.9.2"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.9.14",
+  "version": "0.9.16-next.0",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "bin": {
@@ -11,9 +11,9 @@
   "module": "dist/bin/pikku.js",
   "scripts": {
     "tsc": "tsc",
-    "build:esm": "tsc -b",
-    "schema": "ts-json-schema-generator -o cli.schema.json --path 'src/pikku-cli-config.ts' --type 'PikkuCLIConfig'",
-    "build": "yarn build:esm && yarn schema",
+    "schema": "ts-json-schema-generator -o cli.schema.json --path 'src/utils/pikku-cli-config.ts' --type 'PikkuCLIConfig'",
+    "build": "yarn build:esm",
+    "build:esm": "./build.sh",
     "ncu": "npx npm-check-updates -x '/.*glob.*/'",
     "release": "yarn build && npm test",
     "test": "bash run-tests.sh",
@@ -22,8 +22,8 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.0.2",
-    "@pikku/core": "^0.9.9",
-    "@pikku/inspector": "^0.9.5",
+    "@pikku/core": "^0.9.12-next.0",
+    "@pikku/inspector": "^0.9.6-next.0",
     "@types/cookie": "^1.0.0",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.5.0",

package/pikku.config.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://raw.githubusercontent.com/pikkujs/pikku/refs/heads/main/packages/cli/cli.schema.json",
+  "tsconfig": "./tsconfig.json",
+  "srcDirectories": ["src", "bin", "types"],
+  "outDir": ".pikku",
+  "packageMappings": {
+    "../inspector/src": "@pikku/inspector"
+  },
+  "supportsImportAttributes": true,
+  "schemasFromTypes": ["PikkuCLIConfig"],
+  "websocketFile": ".pikku/pikku-websocket.gen.ts",
+  "cli": {
+    "entrypoints": {
+      "pikku": [
+        ".pikku/cli/pikku-cli.gen.ts",
+        {
+          "type": "channel",
+          "wirePath": ".pikku/cli/pikku-channel.wire.gen.ts",
+          "path": ".pikku/cli/pikku-channel.client.gen.ts"
+        }
+      ]
+    }
+  }
+}

package/src/cli.wiring.ts

@@ -0,0 +1,75 @@
+// import { pikkuSchemas } from './functions/wirings/functions/schemas.js'
+// import { pikkuFetch } from './functions/wirings/fetch/index.js'
+// import { pikkuWebSocketTyped } from './functions/wirings/channels/pikku-command-websocket-typed.js'
+// import { pikkuRPCClient } from './functions/wirings/rpc/pikku-command-rpc-client.js'
+// import { pikkuQueueService } from './functions/wirings/queue/pikku-command-queue-service.js'
+// import { pikkuOpenAPI } from './functions/wirings/http/pikku-command-openapi.js'
+// import { pikkuNext } from './functions/runtimes/nextjs/pikku-command-nextjs.js'
+// import { pikkuCLICommand, wireCLI } from '../.pikku/cli/pikku-cli-types.gen.js'
+// import { all } from './functions/commands/all.js'
+// import { defaultCLIRenderer } from './services.js'
+
+// wireCLI({
+//   program: 'pikku',
+//   description:
+//     'Pikku CLI - Code generation tool for type-safe backend development',
+//   render: defaultCLIRenderer,
+//   options: {
+//     config: {
+//       description: 'Path to pikku.config.json file',
+//       short: 'c',
+//     },
+//     logLevel: {
+//       description: 'Set log level',
+//       default: 'info',
+//       short: 'l',
+//     },
+//   },
+//   commands: {
+//     all: pikkuCLICommand({
+//       func: all,
+//       description: 'Generate all Pikku files (types, schemas, wirings, etc.)',
+//       options: {
+//         tags: {
+//           description: 'Filter functions by tags (comma-separated)',
+//           short: 't',
+//         },
+//         types: {
+//           description: 'Filter functions by types (comma-separated)',
+//         },
+//         directories: {
+//           description: 'Filter functions by directories (comma-separated)',
+//           short: 'd',
+//         },
+//       },
+//     }),
+//     schemas: pikkuCLICommand({
+//       func: pikkuSchemas,
+//       description: 'Generate JSON schemas for function input/output types',
+//     }),
+//     fetch: pikkuCLICommand({
+//       func: pikkuFetch,
+//       description: 'Generate type-safe HTTP fetch client',
+//     }),
+//     websocket: pikkuCLICommand({
+//       func: pikkuWebSocketTyped,
+//       description: 'Generate type-safe WebSocket client',
+//     }),
+//     rpc: pikkuCLICommand({
+//       func: pikkuRPCClient,
+//       description: 'Generate RPC client wrappers',
+//     }),
+//     'queue-service': pikkuCLICommand({
+//       func: pikkuQueueService,
+//       description: 'Generate queue service wrapper',
+//     }),
+//     openapi: pikkuCLICommand({
+//       func: pikkuOpenAPI,
+//       description: 'Generate OpenAPI specification from HTTP routes',
+//     }),
+//     nextjs: pikkuCLICommand({
+//       func: pikkuNext,
+//       description: 'Generate Next.js backend and HTTP wrappers',
+//     }),
+//   },
+// })

package/src/functions/commands/all.ts

@@ -0,0 +1,141 @@
+import { existsSync } from 'fs'
+import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js'
+import { getFileImportRelativePath } from '../../utils/file-import-path.js'
+import { writeFileInDir } from '../../utils/file-writer.js'
+
+export const all: any = pikkuVoidFunc({
+  func: async ({ logger, config, rpc, getInspectorState }) => {
+    const allImports: string[] = []
+    let typesDeclarationFileExists = true
+
+    if (!existsSync(config.typesDeclarationFile)) {
+      typesDeclarationFileExists = false
+    }
+
+    await rpc.invoke('pikkuFunctionTypes', null)
+
+    // This is needed since the wireHTTP function will add the routes to the visitState
+    if (!typesDeclarationFileExists) {
+      logger.info(`• Type file first created, inspecting again...\x1b[0m`)
+      await getInspectorState(true)
+    }
+
+    // Generate wiring-specific type files for tree-shaking
+    await rpc.invoke('pikkuFunctionTypesSplit', null)
+    await rpc.invoke('pikkuHTTPTypes', null)
+    await rpc.invoke('pikkuChannelTypes', null)
+    await rpc.invoke('pikkuSchedulerTypes', null)
+    await rpc.invoke('pikkuQueueTypes', null)
+    await rpc.invoke('pikkuMCPTypes', null)
+    await rpc.invoke('pikkuCLITypes', null)
+
+    const hasFunctionRegistrations = await rpc.invoke('pikkuFunctions', null)
+
+    // Generate and register middleware
+    const middleware = await rpc.invoke('pikkuMiddleware', null)
+    // Middleware must be imported before functions meta to ensure registration happens first
+    if (middleware) {
+      allImports.push(config.middlewareFile)
+    }
+
+    // Always import functions meta (needed for all function metadata)
+    allImports.push(config.functionsMetaFile)
+
+    // Only import functionsFile if it was generated (has internal/external RPCs)
+    if (hasFunctionRegistrations) {
+      allImports.push(config.functionsFile)
+    }
+
+    // Generate services map
+    await rpc.invoke('pikkuServices', null)
+
+    const hasInternalRPCs = await rpc.invoke('pikkuRPC', null)
+    await rpc.invoke('pikkuRPCInternalMap', null)
+    await rpc.invoke('pikkuRPCExposedMap', null)
+    await rpc.invoke('pikkuRPCClient', null)
+
+    if (hasInternalRPCs) {
+      allImports.push(config.rpcInternalWiringMetaFile)
+    }
+
+    const schemas = await rpc.invoke('pikkuSchemas', null)
+    if (schemas) {
+      allImports.push(`${config.schemaDirectory}/register.gen.ts`)
+    }
+
+    // Generate HTTP
+    const http = await rpc.invoke('pikkuHTTP', null)
+    if (http) {
+      await rpc.invoke('pikkuHTTPMap', null)
+      await rpc.invoke('pikkuFetch', null)
+      allImports.push(config.httpWiringMetaFile, config.httpWiringsFile)
+    }
+
+    // Generate Scheduler
+    const scheduler = await rpc.invoke('pikkuScheduler', null)
+    if (scheduler) {
+      allImports.push(
+        config.schedulersWiringMetaFile,
+        config.schedulersWiringFile
+      )
+    }
+
+    // Generate Queues
+    const queues = await rpc.invoke('pikkuQueue', null)
+    if (queues) {
+      await rpc.invoke('pikkuQueueMap', null)
+      await rpc.invoke('pikkuQueueService', null)
+      allImports.push(
+        config.queueWorkersWiringMetaFile,
+        config.queueWorkersWiringFile
+      )
+    }
+
+    // Generate Channels
+    const channels = await rpc.invoke('pikkuChannels', null)
+    if (channels) {
+      await rpc.invoke('pikkuChannelsMap', null)
+      await rpc.invoke('pikkuWebSocketTyped', null)
+      allImports.push(config.channelsWiringMetaFile, config.channelsWiringFile)
+    }
+
+    // Generate MCP
+    const mcp = await rpc.invoke('pikkuMCP', null)
+    if (mcp) {
+      await rpc.invoke('pikkuMCPJSON', null)
+      allImports.push(config.mcpWiringsMetaFile, config.mcpWiringsFile)
+    }
+
+    // Generate CLI
+    const cli = await rpc.invoke('pikkuCLI', null)
+    if (cli) {
+      await rpc.invoke('pikkuCLIEntry', null)
+      allImports.push(config.cliWiringMetaFile, config.cliWiringsFile)
+    }
+
+    if (config.nextBackendFile || config.nextHTTPFile) {
+      await rpc.invoke('pikkuNext', null)
+    }
+
+    if (config.openAPI) {
+      logger.info(
+        `• OpenAPI requires a reinspection to pickup new generated types..`
+      )
+      await getInspectorState(true)
+      await rpc.invoke('pikkuOpenAPI', null)
+    }
+
+    // Generate main bootstrap file (pass all imports directly since this is the main file)
+    await writeFileInDir(
+      logger,
+      config.bootstrapFile,
+      allImports
+        .map(
+          (to) =>
+            `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`
+        )
+        .sort((to) => (to.includes('meta') ? -1 : 1)) // Ensure meta files are at the top
+        .join('\n')
+    )
+  },
+})

package/src/functions/commands/watch.ts

@@ -0,0 +1,58 @@
+import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js'
+import chokidar from 'chokidar'
+
+export const watch: any = pikkuVoidFunc({
+  func: async ({ logger, config, rpc }) => {
+    const configWatcher = chokidar.watch(config.srcDirectories, {
+      ignoreInitial: true,
+      ignored: /.*\.gen\.tsx?/,
+    })
+
+    let watcher = new chokidar.FSWatcher({})
+
+    const generatorWatcher = () => {
+      watcher.close()
+
+      logger.info(
+        `• Watching directories: \n  - ${config.srcDirectories.join('\n  - ')}`
+      )
+      watcher = chokidar.watch(config.srcDirectories, {
+        ignoreInitial: true,
+        ignored: /.*\.gen\.ts/,
+      })
+
+      watcher.on('ready', async () => {
+        const handle = async () => {
+          try {
+            const start = Date.now()
+            await rpc.invoke('all', null)
+            logger.info({
+              message: `✓ Generated in ${Date.now() - start}ms`,
+              type: 'timing',
+            })
+          } catch (err) {
+            logger.error(err)
+          }
+        }
+
+        await handle()
+
+        let timeout: ReturnType<typeof setTimeout> | undefined
+
+        const deduped = (_file: string) => {
+          if (timeout) {
+            clearTimeout(timeout)
+          }
+          timeout = setTimeout(handle, 10)
+        }
+
+        watcher.on('change', deduped)
+        watcher.on('add', deduped)
+        watcher.on('unlink', deduped)
+      })
+    }
+
+    configWatcher.on('ready', generatorWatcher)
+    configWatcher.on('change', generatorWatcher)
+  },
+})

package/src/functions/runtimes/nextjs/pikku-command-nextjs.ts

@@ -0,0 +1,111 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { checkRequiredTypes } from '../../../utils/check-required-types.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from './serialize-nextjs-backend-wrapper.js'
+import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from './serialize-nextjs-http-wrapper.js'
+
+export const pikkuNext: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const {
+      nextBackendFile,
+      nextHTTPFile,
+      httpMapDeclarationFile,
+      packageMappings,
+      fetchFile,
+      bootstrapFiles,
+    } = config
+    const visitState = await getInspectorState()
+
+    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) {
+      // Check for required types
+      checkRequiredTypes(visitState.filesAndMethodsErrors, {
+        config: true,
+        singletonServicesFactory: true,
+        sessionServicesFactory: true,
+      })
+
+      const {
+        pikkuConfigFactory,
+        singletonServicesFactory,
+        sessionServicesFactory,
+      } = visitState.filesAndMethods
+
+      if (
+        !pikkuConfigFactory ||
+        !singletonServicesFactory ||
+        !sessionServicesFactory
+      ) {
+        throw new Error('Required types not found')
+      }
+
+      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,
+        httpMapDeclarationFile,
+        packageMappings
+      )
+
+      const content = serializeNextBackendWrapper(
+        httpBootstrapPath,
+        routesMapDeclarationPath,
+        pikkuConfigImport,
+        singletonServicesImport,
+        sessionServicesImport
+      )
+      await writeFileInDir(logger, nextBackendFile, content)
+    }
+
+    if (nextHTTPFile && fetchFile) {
+      const routesMapDeclarationPath = getFileImportRelativePath(
+        nextHTTPFile,
+        httpMapDeclarationFile,
+        packageMappings
+      )
+
+      const fetchPath = getFileImportRelativePath(
+        nextHTTPFile,
+        fetchFile,
+        packageMappings
+      )
+
+      const content = serializeNextHTTPWrapper(
+        routesMapDeclarationPath,
+        fetchPath
+      )
+      await writeFileInDir(logger, nextHTTPFile, content)
+    }
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Generating nextjs wrapper',
+      commandEnd: 'Generated nextjs wrapper',
+      skipCondition: ({ config }) =>
+        config.nextBackendFile === undefined &&
+        config.nextHTTPFile === undefined,
+      skipMessage: 'nextjs outfile is not defined',
+    }),
+  ],
+})

package/src/functions/wirings/channels/pikku-channels.ts

@@ -0,0 +1,40 @@
+import { pikkuVoidFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { serializeFileImports } from '../../../utils/file-imports-serializer.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+
+export const pikkuChannels: any = pikkuVoidFunc({
+  func: async ({ logger, config, getInspectorState }) => {
+    const visitState = await getInspectorState()
+    const { channelsWiringFile, channelsWiringMetaFile, packageMappings } =
+      config
+    const { channels } = visitState
+
+    await writeFileInDir(
+      logger,
+      channelsWiringFile,
+      serializeFileImports(
+        'addChannel',
+        channelsWiringFile,
+        channels.files,
+        packageMappings
+      )
+    )
+    await writeFileInDir(
+      logger,
+      channelsWiringMetaFile,
+      `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`
+    )
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Finding Channels',
+      commandEnd: 'Found channels',
+      skipCondition: async ({ getInspectorState }: any) => {
+        const visitState = await getInspectorState()
+        return visitState.channels.files.size === 0
+      },
+      skipMessage: 'none found',
+    }),
+  ],
+})

package/src/functions/wirings/channels/pikku-command-channel-types.ts

@@ -0,0 +1,27 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializeChannelTypes } from './serialize-channel-types.js'
+
+export const pikkuChannelTypes: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config }) => {
+    const { channelsTypesFile, functionTypesFile, packageMappings } = config
+
+    const functionTypesImportPath = getFileImportRelativePath(
+      channelsTypesFile,
+      functionTypesFile,
+      packageMappings
+    )
+    const content = serializeChannelTypes(functionTypesImportPath)
+    await writeFileInDir(logger, channelsTypesFile, content)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating channel types',
+      commandEnd: 'Created channel types',
+      skipCondition: false,
+      skipMessage: '',
+    }),
+  ],
+})