@kubb/swagger-ts 2.0.0-beta.6 → 2.0.0-beta.8

package/dist/infer.d.ts

@@ -0,0 +1,381 @@
+import { OasTypes } from '@kubb/swagger';
+import { Pipe, Tuples, Fn, Call, Objects, Booleans, Strings } from 'hotscript';
+import { JSONSchema, FromSchema } from 'json-schema-to-ts';
+import { Object as Object$1 } from 'ts-toolbelt';
+import { TupleToUnion, SplitByDelimiter } from '@kubb/types';
+
+declare namespace Checks$5 {
+    type Required = {
+        required: true;
+    };
+    type Schemas = {
+        schema: JSONSchema;
+    };
+    type Enum = {
+        type: JSONSchemaTypeName;
+        enum?: any[];
+    };
+    type Parameters = {
+        in: string;
+        required?: boolean;
+    }[];
+    type SingleParameter<TParamType> = [{
+        in: TParamType;
+        required?: true;
+    }];
+    type Responses = {
+        responses: any;
+    };
+}
+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$5.Required ? {
+    [TName in TParameter['name']]: TParameter extends Checks$5.Schemas ? FromSchema<TParameter['schema']> : TParameter extends Checks$5.Enum ? FromSchema<{
+        type: TParameter['type'];
+        enum: TParameter['enum'];
+    }> : unknown;
+} : {
+    [TName in TParameter['name']]?: TParameter extends Checks$5.Schemas ? FromSchema<TParameter['schema']> : TParameter extends Checks$5.Enum ? FromSchema<{
+        type: TParameter['type'];
+        enum: TParameter['enum'];
+    }> : unknown;
+};
+interface ParamToRequestParam<TParameters extends Checks$5.Parameters> extends Fn {
+    return: this['arg0'] extends {
+        name: string;
+        in: infer TParamType;
+    } ? TParameters extends Checks$5.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']>;
+    } : {};
+}
+type ParamMap<TParameters extends Checks$5.Parameters> = Pipe<TParameters, [
+    Tuples.Map<ParamToRequestParam<TParameters>>,
+    Tuples.ToIntersection
+]>;
+type MethodMap<TOAS extends OasTypes.OASDocument, TPath extends keyof PathMap<TOAS>> = PathMap<TOAS>[TPath];
+type StatusMap<TOAS extends OasTypes.OASDocument, TPath extends keyof PathMap<TOAS>, TMethod extends keyof MethodMap<TOAS, TPath>> = MethodMap<TOAS, TPath>[TMethod] extends Checks$5.Responses ? MethodMap<TOAS, TPath>[TMethod]['responses'] : never;
+
+declare namespace Checks$4 {
+    type ModelWithSchemas = {
+        components: {
+            schemas: Record<string, JSONSchema>;
+        };
+    };
+    type ModelWithSchemasNamed<TName extends string | number | symbol> = {
+        components: {
+            schemas: {
+                [TModelName in TName]: JSONSchema;
+            };
+        };
+    };
+    type ModelWithDefinitions = {
+        definitions: Record<string, JSONSchema>;
+    };
+    type ModelWithDefinitionsNamed<TName extends string | number | symbol = never> = {
+        definitions: {
+            [TModelName in TName]: JSONSchema;
+        };
+    };
+}
+type Model<TOAS extends OasTypes.OASDocument, TName extends TOAS extends Checks$4.ModelWithSchemas ? keyof TOAS['components']['schemas'] : TOAS extends Checks$4.ModelWithDefinitions ? keyof TOAS['definitions'] : never> = TOAS extends Checks$4.ModelWithSchemasNamed<TName> ? FromSchema<TOAS['components']['schemas'][TName]> : TOAS extends Checks$4.ModelWithDefinitionsNamed<TName> ? FromSchema<TOAS['definitions'][TName]> : never;
+
+declare namespace Checks$3 {
+    type AllOFf = {
+        allOf: any[];
+    };
+    type Object = {
+        type: 'object';
+        properties: any;
+    };
+    type Properties = {
+        properties: any;
+    };
+    type PropertiesRequired = {
+        properties: Record<string, any>;
+        required: string[];
+    };
+}
+type FixAdditionalPropertiesForAllOf<T> = T extends Checks$3.AllOFf ? Omit<T, 'allOf'> & {
+    allOf: Call<Tuples.Map<Objects.Omit<'additionalProperties'>>, T['allOf']>;
+} : T;
+type FixMissingAdditionalProperties<T> = T extends Checks$3.Object ? Omit<T, 'additionalProperties'> & {
+    additionalProperties: false;
+} : T;
+type FixMissingTypeObject<T> = T extends Checks$3.Properties ? T & {
+    type: 'object';
+} : T;
+type FixExtraRequiredFields<T> = T extends Checks$3.PropertiesRequired ? Omit<T, 'required'> & {
+    required: Call<Tuples.Filter<Booleans.Extends<keyof T['properties']>>, T['required']>;
+} : T;
+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$1.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>;
+};
+type Parse<TOAS> = Mutable<ResolveRefsInObj<TOAS>>;
+
+declare namespace Checks$2 {
+    type Security = {
+        security: {
+            [key: string]: any;
+        }[];
+    };
+    namespace AuthParams {
+        type Basic = {
+            type: 'http';
+            scheme: 'basic';
+        } | {
+            type: 'basic';
+        };
+        type Bearer = {
+            type: 'http';
+            scheme: 'bearer';
+        } | {
+            type: 'bearer';
+        };
+        type OAuth2 = {
+            type: 'oauth2';
+        };
+        type ApiKey = {
+            type: 'apiKey';
+            in: 'header';
+        };
+    }
+    namespace AuthName {
+        type Basic = `basic${string}`;
+        type Bearer = `bearer${string}`;
+        type OAuth2 = `oauth${string}`;
+    }
+}
+type SecuritySchemeName<T extends Checks$2.Security> = Call<Tuples.Map<Objects.Keys>, T['security']>[number];
+declare namespace AuthParams {
+    type Basic<TSecurityScheme> = TSecurityScheme extends Checks$2.AuthParams.Basic ? {
+        headers: {
+            /**
+             * `Authorization` header is required for basic authentication
+             * @see https://en.wikipedia.org/wiki/Basic_access_authentication
+             *
+             * It contains the word `Basic` followed by a space and a base64-encoded string `username:password`
+             *
+             * @example
+             * ```
+             * Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==
+             * ```
+             */
+            Authorization: `Basic ${string}`;
+        };
+    } : {};
+    type Bearer<TSecurityScheme> = TSecurityScheme extends Checks$2.AuthParams.Bearer ? {
+        /**
+         * `Authorization` header is required for bearer authentication
+         * @see https://swagger.io/docs/specification/authentication/bearer-authentication/
+         */
+        headers: {
+            /**
+             * It contains the word `Bearer` followed by a space and the token
+             *
+             * @example
+             * ```
+             * Authorization: Bearer {token}
+             * ```
+             */
+            Authorization: `Bearer ${string}`;
+        };
+    } : {};
+    type ApiKey<TSecurityScheme> = TSecurityScheme extends Checks$2.AuthParams.ApiKey & {
+        name: infer TApiKeyHeaderName;
+    } ? {
+        headers: {
+            [THeaderName in TApiKeyHeaderName extends string ? TApiKeyHeaderName : never]: string;
+        };
+    } : TSecurityScheme extends {
+        type: 'apiKey';
+        in: 'query';
+        name: infer TApiKeyQueryName;
+    } ? {
+        query: {
+            [TQueryName in TApiKeyQueryName extends string ? TApiKeyQueryName : never]: string;
+        };
+    } : {};
+    type OAuth2<TSecurityScheme> = TSecurityScheme extends Checks$2.AuthParams.OAuth2 ? {
+        /**
+         * `Authorization` header is required for OAuth2.
+         */
+        headers: {
+            /**
+             * The access token string as issued by the authorization server.
+             * @example `Authorization: Bearer <access_token>`
+             */
+            Authorization: `Bearer ${string}`;
+        };
+    } : {};
+}
+type OASSecurityParams<TSecurityScheme> = AuthParams.Basic<TSecurityScheme> & AuthParams.Bearer<TSecurityScheme> & AuthParams.ApiKey<TSecurityScheme> & AuthParams.OAuth2<TSecurityScheme>;
+type SecurityParamsBySecurityRef<TOAS, TSecurityObj> = TSecurityObj extends Checks$2.Security ? TOAS extends {
+    components: {
+        securitySchemes: {
+            [TSecuritySchemeNameKey in SecuritySchemeName<TSecurityObj> extends string ? SecuritySchemeName<TSecurityObj> : never]: infer TSecurityScheme;
+        };
+    };
+} | {
+    securityDefinitions: {
+        [TSecuritySchemeNameKey in SecuritySchemeName<TSecurityObj> extends string ? SecuritySchemeName<TSecurityObj> : never]: infer TSecurityScheme;
+    };
+} ? OASSecurityParams<TSecurityScheme> : SecuritySchemeName<TSecurityObj> extends Checks$2.AuthName.Basic ? AuthParams.Basic<{
+    type: 'http';
+    scheme: 'basic';
+}> : SecuritySchemeName<TSecurityObj> extends Checks$2.AuthName.Bearer ? AuthParams.Bearer<{
+    type: 'http';
+    scheme: 'bearer';
+}> : SecuritySchemeName<TSecurityObj> extends Checks$2.AuthName.OAuth2 ? AuthParams.OAuth2<{
+    type: 'oauth2';
+}> : {} : {};
+
+declare namespace Checks$1 {
+    type RequestBodyJson = {
+        requestBody: {
+            content: {
+                'application/json': {
+                    schema: JSONSchema;
+                };
+            };
+        };
+    };
+    type RequestBodyFormData = {
+        requestBody: {
+            content: {
+                'multipart/form-data': {
+                    schema: JSONSchema;
+                };
+            };
+        };
+    };
+    type RequestBodyFormEncoded = {
+        requestBody: {
+            content: {
+                'application/x-www-form-urlencoded': {
+                    schema: JSONSchema;
+                };
+            };
+        };
+    };
+    type Parameters = {
+        parameters: {
+            name: string;
+            in: string;
+        }[];
+    };
+    type PathBrackets = `${string}{${string}}${string}`;
+    type PathPattern = `${string}:${string}${string}`;
+    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]>>;
+type RequestParams<TOAS extends OasTypes.OASDocument, TPath extends keyof PathMap<TOAS>, TMethod extends keyof MethodMap<TOAS, TPath>> = (MethodMap<TOAS, TPath>[TMethod] extends Checks$1.RequestBodyJson ? MethodMap<TOAS, TPath>[TMethod]['requestBody'] extends Checks$1.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$1.RequestBodyFormData ? MethodMap<TOAS, TPath>[TMethod]['requestBody'] extends Checks$1.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$1.RequestBodyFormEncoded ? MethodMap<TOAS, TPath>[TMethod]['requestBody'] extends Checks$1.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$1.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$1.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$1.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>;
+
+declare namespace Checks {
+    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'];
+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>>;
+
+export type { MethodMap, Model, Parse, PathMap, RequestParams, Response, StatusMap };

package/dist/infer.js

@@ -0,0 +1,5 @@
+import { createRequire } from 'module';
+
+createRequire(import.meta.url);
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=infer.js.map

package/dist/infer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/swagger-ts",
-  "version": "2.0.0-beta.6",
+  "version": "2.0.0-beta.8",
   "description": "Generator swagger-ts",
   "keywords": [
     "typescript",
@@ -30,6 +30,9 @@
       "require": "./dist/components.cjs",
       "default": "./dist/components.cjs"
     },
+    "./infer": {
+      "types": "./dist/infer.d.ts"
+    },
     "./package.json": "./package.json",
     "./*": "./*"
   },
@@ -43,15 +46,19 @@
     "!/**/__tests__/**"
   ],
   "dependencies": {
-    "typescript": "^5.3.2",
-    "@kubb/core": "2.0.0-beta.6",
-    "@kubb/parser": "2.0.0-beta.6",
-    "@kubb/react": "2.0.0-beta.6",
-    "@kubb/swagger": "2.0.0-beta.6"
+    "json-schema-to-ts": "^2.9.2",
+    "hotscript": "^1.0.13",
+    "ts-toolbelt": "^9.6.0",
+    "@kubb/core": "2.0.0-beta.8",
+    "@kubb/parser": "2.0.0-beta.8",
+    "@kubb/react": "2.0.0-beta.8",
+    "@kubb/types": "2.0.0-beta.8",
+    "@kubb/swagger": "2.0.0-beta.8"
   },
   "devDependencies": {
     "@types/react": "^18.2.38",
     "eslint": "^8.54.0",
+    "expect-type": "^0.17.3",
     "react": "^18.2.0",
     "tsup": "^8.0.1",
     "@kubb/eslint-config": "1.1.8",
@@ -59,8 +66,7 @@
     "@kubb/tsup-config": "1.1.8"
   },
   "peerDependencies": {
-    "typescript": "^5.3.0",
-    "@kubb/react": "2.0.0-beta.6"
+    "@kubb/react": "2.0.0-beta.8"
   },
   "packageManager": "pnpm@8.3.0",
   "engines": {

package/src/OperationGenerator.tsx

@@ -2,16 +2,28 @@ import { createRoot } from '@kubb/react'
 import { OperationGenerator as Generator } from '@kubb/swagger'
 
 import { Mutation } from './components/Mutation.tsx'
+import { Oas } from './components/Oas.tsx'
 import { Query } from './components/Query.tsx'
 
-import type { KubbFile } from '@kubb/core'
 import type { AppContextProps } from '@kubb/react'
 import type { Operation, OperationMethodResult, OperationSchemas } from '@kubb/swagger'
 import type { FileMeta, PluginOptions } from './types.ts'
 
 export class OperationGenerator extends Generator<PluginOptions['resolvedOptions'], PluginOptions> {
-  async all(): Promise<KubbFile.File | null> {
-    return null
+  async all(): OperationMethodResult<FileMeta> {
+    const { oas, pluginManager, plugin } = this.context
+
+    if (!plugin.options.oasType) {
+      return null
+    }
+
+    const root = createRoot<AppContextProps>({ logger: pluginManager.logger })
+    root.render(
+      <Oas.File name="oas" typeName="Oas" />,
+      { meta: { oas, pluginManager, plugin } },
+    )
+
+    return root.files
   }
 
   async get(operation: Operation, schemas: OperationSchemas, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {

package/src/components/Oas.tsx

@@ -0,0 +1,84 @@
+import { File, Type, usePlugin } from '@kubb/react'
+import { useFile } from '@kubb/react'
+import { useOas } from '@kubb/swagger/hooks'
+
+import type { OasTypes } from '@kubb/swagger'
+import type { ReactNode } from 'react'
+import type { FileMeta, PluginOptions } from '../types.ts'
+
+type TemplateProps = {
+  /**
+   * Name of the function
+   */
+  name: string
+  typeName: string
+  api: OasTypes.OASDocument
+}
+
+function Template({
+  name,
+  typeName,
+  api,
+}: TemplateProps): ReactNode {
+  return (
+    <>
+      {`export const ${name} = ${JSON.stringify(api, undefined, 2)} as const`}
+      <br />
+      <Type name={typeName} export>
+        {`Parse<typeof ${name}>`}
+      </Type>
+    </>
+  )
+}
+
+const defaultTemplates = { default: Template } as const
+
+type Props = {
+  name: string
+  typeName: string
+  /**
+   * This will make it possible to override the default behaviour.
+   */
+  Template?: React.ComponentType<React.ComponentProps<typeof Template>>
+}
+
+export function Oas({
+  name,
+  typeName,
+  Template = defaultTemplates.default,
+}: Props): ReactNode {
+  const oas = useOas()
+
+  return <Template name={name} typeName={typeName} api={oas.api} />
+}
+
+type FileProps = {
+  name: string
+  typeName: string
+  /**
+   * This will make it possible to override the default behaviour.
+   */
+  templates?: typeof defaultTemplates
+}
+
+Oas.File = function({ name, typeName, templates = defaultTemplates }: FileProps): ReactNode {
+  const { key: pluginKey } = usePlugin<PluginOptions>()
+  const file = useFile({ name, pluginKey })
+
+  const Template = templates.default
+
+  return (
+    <File<FileMeta>
+      baseName={file.baseName}
+      path={file.path}
+      meta={file.meta}
+    >
+      <File.Import name={['Parse']} path="@kubb/swagger-ts/infer" isTypeOnly />
+      <File.Source>
+        <Oas Template={Template} name={name} typeName={typeName} />
+      </File.Source>
+    </File>
+  )
+}
+
+Oas.templates = defaultTemplates

package/src/components/index.ts

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

package/src/infer/index.ts

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

package/src/infer/mappers.ts

@@ -0,0 +1,93 @@
+/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable @typescript-eslint/no-namespace */
+import type { OasTypes } from '@kubb/swagger'
+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