chore: generate typed baseUrl option

Author: mrlubos

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

@@ -58,6 +58,7 @@ export const compiler = {
   safeAccessExpression: transform.createSafeAccessExpression,
   stringLiteral: types.createStringLiteral,
   stringToTsNodes: utils.stringToTsNodes,
+  templateLiteralType: types.createTemplateLiteralType,
   transformArrayMap: transform.createArrayMapTransform,
   transformArrayMutation: transform.createArrayTransformMutation,
   transformDateMutation: transform.createDateTransformMutation,

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

@@ -1012,3 +1012,31 @@ export const createAsExpression = ({
   expression: ts.Expression;
   type: ts.TypeNode;
 }) => ts.factory.createAsExpression(expression, type);
+
+export const createTemplateLiteralType = ({
+  value,
+}: {
+  value: ReadonlyArray<string | ts.TypeNode>;
+}) => {
+  const spans: Array<ts.TemplateLiteralTypeSpan> = [];
+  let spanText = '';
+
+  for (const item of value.slice(0).reverse()) {
+    if (typeof item === 'string') {
+      spanText = `${item}${spanText}`;
+    } else {
+      const literal = spans.length
+        ? ts.factory.createTemplateMiddle(spanText)
+        : ts.factory.createTemplateTail(spanText);
+      const span = ts.factory.createTemplateLiteralTypeSpan(item, literal);
+      spans.push(span);
+      spanText = '';
+    }
+  }
+
+  const templateLiteralType = ts.factory.createTemplateLiteralType(
+    ts.factory.createTemplateHead(spanText),
+    spans.reverse(),
+  );
+  return templateLiteralType;
+};

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

@@ -56,6 +56,7 @@ interface Events {
     name: string;
     schema: IR.SchemaObject;
   }) => void;
+  server: (args: { server: IR.ServerObject }) => void;
 }
 
 type Listeners = {

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

@@ -7,6 +7,10 @@ import type { IR } from './types';
 export const parseIR = async ({ context }: { context: IR.Context }) => {
   await context.broadcast('before');
 
+  for (const server of context.ir.servers ?? []) {
+    await context.broadcast('server', { server });
+  }
+
   if (context.ir.components) {
     for (const name in context.ir.components.schemas) {
       const schema = context.ir.components.schemas[name]!;

packages/openapi-ts/src/openApi/2.0.x/parser/__tests__/server.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect, it } from 'vitest';
+
+import type { IR } from '../../../../ir/types';
+import type { OpenApi } from '../../../types';
+import { parseServers } from '../server';
+
+describe('parseServers', () => {
+  it('host + basePath + schemes', () => {
+    const context: Partial<IR.Context<Partial<OpenApi.V2_0_X>>> = {
+      // @ts-expect-error
+      config: {
+        input: {
+          path: '',
+        },
+      },
+      ir: {},
+      spec: {
+        basePath: '/v1',
+        host: 'foo.com',
+        schemes: ['http', 'https'],
+      },
+    };
+    parseServers({ context: context as IR.Context });
+    expect(context.ir!.servers).toEqual([
+      {
+        url: 'http://foo.com/v1',
+      },
+      {
+        url: 'https://foo.com/v1',
+      },
+    ]);
+  });
+
+  it('schemes + host', () => {
+    const context: Partial<IR.Context<Partial<OpenApi.V2_0_X>>> = {
+      // @ts-expect-error
+      config: {
+        input: {
+          path: '',
+        },
+      },
+      ir: {},
+      spec: {
+        host: 'foo.com',
+        schemes: ['ws'],
+      },
+    };
+    parseServers({ context: context as IR.Context });
+    expect(context.ir!.servers).toEqual([
+      {
+        url: 'ws://foo.com',
+      },
+    ]);
+  });
+
+  it('host + basePath', () => {
+    const context: Partial<IR.Context<Partial<OpenApi.V2_0_X>>> = {
+      // @ts-expect-error
+      config: {
+        input: {
+          path: '',
+        },
+      },
+      ir: {},
+      spec: {
+        basePath: '/v1',
+        host: 'foo.com',
+      },
+    };
+    parseServers({ context: context as IR.Context });
+    expect(context.ir!.servers).toEqual([
+      {
+        url: 'foo.com/v1',
+      },
+    ]);
+  });
+
+  it('host', () => {
+    const context: Partial<IR.Context<Partial<OpenApi.V2_0_X>>> = {
+      // @ts-expect-error
+      config: {
+        input: {
+          path: '',
+        },
+      },
+      ir: {},
+      spec: {
+        host: 'foo.com',
+      },
+    };
+    parseServers({ context: context as IR.Context });
+    expect(context.ir!.servers).toEqual([
+      {
+        url: 'foo.com',
+      },
+    ]);
+  });
+
+  it('basePath', () => {
+    const context: Partial<IR.Context<Partial<OpenApi.V2_0_X>>> = {
+      // @ts-expect-error
+      config: {
+        input: {
+          path: '',
+        },
+      },
+      ir: {},
+      spec: {
+        basePath: '/v1',
+      },
+    };
+    parseServers({ context: context as IR.Context });
+    expect(context.ir!.servers).toEqual([
+      {
+        url: '/v1',
+      },
+    ]);
+  });
+});

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

@@ -11,6 +11,7 @@ import type {
 import { parseOperation } from './operation';
 import { parametersArrayToObject } from './parameter';
 import { parseSchema } from './schema';
+import { parseServers } from './server';
 
 type PathKeys<T extends keyof PathsObject = keyof PathsObject> =
   keyof T extends infer K ? (K extends `/${string}` ? K : never) : never;
@@ -55,6 +56,8 @@ export const parseV2_0_X = (context: IR.Context<OpenApiV2_0_X>) => {
     }
   }
 
+  parseServers({ context });
+
   for (const path in context.spec.paths) {
     if (path.startsWith('x-')) {
       continue;

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

@@ -0,0 +1,36 @@
+import type { IR } from '../../../ir/types';
+import { parseUrl } from '../../../utils/url';
+
+export const parseServers = ({ context }: { context: IR.Context }) => {
+  let schemes: ReadonlyArray<string> = context.spec.schemes ?? [];
+  let host = context.spec.host ?? '';
+  const path = context.spec.basePath ?? '';
+
+  if (typeof context.config.input.path === 'string') {
+    const url = parseUrl(context.config.input.path);
+
+    if (!schemes.length) {
+      if (url.protocol) {
+        schemes = [url.protocol] as typeof schemes;
+      }
+    }
+
+    if (!host) {
+      host = `${url.host}${url.port ? `:${url.port}` : ''}`;
+    }
+  }
+
+  if (!schemes.length) {
+    schemes = [''];
+  }
+
+  const servers = schemes
+    .map((scheme) => `${scheme ? `${scheme}://` : ''}${host}${path}`)
+    .filter(Boolean);
+
+  if (servers.length) {
+    context.ir.servers = servers.map((url) => ({
+      url,
+    }));
+  }
+};

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

@@ -99,6 +99,10 @@ export const parseV3_0_X = (context: IR.Context<OpenApiV3_0_X>) => {
     }
   }
 
+  if (context.spec.servers) {
+    context.ir.servers = context.spec.servers;
+  }
+
   for (const path in context.spec.paths) {
     const pathItem = context.spec.paths[path as keyof PathsObject]!;
 

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

@@ -236,6 +236,10 @@ export const parseOperation = ({
     context.ir.paths[path] = {};
   }
 
+  if (operation.servers) {
+    context.ir.servers = [...(context.ir.servers ?? []), ...operation.servers];
+  }
+
   operation.id = operationToId({
     context,
     id: operation.operationId,

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

@@ -99,6 +99,10 @@ export const parseV3_1_X = (context: IR.Context<OpenApiV3_1_X>) => {
     }
   }
 
+  if (context.spec.servers) {
+    context.ir.servers = context.spec.servers;
+  }
+
   for (const path in context.spec.paths) {
     const pathItem = context.spec.paths[path as keyof PathsObject]!;