@kubb/plugin-ts 0.0.0-canary-20241104172400

package/src/generators/__snapshots__/enumInObject.ts

@@ -0,0 +1,13 @@
+export const enumInObjectReasonEnum2 = {
+    "created_at": "created_at",
+    "description": "description"
+} as const;
+
+ export type EnumInObjectReasonEnum2 = (typeof enumInObjectReasonEnum2)[keyof typeof enumInObjectReasonEnum2];
+
+ export type enumInObject = {
+    /**
+     * @type string | undefined
+    */
+    reason?: EnumInObjectReasonEnum2;
+};

package/src/generators/__snapshots__/enumItems.ts

@@ -0,0 +1,8 @@
+export const enumItemsEnum2 = {
+    "created_at": "created_at",
+    "description": "description"
+} as const;
+
+ export type EnumItemsEnum2 = (typeof enumItemsEnum2)[keyof typeof enumItemsEnum2];
+
+ export type enumItems = EnumItemsEnum2[];

package/src/generators/__snapshots__/enumNames.ts

@@ -0,0 +1,6 @@
+export enum EnumNamesTypeEnum2 {
+    "Pending" = 0,
+    "Received" = 1
+}
+
+ export type enumNamesType = EnumNamesTypeEnum2;

package/src/generators/__snapshots__/enumNamesConst.ts

@@ -0,0 +1,6 @@
+export const enum EnumNamesTypeEnum2 {
+    "Pending" = 0,
+    "Received" = 1
+}
+
+ export type enumNamesType = EnumNamesTypeEnum2;

package/src/generators/__snapshots__/enumNamesLiteral.ts

@@ -0,0 +1,3 @@
+export type EnumNamesTypeEnum2 = 0 | 1;
+
+ export type enumNamesType = EnumNamesTypeEnum2;

package/src/generators/__snapshots__/enumNamesPascalConst.ts

@@ -0,0 +1,8 @@
+export const EnumNamesTypeEnum2 = {
+    "Pending": 0,
+    "Received": 1
+} as const;
+
+ type EnumNamesTypeEnum2 = (typeof EnumNamesTypeEnum2)[keyof typeof EnumNamesTypeEnum2];
+
+ export type enumNamesType = EnumNamesTypeEnum2;

package/src/generators/__snapshots__/enumNamesType.ts

@@ -0,0 +1,8 @@
+export const enumNamesType = {
+    "Pending": 0,
+    "Received": 1
+} as const;
+
+ export type EnumNamesTypeEnum2 = (typeof enumNamesType)[keyof typeof enumNamesType];
+
+ export type enumNamesType = EnumNamesTypeEnum2;

package/src/generators/__snapshots__/enumNullableMember.ts

@@ -0,0 +1,8 @@
+export const enumNullableMemberEnum2 = {
+    "first": "first",
+    "second": "second"
+} as const;
+
+ export type EnumNullableMemberEnum2 = (typeof enumNullableMemberEnum2)[keyof typeof enumNullableMemberEnum2];
+
+ export type enumNullableMember = EnumNullableMemberEnum2 | null;

package/src/generators/__snapshots__/enumNullableType.ts

@@ -0,0 +1,8 @@
+export const enumNullableTypeEnum2 = {
+    "first": "first",
+    "second": "second"
+} as const;
+
+ export type EnumNullableTypeEnum2 = (typeof enumNullableTypeEnum2)[keyof typeof enumNullableTypeEnum2];
+
+ export type enumNullableType = EnumNullableTypeEnum2 | null;

package/src/generators/__snapshots__/enumString.ts

@@ -0,0 +1,10 @@
+export const enumStringEnum2 = {
+    "created_at": "created_at",
+    "description": "description",
+    "FILE.UPLOADED": "FILE.UPLOADED",
+    "FILE.DOWNLOADED": "FILE.DOWNLOADED"
+} as const;
+
+ export type EnumStringEnum2 = (typeof enumStringEnum2)[keyof typeof enumStringEnum2];
+
+ export type enumString = EnumStringEnum2;

package/src/generators/__snapshots__/enumVarNamesType.ts

@@ -0,0 +1,8 @@
+export const enumVarNamesTypeEnum2 = {
+    "Pending": 0,
+    "Received": 1
+} as const;
+
+ export type EnumVarNamesTypeEnum2 = (typeof enumVarNamesTypeEnum2)[keyof typeof enumVarNamesTypeEnum2];
+
+ export type enumVarNamesType = EnumVarNamesTypeEnum2;

package/src/generators/__snapshots__/getPets.ts

@@ -0,0 +1,26 @@
+
+ export type ListPetsQueryParams = {
+    /**
+     * @description How many items to return at one time (max 100)
+     * @type string | undefined
+    */
+    limit?: string;
+};
+
+ /**
+ * @description A paged array of pets
+*/
+export type ListPets200 = pets;
+
+ /**
+ * @description unexpected error
+*/
+export type ListPetsError = error;
+
+ export type ListPetsQueryResponse = listPets200;
+
+ export type listPetsQuery = {
+    Response: listPets200;
+    QueryParams: listPetsQueryParams;
+    Errors: any;
+};

package/src/generators/__snapshots__/mixedValueTypeConst.ts

@@ -0,0 +1,9 @@
+/**
+ * @description This probably should fail miserably
+*/
+export type mixedValueTypeConst = {
+    /**
+     * @type number | undefined
+    */
+    foobar?: "foobar";
+};

package/src/generators/__snapshots__/nullConstNull.ts

@@ -0,0 +1,7 @@
+
+ /**
+ * @description The value of this keyword MAY be null.\nUse of this keyword is functionally equivalent to an \"enum\" (Section 6.1.2) with a single value.\nAn instance validates successfully against this keyword if its value is equal to the value of the keyword.\n
+*/
+export type nullConst = {
+    withoutValue?: null;
+};

package/src/generators/__snapshots__/numberValueConst.ts

@@ -0,0 +1,9 @@
+/**
+ * @description its value is equal to the value of the keyword
+*/
+export type numberValueConst = {
+    /**
+     * @type number | undefined
+    */
+    foobar?: 42;
+};

package/src/generators/__snapshots__/petMapper.ts

@@ -0,0 +1,15 @@
+export type pet = {
+    /**
+     * @type integer, int64
+    */
+    id: number;
+    /**
+     * @type string
+    */
+    name: string;
+    /**
+     * @type string | undefined
+    */
+    tag?: string;
+    category?: string;
+};

package/src/generators/__snapshots__/petQuestionToken.ts

@@ -0,0 +1,19 @@
+
+ export type pet = {
+    /**
+     * @type integer, int64
+    */
+    id: number;
+    /**
+     * @type string
+    */
+    name: string;
+    /**
+     * @type string | undefined
+    */
+    tag?: string;
+    /**
+     * @type object | undefined
+    */
+    category?: category;
+};

package/src/generators/__snapshots__/petQuestionTokenAndUndefined.ts

@@ -0,0 +1,19 @@
+
+ export type pet = {
+    /**
+     * @type integer, int64
+    */
+    id: number;
+    /**
+     * @type string
+    */
+    name: string;
+    /**
+     * @type string | undefined
+    */
+    tag?: string | undefined;
+    /**
+     * @type object | undefined
+    */
+    category?: category | undefined;
+};

package/src/generators/__snapshots__/petUndefined.ts

@@ -0,0 +1,19 @@
+
+ export type pet = {
+    /**
+     * @type integer, int64
+    */
+    id: number;
+    /**
+     * @type string
+    */
+    name: string;
+    /**
+     * @type string | undefined
+    */
+    tag: string | undefined;
+    /**
+     * @type object | undefined
+    */
+    category: category | undefined;
+};

package/src/generators/__snapshots__/pets.ts

@@ -0,0 +1,14 @@
+export type pets = {
+    /**
+     * @type integer, int64
+    */
+    id: number;
+    /**
+     * @type string
+    */
+    name: string;
+    /**
+     * @type string | undefined
+    */
+    tag?: string;
+}[];

package/src/generators/__snapshots__/petsStoreAdvancedDiscriminator.ts

@@ -0,0 +1,31 @@
+
+ export const advancedTypeEnum2 = {
+    "enum": "enum",
+    "range": "range",
+    "regex": "regex",
+    "slider": "slider"
+} as const;
+
+ export type AdvancedTypeEnum2 = (typeof advancedTypeEnum2)[keyof typeof advancedTypeEnum2];
+
+ export type advanced = ((enumerationValueSpecificationDto & {
+    /**
+     * @type string
+    */
+    readonly type: AdvancedTypeEnum2;
+}) | (rangeValueSpecificationDto & {
+    /**
+     * @type string
+    */
+    readonly type: AdvancedTypeEnum2;
+}) | (regexValueSpecificationDto & {
+    /**
+     * @type string
+    */
+    readonly type: AdvancedTypeEnum2;
+}) | (sliderValueSpecificationDto & {
+    /**
+     * @type string
+    */
+    readonly type: AdvancedTypeEnum2;
+}));

package/src/generators/__snapshots__/petsStoreDiscriminator.ts

@@ -0,0 +1,13 @@
+/**
+ * @description A project is an analysis project. It has a name, an id, and has a dataset
+*/
+export type petstore = {
+    /**
+     * @type integer
+    */
+    id: number;
+    /**
+     * @type array | undefined
+    */
+    pets?: (cat | dog)[];
+};

package/src/generators/__snapshots__/petsStoreRef.ts

@@ -0,0 +1 @@
+export type pets = pet[];

package/src/generators/__snapshots__/plainDateDate.ts

@@ -0,0 +1 @@
+export type plainDate = Date;

package/src/generators/__snapshots__/plainDateString.ts

@@ -0,0 +1 @@
+export type plainDate = string;

package/src/generators/__snapshots__/plainEmail.ts

@@ -0,0 +1 @@
+export type plainEmail = string;

package/src/generators/__snapshots__/plainFile.ts

@@ -0,0 +1 @@
+export type plainFile = Blob;

package/src/generators/__snapshots__/plainTimeDate.ts

@@ -0,0 +1 @@
+export type plainTime = Date;

package/src/generators/__snapshots__/plainUuid.ts

@@ -0,0 +1 @@
+export type plainUuid = string;

package/src/generators/__snapshots__/readOnly.ts

@@ -0,0 +1,20 @@
+
+ export type demo = {
+    /**
+     * @type integer | undefined
+    */
+    readonly attribute_readonly?: number;
+    /**
+     * @description not required
+     * @type integer | undefined
+    */
+    attribute_writeOnly?: number;
+    /**
+     * @type integer | undefined
+    */
+    readonly attribute_with_ref?: attributeReadonly;
+    /**
+     * @type integer | undefined
+    */
+    attribute_with_ref_readonly?: attributeWriteOnly;
+};

package/src/generators/__snapshots__/showPetById.ts

@@ -0,0 +1,31 @@
+
+ export type ShowPetByIdPathParams = {
+    /**
+     * @description The id of the pet to retrieve
+     * @type string
+    */
+    petId: string;
+    /**
+     * @description The id of the pet to retrieve
+     * @type string
+    */
+    testId: string;
+};
+
+ /**
+ * @description Expected response to a valid request
+*/
+export type ShowPetById200 = pet;
+
+ /**
+ * @description unexpected error
+*/
+export type ShowPetByIdError = error;
+
+ export type ShowPetByIdQueryResponse = showPetById200;
+
+ export type showPetByIdQuery = {
+    Response: showPetById200;
+    PathParams: showPetByIdPathParams;
+    Errors: any;
+};

package/src/generators/__snapshots__/stringValueConst.ts

@@ -0,0 +1,9 @@
+/**
+ * @description its value is equal to the value of the keyword
+*/
+export type stringValueConst = {
+    /**
+     * @type string | undefined
+    */
+    foobar?: "foobar";
+};

package/src/generators/index.ts

@@ -0,0 +1,2 @@
+export { typeGenerator } from './typeGenerator.tsx'
+export { oasGenerator } from './oasGenerator.tsx'

package/src/generators/oasGenerator.tsx

@@ -0,0 +1,29 @@
+import { createReactGenerator } from '@kubb/plugin-oas'
+import { useOas } from '@kubb/plugin-oas/hooks'
+import { File, useApp } from '@kubb/react'
+import { OasType } from '../components'
+import type { PluginTs } from '../types.ts'
+
+export const oasGenerator = createReactGenerator<PluginTs>({
+  name: 'oas',
+  Operations() {
+    const {
+      pluginManager,
+      plugin: {
+        options: { output },
+        key: pluginKey,
+      },
+    } = useApp<PluginTs>()
+    const oas = useOas()
+
+    const file = pluginManager.getFile({ name: 'oas', extname: '.ts', pluginKey })
+
+    return (
+      <File baseName={file.baseName} path={file.path} meta={file.meta} banner={output?.banner} footer={output?.footer}>
+        <File.Import name={['Infer']} path="@kubb/oas" isTypeOnly />
+
+        <OasType name={'oas'} typeName={'Oas'} api={oas.api} />
+      </File>
+    )
+  },
+})

package/src/generators/typeGenerator.tsx

@@ -0,0 +1,205 @@
+import type { PluginManager } from '@kubb/core'
+import transformers from '@kubb/core/transformers'
+import { print } from '@kubb/parser-ts'
+import * as factory from '@kubb/parser-ts/factory'
+import { createPropertySignature, modifiers } from '@kubb/parser-ts/factory'
+import { type OperationSchema as OperationSchemaType, type OperationSchemas, SchemaGenerator, createReactGenerator, schemaKeywords } from '@kubb/plugin-oas'
+import { Oas } from '@kubb/plugin-oas/components'
+import { useOas, useOperationManager, useSchemaManager } from '@kubb/plugin-oas/hooks'
+import { pluginTsName } from '@kubb/plugin-ts'
+import { File, useApp } from '@kubb/react'
+import type ts from 'typescript'
+import { Type } from '../components'
+import type { PluginTs } from '../types'
+
+function printCombinedSchema({ name, schemas, pluginManager }: { name: string; schemas: OperationSchemas; pluginManager: PluginManager }): string {
+  const properties: Record<string, ts.TypeNode> = {}
+
+  if (schemas.response) {
+    properties['response'] = factory.createUnionDeclaration({
+      nodes: schemas.responses.map((res) => {
+        const identifier = pluginManager.resolveName({
+          name: res.name,
+          pluginKey: [pluginTsName],
+          type: 'function',
+        })
+
+        return factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
+      }),
+    })!
+  }
+
+  if (schemas.request) {
+    const identifier = pluginManager.resolveName({
+      name: schemas.request.name,
+      pluginKey: [pluginTsName],
+      type: 'function',
+    })
+    properties['request'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
+  }
+
+  if (schemas.pathParams) {
+    const identifier = pluginManager.resolveName({
+      name: schemas.pathParams.name,
+      pluginKey: [pluginTsName],
+      type: 'function',
+    })
+    properties['pathParams'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
+  }
+
+  if (schemas.queryParams) {
+    const identifier = pluginManager.resolveName({
+      name: schemas.queryParams.name,
+      pluginKey: [pluginTsName],
+      type: 'function',
+    })
+    properties['queryParams'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
+  }
+
+  if (schemas.headerParams) {
+    const identifier = pluginManager.resolveName({
+      name: schemas.headerParams.name,
+      pluginKey: [pluginTsName],
+      type: 'function',
+    })
+    properties['headerParams'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
+  }
+
+  if (schemas.errors) {
+    properties['errors'] = factory.createUnionDeclaration({
+      nodes: schemas.errors.map((error) => {
+        const identifier = pluginManager.resolveName({
+          name: error.name,
+          pluginKey: [pluginTsName],
+          type: 'function',
+        })
+
+        return factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
+      }),
+    })!
+  }
+
+  const namespaceNode = factory.createTypeAliasDeclaration({
+    name,
+    type: factory.createTypeLiteralNode(
+      Object.keys(properties)
+        .map((key) => {
+          const type = properties[key]
+          if (!type) {
+            return undefined
+          }
+
+          return factory.createPropertySignature({
+            name: transformers.pascalCase(key),
+            type,
+          })
+        })
+        .filter(Boolean),
+    ),
+    modifiers: [factory.modifiers.export],
+  })
+
+  return print([namespaceNode])
+}
+
+export const typeGenerator = createReactGenerator<PluginTs>({
+  name: 'typescript',
+  Operation({ operation, options }) {
+    const { mapper, enumType, optionalType } = options
+
+    const { plugin, pluginManager, mode } = useApp<PluginTs>()
+    const oas = useOas()
+    const { getSchemas, getFile, getName } = useOperationManager()
+    const schemaManager = useSchemaManager()
+
+    const file = getFile(operation)
+    const schemas = getSchemas(operation)
+    const type = getName(operation, { type: 'function', pluginKey: [pluginTsName] })
+    const combinedSchemaName = operation.method === 'get' ? `${type}Query` : `${type}Mutation`
+    const schemaGenerator = new SchemaGenerator(options, {
+      oas,
+      plugin,
+      pluginManager,
+      mode,
+      override: options.override,
+    })
+
+    const operationSchemas = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response]
+      .flat()
+      .filter(Boolean)
+
+    const mapOperationSchema = ({ name, schema, description, keysToOmit, ...options }: OperationSchemaType, i: number) => {
+      const tree = schemaGenerator.parse({ schema, name })
+      const imports = schemaManager.getImports(tree)
+
+      const type = {
+        name: schemaManager.getName(name, { type: 'type' }),
+        typedName: schemaManager.getName(name, { type: 'type' }),
+        file: schemaManager.getFile(options.operationName || name, { tag: options.operation?.getTags()[0]?.name }),
+      }
+
+      return (
+        <Oas.Schema key={i} name={name} value={schema} tree={tree}>
+          {mode === 'split' && imports.map((imp, index) => <File.Import key={index} root={file.path} path={imp.path} name={imp.name} isTypeOnly />)}
+          <Type
+            name={type.name}
+            typedName={type.typedName}
+            description={description}
+            tree={tree}
+            mapper={mapper}
+            enumType={enumType}
+            optionalType={optionalType}
+            keysToOmit={keysToOmit}
+          />
+        </Oas.Schema>
+      )
+    }
+
+    return (
+      <File baseName={file.baseName} path={file.path} meta={file.meta} banner={plugin.options.output?.banner} footer={plugin.options.output?.footer}>
+        {operationSchemas.map(mapOperationSchema)}
+
+        <File.Source name={combinedSchemaName} isExportable isIndexable isTypeOnly>
+          {printCombinedSchema({ name: combinedSchemaName, schemas, pluginManager })}
+        </File.Source>
+      </File>
+    )
+  },
+  Schema({ schema, options }) {
+    const { mapper, enumType, optionalType } = options
+    const {
+      mode,
+      plugin: {
+        options: { output },
+      },
+    } = useApp<PluginTs>()
+
+    const { getName, getImports, getFile } = useSchemaManager()
+    const imports = getImports(schema.tree)
+
+    if (enumType === 'asPascalConst') {
+      console.warn(`enumType '${enumType}' is deprecated`)
+    }
+
+    const type = {
+      name: getName(schema.name, { type: 'function' }),
+      typedName: getName(schema.name, { type: 'type' }),
+      file: getFile(schema.name),
+    }
+
+    return (
+      <File baseName={type.file.baseName} path={type.file.path} meta={type.file.meta} banner={output?.banner} footer={output?.footer}>
+        {mode === 'split' && imports.map((imp, index) => <File.Import key={index} root={type.file.path} path={imp.path} name={imp.name} isTypeOnly />)}
+        <Type
+          name={type.name}
+          typedName={type.typedName}
+          description={schema.value.description}
+          tree={schema.tree}
+          mapper={mapper}
+          enumType={enumType}
+          optionalType={optionalType}
+        />
+      </File>
+    )
+  },
+})

package/src/index.ts

@@ -0,0 +1,2 @@
+export { pluginTs, pluginTsName } from './plugin.ts'
+export type { PluginTs } from './types.ts'