@pikku/cli 0.6.20 → 0.7.0

package/src/openapi/openapi-spec-generator.ts

@@ -1,227 +0,0 @@
-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
-  }
-}

package/src/pikku-cli-config.ts

@@ -1,204 +0,0 @@
-import { join, dirname, resolve, isAbsolute } from 'path'
-import { readdir, readFile } from 'fs/promises'
-import { OpenAPISpecInfo } from './openapi/openapi-spec-generator.js'
-import { InspectorFilters } from '@pikku/inspector'
-
-export interface PikkuCLICoreOutputFiles {
-  outDir?: string
-  routesFile: string
-  channelsFile: string
-  schedulersFile: string
-  schemaDirectory: string
-  typesDeclarationFile: string
-  routesMapDeclarationFile: string
-  channelsMapDeclarationFile: string
-  bootstrapFile: string
-}
-
-export type PikkuCLIConfig = {
-  $schema?: string
-
-  extends?: string
-
-  rootDir: string
-  routeDirectories: string[]
-  packageMappings: Record<string, string>
-  supportsImportAttributes: boolean
-
-  configDir: string
-  tsconfig: string
-
-  nextBackendFile?: string
-  nextHTTPFile?: string
-  fetchFile?: string
-  websocketFile?: string
-
-  openAPI?: {
-    outputFile: string
-    additionalInfo: OpenAPISpecInfo
-  }
-
-  filters: InspectorFilters
-} & PikkuCLICoreOutputFiles
-
-const CONFIG_DIR_FILES = [
-  'nextBackendFile',
-  'nextHTTPFile',
-  'fetchFile',
-  'websocketFile',
-]
-
-export const getPikkuCLIConfig = async (
-  configFile: string | undefined = undefined,
-  requiredFields: Array<keyof PikkuCLIConfig>,
-  tags: string[] = [],
-  exitProcess: boolean = false
-): Promise<PikkuCLIConfig> => {
-  const config = await _getPikkuCLIConfig(
-    configFile,
-    requiredFields,
-    tags,
-    exitProcess
-  )
-  return config
-}
-
-const _getPikkuCLIConfig = async (
-  configFile: string | undefined = undefined,
-  requiredFields: Array<keyof PikkuCLIConfig>,
-  tags: string[] = [],
-  exitProcess: boolean = false
-): Promise<PikkuCLIConfig> => {
-  if (!configFile) {
-    let execDirectory = process.cwd()
-    const files = await readdir(execDirectory)
-    const file = files.find((file) => /pikku\.config\.(ts|js|json)$/.test(file))
-    if (!file) {
-      const errorMessage =
-        '\nConfig file pikku.config.json not found\nExiting...'
-      if (exitProcess) {
-        console.error(errorMessage)
-        process.exit(1)
-      }
-      throw new Error(errorMessage)
-    }
-    configFile = join(execDirectory, file)
-  }
-
-  try {
-    let result: PikkuCLIConfig
-    const file = await readFile(configFile, 'utf-8')
-    const configDir = dirname(configFile)
-    const config: PikkuCLIConfig = JSON.parse(file)
-    if (config.extends) {
-      const extendedConfig = await getPikkuCLIConfig(
-        resolve(configDir, config.extends),
-        [],
-        tags,
-        exitProcess
-      )
-      result = {
-        ...extendedConfig,
-        ...config,
-        configDir,
-        packageMappings: {
-          ...extendedConfig.packageMappings,
-          ...config.packageMappings,
-        },
-      }
-    } else {
-      result = {
-        ...config,
-        configDir,
-        packageMappings: config.packageMappings || {},
-        rootDir: config.rootDir
-          ? resolve(configDir, config.rootDir)
-          : configDir,
-      }
-    }
-
-    if (result.outDir) {
-      if (!result.schemaDirectory) {
-        result.schemaDirectory = join(result.outDir, 'pikku-schemas')
-      }
-      if (!result.routesFile) {
-        result.routesFile = join(result.outDir, 'pikku-routes.gen.ts')
-      }
-      if (!result.schedulersFile) {
-        result.schedulersFile = join(result.outDir, 'pikku-schedules.gen.ts')
-      }
-      if (!result.channelsFile) {
-        result.channelsFile = join(result.outDir, 'pikku-channels.gen.ts')
-      }
-      if (!result.typesDeclarationFile) {
-        result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.ts')
-      }
-      if (!result.routesMapDeclarationFile) {
-        result.routesMapDeclarationFile = join(
-          result.outDir,
-          'pikku-routes-map.gen.d.ts'
-        )
-      }
-      if (!result.channelsMapDeclarationFile) {
-        result.channelsMapDeclarationFile = join(
-          result.outDir,
-          'pikku-channels-map.gen.d.ts'
-        )
-      }
-      if (!result.bootstrapFile) {
-        result.bootstrapFile = join(result.outDir, 'pikku-bootstrap.gen.ts')
-      }
-    }
-
-    if (requiredFields.length > 0) {
-      validateCLIConfig(result, requiredFields)
-    }
-
-    for (const objectKey of Object.keys(result)) {
-      if (objectKey.endsWith('File') || objectKey.endsWith('Directory')) {
-        const relativeTo = CONFIG_DIR_FILES.includes(objectKey)
-          ? result.configDir
-          : result.rootDir
-        if (result[objectKey]) {
-          if (!isAbsolute(result[objectKey])) {
-            result[objectKey] = join(relativeTo, result[objectKey])
-          }
-        }
-      }
-    }
-
-    result.filters = result.filters || {}
-    if (tags.length > 0) {
-      result.filters.tags = tags
-    }
-
-    if (!isAbsolute(result.tsconfig)) {
-      result.tsconfig = join(result.rootDir, result.tsconfig)
-    }
-
-    return result
-  } catch (e: any) {
-    console.error(e)
-    console.error(`Config file not found: ${configFile}`)
-    process.exit(1)
-  }
-}
-
-export const validateCLIConfig = (
-  cliConfig: PikkuCLIConfig,
-  required: Array<keyof PikkuCLIConfig>
-) => {
-  let errors: string[] = []
-  for (const key of required) {
-    if (!cliConfig[key]) {
-      errors.push(key)
-    }
-  }
-
-  if (errors.length > 0) {
-    console.error(
-      `${errors.join(', ')} ${errors.length === 1 ? 'is' : 'are'} required in pikku.config.json`
-    )
-    process.exit(1)
-  }
-}

package/src/scheduler/serialize-schedulers.ts

@@ -1,41 +0,0 @@
-import { ScheduledTasksMeta } from '@pikku/core/scheduler'
-import { getFileImportRelativePath } from '../utils.js'
-
-export const serializeSchedulers = (
-  outputPath: string,
-  filesWithScheduledTasks: Set<string>,
-  packageMappings: Record<string, string> = {}
-) => {
-  const serializedOutput: string[] = [
-    '/* The files with an addSerializedTasks function call */',
-  ]
-
-  Array.from(filesWithScheduledTasks)
-    .sort()
-    .forEach((path) => {
-      const filePath = getFileImportRelativePath(
-        outputPath,
-        path,
-        packageMappings
-      )
-      serializedOutput.push(`import '${filePath}'`)
-    })
-
-  return serializedOutput.join('\n')
-}
-
-export const serializeSchedulerMeta = (
-  scheduledTasksMeta: ScheduledTasksMeta
-) => {
-  const serializedOutput: string[] = []
-  serializedOutput.push("import { pikkuState } from '@pikku/core'")
-  serializedOutput.push(
-    `pikkuState('scheduler', 'meta', ${JSON.stringify(scheduledTasksMeta, null, 2)})`
-  )
-  if (scheduledTasksMeta.length > 0) {
-    serializedOutput.push(
-      `export type ScheduledTaskNames = '${scheduledTasksMeta.map((s) => s.name).join("' | '")}'`
-    )
-  }
-  return serializedOutput.join('\n')
-}

package/src/schema/schema-generator.ts

@@ -1,114 +0,0 @@
-import { createGenerator, RootlessError } from 'ts-json-schema-generator'
-import { logInfo, writeFileInDir } from '../utils.js'
-import { mkdir, writeFile } from 'fs/promises'
-import { JSONValue } from '@pikku/core'
-import { HTTPRoutesMeta } from '@pikku/core/http'
-import { TypesMap } from '@pikku/inspector'
-
-export async function generateSchemas(
-  tsconfig: string,
-  typesMap: TypesMap,
-  routesMeta: HTTPRoutesMeta
-): Promise<Record<string, JSONValue>> {
-  const schemasSet = new Set(typesMap.customTypes.keys())
-  for (const { input, output, inputTypes } of routesMeta) {
-    if (input) {
-      schemasSet.add(typesMap.getTypeMeta(input).uniqueName)
-    }
-    if (output) {
-      schemasSet.add(typesMap.getTypeMeta(output).uniqueName)
-    }
-    if (inputTypes?.body) {
-      schemasSet.add(inputTypes.body)
-    }
-    if (inputTypes?.query) {
-      schemasSet.add(inputTypes.query)
-    }
-    if (inputTypes?.params) {
-      schemasSet.add(inputTypes.params)
-    }
-  }
-
-  const generator = createGenerator({
-    tsconfig,
-    skipTypeCheck: true,
-    topRef: false,
-    discriminatorType: 'open-api',
-  })
-  const schemas: Record<string, JSONValue> = {}
-  schemasSet.forEach((schema) => {
-    try {
-      schemas[schema] = generator.createSchema(schema) as JSONValue
-    } catch (e) {
-      // Ignore rootless errors
-      if (e instanceof RootlessError) {
-        console.error('Error generating schema since it has no root:', schema)
-        return
-      }
-      throw e
-    }
-  })
-
-  return schemas
-}
-
-export async function saveSchemas(
-  schemaParentDir: string,
-  schemas: Record<string, JSONValue>,
-  typesMap: TypesMap,
-  routesMeta: HTTPRoutesMeta,
-  supportsImportAttributes: boolean
-) {
-  await writeFileInDir(
-    `${schemaParentDir}/register.gen.ts`,
-    'export const empty = null;'
-  )
-
-  const desiredSchemas = new Set([
-    ...routesMeta
-      .map(({ input, output }) => [
-        input ? typesMap.getUniqueName(input) : undefined,
-        output ? typesMap.getUniqueName(output) : undefined,
-      ])
-      .flat()
-      .filter(
-        (s) =>
-          !!s &&
-          !['boolean', 'string', 'number', 'null', 'undefined'].includes(s)
-      ),
-    ...typesMap.customTypes.keys(),
-  ])
-
-  if (desiredSchemas.size === 0) {
-    logInfo(`• Skipping schemas since none found.\x1b[0m`)
-    return
-  }
-
-  await mkdir(`${schemaParentDir}/schemas`, { recursive: true })
-  await Promise.all(
-    Object.entries(schemas).map(async ([schemaName, schema]) => {
-      if (desiredSchemas.has(schemaName)) {
-        await writeFile(
-          `${schemaParentDir}/schemas/${schemaName}.schema.json`,
-          JSON.stringify(schema),
-          'utf-8'
-        )
-      }
-    })
-  )
-
-  const schemaImports = Array.from(desiredSchemas)
-    .map(
-      (schema) => `
-import * as ${schema} from './schemas/${schema}.schema.json' ${supportsImportAttributes ? `with { type: 'json' }` : ''}
-addSchema('${schema}', ${schema})
-`
-    )
-    .join('\n')
-
-  await writeFileInDir(
-    `${schemaParentDir}/register.gen.ts`,
-    `import { addSchema } from '@pikku/core/schema'
-${schemaImports}`
-  )
-}