Merge pull request #1529 from hey-api/feat/integer-int64

fix: add support for long integers

.changeset/cool-days-scream.md

@@ -0,0 +1,5 @@
+---
+'@hey-api/openapi-ts': patch
+---
+
+fix: add support for long integers

.changeset/nasty-comics-smoke.md

@@ -2,4 +2,4 @@
 '@hey-api/openapi-ts': patch
 ---
 
-fix: preserve leading indicators in enum keys
+fix: preserve leading separators in enum keys

packages/openapi-ts/src/ir/schema.ts

@@ -26,6 +26,7 @@ export const deduplicateSchema = <T extends IR.SchemaObject>({
       // no `type` might still include `$ref` or `const`
       !item.type ||
       item.type === 'boolean' ||
+      item.type === 'integer' ||
       item.type === 'null' ||
       item.type === 'number' ||
       item.type === 'string' ||

packages/openapi-ts/src/ir/types.d.ts

@@ -174,6 +174,7 @@ interface IRSchemaObject
     | 'array'
     | 'boolean'
     | 'enum'
+    | 'integer'
     | 'never'
     | 'null'
     | 'number'

packages/openapi-ts/src/openApi/2.0.x/parser/schema.ts

@@ -163,11 +163,12 @@ const parseBoolean = ({
 
 const parseNumber = ({
   irSchema = {},
+  schema,
 }: SchemaContext & {
   irSchema?: IR.SchemaObject;
-  schema: SchemaObject;
+  schema: SchemaWithRequired<SchemaObject, 'type'>;
 }): IR.SchemaObject => {
-  irSchema.type = 'number';
+  irSchema.type = schema.type;
 
   return irSchema;
 };

packages/openapi-ts/src/openApi/3.0.x/parser/schema.ts

@@ -170,11 +170,12 @@ const parseBoolean = ({
 
 const parseNumber = ({
   irSchema = {},
+  schema,
 }: SchemaContext & {
   irSchema?: IR.SchemaObject;
-  schema: SchemaObject;
+  schema: SchemaWithRequired<SchemaObject, 'type'>;
 }): IR.SchemaObject => {
-  irSchema.type = 'number';
+  irSchema.type = schema.type;
 
   return irSchema;
 };

packages/openapi-ts/src/openApi/3.1.x/parser/schema.ts

@@ -223,11 +223,14 @@ const parseNull = ({
 
 const parseNumber = ({
   irSchema = {},
+  schema,
 }: SchemaContext & {
   irSchema?: IR.SchemaObject;
-  schema: SchemaObject;
+  schema: Omit<SchemaObject, 'type'> & {
+    type: SchemaType<SchemaObject>;
+  };
 }): IR.SchemaObject => {
-  irSchema.type = 'number';
+  irSchema.type = schema.type;
 
   return irSchema;
 };

packages/openapi-ts/src/plugins/@hey-api/transformers/config.ts

@@ -8,6 +8,7 @@ export const defaultConfig: Plugin.Config<Config> = {
   _handler: handler,
   _handlerLegacy: handlerLegacy,
   _tags: ['transformer'],
+  bigInt: true,
   dates: true,
   name: '@hey-api/transformers',
   output: 'transformers',

packages/openapi-ts/src/plugins/@hey-api/transformers/plugin.ts

@@ -16,6 +16,75 @@ interface OperationIRRef {
   id: string;
 }
 
+const bigIntExpressions = ({
+  dataExpression,
+}: {
+  dataExpression?: ts.Expression | string;
+}): Array<ts.Expression> => {
+  const bigIntCallExpression =
+    dataExpression !== undefined
+      ? compiler.callExpression({
+          functionName: 'BigInt',
+          parameters: [
+            compiler.callExpression({
+              functionName: compiler.propertyAccessExpression({
+                expression: dataExpression,
+                name: 'toString',
+              }),
+            }),
+          ],
+        })
+      : undefined;
+
+  if (bigIntCallExpression) {
+    if (typeof dataExpression === 'string') {
+      return [bigIntCallExpression];
+    }
+
+    if (dataExpression) {
+      return [
+        compiler.assignment({
+          left: dataExpression,
+          right: bigIntCallExpression,
+        }),
+      ];
+    }
+  }
+
+  return [];
+};
+
+const dateExpressions = ({
+  dataExpression,
+}: {
+  dataExpression?: ts.Expression | string;
+}): Array<ts.Expression> => {
+  const identifierDate = compiler.identifier({ text: 'Date' });
+
+  if (typeof dataExpression === 'string') {
+    return [
+      compiler.newExpression({
+        argumentsArray: [compiler.identifier({ text: dataExpression })],
+        expression: identifierDate,
+      }),
+    ];
+  }
+
+  if (dataExpression) {
+    return [
+      compiler.assignment({
+        left: dataExpression,
+        right: compiler.newExpression({
+          argumentsArray: [dataExpression],
+          expression: identifierDate,
+        }),
+      }),
+    ];
+  }
+
+  return [];
+};
+
 export const operationTransformerIrRef = ({
   id,
   type,
@@ -147,7 +216,7 @@ const processSchemaType = ({
             parameters: [
               {
                 name: dataVariableName,
-                // TODO: parser - add types, generate types without transformed dates
+                // TODO: parser - add types, generate types without transforms
                 type: compiler.keywordTypeNode({ keyword: 'any' }),
               },
             ],
@@ -293,30 +362,11 @@ const processSchemaType = ({
     schema.type === 'string' &&
     (schema.format === 'date' || schema.format === 'date-time')
   ) {
-    const identifierDate = compiler.identifier({ text: 'Date' });
-
-    if (typeof dataExpression === 'string') {
-      return [
-        compiler.newExpression({
-          argumentsArray: [compiler.identifier({ text: dataExpression })],
-          expression: identifierDate,
-        }),
-      ];
-    }
-
-    if (dataExpression) {
-      return [
-        compiler.assignment({
-          left: dataExpression,
-          right: compiler.newExpression({
-            argumentsArray: [dataExpression],
-            expression: identifierDate,
-          }),
-        }),
-      ];
-    }
+    return dateExpressions({ dataExpression });
+  }
 
-    return [];
+  if (plugin.bigInt && schema.type === 'integer' && schema.format === 'int64') {
+    return bigIntExpressions({ dataExpression });
   }
 
   if (schema.items) {
@@ -447,7 +497,7 @@ export const handler: Plugin.Handler<Config> = ({ context, plugin }) => {
           parameters: [
             {
               name: dataVariableName,
-              // TODO: parser - add types, generate types without transformed dates
+              // TODO: parser - add types, generate types without transforms
               type: compiler.keywordTypeNode({ keyword: 'any' }),
             },
           ],

packages/openapi-ts/src/plugins/@hey-api/transformers/types.d.ts

@@ -1,13 +1,23 @@
 import type { Plugin } from '../../types';
 
 export interface Config extends Plugin.Name<'@hey-api/transformers'> {
+  /**
+   * **This feature works only with the [experimental parser](https://heyapi.dev/openapi-ts/configuration#parser)**
+   *
+   * Convert long integers into BigInt values?
+   *
+   * @default true
+   */
+  bigInt?: boolean;
   /**
    * Convert date strings into Date objects?
+   *
    * @default true
    */
   dates?: boolean;
   /**
    * Name of the generated file.
+   *
    * @default 'transformers'
    */
   output?: string;

packages/openapi-ts/src/plugins/@hey-api/typescript/plugin.ts

@@ -402,18 +402,26 @@ const enumTypeToIdentifier = ({
 };
 
 const numberTypeToIdentifier = ({
+  context,
   schema,
 }: {
   context: IR.Context;
   namespace: Array<ts.Statement>;
-  schema: SchemaWithType<'number'>;
+  schema: SchemaWithType<'integer' | 'number'>;
 }) => {
   if (schema.const !== undefined) {
     return compiler.literalTypeNode({
       literal: compiler.ots.number(schema.const as number),
     });
   }
 
+  if (schema.type === 'integer' && schema.format === 'int64') {
+    // TODO: parser - add ability to skip type transformers
+    if (context.config.plugins['@hey-api/transformers']?.bigInt) {
+      return compiler.typeReferenceNode({ typeName: 'BigInt' });
+    }
+  }
+
   return compiler.keywordTypeNode({
     keyword: 'number',
   });
@@ -605,6 +613,13 @@ const schemaTypeToIdentifier = ({
         plugin,
         schema: schema as SchemaWithType<'enum'>,
       });
+    case 'integer':
+    case 'number':
+      return numberTypeToIdentifier({
+        context,
+        namespace,
+        schema: schema as SchemaWithType<'integer' | 'number'>,
+      });
     case 'never':
       return compiler.keywordTypeNode({
         keyword: 'never',
@@ -613,12 +628,6 @@ const schemaTypeToIdentifier = ({
       return compiler.literalTypeNode({
         literal: compiler.null(),
       });
-    case 'number':
-      return numberTypeToIdentifier({
-        context,
-        namespace,
-        schema: schema as SchemaWithType<'number'>,
-      });
     case 'object':
       return objectTypeToIdentifier({
         context,

packages/openapi-ts/src/plugins/zod/plugin.ts

@@ -241,15 +241,28 @@ const numberTypeToZodSchema = ({
   schema,
 }: {
   context: IR.Context;
-  schema: SchemaWithType<'number'>;
+  schema: SchemaWithType<'integer' | 'number'>;
 }) => {
+  const isBigInt = schema.type === 'integer' && schema.format === 'int64';
+
   let numberExpression = compiler.callExpression({
     functionName: compiler.propertyAccessExpression({
       expression: zIdentifier,
-      name: compiler.identifier({ text: schema.type }),
+      name: isBigInt
+        ? compiler.identifier({ text: 'bigint' })
+        : compiler.identifier({ text: 'number' }),
     }),
   });
 
+  if (!isBigInt && schema.type === 'integer') {
+    numberExpression = compiler.callExpression({
+      functionName: compiler.propertyAccessExpression({
+        expression: numberExpression,
+        name: compiler.identifier({ text: 'int' }),
+      }),
+    });
+  }
+
   if (schema.const !== undefined) {
     // TODO: parser - add constant
     // return compiler.literalTypeNode({
@@ -584,6 +597,12 @@ const schemaTypeToZodSchema = ({
         context,
         schema: schema as SchemaWithType<'enum'>,
       });
+    case 'integer':
+    case 'number':
+      return numberTypeToZodSchema({
+        context,
+        schema: schema as SchemaWithType<'integer' | 'number'>,
+      });
     case 'never':
       return neverTypeToZodSchema({
         context,
@@ -594,11 +613,6 @@ const schemaTypeToZodSchema = ({
         context,
         schema: schema as SchemaWithType<'null'>,
       });
-    case 'number':
-      return numberTypeToZodSchema({
-        context,
-        schema: schema as SchemaWithType<'number'>,
-      });
     case 'object':
       return objectTypeToZodSchema({
         context,

packages/openapi-ts/test/2.0.x.test.ts

@@ -11,11 +11,11 @@ import { getFilePaths } from './utils';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-const VERSION = '2.0.x';
+const version = '2.0.x';
 
-const outputDir = path.join(__dirname, 'generated', VERSION);
+const outputDir = path.join(__dirname, 'generated', version);
 
-describe(`OpenAPI ${VERSION}`, () => {
+describe(`OpenAPI ${version}`, () => {
   const createConfig = (userConfig: UserConfig): UserConfig => ({
     client: '@hey-api/client-fetch',
     experimentalParser: true,
@@ -24,7 +24,7 @@ describe(`OpenAPI ${VERSION}`, () => {
     input: path.join(
       __dirname,
       'spec',
-      VERSION,
+      version,
       typeof userConfig.input === 'string' ? userConfig.input : '',
     ),
     output: path.join(
@@ -273,7 +273,7 @@ describe(`OpenAPI ${VERSION}`, () => {
         path.join(
           __dirname,
           '__snapshots__',
-          VERSION,
+          version,
           filePath.slice(outputDir.length + 1),
         ),
       );