chore(parser): pass openAPI schema to write methods

.changeset/giant-sloths-repair.md

@@ -0,0 +1,5 @@
+---
+"@hey-api/openapi-ts": minor
+---
+
+feat: export schemas directly from OpenAPI specification (ie. support exporting JSON schemas draft 2020-12

packages/openapi-ts/src/compiler/index.ts

@@ -24,6 +24,9 @@ export class TypeScriptFile {
     }
 
     public write(file: PathOrFileDescriptor, seperator: string = '\n') {
+        if (!this._items.length) {
+            return;
+        }
         writeFileSync(file, this.toString(seperator));
     }
 }
@@ -45,5 +48,3 @@ export const compiler = {
         object: types.createObjectType,
     },
 };
-
-export default compiler;

packages/openapi-ts/src/compiler/types.ts

@@ -57,6 +57,9 @@
         Object.entries(obj)
             .map(([key, value]) => {
                 const initializer = toExpression(value);
+                if (key.match(/\W/g) && !key.startsWith("'") && !key.endsWith("'")) {
+                    key = `'${key}'`;
+                }
                 return initializer ? ts.factory.createPropertyAssignment(key, initializer) : undefined;
             })
             .filter(isType<ts.PropertyAssignment>),

packages/openapi-ts/src/compiler/utils.ts

@@ -61,6 +61,13 @@
         if (unescape) {
             value = unescapeName(value);
         }
+        if (
+            (value.includes('\n') || (value.includes("'") && value.includes('"'))) &&
+            !value.startsWith('`') &&
+            !value.endsWith('`')
+        ) {
+            value = `\`${value}\``;
+        }
         const text = encodeURIComponent(value);
         if (value.startsWith('`')) {
             return ts.factory.createIdentifier(text);

packages/openapi-ts/src/index.ts

@@ -198,7 +198,7 @@
     if (config.write) {
         logClientMessage(config.client);
         logMissingDependenciesWarning(config.client, dependencies);
-        await writeClient(client, templates, config);
+        await writeClient(openApi, client, templates, config);
         processOutput(config, dependencies);
     }
 

packages/openapi-ts/src/openApi/index.ts

@@ -16,8 +16,11 @@ export { OpenApi } from './common/interfaces/OpenApi';
 export function parse(openApi: OpenApi, config: Config): Client {
     if ('openapi' in openApi) {
         return parseV3(openApi, config);
-    } else if ('swagger' in openApi) {
+    }
+
+    if ('swagger' in openApi) {
         return parseV2(openApi, config);
     }
+
     throw new Error(`Unsupported Open API specification: ${JSON.stringify(openApi, null, 2)}`);
 }

packages/openapi-ts/src/utils/write/__tests__/class.spec.ts

@@ -4,40 +4,47 @@ import { describe, expect, it, vi } from 'vitest';
 
 import { writeClientClass } from '../class';
 import { mockTemplates } from './mocks';
+import { openApi } from './models';
 
 vi.mock('node:fs');
 
 describe('writeClientClass', () => {
     it('should write to filesystem', async () => {
-        const client: Parameters<typeof writeClientClass>[0] = {
+        const client: Parameters<typeof writeClientClass>[2] = {
             enumNames: [],
             models: [],
             server: 'http://localhost:8080',
             services: [],
             version: 'v1',
         };
 
-        await writeClientClass(client, mockTemplates, './dist', {
-            client: 'fetch',
-            debug: false,
-            enums: 'javascript',
-            experimental: false,
-            exportCore: true,
-            exportModels: true,
-            exportSchemas: true,
-            exportServices: true,
-            format: false,
-            input: '',
-            lint: false,
-            name: 'AppClient',
-            operationId: true,
-            output: '',
-            postfixServices: '',
-            serviceResponse: 'body',
-            useDateType: false,
-            useOptions: true,
-            write: true,
-        });
+        await writeClientClass(
+            openApi,
+            './dist',
+            client,
+            {
+                client: 'fetch',
+                debug: false,
+                enums: 'javascript',
+                experimental: false,
+                exportCore: true,
+                exportModels: true,
+                exportSchemas: true,
+                exportServices: true,
+                format: false,
+                input: '',
+                lint: false,
+                name: 'AppClient',
+                operationId: true,
+                output: '',
+                postfixServices: '',
+                serviceResponse: 'body',
+                useDateType: false,
+                useOptions: true,
+                write: true,
+            },
+            mockTemplates
+        );
 
         expect(writeFileSync).toHaveBeenCalled();
     });

packages/openapi-ts/src/utils/write/__tests__/client.spec.ts

@@ -4,20 +4,21 @@ import { describe, expect, it, vi } from 'vitest';
 
 import { writeClient } from '../client';
 import { mockTemplates } from './mocks';
+import { openApi } from './models';
 
 vi.mock('node:fs');
 
 describe('writeClient', () => {
     it('should write to filesystem', async () => {
-        const client: Parameters<typeof writeClient>[0] = {
+        const client: Parameters<typeof writeClient>[1] = {
             enumNames: [],
             models: [],
             server: 'http://localhost:8080',
             services: [],
             version: 'v1',
         };
 
-        await writeClient(client, mockTemplates, {
+        await writeClient(openApi, client, mockTemplates, {
             client: 'fetch',
             debug: false,
             enums: 'javascript',

packages/openapi-ts/src/utils/write/__tests__/core.spec.ts

@@ -5,17 +5,18 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { writeClientCore } from '../core';
 import { mockTemplates } from './mocks';
+import { openApi } from './models';
 
 vi.mock('node:fs');
 
 describe('writeClientCore', () => {
-    let templates: Parameters<typeof writeClientCore>[1];
+    let templates: Parameters<typeof writeClientCore>[4];
     beforeEach(() => {
         templates = mockTemplates;
     });
 
     it('should write to filesystem', async () => {
-        const client: Parameters<typeof writeClientCore>[0] = {
+        const client: Parameters<typeof writeClientCore>[2] = {
             enumNames: [],
             models: [],
             server: 'http://localhost:8080',
@@ -45,7 +46,7 @@ describe('writeClientCore', () => {
             write: true,
         };
 
-        await writeClientCore(client, templates, '/', config);
+        await writeClientCore(openApi, '/', client, config, templates);
 
         expect(writeFileSync).toHaveBeenCalledWith(path.resolve('/', '/OpenAPI.ts'), 'settings');
         expect(writeFileSync).toHaveBeenCalledWith(path.resolve('/', '/ApiError.ts'), 'apiError');
@@ -57,7 +58,7 @@ describe('writeClientCore', () => {
     });
 
     it('uses client server value for base', async () => {
-        const client: Parameters<typeof writeClientCore>[0] = {
+        const client: Parameters<typeof writeClientCore>[2] = {
             enumNames: [],
             models: [],
             server: 'http://localhost:8080',
@@ -87,7 +88,7 @@ describe('writeClientCore', () => {
             write: true,
         };
 
-        await writeClientCore(client, templates, '/', config);
+        await writeClientCore(openApi, '/', client, config, templates);
 
         expect(templates.core.settings).toHaveBeenCalledWith({
             $config: config,
@@ -98,7 +99,7 @@ describe('writeClientCore', () => {
     });
 
     it('uses custom value for base', async () => {
-        const client: Parameters<typeof writeClientCore>[0] = {
+        const client: Parameters<typeof writeClientCore>[2] = {
             enumNames: [],
             models: [],
             server: 'http://localhost:8080',
@@ -129,7 +130,7 @@ describe('writeClientCore', () => {
             write: true,
         };
 
-        await writeClientCore(client, templates, '/', config);
+        await writeClientCore(openApi, '/', client, config, templates);
 
         expect(templates.core.settings).toHaveBeenCalledWith({
             $config: config,

packages/openapi-ts/src/utils/write/__tests__/models.spec.ts

@@ -4,13 +4,13 @@ import path from 'node:path';
 import { describe, expect, it, vi } from 'vitest';
 
 import { writeClientModels } from '../models';
-import { mockTemplates } from './mocks';
+import { openApi } from './models';
 
 vi.mock('node:fs');
 
 describe('writeClientModels', () => {
     it('should write to filesystem', async () => {
-        const client: Parameters<typeof writeClientModels>[0] = {
+        const client: Parameters<typeof writeClientModels>[2] = {
             enumNames: [],
             models: [
                 {
@@ -37,7 +37,7 @@ describe('writeClientModels', () => {
             version: 'v1',
         };
 
-        await writeClientModels(client, mockTemplates, '/', {
+        await writeClientModels(openApi, '/', client, {
             client: 'fetch',
             debug: false,
             enums: 'javascript',

packages/openapi-ts/src/utils/write/__tests__/models.ts

@@ -0,0 +1,11 @@
+import type { OpenApi } from '../../../openApi';
+
+export const openApi: OpenApi = {
+    info: {
+        title: '',
+        version: '',
+    },
+    openapi: '',
+    paths: {},
+    swagger: '',
+};

packages/openapi-ts/src/utils/write/__tests__/schemas.spec.ts

@@ -4,60 +4,23 @@ import path from 'node:path';
 import { describe, expect, it, vi } from 'vitest';
 
 import { writeClientSchemas } from '../schemas';
-import { mockTemplates } from './mocks';
+import { openApi } from './models';
 
 vi.mock('node:fs');
 
 describe('writeClientSchemas', () => {
     it('should write to filesystem', async () => {
-        const client: Parameters<typeof writeClientSchemas>[0] = {
-            enumNames: [],
-            models: [
-                {
-                    $refs: [],
-                    base: 'User',
-                    description: null,
-                    enum: [],
-                    enums: [],
-                    export: 'interface',
-                    imports: [],
-                    isDefinition: true,
-                    isNullable: false,
-                    isReadOnly: false,
-                    isRequired: false,
-                    link: null,
-                    name: 'User',
-                    properties: [],
-                    template: null,
-                    type: 'User',
+        if ('openapi' in openApi) {
+            openApi.components = {
+                schemas: {
+                    foo: {
+                        type: 'object',
+                    },
                 },
-            ],
-            server: 'http://localhost:8080',
-            services: [],
-            version: 'v1',
-        };
+            };
+        }
 
-        await writeClientSchemas(client, mockTemplates, '/', {
-            client: 'fetch',
-            debug: false,
-            enums: 'javascript',
-            experimental: false,
-            exportCore: true,
-            exportModels: true,
-            exportSchemas: true,
-            exportServices: true,
-            format: false,
-            input: '',
-            lint: false,
-            name: 'AppClient',
-            operationId: true,
-            output: '',
-            postfixServices: '',
-            serviceResponse: 'body',
-            useDateType: false,
-            useOptions: true,
-            write: true,
-        });
+        await writeClientSchemas(openApi, '/');
 
         expect(writeFileSync).toHaveBeenCalledWith(path.resolve('/', '/schemas.ts'), expect.anything());
     });