@kubb/plugin-oas 3.0.0-alpha.2 → 3.0.0-alpha.21

package/README.md

@@ -13,10 +13,6 @@
 [![Coverage][coverage-src]][coverage-href]
 [![License][license-src]][license-href]
 
-<!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
-<!-- ALL-CONTRIBUTORS-BADGE:END -->
-</p>
-
 <h4>
     <a href="https://codesandbox.io/s/github/kubb-labs/kubb/tree/alpha/examples/typescript" target="_blank">View Demo</a>
     <span> · </span>
@@ -28,6 +24,19 @@
   </h4>
 </div>
 
+## Supporting Kubb
+
+Kubb uses an MIT-licensed open source project with its ongoing development made possible entirely by the support of Sponsors. If you would like to become a sponsor, please consider:
+
+- [Become a Sponsor on GitHub](https://github.com/sponsors/stijnvanhulle)
+
+<p align="center">
+  <a href="https://github.com/sponsors/stijnvanhulle">
+    <img src="https://raw.githubusercontent.com/stijnvanhulle/sponsors/main/sponsors.svg" alt="My sponsors" />
+  </a>
+</p>
+
+
 <!-- Badges -->
 
 [npm-version-src]: https://img.shields.io/npm/v/@kubb/plugin-oas?flat&colorA=18181B&colorB=f58517

package/dist/OperationGenerator-CHXolL0o.d.cts

@@ -0,0 +1,553 @@
+import { Plugin, ResolveNameParams, Output, PluginFactoryOptions, FileMetaBase, BaseGenerator, PluginManager } from '@kubb/core';
+import * as KubbFile from '@kubb/fs/types';
+import { Oas, contentType, OasTypes, SchemaObject, Operation, HttpMethod } from '@kubb/oas';
+import { KubbNode } from '@kubb/react/types';
+import { FormatOptions } from '@kubb/oas/parser';
+
+type SchemaKeywordMapper = {
+    object: {
+        keyword: 'object';
+        args: {
+            properties: {
+                [x: string]: Schema[];
+            };
+            additionalProperties: Schema[];
+            strict?: boolean;
+        };
+    };
+    strict: {
+        keyword: 'strict';
+    };
+    url: {
+        keyword: 'url';
+    };
+    readOnly: {
+        keyword: 'readOnly';
+    };
+    uuid: {
+        keyword: 'uuid';
+    };
+    email: {
+        keyword: 'email';
+    };
+    firstName: {
+        keyword: 'firstName';
+    };
+    lastName: {
+        keyword: 'lastName';
+    };
+    phone: {
+        keyword: 'phone';
+    };
+    password: {
+        keyword: 'password';
+    };
+    date: {
+        keyword: 'date';
+        args: {
+            type?: 'date' | 'string';
+        };
+    };
+    time: {
+        keyword: 'time';
+        args: {
+            type?: 'date' | 'string';
+        };
+    };
+    datetime: {
+        keyword: 'datetime';
+        args: {
+            offset?: boolean;
+            local?: boolean;
+        };
+    };
+    tuple: {
+        keyword: 'tuple';
+        args: {
+            items: Schema[];
+            min?: number;
+            max?: number;
+        };
+    };
+    array: {
+        keyword: 'array';
+        args: {
+            items: Schema[];
+            min?: number;
+            max?: number;
+        };
+    };
+    enum: {
+        keyword: 'enum';
+        args: {
+            name: string;
+            typeName: string;
+            asConst: boolean;
+            items: Array<{
+                name: string | number;
+                format: 'string' | 'number';
+                value?: string | number;
+            }>;
+        };
+    };
+    and: {
+        keyword: 'and';
+        args: Schema[];
+    };
+    const: {
+        keyword: 'const';
+        args: {
+            name: string | number;
+            format: 'string' | 'number';
+            value?: string | number;
+        };
+    };
+    union: {
+        keyword: 'union';
+        args: Schema[];
+    };
+    ref: {
+        keyword: 'ref';
+        args: {
+            name: string;
+            path: KubbFile.OptionalPath;
+        };
+    };
+    matches: {
+        keyword: 'matches';
+        args?: string;
+    };
+    boolean: {
+        keyword: 'boolean';
+    };
+    default: {
+        keyword: 'default';
+        args: string | number | boolean;
+    };
+    string: {
+        keyword: 'string';
+    };
+    integer: {
+        keyword: 'integer';
+    };
+    number: {
+        keyword: 'number';
+    };
+    max: {
+        keyword: 'max';
+        args: number;
+    };
+    min: {
+        keyword: 'min';
+        args: number;
+    };
+    describe: {
+        keyword: 'describe';
+        args: string;
+    };
+    example: {
+        keyword: 'example';
+        args: string;
+    };
+    deprecated: {
+        keyword: 'deprecated';
+    };
+    optional: {
+        keyword: 'optional';
+    };
+    undefined: {
+        keyword: 'undefined';
+    };
+    nullish: {
+        keyword: 'nullish';
+    };
+    nullable: {
+        keyword: 'nullable';
+    };
+    null: {
+        keyword: 'null';
+    };
+    any: {
+        keyword: 'any';
+    };
+    unknown: {
+        keyword: 'unknown';
+    };
+    blob: {
+        keyword: 'blob';
+    };
+    schema: {
+        keyword: 'schema';
+        args: {
+            type: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object';
+            format?: string;
+        };
+    };
+    name: {
+        keyword: 'name';
+        args: string;
+    };
+    catchall: {
+        keyword: 'catchall';
+    };
+};
+declare const schemaKeywords: {
+    any: "any";
+    strict: "strict";
+    unknown: "unknown";
+    number: "number";
+    integer: "integer";
+    string: "string";
+    boolean: "boolean";
+    undefined: "undefined";
+    nullable: "nullable";
+    null: "null";
+    nullish: "nullish";
+    array: "array";
+    tuple: "tuple";
+    enum: "enum";
+    union: "union";
+    datetime: "datetime";
+    date: "date";
+    email: "email";
+    uuid: "uuid";
+    url: "url";
+    default: "default";
+    const: "const";
+    and: "and";
+    describe: "describe";
+    min: "min";
+    max: "max";
+    optional: "optional";
+    readOnly: "readOnly";
+    object: "object";
+    ref: "ref";
+    matches: "matches";
+    firstName: "firstName";
+    lastName: "lastName";
+    password: "password";
+    phone: "phone";
+    blob: "blob";
+    deprecated: "deprecated";
+    example: "example";
+    schema: "schema";
+    catchall: "catchall";
+    time: "time";
+    name: "name";
+};
+type SchemaKeyword = keyof SchemaKeywordMapper;
+type SchemaMapper<T = string | null | undefined> = {
+    [K in keyof SchemaKeywordMapper]: (() => T | undefined) | undefined;
+};
+type SchemaKeywordBase<T> = {
+    keyword: SchemaKeyword;
+    args: T;
+};
+type Schema = {
+    keyword: string;
+} | SchemaKeywordMapper[keyof SchemaKeywordMapper];
+declare function isKeyword<T extends Schema, K extends keyof SchemaKeywordMapper>(meta: T, keyword: K): meta is Extract<T, SchemaKeywordMapper[K]>;
+
+type Mode = 'schemas' | 'responses' | 'requestBodies';
+type GetSchemasProps = {
+    oas: Oas;
+    contentType?: contentType;
+    includes?: Mode[];
+};
+declare function getSchemas({ oas, contentType, includes }: GetSchemasProps): Record<string, OasTypes.SchemaObject>;
+
+type ResolvePathOptions = {
+    pluginKey?: Plugin['key'];
+    tag?: string;
+    type?: ResolveNameParams['type'];
+};
+type API = {
+    getOas: (formatOptions?: FormatOptions) => Promise<Oas>;
+    getSchemas: (options?: Pick<GetSchemasProps, 'includes'>) => Promise<Record<string, SchemaObject>>;
+    getBaseURL: () => Promise<string | undefined>;
+    contentType?: contentType;
+};
+type Options = {
+    /**
+     * Validate your input(see kubb.config) based on '@readme/openapi-parser'.
+     * @default true
+     */
+    validate?: boolean;
+    /**
+     * @default 'schemas'
+     */
+    output?: Output;
+    /**
+     * Which server to use from the array of `servers.url[serverIndex]`
+     * @example
+     * - `0` will return `http://petstore.swagger.io/api`
+     * - `1` will return `http://localhost:3000`
+     * @default 0
+     */
+    serverIndex?: number;
+    /**
+     * Define which contentType should be used.
+     * By default, this is set based on the first used contentType..
+     */
+    contentType?: contentType;
+    experimentalFilter?: FormatOptions['filterSet'];
+    experimentalSort?: FormatOptions['sortSet'];
+    /**
+     * Override some behaviour of the Oas class instance, see '@kubb/oas'
+     */
+    oasClass?: typeof Oas;
+    /**
+     * Define some generators next to the JSON generation
+     */
+    generators?: Array<Generator<PluginOas>>;
+};
+/**
+ * `propertyName` is the ref name + resolved with the nameResolver
+ *  @example `import { Pet } from './Pet'`
+ *
+ * `originalName` is the original name used(in PascalCase), only used to remove duplicates
+ *
+ * `pluginKey` can be used to override the current plugin being used, handy when you want to import a type/schema out of another plugin
+ * @example import a type(plugin-ts) for a mock file(swagger-faker)
+ */
+type Ref = {
+    propertyName: string;
+    originalName: string;
+    path: KubbFile.OptionalPath;
+    pluginKey?: Plugin['key'];
+};
+type Refs = Record<string, Ref>;
+type Resolver = {
+    /**
+     * Original name or name resolved by `resolveName({ name: operation?.getOperationId() as string, pluginName })`
+     */
+    name: string;
+    baseName: KubbFile.BaseName;
+    path: KubbFile.Path;
+};
+type OperationSchema = {
+    /**
+     * Converted name, contains already `PathParams`, `QueryParams`, ...
+     */
+    name: string;
+    schema: SchemaObject;
+    operation?: Operation;
+    /**
+     * OperationName in PascalCase, only being used in OperationGenerator
+     */
+    operationName?: string;
+    description?: string;
+    statusCode?: number;
+    keys?: string[];
+    keysToOmit?: string[];
+    withData?: boolean;
+};
+type OperationSchemas = {
+    pathParams?: OperationSchema & {
+        keysToOmit?: never;
+    };
+    queryParams?: OperationSchema & {
+        keysToOmit?: never;
+    };
+    headerParams?: OperationSchema & {
+        keysToOmit?: never;
+    };
+    request?: OperationSchema;
+    response: OperationSchema;
+    statusCodes?: Array<OperationSchema>;
+    errors?: Array<OperationSchema>;
+};
+type OperationsByMethod = Record<string, Record<HttpMethod, {
+    operation: Operation;
+    schemas: OperationSchemas;
+}>>;
+type ByTag = {
+    type: 'tag';
+    pattern: string | RegExp;
+};
+type ByOperationId = {
+    type: 'operationId';
+    pattern: string | RegExp;
+};
+type ByPath = {
+    type: 'path';
+    pattern: string | RegExp;
+};
+type ByMethod = {
+    type: 'method';
+    pattern: HttpMethod | RegExp;
+};
+type BySchemaName = {
+    type: 'schemaName';
+    pattern: string | RegExp;
+};
+type Exclude = ByTag | ByOperationId | ByPath | ByMethod;
+type Include = ByTag | ByOperationId | ByPath | ByMethod;
+type Override<TOptions> = (ByTag | ByOperationId | ByPath | ByMethod | BySchemaName) & {
+    options: Partial<TOptions>;
+};
+type ResolvedOptions = Options & {
+    output: Output;
+};
+type PluginOas = PluginFactoryOptions<'plugin-oas', Options, ResolvedOptions, API, never>;
+
+type GetSchemaGeneratorOptions<T extends SchemaGenerator<any, any, any>> = T extends SchemaGenerator<infer Options, any, any> ? Options : never;
+type SchemaMethodResult<TFileMeta extends FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>;
+type Context$1<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+    oas: Oas;
+    pluginManager: PluginManager;
+    /**
+     * Current plugin
+     */
+    plugin: Plugin<TPluginOptions>;
+    mode: KubbFile.Mode;
+    include?: Array<'schemas' | 'responses' | 'requestBodies'>;
+    override: Array<Override<TOptions>> | undefined;
+    contentType?: contentType;
+    output?: string;
+};
+type SchemaGeneratorOptions = {
+    dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
+    unknownType: 'any' | 'unknown';
+    enumType?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal';
+    enumSuffix?: string;
+    usedEnumNames?: Record<string, number>;
+    mapper?: Record<string, string>;
+    typed?: boolean;
+    transformers: {
+        /**
+         * Customize the names based on the type that is provided by the plugin.
+         */
+        name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+        /**
+         * Receive schema and name(propertName) and return FakerMeta array
+         * TODO TODO add docs
+         * @beta
+         */
+        schema?: (schemaProps: SchemaProps$1, defaultSchemas: Schema[]) => Schema[] | undefined;
+    };
+};
+type SchemaGeneratorBuildOptions = Omit<OperationSchema, 'name' | 'schema'>;
+type SchemaProps$1 = {
+    schema?: SchemaObject;
+    name?: string;
+    parentName?: string;
+};
+declare class SchemaGenerator<TOptions extends SchemaGeneratorOptions = SchemaGeneratorOptions, TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TOptions, Context$1<TOptions, TPluginOptions>> {
+    #private;
+    refs: Refs;
+    /**
+     * Creates a type node from a given schema.
+     * Delegates to getBaseTypeFromSchema internally and
+     * optionally adds a union with null.
+     */
+    parse(props: SchemaProps$1): Schema[];
+    deepSearch<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T][];
+    find<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined;
+    static deepSearch<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T][];
+    static findInObject<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined;
+    static find<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined;
+    build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>>;
+    /**
+     * Schema
+     */
+    schema(name: string, object: SchemaObject, options: TOptions): SchemaMethodResult<TFileMeta>;
+}
+
+type OperationsProps<TOptions extends PluginFactoryOptions> = {
+    instance: Omit<OperationGenerator<TOptions>, 'build'>;
+    options: TOptions['resolvedOptions'];
+    operations: Array<Operation>;
+    operationsByMethod: OperationsByMethod;
+};
+type OperationProps<TOptions extends PluginFactoryOptions> = {
+    instance: Omit<OperationGenerator<TOptions>, 'build'>;
+    options: TOptions['resolvedOptions'];
+    operation: Operation;
+};
+type SchemaProps<TOptions extends PluginFactoryOptions> = {
+    instance: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>;
+    schema: {
+        name: string;
+        tree: Array<Schema>;
+        value: SchemaObject;
+    };
+    options: TOptions['resolvedOptions'];
+};
+type GeneratorOptions<TOptions extends PluginFactoryOptions> = {
+    name: string;
+    operations?: (this: GeneratorOptions<TOptions>, props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>;
+    operation?: (this: GeneratorOptions<TOptions>, props: OperationProps<TOptions>) => Promise<KubbFile.File[]>;
+    schema?: (this: GeneratorOptions<TOptions>, props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>;
+};
+type Generator<TOptions extends PluginFactoryOptions> = GeneratorOptions<TOptions>;
+declare function createGenerator<TOptions extends PluginFactoryOptions>(parseOptions: GeneratorOptions<TOptions>): Generator<TOptions>;
+type ReactGeneratorOptions<TOptions extends PluginFactoryOptions> = {
+    name: string;
+    Operations?: (this: ReactGeneratorOptions<TOptions>, props: OperationsProps<TOptions>) => KubbNode;
+    Operation?: (this: ReactGeneratorOptions<TOptions>, props: OperationProps<TOptions>) => KubbNode;
+    Schema?: (this: ReactGeneratorOptions<TOptions>, props: SchemaProps<TOptions>) => KubbNode;
+    /**
+     * Combine all react nodes and only render ones(to string or render)
+     */
+    render?: () => any;
+};
+declare function createReactGenerator<TOptions extends PluginFactoryOptions>(parseOptions: ReactGeneratorOptions<TOptions>): Generator<TOptions>;
+
+/**
+ * @deprecated
+ */
+type GetOperationGeneratorOptions<T = any> = any;
+type OperationMethodResult<TFileMeta extends FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>;
+type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+    oas: Oas;
+    exclude: Array<Exclude> | undefined;
+    include: Array<Include> | undefined;
+    override: Array<Override<TOptions>> | undefined;
+    contentType: contentType | undefined;
+    pluginManager: PluginManager;
+    /**
+     * Current plugin
+     */
+    plugin: Plugin<TPluginOptions>;
+    mode: KubbFile.Mode;
+};
+declare class OperationGenerator<TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TPluginOptions['resolvedOptions'], Context<TPluginOptions['resolvedOptions'], TPluginOptions>> {
+    #private;
+    get operationsByMethod(): OperationsByMethod;
+    set operationsByMethod(paths: OperationsByMethod);
+    getSchemas(operation: Operation, { resolveName, }?: {
+        resolveName?: (name: string) => string;
+    }): OperationSchemas;
+    build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>>;
+    /**
+     * Operation
+     */
+    operation(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta>;
+    /**
+     * GET
+     */
+    get(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta>;
+    /**
+     * POST
+     */
+    post(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta>;
+    /**
+     * PATCH
+     */
+    patch(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta>;
+    /**
+     * PUT
+     */
+    put(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta>;
+    /**
+     * DELETE
+     */
+    delete(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta>;
+    /**
+     * Combination of GET, POST, PATCH, PUT, DELETE
+     */
+    all(operations: Operation[], paths: OperationsByMethod): OperationMethodResult<TFileMeta>;
+}
+
+export { type API as A, getSchemas as B, type Exclude as E, type GetOperationGeneratorOptions as G, type Include as I, type Options as O, type PluginOas as P, type ReactGeneratorOptions as R, type SchemaGeneratorBuildOptions as S, type OperationMethodResult as a, OperationGenerator as b, type GetSchemaGeneratorOptions as c, type SchemaGeneratorOptions as d, type SchemaMethodResult as e, SchemaGenerator as f, type Schema as g, type SchemaKeyword as h, type SchemaKeywordBase as i, type SchemaKeywordMapper as j, type SchemaMapper as k, isKeyword as l, createGenerator as m, createReactGenerator as n, type Generator as o, type GeneratorOptions as p, type ResolvePathOptions as q, type Ref as r, schemaKeywords as s, type Refs as t, type Resolver as u, type OperationSchema as v, type OperationSchemas as w, type OperationsByMethod as x, type Override as y, type GetSchemasProps as z };