@pikku/cli 0.7.7 → 0.8.0

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

@@ -1,16 +1,19 @@
-import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { PikkuCLIConfig } from '../../pikku-cli-config.js'
 import { InspectorState } from '@pikku/inspector'
 import {
   logCommandInfoAndTime,
   serializeFileImports,
   writeFileInDir,
-} from '../src/utils/utils.js'
+} from '../../utils.js'
+import { PikkuCommand } from '../../types.js'
 
-export const pikkuChannels = async (
+export const pikkuChannels: PikkuCommand = async (
+  logger,
   cliConfig: PikkuCLIConfig,
   visitState: InspectorState
 ) => {
   return await logCommandInfoAndTime(
+    logger,
     'Finding Channels',
     'Found channels',
     [visitState.channels.files.size === 0],
@@ -18,6 +21,7 @@ export const pikkuChannels = async (
       const { channelsFile, channelsMetaFile, packageMappings } = cliConfig
       const { channels } = visitState
       await writeFileInDir(
+        logger,
         channelsFile,
         serializeFileImports(
           'addChannel',
@@ -27,6 +31,7 @@ export const pikkuChannels = async (
         )
       )
       await writeFileInDir(
+        logger,
         channelsMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`
       )

package/src/events/channels/pikku-command-channels-map.ts

@@ -0,0 +1,26 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
+import { serializeTypedChannelsMap } from './serialize-typed-channel-map.js'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuChannelsMap: PikkuCommand = async (
+  logger,
+  { channelsMapDeclarationFile, packageMappings },
+  state
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Creating channels map',
+    'Created channels map',
+    [state.channels.files.size === 0],
+    async () => {
+      const content = serializeTypedChannelsMap(
+        channelsMapDeclarationFile,
+        packageMappings,
+        state.functions.typesMap,
+        state.functions.meta,
+        state.channels.meta
+      )
+      await writeFileInDir(logger, channelsMapDeclarationFile, content)
+    }
+  )
+}

package/src/events/channels/pikku-command-channels.ts

@@ -0,0 +1,38 @@
+import {
+  logCommandInfoAndTime,
+  serializeFileImports,
+  writeFileInDir,
+} from '../../utils.js'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuChannels: PikkuCommand = async (
+  logger,
+  cliConfig,
+  visitState
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Finding Channels',
+    'Found channels',
+    [visitState.channels.files.size === 0],
+    async () => {
+      const { channelsFile, channelsMetaFile, packageMappings } = cliConfig
+      const { channels } = visitState
+      await writeFileInDir(
+        logger,
+        channelsFile,
+        serializeFileImports(
+          'addChannel',
+          channelsFile,
+          channels.files,
+          packageMappings
+        )
+      )
+      await writeFileInDir(
+        logger,
+        channelsMetaFile,
+        `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`
+      )
+    }
+  )
+}

package/src/events/channels/pikku-command-websocket-typed.ts

@@ -0,0 +1,36 @@
+import { PikkuCommandWithoutState } from '../../types.js'
+import {
+  logCommandInfoAndTime,
+  getFileImportRelativePath,
+  writeFileInDir,
+} from '../../utils.js'
+import { serializeWebsocketWrapper } from './serialize-websocket-wrapper.js'
+
+export const pikkuWebSocketTyped: PikkuCommandWithoutState = async (
+  logger,
+  { websocketFile, channelsMapDeclarationFile, packageMappings }
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Generating websocket wrapper',
+    'Generated websocket wrapper',
+    [
+      websocketFile === undefined,
+      "websocketFile isn't set in the pikku config",
+    ],
+    async () => {
+      if (!websocketFile) {
+        throw new Error("fetchFile is isn't set in the pikku config")
+      }
+
+      const channelsMapDeclarationPath = getFileImportRelativePath(
+        websocketFile,
+        channelsMapDeclarationFile,
+        packageMappings
+      )
+
+      const content = [serializeWebsocketWrapper(channelsMapDeclarationPath)]
+      await writeFileInDir(logger, websocketFile, content.join('\n'))
+    }
+  )
+}

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

@@ -1,7 +1,7 @@
 import { ChannelsMeta } from '@pikku/core/channel'
-import { serializeImportMap } from './utils/serialize-import-map.js'
+import { serializeImportMap } from '../../serialize-import-map.js'
 import { TypesMap } from '@pikku/inspector'
-import { generateCustomTypes } from './utils/utils.js'
+import { generateCustomTypes } from '../../utils.js'
 import { FunctionsMeta } from '@pikku/core'
 
 export const serializeTypedChannelsMap = (

package/src/events/fetch/index.ts

@@ -0,0 +1,33 @@
+import { serializeFetchWrapper } from '../http/serialize-fetch-wrapper.js'
+import {
+  getFileImportRelativePath,
+  logCommandInfoAndTime,
+  writeFileInDir,
+} from '../../utils.js'
+import { PikkuCommandWithoutState } from '../../types.js'
+
+export const pikkuFetch: PikkuCommandWithoutState = async (
+  logger,
+  { fetchFile, httpRoutesMapDeclarationFile, packageMappings }
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Generating fetch wrapper',
+    'Generated fetch wrapper',
+    [fetchFile === undefined, "fetchFile isn't set in the pikku config"],
+    async () => {
+      if (!fetchFile) {
+        throw new Error("fetchFile is isn't set in the pikku config")
+      }
+
+      const routesMapDeclarationPath = getFileImportRelativePath(
+        fetchFile,
+        httpRoutesMapDeclarationFile,
+        packageMappings
+      )
+
+      const content = [serializeFetchWrapper(routesMapDeclarationPath)]
+      await writeFileInDir(logger, fetchFile, content.join('\n'))
+    }
+  )
+}

package/src/events/functions/pikku-command-function-types.ts

@@ -0,0 +1,48 @@
+import {
+  getFileImportRelativePath,
+  getPikkuFilesAndMethods,
+  logCommandInfoAndTime,
+  writeFileInDir,
+} from '../../utils.js'
+import { serializePikkuTypes } from '../../serialize-pikku-types.js'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuFunctionTypes: PikkuCommand = async (
+  logger,
+  { typesDeclarationFile: typesFile, packageMappings, rpcMapDeclarationFile },
+  visitState,
+  options = {}
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Creating api types',
+    'Created api types',
+    [false],
+    async () => {
+      const { userSessionType, sessionServicesType, singletonServicesType } =
+        await getPikkuFilesAndMethods(
+          logger,
+          visitState,
+          packageMappings,
+          typesFile,
+          options,
+          {
+            userSessionType: true,
+            sessionServiceType: true,
+            singletonServicesType: true,
+          }
+        )
+
+      const content = serializePikkuTypes(
+        `import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`,
+        userSessionType.type,
+        `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`,
+        singletonServicesType.type,
+        `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`,
+        `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcMapDeclarationFile, packageMappings)}'`
+      )
+
+      await writeFileInDir(logger, typesFile, content)
+    }
+  )
+}

package/src/events/functions/pikku-command-functions.ts

@@ -0,0 +1,84 @@
+import {
+  getFileImportRelativePath,
+  logCommandInfoAndTime,
+  writeFileInDir,
+} from '../../utils.js'
+import { PikkuCommand } from '../../types.js'
+
+export const serializeFunctionImports = (
+  outputPath: string,
+  functionsMap: Map<string, { path: string; exportedName: string }>,
+  packageMappings: Record<string, string> = {}
+) => {
+  const serializedImports: string[] = [
+    `/* Import and register RPCs */`,
+    `import { addFunction } from '@pikku/core'`,
+  ]
+
+  const serializedRegistrations: string[] = []
+
+  // Sort by function name for consistent output
+  const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) =>
+    a[0].localeCompare(b[0])
+  )
+
+  for (const [name, { path, exportedName }] of sortedEntries) {
+    const filePath = getFileImportRelativePath(
+      outputPath,
+      path,
+      packageMappings
+    )
+
+    // For directly exported functions, we can just import and register them
+    if (name === exportedName) {
+      serializedImports.push(`import { ${exportedName} } from '${filePath}'`)
+      serializedRegistrations.push(
+        `addFunction('${name}', { func: ${exportedName} })`
+      )
+    }
+    // For renamed functions, we need to import and alias them
+    else {
+      serializedImports.push(
+        `import { ${exportedName} as ${name} } from '${filePath}'`
+      )
+      serializedRegistrations.push(`addFunction('${name}', ${name})`)
+    }
+  }
+
+  // Add a blank line between imports and registrations
+  if (serializedImports.length > 0 && serializedRegistrations.length > 0) {
+    serializedImports.push('')
+  }
+
+  // Combine the imports and registrations
+  return [...serializedImports, ...serializedRegistrations].join('\n')
+}
+
+export const pikkuFunctions: PikkuCommand = async (
+  logger,
+  { functionsMetaFile, functionsFile, packageMappings },
+  { functions }
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Serializing Pikku functions',
+    'Serialized Pikku functions',
+    [false],
+    async () => {
+      await writeFileInDir(
+        logger,
+        functionsFile,
+        serializeFunctionImports(
+          functionsFile,
+          functions.files,
+          packageMappings
+        )
+      )
+      await writeFileInDir(
+        logger,
+        functionsMetaFile,
+        `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`
+      )
+    }
+  )
+}

package/{bin → src/events/functions}/pikku-function-types.ts

@@ -1,30 +1,27 @@
-import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
 import {
   getFileImportRelativePath,
   getPikkuFilesAndMethods,
   logCommandInfoAndTime,
-  PikkuCLIOptions,
   writeFileInDir,
-} from '../src/utils/utils.js'
-import { serializePikkuTypes } from '../src/serialize-pikku-types.js'
+} from '../../utils.js'
+import { serializePikkuTypes } from '../../serialize-pikku-types.js'
+import { PikkuCommand } from '../../types.js'
 
-export const pikkuFunctionTypes = async (
-  {
-    typesDeclarationFile: typesFile,
-    packageMappings,
-    rpcMapDeclarationFile,
-  }: PikkuCLIConfig,
-  options: PikkuCLIOptions,
-  visitState: InspectorState
+export const pikkuFunctionTypes: PikkuCommand = async (
+  logger,
+  { typesDeclarationFile: typesFile, packageMappings, rpcMapDeclarationFile },
+  visitState,
+  options = {}
 ) => {
-  await logCommandInfoAndTime(
+  return await logCommandInfoAndTime(
+    logger,
     'Creating api types',
     'Created api types',
     [false],
     async () => {
       const { userSessionType, sessionServicesType, singletonServicesType } =
         await getPikkuFilesAndMethods(
+          logger,
           visitState,
           packageMappings,
           typesFile,
@@ -44,7 +41,7 @@ export const pikkuFunctionTypes = async (
         `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`,
         `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcMapDeclarationFile, packageMappings)}'`
       )
-      await writeFileInDir(typesFile, content)
+      await writeFileInDir(logger, typesFile, content)
     }
   )
 }

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

@@ -1,10 +1,9 @@
-import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
 import {
   getFileImportRelativePath,
   logCommandInfoAndTime,
   writeFileInDir,
-} from '../src/utils/utils.js'
+} from '../../utils.js'
+import { PikkuCommand } from '../../types.js'
 
 export const serializeFunctionImports = (
   outputPath: string,
@@ -55,16 +54,19 @@ export const serializeFunctionImports = (
   return [...serializedImports, ...serializedRegistrations].join('\n')
 }
 
-export const pikkuFunctions = async (
-  { functionsMetaFile, functionsFile, packageMappings }: PikkuCLIConfig,
-  { functions }: InspectorState
+export const pikkuFunctions: PikkuCommand = async (
+  logger,
+  { functionsMetaFile, functionsFile, packageMappings },
+  { functions }
 ) => {
   return await logCommandInfoAndTime(
+    logger,
     'Serializing Pikku functions',
     'Serialized Pikku functions',
     [false],
     async () => {
       await writeFileInDir(
+        logger,
         functionsFile,
         serializeFunctionImports(
           functionsFile,
@@ -73,6 +75,7 @@ export const pikkuFunctions = async (
         )
       )
       await writeFileInDir(
+        logger,
         functionsMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`
       )

package/src/events/http/pikku-command-http-map.ts

@@ -0,0 +1,27 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
+import { serializeTypedRoutesMap } from './serialize-typed-http-map.js'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuHTTPMap: PikkuCommand = async (
+  logger,
+  { httpRoutesMapDeclarationFile, packageMappings },
+  { http, functions }
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Creating HTTP map',
+    'Created HTTP map',
+    [http.files.size === 0],
+    async () => {
+      const content = serializeTypedRoutesMap(
+        httpRoutesMapDeclarationFile,
+        packageMappings,
+        functions.typesMap,
+        functions.meta,
+        http.meta,
+        http.metaInputTypes
+      )
+      await writeFileInDir(logger, httpRoutesMapDeclarationFile, content)
+    }
+  )
+}

package/src/events/http/pikku-command-http-routes.ts

@@ -0,0 +1,40 @@
+import { PikkuCLIConfig } from '../../pikku-cli-config.js'
+import { InspectorState } from '@pikku/inspector'
+import {
+  logCommandInfoAndTime,
+  serializeFileImports,
+  writeFileInDir,
+} from '../../utils.js'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuHTTP: PikkuCommand = async (
+  logger,
+  cliConfig: PikkuCLIConfig,
+  visitState: InspectorState
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Finding HTTP routes',
+    'Found HTTP routes',
+    [visitState.http.files.size === 0],
+    async () => {
+      const { httpRoutesFile, httpRoutesMetaFile, packageMappings } = cliConfig
+      const { http } = visitState
+      await writeFileInDir(
+        logger,
+        httpRoutesFile,
+        serializeFileImports(
+          'addHTTPRoute',
+          httpRoutesFile,
+          http.files,
+          packageMappings
+        )
+      )
+      await writeFileInDir(
+        logger,
+        httpRoutesMetaFile,
+        `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`
+      )
+    }
+  )
+}

package/src/events/http/pikku-command-nextjs.ts

@@ -0,0 +1,111 @@
+import { PikkuCLIConfig } from '../../pikku-cli-config.js'
+import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from '../../runtimes/nextjs/serialize-nextjs-backend-wrapper.js'
+import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from '../../runtimes/nextjs/serialize-nextjs-http-wrapper.js'
+import {
+  getFileImportRelativePath,
+  getPikkuFilesAndMethods,
+  logCommandInfoAndTime,
+  writeFileInDir,
+} from '../../utils.js'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuNext: PikkuCommand = async (
+  logger,
+  {
+    nextBackendFile,
+    nextHTTPFile,
+    httpRoutesMapDeclarationFile,
+    packageMappings,
+    fetchFile,
+    bootstrapFiles,
+  }: PikkuCLIConfig,
+  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/events/http/pikku-command-openapi.ts

@@ -0,0 +1,54 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
+import { generateSchemas } from '../../schema-generator.js'
+import { generateOpenAPISpec } from './openapi-spec-generator.js'
+import { stringify } from 'yaml'
+import { PikkuCommand } from '../../types.js'
+
+export const pikkuOpenAPI: PikkuCommand = async (
+  logger,
+  { tsconfig, openAPI },
+  { http, functions }
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Creating OpenAPI spec',
+    'Created OpenAPI spec',
+    [openAPI?.outputFile === undefined, 'openAPI outfile is not defined'],
+    async () => {
+      if (!openAPI?.outputFile) {
+        throw new Error('openAPI is required')
+      }
+      const schemas = await generateSchemas(
+        logger,
+        tsconfig,
+        functions.typesMap,
+        functions.meta,
+        http.meta
+      )
+      const openAPISpec = await generateOpenAPISpec(
+        functions.meta,
+        http.meta,
+        schemas,
+        openAPI.additionalInfo
+      )
+      if (openAPI.outputFile.endsWith('.json')) {
+        await writeFileInDir(
+          logger,
+          openAPI.outputFile,
+          JSON.stringify(openAPISpec, null, 2),
+          { ignoreModifyComment: true }
+        )
+      } else if (
+        openAPI.outputFile.endsWith('.yaml') ||
+        openAPI.outputFile.endsWith('.yml')
+      ) {
+        await writeFileInDir(
+          logger,
+          openAPI.outputFile,
+          stringify(openAPISpec),
+          { ignoreModifyComment: true }
+        )
+      }
+    }
+  )
+}

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

@@ -1,16 +1,19 @@
-import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { PikkuCLIConfig } from '../../pikku-cli-config.js'
 import { InspectorState } from '@pikku/inspector'
 import {
   logCommandInfoAndTime,
   serializeFileImports,
   writeFileInDir,
-} from '../src/utils/utils.js'
+} from '../../utils.js'
+import { PikkuCommand } from '../../types.js'
 
-export const pikkuHTTP = async (
+export const pikkuHTTP: PikkuCommand = async (
+  logger,
   cliConfig: PikkuCLIConfig,
   visitState: InspectorState
 ) => {
   return await logCommandInfoAndTime(
+    logger,
     'Finding HTTP routes',
     'Found HTTP routes',
     [visitState.http.files.size === 0],
@@ -18,6 +21,7 @@ export const pikkuHTTP = async (
       const { httpRoutesFile, httpRoutesMetaFile, packageMappings } = cliConfig
       const { http } = visitState
       await writeFileInDir(
+        logger,
         httpRoutesFile,
         serializeFileImports(
           'addHTTPRoute',
@@ -27,6 +31,7 @@ export const pikkuHTTP = async (
         )
       )
       await writeFileInDir(
+        logger,
         httpRoutesMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`
       )