@kubb/swagger-ts 2.0.0-canary.20231030T125204 → 2.0.1

package/src/components/Query.tsx

@@ -0,0 +1,137 @@
+import transformers from '@kubb/core/transformers'
+import { print } from '@kubb/parser'
+import * as factory from '@kubb/parser/factory'
+import { File, usePlugin, usePluginManager } from '@kubb/react'
+import { useOas, useOperation, useOperationFile, useOperationName, useSchemas } from '@kubb/swagger/hooks'
+
+import { TypeBuilder } from '../TypeBuilder.ts'
+
+import type { KubbFile } from '@kubb/core'
+import type { ts } from '@kubb/parser'
+import type { OperationSchemas } from '@kubb/swagger'
+import type { Operation } from '@kubb/swagger/oas'
+import type { ReactNode } from 'react'
+import type { FileMeta, PluginOptions } from '../types.ts'
+
+type Props = {
+  builder: TypeBuilder
+}
+
+function printCombinedSchema(name: string, operation: Operation, schemas: OperationSchemas): string {
+  const properties: Record<string, ts.TypeNode> = {
+    'response': factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.response.name),
+      undefined,
+    ),
+  }
+
+  if (schemas.request) {
+    properties['request'] = factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.request.name),
+      undefined,
+    )
+  }
+
+  if (schemas.pathParams) {
+    properties['pathParams'] = factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.pathParams.name),
+      undefined,
+    )
+  }
+
+  if (schemas.queryParams) {
+    properties['queryParams'] = factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.queryParams.name),
+      undefined,
+    )
+  }
+
+  if (schemas.headerParams) {
+    properties['headerParams'] = factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.headerParams.name),
+      undefined,
+    )
+  }
+
+  if (schemas.errors) {
+    properties['errors'] = factory.createUnionDeclaration({
+      nodes: schemas.errors.map(error => {
+        return factory.createTypeReferenceNode(
+          factory.createIdentifier(error.name),
+          undefined,
+        )
+      }),
+    })!
+  }
+
+  const namespaceNode = factory.createNamespaceDeclaration({
+    name: operation.method === 'get' ? `${name}Query` : `${name}Mutation`,
+    statements: Object.keys(properties).map(key => {
+      const type = properties[key]
+      if (!type) {
+        return undefined
+      }
+      return factory.createTypeAliasDeclaration({
+        modifiers: [factory.modifiers.export],
+        name: transformers.pascalCase(key),
+        type,
+      })
+    }).filter(Boolean),
+  })
+
+  return print(namespaceNode)
+}
+
+export function Query({
+  builder,
+}: Props): ReactNode {
+  const { source } = builder.build()
+
+  return (
+    <>
+      {source}
+    </>
+  )
+}
+
+type FileProps = {
+  mode: KubbFile.Mode
+}
+
+Query.File = function({ mode }: FileProps): ReactNode {
+  const { options } = usePlugin<PluginOptions>()
+
+  const schemas = useSchemas()
+  const pluginManager = usePluginManager()
+  const oas = useOas()
+  const file = useOperationFile()
+  const factoryName = useOperationName({ type: 'type' })
+  const operation = useOperation()
+
+  const builder = new TypeBuilder(options, { oas, pluginManager })
+    .add(schemas.pathParams)
+    .add(schemas.queryParams)
+    .add(schemas.headerParams)
+    .add(schemas.response)
+    .add(schemas.errors)
+
+  const { source, imports } = builder.build()
+
+  return (
+    <>
+      <File<FileMeta>
+        baseName={file.baseName}
+        path={file.path}
+        meta={file.meta}
+      >
+        {mode === 'directory' && imports.map((item, index) => {
+          return <File.Import key={index} root={file.path} {...item} />
+        })}
+        <File.Source>
+          {source}
+          {printCombinedSchema(factoryName, operation, schemas)}
+        </File.Source>
+      </File>
+    </>
+  )
+}

package/src/components/index.ts

@@ -0,0 +1,3 @@
+export { Mutation } from './Mutation.tsx'
+export { Oas } from './Oas.tsx'
+export { Query } from './Query.tsx'

package/src/index.ts

@@ -0,0 +1,6 @@
+import { definePlugin } from './plugin.ts'
+
+export { definePlugin, pluginKey, pluginName } from './plugin.ts'
+export type * from './types.ts'
+
+export default definePlugin

package/src/oas/index.ts

@@ -0,0 +1,7 @@
+// based on https://github.com/ardatan/feTS/tree/master
+
+export type { Infer } from './infer.ts'
+export type { MethodMap, PathMap, StatusMap } from './mappers.ts'
+export type { Model } from './model.ts'
+export type { RequestParams } from './requestParams.ts'
+export type { Response } from './response.ts'

package/src/oas/infer.ts

@@ -0,0 +1,58 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+import type { Booleans, Call, Objects, Strings, Tuples } from 'hotscript'
+import type { Object } from 'ts-toolbelt'
+
+namespace Checks {
+  export type AllOFf = { allOf: any[] }
+  export type Object = {
+    type: 'object'
+    properties: any
+  }
+  export type Properties = { properties: any }
+  export type PropertiesRequired = {
+    properties: Record<string, any>
+    required: string[]
+  }
+}
+
+type FixAdditionalPropertiesForAllOf<T> = T extends Checks.AllOFf ? Omit<T, 'allOf'> & {
+    allOf: Call<Tuples.Map<Objects.Omit<'additionalProperties'>>, T['allOf']>
+  }
+  : T
+
+type FixMissingAdditionalProperties<T> = T extends Checks.Object ? Omit<T, 'additionalProperties'> & { additionalProperties: false }
+  : T
+type FixMissingTypeObject<T> = T extends Checks.Properties ? T & { type: 'object' } : T
+
+type FixExtraRequiredFields<T> = T extends Checks.PropertiesRequired ? Omit<T, 'required'> & {
+    required: Call<Tuples.Filter<Booleans.Extends<keyof T['properties']>>, T['required']>
+  }
+  : T
+
+// Later suggest using json-machete
+type FixJSONSchema<T> = FixAdditionalPropertiesForAllOf<
+  FixMissingAdditionalProperties<FixMissingTypeObject<FixExtraRequiredFields<T>>>
+>
+
+type Mutable<Type> = FixJSONSchema<
+  {
+    -readonly [Key in keyof Type]: Mutable<Type[Key]>
+  }
+>
+
+type RefToPath<T extends string> = T extends `#/${infer Ref}` ? Call<Strings.Split<'/'>, Ref>
+  : never
+
+type ResolveRef<TObj, TRef extends string> = {
+  $id: TRef
+} & Object.Path<TObj, RefToPath<TRef>>
+
+type ResolveRefInObj<T, TBase> = T extends { $ref: infer Ref } ? Ref extends string ? ResolveRef<TBase, Ref>
+  : T
+  : T
+
+type ResolveRefsInObj<T, TBase = T> = {
+  [K in keyof T]: ResolveRefsInObj<ResolveRefInObj<T[K], TBase>, TBase>
+}
+
+export type Infer<TOAS> = Mutable<ResolveRefsInObj<TOAS>>

package/src/oas/mappers.ts

@@ -0,0 +1,93 @@
+/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable @typescript-eslint/no-namespace */
+import type { OasTypes } from '@kubb/swagger/oas'
+import type { Fn, Pipe, Tuples } from 'hotscript'
+import type {
+  FromSchema,
+  JSONSchema,
+} from 'json-schema-to-ts'
+
+namespace Checks {
+  export type Required = { required: true }
+
+  export type Schemas = {
+    schema: JSONSchema
+  }
+  export type Enum = { type: JSONSchemaTypeName; enum?: any[] }
+  export type Parameters = { in: string; required?: boolean }[]
+  export type SingleParameter<TParamType> = [{ in: TParamType; required?: true }]
+  export type Responses = { responses: any }
+}
+
+export type PathMap<TOAS extends OasTypes.OASDocument> = TOAS['paths']
+
+interface ParamPropMap {
+  query: 'query'
+  path: 'params'
+  header: 'headers'
+}
+
+type JSONSchemaTypeName =
+  | 'string'
+  | 'number'
+  | 'integer'
+  | 'boolean'
+  | 'object'
+  | 'array'
+  | 'null'
+
+type ParamObj<
+  TParameter extends {
+    name: string
+  },
+> = TParameter extends Checks.Required ? {
+    [TName in TParameter['name']]: TParameter extends Checks.Schemas ? FromSchema<TParameter['schema']>
+      : TParameter extends Checks.Enum ? FromSchema<{
+          type: TParameter['type']
+          enum: TParameter['enum']
+        }>
+      : unknown
+  }
+  : {
+    [TName in TParameter['name']]?: TParameter extends Checks.Schemas ? FromSchema<TParameter['schema']>
+      : TParameter extends Checks.Enum ? FromSchema<{
+          type: TParameter['type']
+          enum: TParameter['enum']
+        }>
+      : unknown
+  }
+
+interface ParamToRequestParam<TParameters extends Checks.Parameters> extends Fn {
+  return: this['arg0'] extends { name: string; in: infer TParamType }
+    // If there is any required parameter for this parameter type, make that parameter type required
+    ? TParameters extends Checks.SingleParameter<TParamType> ? {
+        [
+          TKey in TParamType extends keyof ParamPropMap ? ParamPropMap[TParamType]
+            : never
+        ]: ParamObj<this['arg0']>
+      }
+    : {
+      [
+        TKey in TParamType extends keyof ParamPropMap ? ParamPropMap[TParamType]
+          : never
+      ]?: ParamObj<this['arg0']>
+    }
+    : {}
+}
+
+export type ParamMap<TParameters extends Checks.Parameters> = Pipe<
+  TParameters,
+  [Tuples.Map<ParamToRequestParam<TParameters>>, Tuples.ToIntersection]
+>
+
+export type MethodMap<
+  TOAS extends OasTypes.OASDocument,
+  TPath extends keyof PathMap<TOAS>,
+> = PathMap<TOAS>[TPath]
+
+export type StatusMap<
+  TOAS extends OasTypes.OASDocument,
+  TPath extends keyof PathMap<TOAS>,
+  TMethod extends keyof MethodMap<TOAS, TPath>,
+> = MethodMap<TOAS, TPath>[TMethod] extends Checks.Responses ? MethodMap<TOAS, TPath>[TMethod]['responses']
+  : never

package/src/oas/model.ts

@@ -0,0 +1,38 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+import type { OasTypes } from '@kubb/swagger/oas'
+import type {
+  FromSchema,
+  JSONSchema,
+} from 'json-schema-to-ts'
+
+namespace Checks {
+  export type ModelWithSchemas = {
+    components: {
+      schemas: Record<string, JSONSchema>
+    }
+  }
+  export type ModelWithSchemasNamed<TName extends string | number | symbol> = {
+    components: {
+      schemas: {
+        [TModelName in TName]: JSONSchema
+      }
+    }
+  }
+  export type ModelWithDefinitions = {
+    definitions: Record<string, JSONSchema>
+  }
+  export type ModelWithDefinitionsNamed<TName extends string | number | symbol = never> = {
+    definitions: {
+      [TModelName in TName]: JSONSchema
+    }
+  }
+}
+
+export type Model<
+  TOAS extends OasTypes.OASDocument,
+  TName extends TOAS extends Checks.ModelWithSchemas ? keyof TOAS['components']['schemas']
+    : TOAS extends Checks.ModelWithDefinitions ? keyof TOAS['definitions']
+    : never,
+> = TOAS extends Checks.ModelWithSchemasNamed<TName> ? FromSchema<TOAS['components']['schemas'][TName]>
+  : TOAS extends Checks.ModelWithDefinitionsNamed<TName> ? FromSchema<TOAS['definitions'][TName]>
+  : never

package/src/oas/requestParams.ts

@@ -0,0 +1,170 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/ban-types */
+
+import type { OasTypes } from '@kubb/swagger/oas'
+import type { SplitByDelimiter, TupleToUnion } from '@kubb/types'
+import type { Pipe, Strings, Tuples } from 'hotscript'
+import type {
+  FromSchema,
+  JSONSchema,
+} from 'json-schema-to-ts'
+import type { MethodMap, ParamMap, PathMap } from './mappers.ts'
+import type { SecurityParamsBySecurityRef } from './security.ts'
+
+namespace Checks {
+  export type RequestBodyJson = {
+    requestBody: { content: { 'application/json': { schema: JSONSchema } } }
+  }
+  export type RequestBodyFormData = {
+    requestBody: {
+      content: { 'multipart/form-data': { schema: JSONSchema } }
+    }
+  }
+  export type RequestBodyFormEncoded = {
+    requestBody: {
+      content: {
+        'application/x-www-form-urlencoded': { schema: JSONSchema }
+      }
+    }
+  }
+  export type Parameters = {
+    parameters: { name: string; in: string }[]
+  }
+  export type PathBrackets = `${string}{${string}}${string}`
+  export type PathPattern = `${string}:${string}${string}`
+  export type Required = { required: true }
+}
+
+type ExtractPathParamsWithPattern<TPath extends string> = Pipe<
+  TPath,
+  [
+    Strings.Split<'/'>,
+    Tuples.Filter<Strings.StartsWith<':'>>,
+    Tuples.Map<Strings.Trim<':'>>,
+    Tuples.ToUnion,
+  ]
+>
+
+type IsPathParameter<T extends string> = T extends `{${infer U}}` ? U : never
+
+type ExtractPathParameters<T extends any[]> = {
+  [K in keyof T]: IsPathParameter<T[K]>
+}
+
+type ExtractSegments<TPath extends string> = SplitByDelimiter<TPath, '/'>
+
+type ExtractSubSegments<T extends any[]> = {
+  [K in keyof T]: SplitByDelimiter<T[K], ';'>
+}
+
+type ExtractPathParamsWithBrackets<TPath extends string> = TupleToUnion<
+  ExtractPathParameters<ExtractSubSegments<ExtractSegments<TPath>>[number]>
+>
+
+export type RequestParams<
+  TOAS extends OasTypes.OASDocument,
+  TPath extends keyof PathMap<TOAS>,
+  TMethod extends keyof MethodMap<TOAS, TPath>,
+> =
+  & (MethodMap<TOAS, TPath>[TMethod] extends Checks.RequestBodyJson ? MethodMap<TOAS, TPath>[TMethod]['requestBody'] extends Checks.Required ? {
+        /**
+         * The request body in JSON is required for this request.
+         *
+         * The value of `json` will be stringified and sent as the request body with `Content-Type: application/json`.
+         */
+        json: FromSchema<
+          MethodMap<TOAS, TPath>[TMethod]['requestBody']['content']['application/json']['schema']
+        >
+      }
+    : {
+      /**
+       * The request body in JSON is optional for this request.
+       *
+       * The value of `json` will be stringified and sent as the request body with `Content-Type: application/json`.
+       */
+      json?: FromSchema<
+        MethodMap<TOAS, TPath>[TMethod]['requestBody']['content']['application/json']['schema']
+      >
+    }
+    : MethodMap<TOAS, TPath>[TMethod] extends Checks.RequestBodyFormData ? MethodMap<TOAS, TPath>[TMethod]['requestBody'] extends Checks.Required ? {
+          /**
+           * The request body in multipart/form-data is required for this request.
+           *
+           * The value of `formData` will be sent as the request body with `Content-Type: multipart/form-data`.
+           */
+          formData: FromSchema<
+            MethodMap<
+              TOAS,
+              TPath
+            >[TMethod]['requestBody']['content']['multipart/form-data']['schema']
+          >
+        }
+      : {
+        /**
+         * The request body in multipart/form-data is optional for this request.
+         *
+         * The value of `formData` will be sent as the request body with `Content-Type: multipart/form-data`.
+         */
+        formData?: FromSchema<
+          MethodMap<
+            TOAS,
+            TPath
+          >[TMethod]['requestBody']['content']['multipart/form-data']['schema']
+        >
+      }
+    : MethodMap<TOAS, TPath>[TMethod] extends Checks.RequestBodyFormEncoded ? MethodMap<TOAS, TPath>[TMethod]['requestBody'] extends Checks.Required ? {
+          /**
+           * The request body in application/x-www-form-urlencoded is required for this request.
+           *
+           * The value of `formUrlEncoded` will be sent as the request body with `Content-Type: application/x-www-form-urlencoded`.
+           */
+          formUrlEncoded: FromSchema<
+            MethodMap<
+              TOAS,
+              TPath
+            >[TMethod]['requestBody']['content']['application/x-www-form-urlencoded']['schema']
+          >
+        }
+      : {
+        /**
+         * The request body in application/x-www-form-urlencoded is optional for this request.
+         *
+         * The value of `formUrlEncoded` will be sent as the request body with `Content-Type: application/x-www-form-urlencoded`.
+         */
+        formUrlEncoded?: FromSchema<
+          MethodMap<
+            TOAS,
+            TPath
+          >[TMethod]['requestBody']['content']['application/x-www-form-urlencoded']['schema']
+        >
+      }
+    : {})
+  & (MethodMap<TOAS, TPath>[TMethod] extends Checks.Parameters ? ParamMap<MethodMap<TOAS, TPath>[TMethod]['parameters']>
+    : {})
+  & // If there is any parameters defined in path but not in the parameters array, we should add them to the params
+  (TPath extends Checks.PathBrackets ? {
+      /**
+       * Parameters defined in the path are required for this request.
+       *
+       * The value of `params` will be used to replace the path parameters.
+       *
+       * For example if path is `/todos/{id}` and `params` is `{ id: '1' }`, the path will be `/todos/1`
+       */
+      params: Record<ExtractPathParamsWithBrackets<TPath>, string | number | bigint | boolean>
+    }
+    : {})
+  & (TPath extends Checks.PathPattern ? {
+      /**
+       * Parameters defined in the path are required for this request.
+       *
+       * The value of `params` will be used to replace the path parameters.
+       *
+       * For example if path is `/todos/:id` and `params` is `{ id: '1' }`, the path will be `/todos/1`.
+       */
+      params: Record<ExtractPathParamsWithPattern<TPath>, string | number | bigint | boolean>
+    }
+    : {})
+  & // Respect security definitions in path object
+  SecurityParamsBySecurityRef<TOAS, MethodMap<TOAS, TPath>[TMethod]>
+  & // Respect global security definitions
+  SecurityParamsBySecurityRef<TOAS, TOAS>

package/src/oas/response.ts

@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+import type { OasTypes } from '@kubb/swagger/oas'
+import type {
+  FromSchema,
+} from 'json-schema-to-ts'
+import type { MethodMap, PathMap, StatusMap } from './mappers.ts'
+
+namespace Checks {
+  export type Content = { content: any }
+}
+
+type ResponseSchemas<
+  TOAS extends OasTypes.OASDocument,
+  TPath extends keyof PathMap<TOAS>,
+  TMethod extends keyof MethodMap<TOAS, TPath>,
+  TStatus extends keyof StatusMap<TOAS, TPath, TMethod>,
+> = StatusMap<TOAS, TPath, TMethod>[TStatus]['content']
+
+type JSONResponseSchema<
+  TOAS extends OasTypes.OASDocument,
+  TPath extends keyof PathMap<TOAS>,
+  TMethod extends keyof MethodMap<TOAS, TPath>,
+  TStatus extends keyof StatusMap<TOAS, TPath, TMethod>,
+> = StatusMap<TOAS, TPath, TMethod>[TStatus] extends Checks.Content ? ResponseSchemas<TOAS, TPath, TMethod, TStatus>[
+    keyof ResponseSchemas<
+      TOAS,
+      TPath,
+      TMethod,
+      TStatus
+    >
+  ]['schema']
+  : StatusMap<TOAS, TPath, TMethod>[TStatus]['schema']
+
+export type Response<
+  TOAS extends OasTypes.OASDocument,
+  TPath extends keyof PathMap<TOAS>,
+  TMethod extends keyof MethodMap<TOAS, TPath>,
+  TStatusCode extends keyof StatusMap<TOAS, TPath, TMethod> = 200,
+> = FromSchema<JSONResponseSchema<TOAS, TPath, TMethod, TStatusCode>>