@pikku/cli 0.11.2 → 0.12.0

package/src/functions/wirings/http/openapi-spec-generator.ts

@@ -1,265 +0,0 @@
-import { FunctionsMeta, pikkuState } from '@pikku/core'
-import { HTTPWiringsMeta } from '@pikku/core/http'
-import _convertSchema from '@openapi-contrib/json-schema-to-openapi-schema'
-import { CLILogger } from '../../../services/cli-logger.service.js'
-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 (
-  functionsMeta: FunctionsMeta,
-  routesMeta: HTTPWiringsMeta,
-  schemas: Record<string, any>
-) => {
-  const requiredSchemas = new Set<string>()
-  for (const routeMeta of Object.values(routesMeta)) {
-    for (const { inputTypes, pikkuFuncName } of Object.values(routeMeta)) {
-      const output = functionsMeta[pikkuFuncName]?.outputs?.[0]
-      if (inputTypes?.body) {
-        requiredSchemas.add(inputTypes?.body)
-      }
-      if (output) {
-        requiredSchemas.add(output)
-      }
-    }
-  }
-
-  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(
-  logger: CLILogger,
-  functionsMeta: FunctionsMeta,
-  httpMeta: HTTPWiringsMeta,
-  schemas: Record<string, any>,
-  additionalInfo: OpenAPISpecInfo
-): Promise<OpenAPISpec> {
-  const paths: Record<string, any> = {}
-
-  for (const routeMeta of Object.values(httpMeta)) {
-    for (const meta of Object.values(routeMeta)) {
-      const {
-        route,
-        method,
-        inputTypes,
-        pikkuFuncName,
-        params,
-        query,
-        errors,
-        description,
-        tags,
-      } = meta
-      const functionMeta = functionsMeta[pikkuFuncName]
-      if (!functionMeta) {
-        logger.error(
-          `• No function metadata found for '${pikkuFuncName}' in route '${route}'.`
-        )
-        continue
-      }
-
-      const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
-
-      const path = route.replace(/:(\w+)/g, '{$1}') // Convert ":param" to "{param}"
-
-      if (!paths[path]) {
-        paths[path] = {}
-      }
-
-      const responses = {}
-      errors?.forEach((error) => {
-        const errorResponse = getErrorResponseForConstructorName(error)
-        if (errorResponse) {
-          responses[errorResponse.status] = {
-            description: errorResponse.message,
-          }
-        }
-      })
-
-      const operation: any = {
-        description:
-          description ||
-          `This endpoint handles the ${method.toUpperCase()} request for the route ${route}.`,
-        tags: 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(
-        functionsMeta,
-        httpMeta,
-        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
-  }
-}

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

@@ -1,27 +0,0 @@
-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 { serializeTypedHTTPWiringsMap } from './serialize-typed-http-map.js'
-
-export const pikkuHTTPMap: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config, getInspectorState }) => {
-    const { http, functions } = await getInspectorState()
-    const { httpMapDeclarationFile, packageMappings } = config
-
-    const content = serializeTypedHTTPWiringsMap(
-      httpMapDeclarationFile,
-      packageMappings,
-      functions.typesMap,
-      functions.meta,
-      http.meta,
-      http.metaInputTypes
-    )
-    await writeFileInDir(logger, httpMapDeclarationFile, content)
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Creating HTTP map',
-      commandEnd: 'Created HTTP map',
-    }),
-  ],
-})

package/src/functions/wirings/http/pikku-command-http-routes.ts

@@ -1,36 +0,0 @@
-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 pikkuHTTP: any = pikkuSessionlessFunc<void, boolean | undefined>({
-  func: async ({ logger, config, getInspectorState }) => {
-    const visitState = await getInspectorState()
-    const { httpWiringsFile, httpWiringMetaFile, packageMappings } = config
-    const { http } = visitState
-
-    await writeFileInDir(
-      logger,
-      httpWiringsFile,
-      serializeFileImports(
-        'wireHTTP',
-        httpWiringsFile,
-        http.files,
-        packageMappings
-      )
-    )
-    await writeFileInDir(
-      logger,
-      httpWiringMetaFile,
-      `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`
-    )
-
-    return true
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Finding HTTP routes',
-      commandEnd: 'Found HTTP routes',
-    }),
-  ],
-})

package/src/functions/wirings/http/pikku-command-http-types.ts

@@ -1,25 +0,0 @@
-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 { serializeHTTPTypes } from './serialize-http-types.js'
-
-export const pikkuHTTPTypes: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config }) => {
-    const { httpTypesFile, functionTypesFile, packageMappings } = config
-
-    const functionTypesImportPath = getFileImportRelativePath(
-      httpTypesFile,
-      functionTypesFile,
-      packageMappings
-    )
-    const content = serializeHTTPTypes(functionTypesImportPath)
-    await writeFileInDir(logger, httpTypesFile, content)
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Creating HTTP types',
-      commandEnd: 'Created HTTP types',
-    }),
-  ],
-})

package/src/functions/wirings/http/pikku-command-openapi.ts

@@ -1,63 +0,0 @@
-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 { generateSchemas } from '../../../utils/schema-generator.js'
-import { generateOpenAPISpec } from './openapi-spec-generator.js'
-import { stringify } from 'yaml'
-
-export const pikkuOpenAPI: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config, getInspectorState }) => {
-    const { tsconfig, openAPI, schemasFromTypes } = config
-
-    // If openAPI outputFile is not defined, clean up any existing file and return
-    if (!openAPI?.outputFile) {
-      logger.info({
-        message:
-          'Skipping creating OpenAPI spec since openAPI outfile is not defined.',
-        type: 'skip',
-      })
-      return
-    }
-
-    const { http, functions } = await getInspectorState()
-
-    const schemas = await generateSchemas(
-      logger,
-      tsconfig,
-      functions.typesMap,
-      functions.meta,
-      http.meta,
-      schemasFromTypes,
-      config.schema?.additionalProperties
-    )
-    const openAPISpec = await generateOpenAPISpec(
-      logger,
-      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,
-      })
-    }
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Creating OpenAPI spec',
-      commandEnd: 'Created OpenAPI spec',
-    }),
-  ],
-})

package/src/functions/wirings/http/pikku-http-routes.ts

@@ -1,61 +0,0 @@
-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'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-
-export const pikkuHTTP: any = pikkuSessionlessFunc<void, boolean>({
-  func: async ({ logger, config, getInspectorState }) => {
-    const visitState = await getInspectorState()
-    const {
-      httpWiringsFile,
-      httpWiringMetaFile,
-      httpWiringMetaJsonFile,
-      packageMappings,
-      schema,
-    } = config
-    const { http } = visitState
-
-    await writeFileInDir(
-      logger,
-      httpWiringsFile,
-      serializeFileImports(
-        'wireHTTP',
-        httpWiringsFile,
-        http.files,
-        packageMappings
-      )
-    )
-
-    await writeFileInDir(
-      logger,
-      httpWiringMetaJsonFile,
-      JSON.stringify(http.meta, null, 2)
-    )
-
-    const jsonImportPath = getFileImportRelativePath(
-      httpWiringMetaFile,
-      httpWiringMetaJsonFile,
-      packageMappings
-    )
-
-    const supportsImportAttributes = schema?.supportsImportAttributes ?? false
-    const importStatement = supportsImportAttributes
-      ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-      : `import metaData from '${jsonImportPath}'`
-
-    await writeFileInDir(
-      logger,
-      httpWiringMetaFile,
-      `import { pikkuState, HTTPWiringsMeta } from '@pikku/core'\n${importStatement}\npikkuState('http', 'meta', metaData as HTTPWiringsMeta)`
-    )
-
-    return true
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Finding HTTP routes',
-      commandEnd: 'Found HTTP routes',
-    }),
-  ],
-})

package/src/functions/wirings/http/serialize-fetch-wrapper.ts

@@ -1,67 +0,0 @@
-export const serializeFetchWrapper = (routesMapPath: string) => {
-  return `
-import { CorePikkuFetch, HTTPMethod } from '@pikku/fetch'
-import type { HTTPWiringsMap, HTTPWiringHandlerOf, HTTPWiringsWithMethod } from '${routesMapPath}'
-
-export class PikkuFetch extends CorePikkuFetch {
-    public async post<Route extends HTTPWiringsWithMethod<'POST'>>(
-        route: Route,
-        ...args: null extends HTTPWiringHandlerOf<Route, 'POST'>['input']
-            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'POST'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: HTTPWiringHandlerOf<Route, 'POST'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'POST', data, options);
-    }
-
-    public async get<Route extends HTTPWiringsWithMethod<'GET'>>(
-        route: Route,
-        ...args: null extends HTTPWiringHandlerOf<Route, 'GET'>['input']
-            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'GET'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: HTTPWiringHandlerOf<Route, 'GET'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'GET', data, options);
-    }
-
-    public async patch<Route extends HTTPWiringsWithMethod<'PATCH'>>(
-        route: Route,
-        ...args: null extends HTTPWiringHandlerOf<Route, 'PATCH'>['input']
-            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'PATCH'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: HTTPWiringHandlerOf<Route, 'PATCH'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<HTTPWiringHandlerOf<Route, 'PATCH'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'PATCH', data, options);
-    }
-
-    public async head<Route extends HTTPWiringsWithMethod<'HEAD'>>(
-        route: Route,
-        ...args: null extends HTTPWiringHandlerOf<Route, 'HEAD'>['input']
-            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'HEAD'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: HTTPWiringHandlerOf<Route, 'HEAD'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<HTTPWiringHandlerOf<Route, 'HEAD'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'HEAD', data, options);
-    }
-
-    public async delete<Route extends HTTPWiringsWithMethod<'DELETE'>>(
-        route: Route,
-        ...args: null extends HTTPWiringHandlerOf<Route, 'DELETE'>['input']
-            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'DELETE'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: HTTPWiringHandlerOf<Route, 'DELETE'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<HTTPWiringHandlerOf<Route, 'DELETE'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'DELETE', data, options);
-    }
-
-    public async fetch<
-        Route extends keyof HTTPWiringsMap,
-        Method extends keyof HTTPWiringsMap[Route]
-    >(route: Route, method: Method, data: HTTPWiringHandlerOf<Route, Method>['input'], options?: Omit<RequestInit, 'body'>): Promise<Response> {
-        return await super.fetch(route, method as HTTPMethod, data, options);
-    }
-}
-
-export const pikkuFetch = new PikkuFetch();
-`
-}

package/src/functions/wirings/http/serialize-http-types.ts

@@ -1,89 +0,0 @@
-/**
- * Generates type definitions for HTTP wirings
- */
-export const serializeHTTPTypes = (functionTypesImportPath: string) => {
-  return `/**
- * HTTP-specific type definitions for tree-shaking optimization
- */
-
-import { AssertHTTPWiringParams, wireHTTP as wireHTTPCore, addHTTPMiddleware as addHTTPMiddlewareCore, addHTTPPermission as addHTTPPermissionCore } from '@pikku/core/http'
-import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
-import type { CoreHTTPFunctionWiring } from '@pikku/core/http'
-
-/**
- * Type definition for HTTP API wirings with type-safe path parameters.
- * Supports both authenticated and unauthenticated functions.
- *
- * @template In - Input type for the HTTP wiring
- * @template Out - Output type for the HTTP wiring
- * @template Route - String literal type for the HTTP path (e.g., "/users/:id")
- */
-type HTTPWiring<In, Out, Route extends string> = CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction<In, Out, 'rpc' | 'session'>, PikkuFunctionSessionless<In, Out, 'rpc' | 'session'>, PikkuPermission<In>, PikkuMiddleware>
-
-/**
- * Registers an HTTP wiring with the Pikku framework.
- *
- * @template In - Input type for the HTTP wiring
- * @template Out - Output type for the HTTP wiring
- * @template Route - String literal type for the HTTP path (e.g., "/users/:id")
- * @param httpWiring - HTTP wiring definition with handler, method, and optional middleware
- */
-export const wireHTTP = <In, Out, Route extends string>(
-  httpWiring: HTTPWiring<In, Out, Route> & AssertHTTPWiringParams<In, Route>
-) => {
-  wireHTTPCore(httpWiring as any)
-}
-
-/**
- * Registers HTTP middleware either globally or for a specific route pattern.
- *
- * When a string route pattern is provided along with middleware, the middleware
- * is applied only to that route. Otherwise, if an array is provided, it is treated
- * as global middleware (applied to all routes).
- *
- * @param routeOrMiddleware - Either a global middleware array or a route pattern string
- * @param middleware - The middleware array to apply when a route pattern is specified
- *
- * @example
- * \`\`\`typescript
- * // Add global HTTP middleware
- * addHTTPMiddleware([authMiddleware, loggingMiddleware])
- *
- * // Add route-specific middleware
- * addHTTPMiddleware('/api/admin/*', [adminAuthMiddleware])
- * \`\`\`
- */
-export const addHTTPMiddleware = (
-  routeOrMiddleware: PikkuMiddleware[] | string,
-  middleware?: PikkuMiddleware[]
-) => {
-  addHTTPMiddlewareCore(routeOrMiddleware as any, middleware as any)
-}
-
-/**
- * Registers HTTP permissions either globally or for a specific route pattern.
- *
- * When a string route pattern is provided along with permissions, the permissions
- * are applied only to that route. Permissions can be passed as an array or as a
- * permission group object.
- *
- * @param pattern - Route pattern string (e.g., '*' for all routes, '/api/*' for specific routes)
- * @param permissions - The permissions to apply for the specified route pattern
- *
- * @example
- * \`\`\`typescript
- * // Add global HTTP permissions
- * addHTTPPermission('*', { global: globalPermission })
- *
- * // Add route-specific permissions
- * addHTTPPermission('/api/admin/*', { admin: adminPermission })
- * \`\`\`
- */
-export const addHTTPPermission = <In = unknown>(
-  pattern: string,
-  permissions: Record<string, PikkuPermission<In>> | PikkuPermission<In>[]
-) => {
-  addHTTPPermissionCore(pattern, permissions as any)
-}
-`
-}