chore: generate typed baseUrl option

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]!;
 

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

@@ -221,6 +221,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/plugins/@hey-api/typescript/clientOptions.ts

@@ -0,0 +1,78 @@
+import ts from 'typescript';
+
+import { compiler } from '../../../compiler';
+import type { Identifier } from '../../../generate/files';
+import type { IR } from '../../../ir/types';
+import { parseUrl } from '../../../utils/url';
+import type { Plugin } from '../../types';
+import { getClientBaseUrlKey } from '../client-core/utils';
+import { typesId } from './ref';
+import type { Config } from './types';
+
+const stringType = compiler.keywordTypeNode({ keyword: 'string' });
+
+const serverToBaseUrlType = ({ server }: { server: IR.ServerObject }) => {
+  const url = parseUrl(server.url);
+
+  if (url.protocol && url.host) {
+    return compiler.literalTypeNode({
+      literal: compiler.stringLiteral({ text: server.url }),
+    });
+  }
+
+  return compiler.templateLiteralType({
+    value: [
+      url.protocol || stringType,
+      '://',
+      url.host || stringType,
+      url.port ? `:${url.port}` : '',
+      url.path || '',
+    ],
+  });
+};
+
+export const createClientOptions = ({
+  context,
+  identifier,
+  servers,
+}: {
+  context: IR.Context;
+  identifier: Identifier;
+  plugin: Plugin.Instance<Config>;
+  servers: ReadonlyArray<IR.ServerObject>;
+}) => {
+  const file = context.file({ id: typesId })!;
+
+  if (!identifier.name) {
+    return;
+  }
+
+  const typeClientOptions = compiler.typeAliasDeclaration({
+    exportType: true,
+    name: identifier.name,
+    type: compiler.typeInterfaceNode({
+      properties: [
+        {
+          name: getClientBaseUrlKey(context.config),
+          type: compiler.typeUnionNode({
+            types: [
+              ...servers.map((server) =>
+                serverToBaseUrlType({
+                  server,
+                }),
+              ),
+              servers.length
+                ? compiler.typeIntersectionNode({
+                    types: [stringType, ts.factory.createTypeLiteralNode([])],
+                  })
+                : stringType,
+            ],
+          }),
+        },
+      ],
+      useLegacyResolution: false,
+    }),
+  });
+
+  file.add(typeClientOptions);
+};