@pikku/cli 0.7.6 → 0.8.0

package/{bin → src/events/rpc}/pikku-rpc.ts

@@ -1,17 +1,19 @@
-import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
-import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js'
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
+import { PikkuCommand } from '../../types.js'
 
-export const pikkuRPC = async (
-  { rpcMetaFile }: PikkuCLIConfig,
-  { rpc }: InspectorState
+export const pikkuRPC: PikkuCommand = 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/src/{serialize-typed-rpc-map.ts → events/rpc/serialize-typed-rpc-map.ts}

@@ -1,8 +1,9 @@
-import { serializeImportMap } from './utils/serialize-import-map.js'
+import type { RPCMeta } from '@pikku/core/rpc'
+
+import { serializeImportMap } from '../../serialize-import-map.js'
 import { TypesMap } from '@pikku/inspector'
 import { FunctionsMeta } from '@pikku/core'
-import { generateCustomTypes } from './utils/utils.js'
-import { RPCMeta } from '../../core/src/rpc/rpc-types.js'
+import { generateCustomTypes } from '../../utils.js'
 
 export const serializeTypedRPCMap = (
   relativeToPath: string,

package/{bin/pikku-scheduler.ts → src/events/scheduler/pikku-command-scheduler.ts}

@@ -1,17 +1,18 @@
-import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
 import {
   logCommandInfoAndTime,
   serializeFileImports,
   writeFileInDir,
-} from '../src/utils/utils.js'
-import { serializeSchedulerMeta } from '../src/serialize-scheduler-meta.js'
+} from '../../utils.js'
+import { serializeSchedulerMeta } from './serialize-scheduler-meta.js'
+import { PikkuCommand } from '../../types.js'
 
-export const pikkuScheduler = async (
-  cliConfig: PikkuCLIConfig,
-  visitState: InspectorState
+export const pikkuScheduler: PikkuCommand = async (
+  logger,
+  cliConfig,
+  visitState
 ) => {
   return await logCommandInfoAndTime(
+    logger,
     'Finding scheduled tasks',
     'Found scheduled tasks',
     [visitState.scheduledTasks.files.size === 0],
@@ -19,13 +20,15 @@ export const pikkuScheduler = async (
       const { schedulersFile, schedulersMetaFile, packageMappings } = cliConfig
       const { scheduledTasks } = visitState
       await writeFileInDir(
+        logger,
         schedulersMetaFile,
         serializeSchedulerMeta(scheduledTasks.meta)
       )
       await writeFileInDir(
+        logger,
         schedulersFile,
         serializeFileImports(
-          'addSerializedTasks',
+          'addScheduledTasks',
           schedulersFile,
           scheduledTasks.files,
           packageMappings

package/src/inspector-glob.ts

@@ -1,15 +1,17 @@
 import * as path from 'path'
 import { glob } from 'tinyglobby'
 import { InspectorFilters, InspectorState, inspect } from '@pikku/inspector'
-import { logCommandInfoAndTime } from './utils/utils.js'
+import { logCommandInfoAndTime } from './utils.js'
 
 export const inspectorGlob = async (
+  logger,
   rootDir: string,
   srcDirectories: string[],
   filters: InspectorFilters
 ) => {
   let result: InspectorState
   await logCommandInfoAndTime(
+    logger,
     'Inspecting codebase',
     'Inspected codebase',
     [false],

package/src/pikku-cli-config.ts

@@ -1,6 +1,6 @@
 import { join, dirname, resolve, isAbsolute } from 'path'
 import { readdir, readFile } from 'fs/promises'
-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'
 
@@ -34,6 +34,15 @@ export interface PikkuCLICoreOutputFiles {
   schedulersFile: string
   schedulersMetaFile: string
 
+  // Queue processors
+  queueWorkersFile: string
+  queueWorkersMetaFile: string
+  queueMapDeclarationFile: string
+
+  // MCP
+  mcpEndpointsFile: string
+  mcpEndpointsMetaFile: string
+
   // Application bootstrap
   bootstrapFile: string
   bootstrapFiles: Record<PikkuEventTypes, string>
@@ -56,6 +65,8 @@ export type PikkuCLIConfig = {
   nextHTTPFile?: string
   fetchFile?: string
   websocketFile?: string
+  queueFile?: string
+  mcpJsonFile?: string
 
   openAPI?: {
     outputFile: string
@@ -70,6 +81,8 @@ const CONFIG_DIR_FILES = [
   'nextHTTPFile',
   'fetchFile',
   'websocketFile',
+  'queueFile',
+  'mcpJsonFile',
 ]
 
 export const getPikkuCLIConfig = async (
@@ -142,9 +155,21 @@ const _getPikkuCLIConfig = async (
     }
 
     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')
       }
@@ -154,65 +179,101 @@ const _getPikkuCLIConfig = async (
           '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,
+          httpDir,
           'pikku-http-routes-meta.gen.ts'
         )
       }
-      if (!result.schedulersFile) {
-        result.schedulersFile = join(result.outDir, 'pikku-schedules.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,
+          channelsDir,
           'pikku-channels-meta.gen.ts'
         )
       }
-      if (!result.typesDeclarationFile) {
-        result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.ts')
-      }
-      if (!result.httpRoutesMapDeclarationFile) {
-        result.httpRoutesMapDeclarationFile = join(
-          result.outDir,
-          'pikku-routes-map.gen.d.ts'
-        )
-      }
       if (!result.channelsMapDeclarationFile) {
         result.channelsMapDeclarationFile = join(
-          result.outDir,
+          channelsDir,
           'pikku-channels-map.gen.d.ts'
         )
       }
+
+      // RPC
+      if (!result.rpcMetaFile) {
+        result.rpcMetaFile = join(rpcDir, 'pikku-rpc-meta.gen.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)) {
+        const eventDir = join(result.outDir, key.toLowerCase())
         result.bootstrapFiles[key] = join(
-          result.outDir,
+          eventDir,
           `pikku-bootstrap-${key}.gen.ts`
         )
       }

package/src/pikku-command-schemas.ts

@@ -0,0 +1,33 @@
+import { generateSchemas, saveSchemas } from './schema-generator.js'
+import { logCommandInfoAndTime } from './utils.js'
+import { PikkuCommand } from './types.js'
+
+export const pikkuSchemas: PikkuCommand = 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/src/runtimes/nextjs/pikku-command-nextjs.ts

@@ -0,0 +1,110 @@
+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'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuNext: PikkuCommand = 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/src/{serialize-nextjs-http-wrapper.ts → runtimes/nextjs/serialize-nextjs-http-wrapper.ts}

@@ -10,11 +10,10 @@ export const serializeNextJsHTTPWrapper = (
  */
 import { CorePikkuFetchOptions } from '@pikku/fetch'
 import type { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPath}'
+import { PikkuFetch } from '${pikkuFetchImport}'
 
 let _pikku: PikkuFetch | undefined
 
-${pikkuFetchImport}
-
 /**
  * Initializes and returns an instance of PikkuNextJS with helper methods for handling route requests.
  *

package/src/schema-generator.ts

@@ -1,11 +1,12 @@
 import { createGenerator, RootlessError } from 'ts-json-schema-generator'
-import { logInfo, writeFileInDir } from './utils/utils.js'
+import { CLILogger, writeFileInDir } from './utils.js'
 import { mkdir, writeFile } from 'fs/promises'
 import { FunctionsMeta, JSONValue } from '@pikku/core'
 import { HTTPRoutesMeta } from '@pikku/core/http'
 import { TypesMap } from '@pikku/inspector'
 
 export async function generateSchemas(
+  logger: CLILogger,
   tsconfig: string,
   typesMap: TypesMap,
   functionMeta: FunctionsMeta,
@@ -63,6 +64,7 @@ export async function generateSchemas(
 }
 
 export async function saveSchemas(
+  logger: CLILogger,
   schemaParentDir: string,
   schemas: Record<string, JSONValue>,
   typesMap: TypesMap,
@@ -70,6 +72,7 @@ export async function saveSchemas(
   supportsImportAttributes: boolean
 ) {
   await writeFileInDir(
+    logger,
     `${schemaParentDir}/register.gen.ts`,
     'export const empty = null;'
   )
@@ -90,7 +93,7 @@ export async function saveSchemas(
   ])
 
   if (desiredSchemas.size === 0) {
-    logInfo(`• Skipping schemas since none found.\x1b[0m`)
+    logger.info(`• Skipping schemas since none found.\x1b[0m`)
     return
   }
 
@@ -117,8 +120,10 @@ addSchema('${schema}', ${schema})
     .join('\n')
 
   await writeFileInDir(
+    logger,
     `${schemaParentDir}/register.gen.ts`,
     `import { addSchema } from '@pikku/core/schema'
-${schemaImports}`
+${schemaImports}`,
+    { logWrite: true }
   )
 }

package/src/schemas.ts

@@ -0,0 +1,33 @@
+import { saveSchemas, generateSchemas } from './schema-generator.js'
+import { logCommandInfoAndTime } from './utils.js'
+import { PikkuCommand } from './types.js'
+
+export const pikkuSchemas: PikkuCommand = 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/src/{utils/serialize-import-map.ts → serialize-import-map.ts}

@@ -16,6 +16,11 @@ export const serializeImportMap = (
       return
     }
     const variables = paths.get(path) || []
+
+    if (uniqueName === '__object') {
+      return
+    }
+
     if (originalName === uniqueName) {
       variables.push(originalName)
     } else {