@pikku/cli 0.7.7 → 0.8.1

package/bin/pikku-openapi.ts

@@ -1,70 +1,25 @@
 import { Command } from 'commander'
-import {
-  logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils/utils.js'
-import { generateSchemas } from '../src/schema-generator.js'
-import { generateOpenAPISpec } from '../src/openapi-spec-generator.js'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
-import { stringify } from 'yaml'
+import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
-
-export const pikkuOpenAPI = async (
-  { tsconfig, openAPI }: PikkuCLIConfig,
-  { http, functions }: InspectorState
-) => {
-  await logCommandInfoAndTime(
-    '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(
-        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(
-          openAPI.outputFile,
-          JSON.stringify(openAPISpec, null, 2),
-          true
-        )
-      } else if (
-        openAPI.outputFile.endsWith('.yaml') ||
-        openAPI.outputFile.endsWith('.yml')
-      ) {
-        await writeFileInDir(openAPI.outputFile, stringify(openAPISpec), true)
-      }
-    }
-  )
-}
+import { pikkuOpenAPI } from '../src/events/http/pikku-command-openapi.js'
 
 async function action({ config, tags }: PikkuCLIOptions): Promise<void> {
-  logPikkuLogo()
+  const logger = new CLILogger({ logLogo: true })
   const cliConfig = await getPikkuCLIConfig(
     config,
     ['rootDir', 'httpRoutesFile', 'openAPI', 'schemaDirectory', 'tsconfig'],
-    tags
+    {
+      tags: tags || [],
+    }
   )
   const visitState = await inspectorGlob(
+    logger,
     cliConfig.rootDir,
     cliConfig.srcDirectories,
     cliConfig.filters
   )
-  await pikkuOpenAPI(cliConfig, visitState)
+  await pikkuOpenAPI(logger, cliConfig, visitState)
 }
 
 export const openapi = (program: Command): void => {

package/bin/pikku-queue-service.ts

@@ -0,0 +1,28 @@
+import { Command } from 'commander'
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
+import { pikkuQueueService } from '../src/events/queue/pikku-command-queue-service.js'
+
+export const action = async (options: PikkuCLIOptions): Promise<void> => {
+  const logger = new CLILogger({ logLogo: true })
+
+  const cliConfig = await getPikkuCLIConfig(
+    options.config,
+    ['rootDir', 'schemaDirectory', 'configDir', 'queueFile'],
+    {
+      tags: options.tags,
+      types: options.types,
+      directories: options.directories,
+    },
+    true
+  )
+  await pikkuQueueService(logger, cliConfig)
+}
+
+export const queue = (program: Command): void => {
+  program
+    .command('queue')
+    .description('generate queue service wrapper')
+    .option('-c | --config <string>', 'The path to pikku cli config file')
+    .action(action)
+}

package/bin/pikku-schemas.ts

@@ -1,39 +1,12 @@
 import { Command } from 'commander'
-import { saveSchemas, generateSchemas } from '../src/schema-generator.js'
 
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
-import { logCommandInfoAndTime, logPikkuLogo } from '../src/utils/utils.js'
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
-
-export const pikkuSchemas = async (
-  { tsconfig, schemaDirectory, supportsImportAttributes }: PikkuCLIConfig,
-  { functions, http }: InspectorState
-) => {
-  return await logCommandInfoAndTime(
-    'Creating schemas',
-    'Created schemas',
-    [false],
-    async () => {
-      const schemas = await generateSchemas(
-        tsconfig,
-        functions.typesMap,
-        functions.meta,
-        http.meta
-      )
-      await saveSchemas(
-        schemaDirectory,
-        schemas,
-        functions.typesMap,
-        functions.meta,
-        supportsImportAttributes
-      )
-    }
-  )
-}
+import { pikkuSchemas } from '../src/schemas.js'
+import { CLILogger } from '../src/utils.js'
 
 async function action({ config }: { config?: string }): Promise<void> {
-  logPikkuLogo()
+  const logger = new CLILogger({ logLogo: true })
 
   const cliConfig = await getPikkuCLIConfig(config, [
     'srcDirectories',
@@ -41,11 +14,12 @@ async function action({ config }: { config?: string }): Promise<void> {
     'tsconfig',
   ])
   const visitState = await inspectorGlob(
+    logger,
     cliConfig.rootDir,
     cliConfig.srcDirectories,
     cliConfig.filters
   )
-  await pikkuSchemas(cliConfig, visitState)
+  await pikkuSchemas(logger, cliConfig, visitState)
 }
 
 export const schemas = (program: Command): void => {

package/bin/pikku-websocket.ts

@@ -1,52 +1,22 @@
 import { Command } from 'commander'
-import {
-  getFileImportRelativePath,
-  logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils/utils.js'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { serializeWebsocketWrapper } from '../src/serialize-websocket-wrapper.js'
-
-export const pikkuWebSocket = async ({
-  websocketFile,
-  channelsMapDeclarationFile,
-  packageMappings,
-}: PikkuCLIConfig) => {
-  await logCommandInfoAndTime(
-    '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(websocketFile, content.join('\n'))
-    }
-  )
-}
+import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { pikkuWebSocketTyped } from '../src/events/channels/pikku-command-websocket-typed.js'
 
 export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  logPikkuLogo()
+  const logger = new CLILogger({ logLogo: true })
+
   const cliConfig = await getPikkuCLIConfig(
     options.config,
     ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'],
-    options.tags,
+    {
+      tags: options.tags,
+      types: options.types,
+      directories: options.directories,
+    },
     true
   )
-  await pikkuWebSocket(cliConfig)
+  await pikkuWebSocketTyped(logger, cliConfig)
 }
 
 export const websocket = (program: Command): void => {

package/bin/pikku.ts

@@ -4,6 +4,7 @@ import { schemas } from './pikku-schemas.js'
 import { nextjs } from './pikku-nextjs.js'
 import { all } from './pikku-all.js'
 import { fetch } from './pikku-fetch.js'
+import { queue } from './pikku-queue-service.js'
 
 const program = new Command('pikku')
 program.usage('[command]')
@@ -12,5 +13,6 @@ all(program)
 schemas(program)
 nextjs(program)
 fetch(program)
+queue(program)
 
 program.parse(process.argv)

package/cli.schema.json

@@ -2,6 +2,18 @@
   "$ref": "#/definitions/PikkuCLIConfig",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "definitions": {
+    "InspectorFilters": {
+      "additionalProperties": false,
+      "properties": {
+        "tags": {
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
     "OpenAPISpecInfo": {
       "additionalProperties": false,
       "properties": {
@@ -123,12 +135,40 @@
         "bootstrapFile": {
           "type": "string"
         },
+        "bootstrapFiles": {
+          "additionalProperties": false,
+          "properties": {
+            "channel": {
+              "type": "string"
+            },
+            "http": {
+              "type": "string"
+            },
+            "mcp": {
+              "type": "string"
+            },
+            "queue": {
+              "type": "string"
+            },
+            "rpc": {
+              "type": "string"
+            },
+            "scheduled": {
+              "type": "string"
+            }
+          },
+          "required": ["http", "scheduled", "channel", "rpc", "queue", "mcp"],
+          "type": "object"
+        },
         "channelsFile": {
           "type": "string"
         },
         "channelsMapDeclarationFile": {
           "type": "string"
         },
+        "channelsMetaFile": {
+          "type": "string"
+        },
         "configDir": {
           "type": "string"
         },
@@ -138,6 +178,33 @@
         "fetchFile": {
           "type": "string"
         },
+        "filters": {
+          "$ref": "#/definitions/InspectorFilters"
+        },
+        "functionsFile": {
+          "type": "string"
+        },
+        "functionsMetaFile": {
+          "type": "string"
+        },
+        "httpRoutesFile": {
+          "type": "string"
+        },
+        "httpRoutesMapDeclarationFile": {
+          "type": "string"
+        },
+        "httpRoutesMetaFile": {
+          "type": "string"
+        },
+        "mcpEndpointsFile": {
+          "type": "string"
+        },
+        "mcpEndpointsMetaFile": {
+          "type": "string"
+        },
+        "mcpJsonFile": {
+          "type": "string"
+        },
         "nextBackendFile": {
           "type": "string"
         },
@@ -166,27 +233,48 @@
           },
           "type": "object"
         },
+        "queueFile": {
+          "type": "string"
+        },
+        "queueMapDeclarationFile": {
+          "type": "string"
+        },
+        "queueWorkersFile": {
+          "type": "string"
+        },
+        "queueWorkersMetaFile": {
+          "type": "string"
+        },
         "rootDir": {
           "type": "string"
         },
-        "srcDirectories": {
-          "items": {
-            "type": "string"
-          },
-          "type": "array"
+        "rpcFile": {
+          "type": "string"
         },
-        "routesFile": {
+        "rpcMapDeclarationFile": {
           "type": "string"
         },
-        "routesMapDeclarationFile": {
+        "rpcMetaFile": {
           "type": "string"
         },
         "schedulersFile": {
           "type": "string"
         },
+        "schedulersMetaFile": {
+          "type": "string"
+        },
         "schemaDirectory": {
           "type": "string"
         },
+        "servicesFile": {
+          "type": "string"
+        },
+        "srcDirectories": {
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
         "supportsImportAttributes": {
           "type": "boolean"
         },
@@ -202,16 +290,31 @@
       },
       "required": [
         "bootstrapFile",
+        "bootstrapFiles",
         "channelsFile",
         "channelsMapDeclarationFile",
+        "channelsMetaFile",
         "configDir",
+        "filters",
+        "functionsFile",
+        "functionsMetaFile",
+        "httpRoutesFile",
+        "httpRoutesMapDeclarationFile",
+        "httpRoutesMetaFile",
+        "mcpEndpointsFile",
+        "mcpEndpointsMetaFile",
         "packageMappings",
+        "queueMapDeclarationFile",
+        "queueWorkersFile",
+        "queueWorkersMetaFile",
         "rootDir",
-        "srcDirectories",
-        "routesFile",
-        "routesMapDeclarationFile",
+        "rpcMapDeclarationFile",
+        "rpcMetaFile",
         "schedulersFile",
+        "schedulersMetaFile",
         "schemaDirectory",
+        "servicesFile",
+        "srcDirectories",
         "supportsImportAttributes",
         "tsconfig",
         "typesDeclarationFile"

package/dist/bin/pikku-all.d.ts

@@ -1,4 +1,4 @@
 import { Command } from 'commander';
-import { PikkuCLIOptions } from '../src/utils/utils.js';
+import { PikkuCLIOptions } from '../src/utils.js';
 export declare const action: (options: PikkuCLIOptions) => Promise<void>;
 export declare const all: (program: Command) => void;