@pikku/cli 0.9.15 → 0.10.0

package/src/functions/commands/all.ts

@@ -0,0 +1,153 @@
+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)
+    }
+
+    // Generate and register permissions
+    const permissions = await rpc.invoke('pikkuPermissions', null)
+    // Permissions must be imported before functions meta to ensure registration happens first
+    if (permissions) {
+      allImports.push(config.permissionsFile)
+    }
+
+    // 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')
+    )
+
+    // Check for critical errors and exit if any were logged
+    if (logger.hasCriticalErrors()) {
+      process.exit(1)
+    }
+  },
+})

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,
+    } = config
+
+    // If both files are undefined, clean up any existing files and return
+    if (!nextBackendFile && !nextHTTPFile) {
+      logger.info({
+        message:
+          'Skipping generating nextjs wrapper since nextjs outfile is not defined.',
+        type: 'skip',
+      })
+      return
+    }
+
+    const visitState = await getInspectorState()
+
+    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 bootstrapPath = getFileImportRelativePath(
+        nextBackendFile,
+        config.bootstrapFile,
+        packageMappings
+      )
+
+      const routesMapDeclarationPath = getFileImportRelativePath(
+        nextBackendFile,
+        httpMapDeclarationFile,
+        packageMappings
+      )
+
+      const content = serializeNextBackendWrapper(
+        bootstrapPath,
+        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',
+    }),
+  ],
+})

package/src/{runtimes → functions/runtimes}/nextjs/serialize-nextjs-backend-wrapper.ts

@@ -1,5 +1,5 @@
 export const serializeNextJsBackendWrapper = (
-  httpBootstrapPath: string,
+  bootstrapPath: string,
   routesMapPath: string,
   configImport: string,
   singleServicesFactoryImport: string,
@@ -18,7 +18,7 @@ ${configImport}
 ${singleServicesFactoryImport}
 ${sessionServicesImport}
 
-import '${httpBootstrapPath}'
+import '${bootstrapPath}'
 
 let _pikku: PikkuNextJS | undefined
 

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

@@ -0,0 +1,35 @@
+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',
+    }),
+  ],
+})

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

@@ -0,0 +1,25 @@
+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',
+    }),
+  ],
+})

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

@@ -0,0 +1,26 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializeTypedChannelsMap } from './serialize-typed-channel-map.js'
+
+export const pikkuChannelsMap: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const state = await getInspectorState()
+    const { channelsMapDeclarationFile, packageMappings } = config
+
+    const content = serializeTypedChannelsMap(
+      channelsMapDeclarationFile,
+      packageMappings,
+      state.functions.typesMap,
+      state.functions.meta,
+      state.channels.meta
+    )
+    await writeFileInDir(logger, channelsMapDeclarationFile, content)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating channels map',
+      commandEnd: 'Created channels map',
+    }),
+  ],
+})

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

@@ -0,0 +1,40 @@
+import { pikkuSessionlessFunc } 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 = pikkuSessionlessFunc<
+  void,
+  boolean | undefined
+>({
+  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)})`
+    )
+
+    return true
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Finding Channels',
+      commandEnd: 'Found channels',
+    }),
+  ],
+})

package/src/functions/wirings/channels/pikku-command-websocket-typed.ts

@@ -0,0 +1,37 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.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 { serializeWebsocketWrapper } from './serialize-websocket-wrapper.js'
+
+export const pikkuWebSocketTyped: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config }) => {
+    const { websocketFile, channelsMapDeclarationFile, packageMappings } =
+      config
+
+    // If websocketFile is not set, clean up any existing file and return
+    if (!websocketFile) {
+      logger.info({
+        message:
+          "Skipping generating websocket wrapper since websocketFile isn't set in the pikku config.",
+        type: 'skip',
+      })
+      return
+    }
+
+    const channelsMapDeclarationPath = getFileImportRelativePath(
+      websocketFile,
+      channelsMapDeclarationFile,
+      packageMappings
+    )
+
+    const content = [serializeWebsocketWrapper(channelsMapDeclarationPath)]
+    await writeFileInDir(logger, websocketFile, content.join('\n'))
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Generating websocket wrapper',
+      commandEnd: 'Generated websocket wrapper',
+    }),
+  ],
+})

package/src/functions/wirings/channels/serialize-channel-types.ts

@@ -0,0 +1,94 @@
+/**
+ * Generates type definitions for WebSocket channel wirings
+ */
+export const serializeChannelTypes = (functionTypesImportPath: string) => {
+  return `/**
+
+ * Channel-specific type definitions for tree-shaking optimization
+ */
+
+import { CoreChannel, wireChannel as wireChannelCore } from '@pikku/core/channel'
+import { CorePikkuFunctionConfig } from '@pikku/core'
+import { AssertHTTPWiringParams } from '@pikku/core/http'
+import type { PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
+
+/**
+ * Type definition for WebSocket channels with typed data exchange.
+ * Supports connection, disconnection, and message handling.
+ *
+ * @template ChannelData - Type of data exchanged through the channel
+ * @template Channel - String literal type for the channel name
+ */
+type ChannelWiring<ChannelData, Channel extends string> = CoreChannel<
+  ChannelData,
+  Channel,
+  CorePikkuFunctionConfig<PikkuFunctionSessionless<void, any, ChannelData>, PikkuPermission<void>, PikkuMiddleware>,
+  CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void, ChannelData>, PikkuPermission<void>, PikkuMiddleware>,
+  CorePikkuFunctionConfig<PikkuFunctionSessionless<any, any, ChannelData>, PikkuPermission<any>, PikkuMiddleware>,
+  PikkuPermission,
+  PikkuMiddleware
+>
+
+/**
+ * Creates a function that handles WebSocket channel connections.
+ * Called when a client connects to a channel.
+ *
+ * @template Out - Output type for connection response
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The normalized configuration object
+ */
+export const pikkuChannelConnectionFunc = <Out = unknown>(
+  func:
+    | PikkuFunctionSessionless<void, Out, unknown>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, Out, unknown>, PikkuPermission<void>, PikkuMiddleware>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Creates a function that handles WebSocket channel disconnections.
+ * Called when a client disconnects from a channel.
+ *
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The normalized configuration object
+ */
+export const pikkuChannelDisconnectionFunc = (
+  func:
+    | PikkuFunctionSessionless<void, void, unknown>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void, unknown>, PikkuPermission<void>, PikkuMiddleware>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Creates a function that handles WebSocket channel messages.
+ * Called when a message is received on a channel.
+ * This is the same as pikkuSessionlessFunc but with ChannelData = unknown by default.
+ *
+ * @template In - Input type for channel messages
+ * @template Out - Output type for channel responses
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The normalized configuration object
+ */
+export const pikkuChannelFunc = <In, Out = unknown>(
+  func:
+    | PikkuFunctionSessionless<In, Out, unknown>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<In, Out, unknown>, PikkuPermission<In>, PikkuMiddleware>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Registers a WebSocket channel with the Pikku framework.
+ *
+ * @template ChannelData - Type of data associated with the channel
+ * @template Channel - String literal type for the channel name
+ * @param channel - Channel definition with connection, disconnection, and message handlers
+ */
+export const wireChannel = <ChannelData, Channel extends string>(
+  channel: ChannelWiring<ChannelData, Channel> & AssertHTTPWiringParams<ChannelData, Channel>
+) => {
+  wireChannelCore(channel as any) // TODO
+}
+`
+}

package/src/{wirings → functions/wirings}/channels/serialize-typed-channel-map.ts

@@ -1,7 +1,7 @@
 import { ChannelsMeta } from '@pikku/core/channel'
-import { serializeImportMap } from '../../serialize-import-map.js'
+import { serializeImportMap } from '../../../utils/serialize-import-map.js'
 import { TypesMap } from '@pikku/inspector'
-import { generateCustomTypes } from '../../utils.js'
+import { generateCustomTypes } from '../../../utils/custom-types-generator.js'
 import { FunctionsMeta } from '@pikku/core'
 
 export const serializeTypedChannelsMap = (
@@ -17,7 +17,10 @@ export const serializeTypedChannelsMap = (
   )
   typesMap.customTypes.forEach(({ references }) => {
     for (const reference of references) {
-      requiredTypes.add(reference)
+      // Skip __object types (placeholder types for invalid/broken functions)
+      if (reference !== '__object' && !reference.startsWith('__object_')) {
+        requiredTypes.add(reference)
+      }
     }
   })
   const imports = serializeImportMap(