Merge pull request #1884 from hey-api/feat/client-custom

refactor: move snapshot tests into separate package

Author: mrlubos

package.json

@@ -28,6 +28,7 @@
     "lint:fix": "prettier --check --write . && eslint . --fix",
     "lint": "prettier --check . && eslint .",
     "openapi-ts": "turbo run $1 --filter=\"@hey-api/openapi-ts\"",
+    "openapi-ts-tests": "turbo run $1 --filter=\"@test/openapi-ts\"",
     "prepare": "husky",
     "test:coverage": "turbo run test:coverage",
     "test:e2e": "turbo run test:e2e",

packages/client-custom/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Hey API
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

packages/client-custom/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@hey-api/client-custom",
+  "version": "0.0.0",
+  "description": "Custom client for `@hey-api/openapi-ts` codegen. Used for testing.",
+  "private": true,
+  "homepage": "https://heyapi.dev/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hey-api/openapi-ts.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hey-api/openapi-ts/issues"
+  },
+  "license": "MIT",
+  "author": {
+    "email": "[email protected]",
+    "name": "Hey API",
+    "url": "https://heyapi.dev"
+  },
+  "funding": "https://github.com/sponsors/hey-api",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./plugin": {
+      "import": {
+        "types": "./dist/plugin.d.ts",
+        "default": "./dist/plugin.js"
+      },
+      "require": {
+        "types": "./dist/plugin.d.cts",
+        "default": "./dist/plugin.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "LICENSE.md",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsup && rollup -c && pnpm check-exports",
+    "check-exports": "attw --profile node16 --pack .",
+    "dev": "tsup --watch",
+    "prepublishOnly": "pnpm build",
+    "test:coverage": "vitest run --coverage",
+    "test:update": "vitest watch --update",
+    "test:watch": "vitest watch",
+    "test": "vitest run",
+    "typecheck": "vitest --typecheck --watch=false"
+  },
+  "peerDependencies": {
+    "@hey-api/openapi-ts": "< 2"
+  },
+  "devDependencies": {
+    "@hey-api/client-core": "workspace:*",
+    "@hey-api/openapi-ts": "workspace:*"
+  }
+}

packages/client-custom/rollup.config.mjs

@@ -0,0 +1,30 @@
+import path from 'node:path';
+
+import { defineConfig } from 'rollup';
+import dts from 'rollup-plugin-dts';
+
+const files = ['index.d.ts', 'index.d.cts', 'plugin.d.ts', 'plugin.d.cts'];
+
+export default files.map((file) =>
+  defineConfig({
+    external: (id) => {
+      const normalizedId = id.split(path.sep).join('/');
+      if (normalizedId === '@hey-api/client-core') {
+        return false;
+      }
+      return (
+        !normalizedId.startsWith('/') && !/^[a-zA-Z]:\//.test(normalizedId)
+      );
+    },
+    input: `./dist/${file}`,
+    output: {
+      file: `./dist/${file}`,
+      format: 'es',
+    },
+    plugins: [
+      dts({
+        respectExternal: true,
+      }),
+    ],
+  }),
+);

packages/client-custom/src/__tests__/client.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+
+import { createClient } from '../client';
+
+describe('buildUrl', () => {
+  const client = createClient();
+
+  const scenarios: {
+    options: Parameters<typeof client.buildUrl>[0];
+    url: string;
+  }[] = [
+    {
+      options: {
+        url: '',
+      },
+      url: '/',
+    },
+    {
+      options: {
+        url: '/foo',
+      },
+      url: '/foo',
+    },
+    {
+      options: {
+        path: {
+          fooId: 1,
+        },
+        url: '/foo/{fooId}',
+      },
+      url: '/foo/1',
+    },
+    {
+      options: {
+        path: {
+          fooId: 1,
+        },
+        query: {
+          bar: 'baz',
+        },
+        url: '/foo/{fooId}',
+      },
+      url: '/foo/1?bar=baz',
+    },
+  ];
+
+  it.each(scenarios)('returns $url', ({ options, url }) => {
+    expect(client.buildUrl(options)).toBe(url);
+  });
+});

packages/client-custom/src/__tests__/utils.test.ts

@@ -0,0 +1,210 @@
+import type { Auth } from '@hey-api/client-core';
+import { describe, expect, it, vi } from 'vitest';
+
+import { getParseAs, setAuthParams } from '../utils';
+
+describe('getParseAs', () => {
+  const scenarios: Array<{
+    content: Parameters<typeof getParseAs>[0];
+    parseAs: ReturnType<typeof getParseAs>;
+  }> = [
+    {
+      content: null,
+      parseAs: 'stream',
+    },
+    {
+      content: 'application/json',
+      parseAs: 'json',
+    },
+    {
+      content: 'application/ld+json',
+      parseAs: 'json',
+    },
+    {
+      content: 'application/ld+json;charset=utf-8',
+      parseAs: 'json',
+    },
+    {
+      content: 'application/ld+json; charset=utf-8',
+      parseAs: 'json',
+    },
+    {
+      content: 'multipart/form-data',
+      parseAs: 'formData',
+    },
+    {
+      content: 'application/*',
+      parseAs: 'blob',
+    },
+    {
+      content: 'audio/*',
+      parseAs: 'blob',
+    },
+    {
+      content: 'image/*',
+      parseAs: 'blob',
+    },
+    {
+      content: 'video/*',
+      parseAs: 'blob',
+    },
+    {
+      content: 'text/*',
+      parseAs: 'text',
+    },
+    {
+      content: 'unsupported',
+      parseAs: undefined,
+    },
+  ];
+
+  it.each(scenarios)(
+    'detects $content as $parseAs',
+    async ({ content, parseAs }) => {
+      expect(getParseAs(content)).toEqual(parseAs);
+    },
+  );
+});
+
+describe('setAuthParams', () => {
+  it('sets bearer token in headers', async () => {
+    const auth = vi.fn().mockReturnValue('foo');
+    const headers = new Headers();
+    const query: Record<any, unknown> = {};
+    await setAuthParams({
+      auth,
+      headers,
+      query,
+      security: [
+        {
+          name: 'baz',
+          scheme: 'bearer',
+          type: 'http',
+        },
+      ],
+    });
+    expect(auth).toHaveBeenCalled();
+    expect(headers.get('baz')).toBe('Bearer foo');
+    expect(Object.keys(query).length).toBe(0);
+  });
+
+  it('sets access token in query', async () => {
+    const auth = vi.fn().mockReturnValue('foo');
+    const headers = new Headers();
+    const query: Record<any, unknown> = {};
+    await setAuthParams({
+      auth,
+      headers,
+      query,
+      security: [
+        {
+          in: 'query',
+          name: 'baz',
+          scheme: 'bearer',
+          type: 'http',
+        },
+      ],
+    });
+    expect(auth).toHaveBeenCalled();
+    expect(headers.get('baz')).toBeNull();
+    expect(query.baz).toBe('Bearer foo');
+  });
+
+  it('sets Authorization header when `in` and `name` are undefined', async () => {
+    const auth = vi.fn().mockReturnValue('foo');
+    const headers = new Headers();
+    const query: Record<any, unknown> = {};
+    await setAuthParams({
+      auth,
+      headers,
+      query,
+      security: [
+        {
+          type: 'http',
+        },
+      ],
+    });
+    expect(auth).toHaveBeenCalled();
+    expect(headers.get('Authorization')).toBe('foo');
+    expect(query).toEqual({});
+  });
+
+  it('sets first scheme only', async () => {
+    const auth = vi.fn().mockReturnValue('foo');
+    const headers = new Headers();
+    const query: Record<any, unknown> = {};
+    await setAuthParams({
+      auth,
+      headers,
+      query,
+      security: [
+        {
+          name: 'baz',
+          scheme: 'bearer',
+          type: 'http',
+        },
+        {
+          in: 'query',
+          name: 'baz',
+          scheme: 'bearer',
+          type: 'http',
+        },
+      ],
+    });
+    expect(auth).toHaveBeenCalled();
+    expect(headers.get('baz')).toBe('Bearer foo');
+    expect(Object.keys(query).length).toBe(0);
+  });
+
+  it('sets first scheme with token', async () => {
+    const auth = vi.fn().mockImplementation((auth: Auth) => {
+      if (auth.type === 'apiKey') {
+        return;
+      }
+      return 'foo';
+    });
+    const headers = new Headers();
+    const query: Record<any, unknown> = {};
+    await setAuthParams({
+      auth,
+      headers,
+      query,
+      security: [
+        {
+          name: 'baz',
+          type: 'apiKey',
+        },
+        {
+          in: 'query',
+          name: 'baz',
+          scheme: 'bearer',
+          type: 'http',
+        },
+      ],
+    });
+    expect(auth).toHaveBeenCalled();
+    expect(headers.get('baz')).toBeNull();
+    expect(query.baz).toBe('Bearer foo');
+  });
+
+  it('sets an API key in a cookie', async () => {
+    const auth = vi.fn().mockReturnValue('foo');
+    const headers = new Headers();
+    const query: Record<any, unknown> = {};
+    await setAuthParams({
+      auth,
+      headers,
+      query,
+      security: [
+        {
+          in: 'cookie',
+          name: 'baz',
+          type: 'apiKey',
+        },
+      ],
+    });
+    expect(auth).toHaveBeenCalled();
+    expect(headers.get('Cookie')).toBe('baz=foo');
+    expect(query).toEqual({});
+  });
+});