@pikku/cli 0.7.0 → 0.7.1

package/bin/pikku-websocket.ts

@@ -0,0 +1,58 @@
+import { Command } from 'commander'
+import {
+  getFileImportRelativePath,
+  logCommandInfoAndTime,
+  logPikkuLogo,
+  PikkuCLIOptions,
+  writeFileInDir,
+} from '../src/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'))
+    }
+  )
+}
+
+export const action = async (options: PikkuCLIOptions): Promise<void> => {
+  logPikkuLogo()
+  const cliConfig = await getPikkuCLIConfig(
+    options.config,
+    ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'],
+    options.tags,
+    true
+  )
+  await pikkuWebSocket(cliConfig)
+}
+
+export const websocket = (program: Command): void => {
+  program
+    .command('websocket')
+    .description('generate websocket wrapper')
+    .option('-c | --config <string>', 'The path to pikku cli config file')
+    .action(action)
+}

package/bin/pikku.ts

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { Command } from 'commander'
+import { schemas } from './pikku-schemas.js'
+import { routes } from './pikku-http-routes.js'
+import { nextjs } from './pikku-nextjs.js'
+import { all } from './pikku-all.js'
+import { functionTypes } from './pikku-function-types.js'
+import { routesMap } from './pikku-http-map.js'
+import { fetch } from './pikku-fetch.js'
+import { channels } from './pikku-channels.js'
+import { schedules } from './pikku-scheduler.js'
+
+const program = new Command('pikku')
+program.usage('[command]')
+
+all(program)
+routes(program)
+routesMap(program)
+functionTypes(program)
+schemas(program)
+nextjs(program)
+fetch(program)
+channels(program)
+schedules(program)
+
+program.parse(process.argv)

package/dist/bin/pikku-all.js

@@ -15,6 +15,7 @@ import { pikkuWebSocket } from './pikku-websocket.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
 import chokidar from 'chokidar';
 import { pikkuFunctions } from './pikku-functions.js';
+import { pikkuRPC } from './pikku-rpc.js';
 const runAll = async (cliConfig, options) => {
     const metaImports = [];
     const imports = [];
@@ -45,6 +46,8 @@ const runAll = async (cliConfig, options) => {
     }
     addImport(cliConfig.functionsMetaFile, 'meta');
     addImport(cliConfig.functionsFile, 'events');
+    await pikkuRPC(cliConfig, visitState);
+    addImport(cliConfig.rpcFile, 'meta');
     const routes = await pikkuHTTP(cliConfig, visitState);
     if (routes) {
         await pikkuHTTPMap(cliConfig, visitState);

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

@@ -1,5 +1,3 @@
-import { Command } from 'commander';
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { InspectorState } from '@pikku/inspector';
 export declare const pikkuFunctions: (cliConfig: PikkuCLIConfig, visitState: InspectorState) => Promise<boolean>;
-export declare const routes: (program: Command) => void;

package/dist/bin/pikku-functions.js

@@ -1,24 +1,9 @@
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { logCommandInfoAndTime, logPikkuLogo, serializeFileImports, writeFileInDir, } from '../src/utils.js';
-import { inspectorGlob } from '../src/inspector-glob.js';
+import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../src/utils.js';
 export const pikkuFunctions = async (cliConfig, visitState) => {
     return await logCommandInfoAndTime('Finding Pikku functions', 'Found Pikku functions', [visitState.functions.files.size === 0], async () => {
         const { functionsFile, functionsMetaFile, packageMappings } = cliConfig;
         const { functions } = visitState;
         await writeFileInDir(functionsFile, serializeFileImports('addFunction', functionsFile, functions.files, packageMappings));
-        await writeFileInDir(functionsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('functions', 'meta', ${JSON.stringify(functions.meta, null, 2)})`);
+        await writeFileInDir(functionsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`);
     });
 };
-async function action(cliOptions) {
-    logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'srcDirectories', 'functionsFile'], cliOptions.tags);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-    await pikkuFunctions(cliConfig, visitState);
-}
-export const routes = (program) => {
-    program
-        .command('functions')
-        .description('Find all functions to import')
-        .option('-c | --config <string>', 'The path to pikku cli config file')
-        .action(action);
-};

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

@@ -0,0 +1,3 @@
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { InspectorState } from '@pikku/inspector';
+export declare const pikkuRPC: (cliConfig: PikkuCLIConfig, visitState: InspectorState) => Promise<boolean>;

package/dist/bin/pikku-rpc.js

@@ -0,0 +1,8 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../src/utils.js';
+export const pikkuRPC = async (cliConfig, visitState) => {
+    return await logCommandInfoAndTime('Finding RPCs tasks', 'Found rpcs', [visitState.functions.files.size === 0], async () => {
+        const { rpcFile } = cliConfig;
+        const { rpc } = visitState;
+        await writeFileInDir(rpcFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`);
+    });
+};

package/dist/src/pikku-cli-config.d.ts

@@ -10,6 +10,7 @@ export interface PikkuCLICoreOutputFiles {
     channelsMetaFile: string;
     schedulersFile: string;
     schedulersMetaFile: string;
+    rpcFile: string;
     schemaDirectory: string;
     typesDeclarationFile: string;
     httpRoutesMapDeclarationFile: string;

package/dist/src/pikku-cli-config.js

@@ -62,6 +62,9 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
             if (!result.functionsMetaFile) {
                 result.functionsMetaFile = join(result.outDir, 'pikku-functions-meta.gen.ts');
             }
+            if (!result.rpcFile) {
+                result.rpcFile = join(result.outDir, 'pikku-rpc.gen.ts');
+            }
             if (!result.httpRoutesFile) {
                 result.httpRoutesFile = join(result.outDir, 'pikku-http-routes.gen.ts');
             }

package/dist/src/schema-generator.js

@@ -15,8 +15,7 @@ export async function generateSchemas(tsconfig, typesMaps, httpRoutesMeta) {
                         break;
                     }
                 }
-                catch (e) {
-                }
+                catch (e) { }
             }
             if (!found) {
                 console.error('Input type not found in any types map:', input);

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../bin/pikku-all.ts","../bin/pikku-channels-map.ts","../bin/pikku-channels.ts","../bin/pikku-fetch.ts","../bin/pikku-function-types.ts","../bin/pikku-functions.ts","../bin/pikku-http-map.ts","../bin/pikku-http-routes.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-rpc.ts","../bin/pikku-scheduler.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/openapi-spec-generator.ts","../src/pikku-cli-config.ts","../src/schema-generator.ts","../src/serialize-fetch-wrapper.ts","../src/serialize-import-map.ts","../src/serialize-nextjs-backend-wrapper.ts","../src/serialize-nextjs-http-wrapper.ts","../src/serialize-pikku-types.ts","../src/serialize-scheduler-meta.ts","../src/serialize-typed-channel-map.ts","../src/serialize-typed-function-map.ts","../src/serialize-typed-http-map.ts","../src/serialize-websocket-wrapper.ts","../src/utils.ts"],"version":"5.7.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "bin": {
@@ -22,8 +22,8 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^3.0.2",
-    "@pikku/core": "^0.7.0",
-    "@pikku/inspector": "^0.7.0",
+    "@pikku/core": "^0.7.3",
+    "@pikku/inspector": "^0.7.3",
     "@types/cookie": "^0.6.0",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.4.1",

package/src/inspector-glob.ts

@@ -0,0 +1,28 @@
+import * as path from 'path'
+import { glob } from 'tinyglobby'
+import { InspectorFilters, InspectorState, inspect } from '@pikku/inspector'
+import { logCommandInfoAndTime } from './utils.js'
+
+export const inspectorGlob = async (
+  rootDir: string,
+  srcDirectories: string[],
+  filters: InspectorFilters
+) => {
+  let result: InspectorState
+  await logCommandInfoAndTime(
+    'Inspecting codebase',
+    'Inspected codebase',
+    [false],
+    async () => {
+      const routeFiles = (
+        await Promise.all(
+          srcDirectories.map((dir) =>
+            glob(`${path.join(rootDir, dir)}/**/*.ts`)
+          )
+        )
+      ).flat()
+      result = await inspect(routeFiles, filters)
+    }
+  )
+  return result!
+}

package/src/openapi-spec-generator.ts

@@ -0,0 +1,227 @@
+import { HTTPRoutesMeta, pikkuState } from '@pikku/core'
+import _convertSchema from '@openapi-contrib/json-schema-to-openapi-schema'
+const convertSchema =
+  'default' in _convertSchema ? (_convertSchema.default as any) : _convertSchema
+
+interface OpenAPISpec {
+  openapi: string
+  info: {
+    title: string
+    version: string
+    description?: string
+    termsOfService?: string
+    contact?: {
+      name?: string
+      url?: string
+      email?: string
+    }
+    license?: {
+      name: string
+      url?: string
+    }
+  }
+  servers: { url: string; description?: string }[]
+  paths: Record<string, any>
+  components: {
+    schemas: Record<string, any>
+    responses?: Record<string, any>
+    parameters?: Record<string, any>
+    examples?: Record<string, any>
+    requestBodies?: Record<string, any>
+    headers?: Record<string, any>
+    securitySchemes?: Record<string, any>
+  }
+  security?: { [key: string]: any[] }[]
+  tags?: { name: string; description?: string }[]
+  externalDocs?: {
+    description?: string
+    url: string
+  }
+}
+
+export interface OpenAPISpecInfo {
+  info: {
+    title: string
+    version: string
+    description: string
+    termsOfService?: string
+    contact?: {
+      name?: string
+      url?: string
+      email?: string
+    }
+    license?: {
+      name: string
+      url?: string
+    }
+  }
+  servers: { url: string; description?: string }[]
+  tags?: { name: string; description?: string }[]
+  externalDocs?: {
+    description?: string
+    url: string
+  }
+  securitySchemes?: Record<string, any>
+  security?: { [key: string]: any[] }[]
+}
+
+const getErrorResponseForConstructorName = (constructorName: string) => {
+  const errors = Array.from(pikkuState('misc', 'errors').entries())
+  const foundError = errors.find(([e]) => e.name === constructorName)
+  if (foundError) {
+    return foundError[1]
+  }
+  return undefined
+}
+
+const convertSchemasToBodyPayloads = async (
+  routesMeta: HTTPRoutesMeta,
+  schemas: Record<string, any>
+) => {
+  const requiredSchemas = new Set(
+    routesMeta
+      .map(({ inputTypes, output }) => [inputTypes?.body, output])
+      .flat()
+      .filter((schema) => !!schema)
+  )
+  const convertedEntries = await Promise.all(
+    Object.entries(schemas).map(async ([key, schema]) => {
+      if (requiredSchemas.has(key)) {
+        const convertedSchema = await convertSchema(schema, {
+          convertUnreferencedDefinitions: false,
+          dereference: { circular: 'ignore' },
+        })
+        return [key, convertedSchema]
+      }
+      return
+    })
+  )
+  return Object.fromEntries(convertedEntries.filter((s) => !!s))
+}
+
+export async function generateOpenAPISpec(
+  routeMeta: HTTPRoutesMeta,
+  schemas: Record<string, any>,
+  additionalInfo: OpenAPISpecInfo
+): Promise<OpenAPISpec> {
+  const paths: Record<string, any> = {}
+
+  routeMeta.forEach((meta) => {
+    const { route, method, inputTypes, output, params, query, docs } = meta
+    const path = route.replace(/:(\w+)/g, '{$1}') // Convert ":param" to "{param}"
+
+    if (!paths[path]) {
+      paths[path] = {}
+    }
+
+    const responses = {}
+    docs?.errors?.forEach((error) => {
+      const errorResponse = getErrorResponseForConstructorName(error)
+      if (errorResponse) {
+        responses[errorResponse.status] = {
+          description: errorResponse.message,
+        }
+      }
+    })
+
+    const operation: any = {
+      description:
+        docs?.description ||
+        `This endpoint handles the ${method.toUpperCase()} request for the route ${route}.`,
+      tags: docs?.tags || [route.split('/')[1] || 'default'],
+      parameters: [],
+      responses: {
+        ...responses,
+        '200': {
+          description: 'Successful response',
+          content: output
+            ? {
+                'application/json': {
+                  schema:
+                    typeof output === 'string' &&
+                    ['boolean', 'string', 'number'].includes(output)
+                      ? { type: output }
+                      : { $ref: `#/components/schemas/${output}` },
+                },
+              }
+            : undefined,
+        },
+      },
+    }
+
+    const bodyType = inputTypes?.body
+    if (bodyType) {
+      operation.requestBody = {
+        required: true,
+        content: {
+          'application/json': {
+            schema:
+              typeof bodyType === 'string' &&
+              ['boolean', 'string', 'number'].includes(bodyType)
+                ? { type: bodyType }
+                : { $ref: `#/components/schemas/${bodyType}` },
+          },
+        },
+      }
+    }
+
+    if (params) {
+      operation.parameters = params.map((param) => ({
+        name: param,
+        in: 'path',
+        required: true,
+        schema: { type: 'string' },
+      }))
+    }
+
+    if (query) {
+      operation.parameters.push(
+        ...query.map((query) => ({
+          name: query,
+          in: 'query',
+          required: false,
+          schema: { type: 'string' },
+        }))
+      )
+    }
+
+    paths[path][method] = operation
+  })
+
+  return {
+    openapi: '3.1.0',
+    info: additionalInfo.info,
+    servers: additionalInfo.servers,
+    paths,
+    components: {
+      schemas: await convertSchemasToBodyPayloads(routeMeta, schemas),
+      responses: {},
+      parameters: {},
+      examples: {},
+      requestBodies: {},
+      headers: {},
+      securitySchemes: additionalInfo.securitySchemes || {
+        ApiKeyAuth: {
+          type: 'apiKey',
+          in: 'header',
+          name: 'x-api-key',
+        },
+        BearerAuth: {
+          type: 'http',
+          scheme: 'bearer',
+        },
+      },
+    },
+    security: additionalInfo.security || [
+      {
+        ApiKeyAuth: [],
+      },
+      {
+        BearerAuth: [],
+      },
+    ],
+    tags: additionalInfo.tags,
+    externalDocs: additionalInfo.externalDocs,
+    // definitions
+  }
+}