massimo-cli 0.0.1 → 0.1.2

package/lib/graphql-generator.js

@@ -0,0 +1,136 @@
+import CodeBlockWriter from 'code-block-writer'
+import { UnknownTypeError } from './errors.js'
+import { capitalize, toJavaScriptName } from './utils.js'
+
+export function processGraphQL ({ schema, name, folder, url }) {
+  schema = schema.__schema
+  return {
+    types: generateTypesFromGraphQL({ schema, name }),
+    implementation: generateImplementationFromGraqhQL({ schema, name, url })
+  }
+}
+
+const skip = new Set(['Query', 'Mutation', 'Subscription', 'Boolean', 'String'])
+
+function generateTypesFromGraphQL ({ schema, name }) {
+  const camelcasedName = toJavaScriptName(name)
+
+  const writer = new CodeBlockWriter({
+    indentNumberOfSpaces: 2,
+    useTabs: false,
+    useSingleQuote: true
+  })
+
+  const functionName = `generate${capitalize(camelcasedName)}Client`
+
+  writer.writeLine("import { type PlatformaticClientOptions } from '@platformatic/massimo'")
+  writer.blankLine()
+
+  writer.write('interface GraphQLQueryOptions').block(() => {
+    writer.writeLine('query: string;')
+    writer.writeLine('headers: Record<string, string>;')
+    writer.writeLine('variables: Record<string, unknown>;')
+  })
+
+  writer.write('interface GraphQLClient').block(() => {
+    writer.writeLine('graphql<T>(options: GraphQLQueryOptions): PromiseLike<T>;')
+  })
+  writer.blankLine()
+
+  for (const type of schema.types) {
+    if (type.kind === 'OBJECT' && type.name.indexOf('__') === -1 && !skip.has(type.name)) {
+      const capitalizedName = capitalize(type.name)
+      writer.write(`export interface ${capitalizedName}`).block(() => {
+        const addedProps = new Set()
+        for (const field of type.fields) {
+          writeProperty(writer, field.name, field.type, addedProps)
+        }
+      })
+    }
+  }
+
+  writer.write('interface GraphQLClient').block(() => {
+    writer.writeLine('graphql<T>(GraphQLQuery): Promise<T>;')
+  })
+
+  writer.blankLine()
+  writer.writeLine(`export function ${functionName}(opts: PlatformaticClientOptions): Promise<GraphQLClient>;`)
+  writer.writeLine(`export default ${functionName};`)
+
+  return writer.toString()
+}
+
+function generateImplementationFromGraqhQL ({ name, url }) {
+  const camelcasedName = toJavaScriptName(name)
+
+  const writer = new CodeBlockWriter({
+    indentNumberOfSpaces: 2,
+    useTabs: false,
+    useSingleQuote: true
+  })
+
+  writer.writeLine("import { buildGraphQLClient } from '@platformatic/massimo'")
+  writer.writeLine("import { join } from 'node:path'")
+  writer.blankLine()
+
+  url = new URL(url)
+
+  const functionName = `generate${capitalize(camelcasedName)}Client`
+  writer.write(`export async function ${functionName} (opts)`).block(() => {
+    writer.writeLine('const url = new URL(opts.url)')
+    writer.writeLine(`url.pathname = '${url.pathname}'`)
+    writer.write('return buildGraphQLClient(').inlineBlock(() => {
+      writer.writeLine("type: 'graphql',")
+      writer.writeLine(`name: '${camelcasedName}',`)
+      writer.writeLine(`path: join(import.meta.dirname, '${name}.schema.graphql'),`)
+      writer.writeLine('serviceId: opts.serviceId,')
+      writer.writeLine('url: url.toString()')
+    })
+    writer.write(')')
+  })
+  writer.blankLine()
+  writer.writeLine(`export default ${functionName}`)
+  return writer.toString()
+}
+
+function GraphQLScalarToTsType (type) {
+  switch (type) {
+    case 'String':
+      return 'string'
+    case 'ID':
+      return 'string'
+    case 'Int':
+      return 'number'
+    case 'Float':
+      return 'number'
+    case 'Date':
+      return 'string'
+    case 'DateTime':
+      return 'string'
+    // TODO test other scalar types
+    /* c8 ignore next 3 */
+    default:
+      throw new UnknownTypeError(type)
+  }
+}
+
+function writeProperty (writer, key, value, addedProps) {
+  addedProps.add(key)
+  writer.quote(key)
+  writer.write('?')
+  if (value.kind === 'SCALAR') {
+    writer.write(`: ${GraphQLScalarToTsType(value.name)};`)
+    writer.newLine()
+  } else if (value.kind === 'LIST') {
+    writer.write(`: Array<${capitalize(value.ofType.name)}>;`)
+    writer.newLine()
+  } else if (value.kind === 'OBJECT') {
+    writer.write(`: ${capitalize(value.name)};`)
+    writer.newLine()
+    // TODO are there other kinds that needs to be handled?
+    /* c8 ignore next 3 */
+  } else {
+    throw new UnknownTypeError(value.kind)
+  }
+  writer.newLine()
+}

package/lib/openapi-common.js

@@ -0,0 +1,281 @@
+import { hasDuplicatedParameters } from '@platformatic/massimo'
+import camelcase from 'camelcase'
+import CodeBlockWriter from 'code-block-writer'
+import jsonpointer from 'jsonpointer'
+import { TypeNotSupportedError } from './errors.js'
+import { getType } from './get-type.js'
+import { responsesWriter } from './responses-writer.js'
+import { capitalize, getBodyType } from './utils.js'
+
+export function writeOperations (
+  interfacesWriter,
+  mainWriter,
+  operations,
+  { fullRequest, fullResponse, optionalHeaders, schema, propsOptional }
+) {
+  const originalFullResponse = fullResponse
+  const originalFullRequest = fullRequest
+  let currentFullResponse = originalFullResponse
+  let currentFullRequest = originalFullRequest
+  for (const operation of operations) {
+    const { operationId, description, summary, deprecated } = operation.operation
+    const camelCaseOperationId = camelcase(operationId)
+    const { parameters, responses, requestBody } = operation.operation
+    currentFullRequest = fullRequest || hasDuplicatedParameters(operation.operation)
+    if (!responses) {
+      throw new Error(`Cannot find any response definition in operation ${operationId}.`)
+    }
+    const successResponses = Object.entries(responses).filter(([s]) => s.startsWith('2'))
+    if (successResponses.length !== 1) {
+      currentFullResponse = true
+    }
+
+    const capitalizedCamelCaseOperationId = capitalize(camelCaseOperationId)
+    const operationRequestName = `${capitalizedCamelCaseOperationId}Request`
+
+    let isRequestArray = false
+    let isStructuredType = false
+    const bodyWriter = new CodeBlockWriter({
+      indentNumberOfSpaces: 2,
+      useTabs: false,
+      useSingleQuote: true
+    })
+
+    const addedProps = new Set()
+    if (parameters) {
+      if (currentFullRequest) {
+        const bodyParams = []
+        const pathParams = []
+        const queryParams = []
+        const headersParams = []
+        for (const parameter of parameters) {
+          if (optionalHeaders.includes(parameter.name)) {
+            parameter.required = false
+          }
+          switch (parameter.in) {
+            case 'query':
+              queryParams.push(parameter)
+              break
+            case 'path':
+              pathParams.push(parameter)
+              break
+            case 'body':
+              bodyParams.push(parameter)
+              break
+            case 'header':
+              headersParams.push(parameter)
+              break
+          }
+        }
+        writeProperties(bodyWriter, 'body', bodyParams, addedProps, 'req', schema)
+        writeProperties(bodyWriter, 'path', pathParams, addedProps, 'req', schema)
+        writeProperties(bodyWriter, 'query', queryParams, addedProps, 'req', schema)
+        writeProperties(bodyWriter, 'headers', headersParams, addedProps, 'req', schema)
+      } else {
+        for (const parameter of parameters) {
+          let { name, required } = parameter
+          if (optionalHeaders.includes(name)) {
+            required = false
+          }
+          // We do not check for addedProps here because it's the first
+          // group of properties
+          writeProperty(bodyWriter, name, parameter, addedProps, required, 'req', schema)
+        }
+      }
+    }
+    if (requestBody) {
+      const bodyType = getBodyType(requestBody)
+      if (parameters && parameters.length && (bodyType === 'array' || bodyType === 'plain')) {
+        currentFullRequest = true
+      }
+      const writeContentOutput = writeContent(
+        bodyWriter,
+        requestBody.content,
+        schema,
+        addedProps,
+        'req',
+        currentFullRequest ? 'body' : null,
+        propsOptional
+      )
+      isRequestArray = writeContentOutput.isArray
+      isStructuredType = writeContentOutput.isStructuredType
+    }
+
+    if (isStructuredType || currentFullRequest || !isRequestArray) {
+      interfacesWriter.write(`export type ${operationRequestName} =`).block(() => {
+        interfacesWriter.write(bodyWriter.toString())
+      })
+    } else {
+      interfacesWriter.write(`export type ${operationRequestName} = `)
+      interfacesWriter.write(bodyWriter.toString())
+    }
+
+    interfacesWriter.blankLine()
+    const allResponsesName = responsesWriter(
+      capitalizedCamelCaseOperationId,
+      responses,
+      currentFullResponse,
+      interfacesWriter,
+      schema
+    )
+    mainWriter.writeLine('/**')
+    if (summary) {
+      for (const line of summary.split('\n')) {
+        mainWriter.writeLine(` * ${line}`)
+      }
+      // Separate summary and description by blank line
+      if (description) {
+        mainWriter.writeLine(' *')
+      }
+    }
+    if (description) {
+      for (const line of description.split('\n')) {
+        mainWriter.writeLine(` * ${line}`)
+      }
+    }
+    if (deprecated) {
+      mainWriter.writeLine(' * @deprecated')
+    }
+    mainWriter.writeLine(' * @param req - request parameters object')
+    mainWriter.writeLine(` * @returns the API response${fullResponse ? '' : ' body'}`)
+    mainWriter.writeLine(' */')
+    mainWriter.writeLine(`${camelCaseOperationId}(req: ${operationRequestName}): Promise<${allResponsesName}>;`)
+    currentFullResponse = originalFullResponse
+    currentFullRequest = originalFullRequest
+  }
+}
+
+export function writeProperties (writer, blockName, parameters, addedProps, methodType, spec) {
+  if (parameters.length > 0) {
+    let allOptionalParams = true
+    for (const { required } of parameters) {
+      if (required !== false) {
+        allOptionalParams = false
+      }
+    }
+    const nameToWrite = allOptionalParams ? `${blockName}?: ` : `${blockName}: `
+    writer.write(nameToWrite).block(() => {
+      for (const parameter of parameters) {
+        const { name, required } = parameter
+        // We do not check for addedProps here because it's the first
+        // group of properties
+        writeProperty(writer, name, parameter, addedProps, required, methodType, spec)
+      }
+    })
+  }
+}
+
+export function writeProperty (writer, key, value, addedProps, required = true, methodType, spec) {
+  addedProps.add(key)
+
+  if (value.description || value.deprecated) {
+    writer.writeLine('/**')
+    if (value.description) {
+      for (const line of value.description.split('\n')) {
+        writer.writeLine(` * ${line}`)
+      }
+    }
+    if (value.deprecated) {
+      writer.writeLine(' * @deprecated')
+    }
+    writer.writeLine(' */')
+  }
+
+  if (required) {
+    writer.quote(key)
+  } else {
+    writer.quote(key)
+    writer.write('?')
+  }
+
+  writer.write(`: ${getType(value, methodType, spec)};`)
+  writer.newLine()
+}
+
+export function writeContent (writer, content, spec, addedProps, methodType, wrapper, propsOptional) {
+  let isArray = false
+  let isStructuredType = false
+  if (content) {
+    for (const [contentType, body] of Object.entries(content)) {
+      const isFormDataContent = contentType.indexOf('multipart/form-data') === 0
+
+      // We ignore all non-JSON endpoints for now
+      // TODO: support other content types
+      /* c8 ignore next 3 */
+      if (contentType.indexOf('application/json') !== 0 && !isFormDataContent) {
+        continue
+      }
+
+      if (isFormDataContent && wrapper) {
+        writer.write(`${wrapper}: FormData;`)
+        break
+      }
+
+      // Response body has no schema that can be processed
+      // Should not be possible with well formed OpenAPI
+      /* c8 ignore next 3 */
+      if (!body.schema?.type && !body.schema?.$ref && !body.schema?.allOf && !body.schema?.anyOf) {
+        break
+      }
+      if (body.schema.type === 'object' || body.schema.$ref) {
+        isStructuredType = true
+      }
+      let schema
+      // This is likely buggy as there can be multiple responses for different
+      // status codes. This is currently not possible with Platformatic DB
+      // services so we skip for now.
+      // TODO: support different schemas for different status codes
+      if (body.schema.type === 'array') {
+        isArray = true
+        if (wrapper) {
+          writer.write(`${wrapper}: `)
+        }
+        writer.write(getType(body.schema, methodType, spec))
+        return { isArray, isStructuredType }
+      } else {
+        schema = body.schema
+      }
+
+      if (wrapper) {
+        if (isStructuredType) {
+          writer
+            .write(`${wrapper}: `)
+            .block(() => writeObjectProperties(writer, schema, spec, addedProps, methodType, propsOptional))
+        } else {
+          writer.write(`${wrapper}: ${getType(body.schema, methodType, spec)}`)
+        }
+      } else {
+        writeObjectProperties(writer, schema, spec, addedProps, methodType, propsOptional)
+      }
+      break
+    }
+  }
+  return { isArray, isStructuredType }
+}
+
+export function writeObjectProperties (writer, schema, spec, addedProps, methodType, propsOptional) {
+  function _writeObjectProps (obj) {
+    for (const [key, value] of Object.entries(obj)) {
+      if (addedProps.has(key)) {
+        continue
+      }
+      const required = (propsOptional ? !!schema.required : schema.required) && schema.required.includes(key)
+      writeProperty(writer, key, value, addedProps, required, methodType, spec)
+    }
+  }
+
+  if (schema.$ref) {
+    schema = jsonpointer.get(spec, schema.$ref.replace('#', ''))
+  }
+  if (schema.type === 'object') {
+    if (schema.properties) {
+      _writeObjectProps(schema.properties)
+    }
+
+    if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+      _writeObjectProps(schema.additionalProperties)
+    }
+  } else {
+    throw new TypeNotSupportedError(schema.type)
+  }
+}

package/lib/openapi-generator.js

@@ -0,0 +1,153 @@
+import { generateOperationId } from '@platformatic/massimo'
+import CodeBlockWriter from 'code-block-writer'
+import { writeOperations } from './openapi-common.js'
+import { capitalize, toJavaScriptName } from './utils.js'
+
+export function processOpenAPI ({
+  schema,
+  name,
+  fullResponse,
+  fullRequest,
+  optionalHeaders,
+  validateResponse,
+  typesComment,
+  propsOptional
+}) {
+  return {
+    types: generateTypesFromOpenAPI({
+      schema,
+      name,
+      fullResponse,
+      fullRequest,
+      optionalHeaders,
+      typesComment,
+      propsOptional
+    }),
+    implementation: generateImplementationFromOpenAPI({ name, fullResponse, fullRequest, validateResponse })
+  }
+}
+
+function generateImplementationFromOpenAPI ({ name, fullResponse, fullRequest, validateResponse }) {
+  const camelcasedName = toJavaScriptName(name)
+
+  const writer = new CodeBlockWriter({
+    indentNumberOfSpaces: 2,
+    useTabs: false,
+    useSingleQuote: true
+  })
+
+  writer.writeLine("import { buildOpenAPIClient } from '@platformatic/massimo'")
+  writer.writeLine("import { join } from 'node:path'")
+  writer.blankLine()
+
+  const functionName = `generate${capitalize(camelcasedName)}Client`
+  writer.write(`export async function ${functionName} (opts)`).block(() => {
+    writer.write('return buildOpenAPIClient(').inlineBlock(() => {
+      writer.writeLine("type: 'openapi',")
+      writer.writeLine(`name: '${camelcasedName}',`)
+      writer.writeLine(`path: join(import.meta.dirname, '${name}.openapi.json'),`)
+      writer.writeLine('url: opts.url,')
+      writer.writeLine('serviceId: opts.serviceId,')
+      writer.writeLine('throwOnError: opts.throwOnError,')
+      writer.writeLine(`fullResponse: ${fullResponse},`)
+      writer.writeLine(`fullRequest: ${fullRequest},`)
+      writer.writeLine(`validateResponse: ${validateResponse},`)
+      writer.writeLine('getHeaders: opts.getHeaders')
+    })
+    writer.write(')')
+  })
+  writer.blankLine()
+  writer.writeLine(`export default ${functionName}`)
+  return writer.toString()
+}
+
+function generateTypesFromOpenAPI ({
+  schema,
+  name,
+  fullResponse,
+  fullRequest,
+  optionalHeaders,
+  typesComment,
+  propsOptional
+}) {
+  const camelcasedName = toJavaScriptName(name)
+  const capitalizedName = capitalize(camelcasedName)
+  const { paths } = schema
+  const generatedOperationIds = []
+
+  const operations = Object.entries(paths).flatMap(([path, methods]) => {
+    let commonParameters = []
+    if (methods.parameters) {
+      // common parameters for all operations
+      commonParameters = methods.parameters
+      delete methods.parameters
+    }
+    return Object.entries(methods).map(([method, operation]) => {
+      if (operation.parameters) {
+        operation.parameters = [...operation.parameters, ...commonParameters]
+      } else {
+        operation.parameters = commonParameters
+      }
+      const opId = generateOperationId(path, method, operation, generatedOperationIds)
+      return {
+        path,
+        method,
+        operation: {
+          ...operation,
+          operationId: opId
+        }
+      }
+    })
+  })
+
+  const writer = new CodeBlockWriter({
+    indentNumberOfSpaces: 2,
+    useTabs: false,
+    useSingleQuote: true
+  })
+
+  const interfaces = new CodeBlockWriter({
+    indentNumberOfSpaces: 2,
+    useTabs: false,
+    useSingleQuote: true
+  })
+
+  if (typesComment) {
+    writer.writeLine(`// ${typesComment}`)
+  }
+
+  writer.writeLine(
+    "import { type GetHeadersOptions, type PlatformaticClientOptions, type StatusCode1xx, type StatusCode2xx, type StatusCode3xx, type StatusCode4xx, type StatusCode5xx } from '@platformatic/massimo'"
+  )
+  writer.writeLine("import { type FormData } from 'undici'")
+  writer.blankLine()
+
+  const functionName = `generate${capitalize(camelcasedName)}Client`
+
+  // Add always FullResponse interface because we don't know yet
+  // if we are going to use it
+  interfaces.write('export interface FullResponse<T, U extends number>').block(() => {
+    interfaces.writeLine("'statusCode': U;")
+    interfaces.writeLine("'headers': Record<string, string>;")
+    interfaces.writeLine("'body': T;")
+  })
+  interfaces.blankLine()
+
+  writer.write(`export type ${capitalizedName} =`).block(() => {
+    writeOperations(interfaces, writer, operations, {
+      fullRequest,
+      fullResponse,
+      optionalHeaders,
+      schema,
+      propsOptional
+    })
+  })
+
+  writer.write(interfaces.toString())
+
+  writer.blankLine()
+  writer.writeLine(`export function ${functionName}(opts: PlatformaticClientOptions): Promise<${capitalizedName}>;`)
+  writer.writeLine(`export default ${functionName};`)
+
+  return writer.toString()
+}

package/lib/responses-writer.js

@@ -0,0 +1,91 @@
+import { STATUS_CODES } from 'node:http'
+import { getType } from './get-type.js'
+import { capitalize, classCase, getResponseContentType, getResponseTypes } from './utils.js'
+
+function responsesWriter (operationId, responsesObject, isFullResponse, writer, spec) {
+  const mappedResponses = getResponseTypes(responsesObject)
+  const responseTypes = Object.entries(responsesObject).map(([statusCode, response]) => {
+    // Unrecognized status code
+    const statusCodeName = STATUS_CODES[statusCode]
+    let typeName
+    if (statusCodeName === undefined) {
+      typeName = `${operationId}${statusCode}Response`
+    } else {
+      typeName = `${operationId}Response${classCase(STATUS_CODES[statusCode])}`
+    }
+    let isResponseArray
+    const responseContentType = getResponseContentType(response)
+    if (responseContentType === 'application/json') {
+      writeResponse(typeName, response.content['application/json'].schema, response.summary, response.description)
+    } else if (responseContentType === null) {
+      isFullResponse = true
+      writer.writeLine(`export type ${typeName} = unknown`)
+    } else if (mappedResponses.blob.includes(parseInt(statusCode))) {
+      writer.writeLine(`export type ${typeName} = Blob`)
+    } else if (mappedResponses.text.includes(parseInt(statusCode))) {
+      writer.writeLine(`export type ${typeName} = string`)
+    } else {
+      isFullResponse = true
+      writer.writeLine(`export type ${typeName} = string`)
+    }
+
+    const lowerStatusCode = statusCode.toLowerCase()
+    const isStatusCodeRange =
+      lowerStatusCode === '1xx' ||
+      lowerStatusCode === '2xx' ||
+      lowerStatusCode === '3xx' ||
+      lowerStatusCode === '4xx' ||
+      lowerStatusCode === '5xx'
+    if (statusCode === '204') {
+      if (isFullResponse) {
+        typeName = undefined
+      } else {
+        return 'undefined'
+      }
+    }
+    if (isResponseArray) typeName = `Array<${typeName}>`
+    if (isFullResponse) {
+      typeName = `FullResponse<${typeName}, ${isStatusCodeRange ? `StatusCode${lowerStatusCode}` : statusCode}>`
+    }
+    return typeName
+  })
+  // write response unions
+  if (responseTypes.length) {
+    const allResponsesName = `${capitalize(operationId)}Responses`
+    writer.writeLine(`export type ${allResponsesName} =`)
+    writer.indent(() => {
+      if (responseTypes.length > 0) {
+        writer.write(responseTypes.join('\n| '))
+      } else {
+        writer.write('unknown')
+      }
+    })
+    writer.blankLine()
+    return allResponsesName
+  }
+  return 'FullResponse<unknown, 200>'
+
+  function writeResponse (typeName, responseSchema, summary, description) {
+    if (!responseSchema) {
+      return
+    }
+    if (description || summary) {
+      writer.writeLine('/**')
+      if (summary) {
+        for (const line of summary.split('\n')) {
+          writer.writeLine(` * ${line}`)
+        }
+        writer.writeLine(' *')
+      }
+      if (description) {
+        for (const line of description.split('\n')) {
+          writer.writeLine(` * ${line}`)
+        }
+      }
+      writer.writeLine(' */')
+    }
+    writer.writeLine(`export type ${typeName} = ${getType(responseSchema, 'res', spec)}`)
+  }
+}
+
+export { responsesWriter }