@raketa-cloud/admin 1.8.10 → 1.8.11

package/src/tests/RaketaClient.test.js

@@ -1,636 +1,650 @@
-import RaketaClient from '../cloud/RaketaClient'
-import { request } from 'graphql-request'
+import RaketaClient from "../cloud/RaketaClient";
+import { request } from "graphql-request";
 
-jest.mock('graphql-request', () => ({
+jest.mock("graphql-request", () => ({
   request: jest.fn(),
-}))
+}));
 
-describe('RaketaClient', () => {
+describe("RaketaClient", () => {
   function buildMockConfig(overrides = {}) {
     return {
       cloud: {
-        gateway_url: 'https://api.example.com',
-        gateway_project: 'test-project',
-        dxp_service_private: 'test-service',
+        gateway_url: "https://api.example.com",
+        gateway_project: "test-project",
+        dxp_service_private: "test-service",
       },
       ...overrides,
-    }
+    };
   }
 
-  function buildClient(config = buildMockConfig(), token = 'test-token') {
-    const getConfig = () => config
-    return new RaketaClient(getConfig, token)
+  function buildClient(config = buildMockConfig(), token = "test-token") {
+    const getConfig = () => config;
+    return new RaketaClient(getConfig, token);
   }
 
   beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  describe('constructor', () => {
-    test('initializes with getConfig and token', () => {
-      const getConfig = jest.fn(() => buildMockConfig())
-      const client = new RaketaClient(getConfig, 'my-token')
-
-      expect(client.getConfig).toBe(getConfig)
-      expect(client.token).toBe('my-token')
-    })
-  })
-
-  describe('gqlRequest', () => {
-    test('makes GraphQL request with correct parameters', async () => {
-      const client = buildClient()
-      const query = 'query { test }'
-      const variables = { id: '123' }
-      const headers = { 'x-custom': 'value' }
-
-      request.mockResolvedValue({ data: 'response' })
-
-      await client.gqlRequest('https://api.example.com/graphql', query, variables, headers)
+    jest.clearAllMocks();
+  });
+
+  describe("constructor", () => {
+    test("initializes with getConfig and token", () => {
+      const getConfig = jest.fn(() => buildMockConfig());
+      const client = new RaketaClient(getConfig, "my-token");
+
+      expect(client.getConfig).toBe(getConfig);
+      expect(client.token).toBe("my-token");
+    });
+  });
+
+  describe("gqlRequest", () => {
+    test("makes GraphQL request with correct parameters", async () => {
+      const client = buildClient();
+      const query = "query { test }";
+      const variables = { id: "123" };
+      const headers = { "x-custom": "value" };
+
+      request.mockResolvedValue({ data: "response" });
+
+      await client.gqlRequest(
+        "https://api.example.com/graphql",
+        query,
+        variables,
+        headers,
+      );
 
       expect(request).toHaveBeenCalledWith({
-        url: 'https://api.example.com/graphql',
+        url: "https://api.example.com/graphql",
         document: query,
         variables: variables,
         requestHeaders: headers,
-      })
-    })
+      });
+    });
 
-    test('makes request with default empty variables and headers', async () => {
-      const client = buildClient()
-      const query = 'query { test }'
+    test("makes request with default empty variables and headers", async () => {
+      const client = buildClient();
+      const query = "query { test }";
 
-      request.mockResolvedValue({ data: 'response' })
+      request.mockResolvedValue({ data: "response" });
 
-      await client.gqlRequest('https://api.example.com/graphql', query)
+      await client.gqlRequest("https://api.example.com/graphql", query);
 
       expect(request).toHaveBeenCalledWith({
-        url: 'https://api.example.com/graphql',
+        url: "https://api.example.com/graphql",
         document: query,
         variables: {},
         requestHeaders: {},
-      })
-    })
-  })
+      });
+    });
+  });
 
-  describe('query', () => {
-    test('makes request to gateway with proper headers', async () => {
-      const client = buildClient()
-      const query = 'query { users }'
-      const variables = { limit: 10 }
+  describe("query", () => {
+    test("makes request to gateway with proper headers", async () => {
+      const client = buildClient();
+      const query = "query { users }";
+      const variables = { limit: 10 };
 
-      request.mockResolvedValue({ data: { users: [] } })
+      request.mockResolvedValue({ data: { users: [] } });
 
-      await client.query(query, variables)
+      await client.query(query, variables);
 
       expect(request).toHaveBeenCalledWith({
-        url: 'https://api.example.com/dispatch',
+        url: "https://api.example.com/dispatch",
         document: query,
         variables: variables,
         requestHeaders: {
-          'x-raketa-project': 'test-project',
-          'x-raketa-service': 'test-service',
-          'x-raketa-identity': 'test-token',
+          "x-raketa-project": "test-project",
+          "x-raketa-service": "test-service",
+          "x-raketa-identity": "test-token",
         },
-      })
-    })
+      });
+    });
 
-    test('uses token from constructor in headers', async () => {
-      const client = buildClient(buildMockConfig(), 'custom-token-123')
-      const query = 'query { test }'
+    test("uses token from constructor in headers", async () => {
+      const client = buildClient(buildMockConfig(), "custom-token-123");
+      const query = "query { test }";
 
-      request.mockResolvedValue({ data: {} })
+      request.mockResolvedValue({ data: {} });
 
-      await client.query(query)
+      await client.query(query);
 
       expect(request).toHaveBeenCalledWith(
         expect.objectContaining({
           requestHeaders: expect.objectContaining({
-            'x-raketa-identity': 'custom-token-123',
+            "x-raketa-identity": "custom-token-123",
           }),
-        })
-      )
-    })
-  })
+        }),
+      );
+    });
+  });
 
-  describe('logError', () => {
-    test('throws error with message', () => {
-      const client = buildClient()
-      const consoleSpy = jest.spyOn(console, 'error').mockImplementation()
+  describe("logError", () => {
+    test("throws error with message", () => {
+      const client = buildClient();
+      const consoleSpy = jest.spyOn(console, "error").mockImplementation();
 
-      expect(() => client.logError('Something went wrong')).toThrow('Something went wrong')
+      expect(() => client.logError("Something went wrong")).toThrow(
+        "Something went wrong",
+      );
 
-      consoleSpy.mockRestore()
-    })
+      consoleSpy.mockRestore();
+    });
 
-    test('logs context to console when provided', () => {
-      const client = buildClient()
-      const consoleSpy = jest.spyOn(console, 'error').mockImplementation()
-      const context = { code: 'ERR_001', details: 'Invalid input' }
+    test("logs context to console when provided", () => {
+      const client = buildClient();
+      const consoleSpy = jest.spyOn(console, "error").mockImplementation();
+      const context = { code: "ERR_001", details: "Invalid input" };
 
-      expect(() => client.logError('Error occurred', context)).toThrow('Error occurred')
-      expect(consoleSpy).toHaveBeenCalledWith(context)
+      expect(() => client.logError("Error occurred", context)).toThrow(
+        "Error occurred",
+      );
+      expect(consoleSpy).toHaveBeenCalledWith(context);
 
-      consoleSpy.mockRestore()
-    })
+      consoleSpy.mockRestore();
+    });
 
-    test('does not log when context is not provided', () => {
-      const client = buildClient()
-      const consoleSpy = jest.spyOn(console, 'error').mockImplementation()
+    test("does not log when context is not provided", () => {
+      const client = buildClient();
+      const consoleSpy = jest.spyOn(console, "error").mockImplementation();
 
-      expect(() => client.logError('Error occurred')).toThrow('Error occurred')
-      expect(consoleSpy).not.toHaveBeenCalled()
+      expect(() => client.logError("Error occurred")).toThrow("Error occurred");
+      expect(consoleSpy).not.toHaveBeenCalled();
 
-      consoleSpy.mockRestore()
-    })
-  })
+      consoleSpy.mockRestore();
+    });
+  });
 
-  describe('formatErrors', () => {
-    test('formats single error into object', () => {
-      const client = buildClient()
-      const errors = [{ key: 'email', message: 'Email is invalid' }]
+  describe("formatErrors", () => {
+    test("formats single error into object", () => {
+      const client = buildClient();
+      const errors = [{ key: "email", message: "Email is invalid" }];
 
-      const result = client.formatErrors(errors)
+      const result = client.formatErrors(errors);
 
       expect(result).toEqual({
-        email: 'Email is invalid',
-      })
-    })
+        email: "Email is invalid",
+      });
+    });
 
-    test('formats multiple errors for different keys', () => {
-      const client = buildClient()
+    test("formats multiple errors for different keys", () => {
+      const client = buildClient();
       const errors = [
-        { key: 'email', message: 'Email is required' },
-        { key: 'password', message: 'Password is too short' },
-        { key: 'username', message: 'Username is taken' },
-      ]
+        { key: "email", message: "Email is required" },
+        { key: "password", message: "Password is too short" },
+        { key: "username", message: "Username is taken" },
+      ];
 
-      const result = client.formatErrors(errors)
+      const result = client.formatErrors(errors);
 
       expect(result).toEqual({
-        email: 'Email is required',
-        password: 'Password is too short',
-        username: 'Username is taken',
-      })
-    })
-
-    test('concatenates multiple messages for same key', () => {
-      const client = buildClient()
+        email: "Email is required",
+        password: "Password is too short",
+        username: "Username is taken",
+      });
+    });
+
+    test("concatenates multiple messages for same key", () => {
+      const client = buildClient();
       const errors = [
-        { key: 'email', message: 'Email is required' },
-        { key: 'email', message: 'Email format is invalid' },
-        { key: 'password', message: 'Password is required' },
-      ]
+        { key: "email", message: "Email is required" },
+        { key: "email", message: "Email format is invalid" },
+        { key: "password", message: "Password is required" },
+      ];
 
-      const result = client.formatErrors(errors)
+      const result = client.formatErrors(errors);
 
       expect(result).toEqual({
-        email: 'Email is required, Email format is invalid',
-        password: 'Password is required',
-      })
-    })
+        email: "Email is required, Email format is invalid",
+        password: "Password is required",
+      });
+    });
 
-    test('remaps generalError to specified key', () => {
-      const client = buildClient()
+    test("remaps generalError to specified key", () => {
+      const client = buildClient();
       const errors = [
-        { key: 'generalError', message: 'Something went wrong' },
-        { key: 'email', message: 'Email is invalid' },
-      ]
+        { key: "generalError", message: "Something went wrong" },
+        { key: "email", message: "Email is invalid" },
+      ];
 
-      const result = client.formatErrors(errors, 'base')
+      const result = client.formatErrors(errors, "base");
 
       expect(result).toEqual({
-        base: 'Something went wrong',
-        email: 'Email is invalid',
-      })
-    })
+        base: "Something went wrong",
+        email: "Email is invalid",
+      });
+    });
 
-    test('keeps generalError key when no remap specified', () => {
-      const client = buildClient()
-      const errors = [{ key: 'generalError', message: 'Operation failed' }]
+    test("keeps generalError key when no remap specified", () => {
+      const client = buildClient();
+      const errors = [{ key: "generalError", message: "Operation failed" }];
 
-      const result = client.formatErrors(errors)
+      const result = client.formatErrors(errors);
 
       expect(result).toEqual({
-        generalError: 'Operation failed',
-      })
-    })
+        generalError: "Operation failed",
+      });
+    });
 
-    test('handles empty errors array', () => {
-      const client = buildClient()
-      const result = client.formatErrors([])
+    test("handles empty errors array", () => {
+      const client = buildClient();
+      const result = client.formatErrors([]);
 
-      expect(result).toEqual({})
-    })
-  })
+      expect(result).toEqual({});
+    });
+  });
 
-  describe('buildFiltersInput', () => {
-    test('extracts filters with f: prefix', () => {
-      const client = buildClient()
+  describe("buildFiltersInput", () => {
+    test("extracts filters with f: prefix", () => {
+      const client = buildClient();
       const query = {
-        'f:status': 'active',
-        'f:category': 'news',
-        page: '2',
-        order_by: 'created_at',
-      }
+        "f:status": "active",
+        "f:category": "news",
+        page: "2",
+        order_by: "created_at",
+      };
 
-      const result = client.buildFiltersInput(query)
+      const result = client.buildFiltersInput(query);
 
       expect(result).toEqual({
-        status: 'active',
-        category: 'news',
-      })
-    })
+        status: "active",
+        category: "news",
+      });
+    });
 
-    test('ignores filters with empty values', () => {
-      const client = buildClient()
+    test("ignores filters with empty values", () => {
+      const client = buildClient();
       const query = {
-        'f:status': 'active',
-        'f:category': '',
-        'f:tag': null,
-        'f:author': undefined,
-      }
+        "f:status": "active",
+        "f:category": "",
+        "f:tag": null,
+        "f:author": undefined,
+      };
 
-      const result = client.buildFiltersInput(query)
+      const result = client.buildFiltersInput(query);
 
       expect(result).toEqual({
-        status: 'active',
-      })
-    })
+        status: "active",
+      });
+    });
 
-    test('returns empty object when no filters present', () => {
-      const client = buildClient()
+    test("returns empty object when no filters present", () => {
+      const client = buildClient();
       const query = {
-        page: '1',
-        order_by: 'title',
-      }
+        page: "1",
+        order_by: "title",
+      };
 
-      const result = client.buildFiltersInput(query)
+      const result = client.buildFiltersInput(query);
 
-      expect(result).toEqual({})
-    })
+      expect(result).toEqual({});
+    });
 
-    test('returns empty object when query is null or undefined', () => {
-      const client = buildClient()
+    test("returns empty object when query is null or undefined", () => {
+      const client = buildClient();
 
-      expect(client.buildFiltersInput(null)).toEqual({})
-      expect(client.buildFiltersInput(undefined)).toEqual({})
-    })
+      expect(client.buildFiltersInput(null)).toEqual({});
+      expect(client.buildFiltersInput(undefined)).toEqual({});
+    });
 
-    test('returns empty object when only page param exists', () => {
-      const client = buildClient()
-      const query = { page: '3' }
+    test("returns empty object when only page param exists", () => {
+      const client = buildClient();
+      const query = { page: "3" };
 
-      const result = client.buildFiltersInput(query)
+      const result = client.buildFiltersInput(query);
 
-      expect(result).toEqual({})
-    })
-  })
+      expect(result).toEqual({});
+    });
+  });
 
-  describe('buildOrderInput', () => {
-    test('builds order object with field and direction', () => {
-      const client = buildClient()
+  describe("buildOrderInput", () => {
+    test("builds order object with field and direction", () => {
+      const client = buildClient();
       const query = {
-        order_by: 'created_at',
-        order_direction: 'DESC',
-      }
+        order_by: "created_at",
+        order_direction: "DESC",
+      };
 
-      const result = client.buildOrderInput(query)
+      const result = client.buildOrderInput(query);
 
       expect(result).toEqual({
-        field: 'created_at',
-        direction: 'DESC',
-      })
-    })
+        field: "created_at",
+        direction: "DESC",
+      });
+    });
 
-    test('defaults to ASC when direction not provided', () => {
-      const client = buildClient()
-      const query = { order_by: 'title' }
+    test("defaults to ASC when direction not provided", () => {
+      const client = buildClient();
+      const query = { order_by: "title" };
 
-      const result = client.buildOrderInput(query)
+      const result = client.buildOrderInput(query);
 
       expect(result).toEqual({
-        field: 'title',
-        direction: 'ASC',
-      })
-    })
+        field: "title",
+        direction: "ASC",
+      });
+    });
 
-    test('returns null when order_by not provided', () => {
-      const client = buildClient()
-      const query = { order_direction: 'DESC' }
+    test("returns null when order_by not provided", () => {
+      const client = buildClient();
+      const query = { order_direction: "DESC" };
 
-      const result = client.buildOrderInput(query)
+      const result = client.buildOrderInput(query);
 
-      expect(result).toBeNull()
-    })
+      expect(result).toBeNull();
+    });
 
-    test('returns null when order_by is empty string', () => {
-      const client = buildClient()
-      const query = { order_by: '' }
+    test("returns null when order_by is empty string", () => {
+      const client = buildClient();
+      const query = { order_by: "" };
 
-      const result = client.buildOrderInput(query)
+      const result = client.buildOrderInput(query);
 
-      expect(result).toBeNull()
-    })
-  })
+      expect(result).toBeNull();
+    });
+  });
 
-  describe('buildPaginationInput', () => {
-    test('builds pagination with page number from query', () => {
-      const client = buildClient()
-      const query = { page: '3' }
+  describe("buildPaginationInput", () => {
+    test("builds pagination with page number from query", () => {
+      const client = buildClient();
+      const query = { page: "3" };
 
-      const result = client.buildPaginationInput(query)
+      const result = client.buildPaginationInput(query);
 
       expect(result).toEqual({
         page: 3,
         pageSize: 25,
-      })
-    })
+      });
+    });
 
-    test('defaults to page 1 when not provided', () => {
-      const client = buildClient()
-      const query = {}
+    test("defaults to page 1 when not provided", () => {
+      const client = buildClient();
+      const query = {};
 
-      const result = client.buildPaginationInput(query)
+      const result = client.buildPaginationInput(query);
 
       expect(result).toEqual({
         page: 1,
         pageSize: 25,
-      })
-    })
+      });
+    });
 
-    test('parses string page number to integer', () => {
-      const client = buildClient()
-      const query = { page: '10' }
+    test("parses string page number to integer", () => {
+      const client = buildClient();
+      const query = { page: "10" };
 
-      const result = client.buildPaginationInput(query)
+      const result = client.buildPaginationInput(query);
 
-      expect(result.page).toBe(10)
-      expect(typeof result.page).toBe('number')
-    })
+      expect(result.page).toBe(10);
+      expect(typeof result.page).toBe("number");
+    });
 
-    test('handles invalid page values by defaulting to 1', () => {
-      const client = buildClient()
+    test("handles invalid page values by defaulting to 1", () => {
+      const client = buildClient();
 
-      expect(client.buildPaginationInput({ page: 'invalid' })).toEqual({
+      expect(client.buildPaginationInput({ page: "invalid" })).toEqual({
         page: NaN,
         pageSize: 25,
-      })
-    })
-  })
+      });
+    });
+  });
 
-  describe('buildListInput', () => {
-    test('builds complete input with pagination, filters, orderBy, and locale', () => {
-      const client = buildClient()
+  describe("buildListInput", () => {
+    test("builds complete input with pagination, filters, orderBy, and locale", () => {
+      const client = buildClient();
       const query = {
-        page: '2',
-        'f:status': 'published',
-        'f:category': 'tech',
-        order_by: 'created_at',
-        order_direction: 'DESC',
-      }
+        page: "2",
+        "f:status": "published",
+        "f:category": "tech",
+        order_by: "created_at",
+        order_direction: "DESC",
+      };
 
-      const result = client.buildListInput(query, 'en')
+      const result = client.buildListInput(query, "en");
 
       expect(result).toEqual({
         input: {
           pagination: { page: 2, pageSize: 25 },
-          filters: { status: 'published', category: 'tech' },
-          orderBy: { field: 'created_at', direction: 'DESC' },
-          locale: 'en',
+          filters: { status: "published", category: "tech" },
+          orderBy: { field: "created_at", direction: "DESC" },
+          locale: "en",
         },
-      })
-    })
+      });
+    });
 
-    test('omits orderBy when not provided', () => {
-      const client = buildClient()
-      const query = { page: '1', 'f:status': 'active' }
+    test("omits orderBy when not provided", () => {
+      const client = buildClient();
+      const query = { page: "1", "f:status": "active" };
 
-      const result = client.buildListInput(query)
+      const result = client.buildListInput(query);
 
       expect(result).toEqual({
         input: {
           pagination: { page: 1, pageSize: 25 },
-          filters: { status: 'active' },
+          filters: { status: "active" },
         },
-      })
-    })
+      });
+    });
 
-    test('omits locale when not provided', () => {
-      const client = buildClient()
-      const query = { page: '1' }
+    test("omits locale when not provided", () => {
+      const client = buildClient();
+      const query = { page: "1" };
 
-      const result = client.buildListInput(query)
+      const result = client.buildListInput(query);
 
-      expect(result.input).not.toHaveProperty('locale')
-    })
+      expect(result.input).not.toHaveProperty("locale");
+    });
 
-    test('includes locale when provided', () => {
-      const client = buildClient()
-      const query = { page: '1' }
+    test("includes locale when provided", () => {
+      const client = buildClient();
+      const query = { page: "1" };
 
-      const result = client.buildListInput(query, 'de')
+      const result = client.buildListInput(query, "de");
 
-      expect(result.input.locale).toBe('de')
-    })
+      expect(result.input.locale).toBe("de");
+    });
 
-    test('handles empty query object', () => {
-      const client = buildClient()
+    test("handles empty query object", () => {
+      const client = buildClient();
 
-      const result = client.buildListInput({})
+      const result = client.buildListInput({});
 
       expect(result).toEqual({
         input: {
           pagination: { page: 1, pageSize: 25 },
           filters: {},
         },
-      })
-    })
-  })
+      });
+    });
+  });
 
-  describe('buildAllInput', () => {
-    test('builds input without pagination', () => {
-      const client = buildClient()
+  describe("buildAllInput", () => {
+    test("builds input without pagination", () => {
+      const client = buildClient();
       const query = {
-        page: '2',
-        'f:status': 'active',
-        order_by: 'title',
-        order_direction: 'ASC',
-      }
+        page: "2",
+        "f:status": "active",
+        order_by: "title",
+        order_direction: "ASC",
+      };
 
-      const result = client.buildAllInput(query, 'fr')
+      const result = client.buildAllInput(query, "fr");
 
       expect(result).toEqual({
         input: {
-          filters: { status: 'active' },
-          orderBy: { field: 'title', direction: 'ASC' },
-          locale: 'fr',
+          filters: { status: "active" },
+          orderBy: { field: "title", direction: "ASC" },
+          locale: "fr",
         },
-      })
-      expect(result.input).not.toHaveProperty('pagination')
-    })
+      });
+      expect(result.input).not.toHaveProperty("pagination");
+    });
 
-    test('omits orderBy when not provided', () => {
-      const client = buildClient()
-      const query = { 'f:category': 'news' }
+    test("omits orderBy when not provided", () => {
+      const client = buildClient();
+      const query = { "f:category": "news" };
 
-      const result = client.buildAllInput(query)
+      const result = client.buildAllInput(query);
 
       expect(result).toEqual({
         input: {
-          filters: { category: 'news' },
+          filters: { category: "news" },
         },
-      })
-    })
+      });
+    });
 
-    test('omits locale when not provided', () => {
-      const client = buildClient()
-      const query = {}
+    test("omits locale when not provided", () => {
+      const client = buildClient();
+      const query = {};
 
-      const result = client.buildAllInput(query)
+      const result = client.buildAllInput(query);
 
-      expect(result.input).not.toHaveProperty('locale')
-    })
-  })
+      expect(result.input).not.toHaveProperty("locale");
+    });
+  });
 
-  describe('deepMerge', () => {
-    test('merges two simple objects', () => {
-      const client = buildClient()
-      const target = { a: 1, b: 2 }
-      const source = { b: 3, c: 4 }
+  describe("deepMerge", () => {
+    test("merges two simple objects", () => {
+      const client = buildClient();
+      const target = { a: 1, b: 2 };
+      const source = { b: 3, c: 4 };
 
-      const result = client.deepMerge(target, source)
+      const result = client.deepMerge(target, source);
 
-      expect(result).toEqual({ a: 1, b: 3, c: 4 })
+      expect(result).toEqual({ a: 1, b: 3, c: 4 });
       // Verify original is not modified
-      expect(target).toEqual({ a: 1, b: 2 })
-    })
+      expect(target).toEqual({ a: 1, b: 2 });
+    });
 
-    test('merges nested objects deeply', () => {
-      const client = buildClient()
+    test("merges nested objects deeply", () => {
+      const client = buildClient();
       const target = {
-        settings: { theme: 'dark', locale: 'en' },
-        profile: { name: 'John' },
-      }
+        settings: { theme: "dark", locale: "en" },
+        profile: { name: "John" },
+      };
       const source = {
-        settings: { locale: 'fr', notifications: true },
+        settings: { locale: "fr", notifications: true },
         profile: { age: 30 },
-      }
+      };
 
-      const result = client.deepMerge(target, source)
+      const result = client.deepMerge(target, source);
 
       expect(result).toEqual({
-        settings: { theme: 'dark', locale: 'fr', notifications: true },
-        profile: { name: 'John', age: 30 },
-      })
-    })
+        settings: { theme: "dark", locale: "fr", notifications: true },
+        profile: { name: "John", age: 30 },
+      });
+    });
 
-    test('replaces arrays instead of merging', () => {
-      const client = buildClient()
-      const target = { tags: ['javascript', 'node'] }
-      const source = { tags: ['typescript', 'deno'] }
+    test("replaces arrays instead of merging", () => {
+      const client = buildClient();
+      const target = { tags: ["javascript", "node"] };
+      const source = { tags: ["typescript", "deno"] };
 
-      const result = client.deepMerge(target, source)
+      const result = client.deepMerge(target, source);
 
-      expect(result).toEqual({ tags: ['typescript', 'deno'] })
-    })
+      expect(result).toEqual({ tags: ["typescript", "deno"] });
+    });
 
-    test('parses JSON strings in source', () => {
-      const client = buildClient()
-      const target = { config: {} }
-      const source = { config: '{"enabled": true, "count": 5}' }
+    test("parses JSON strings in source", () => {
+      const client = buildClient();
+      const target = { config: {} };
+      const source = { config: '{"enabled": true, "count": 5}' };
 
-      const result = client.deepMerge(target, source)
+      const result = client.deepMerge(target, source);
 
-      expect(result.config).toEqual({ enabled: true, count: 5 })
-    })
+      expect(result.config).toEqual({ enabled: true, count: 5 });
+    });
 
-    test('parses JSON strings in nested objects', () => {
-      const client = buildClient()
-      const target = { settings: { meta: {} } }
-      const source = { settings: { meta: '{"title": "Test", "tags": ["a", "b"]}' } }
+    test("parses JSON strings in nested objects", () => {
+      const client = buildClient();
+      const target = { settings: { meta: {} } };
+      const source = {
+        settings: { meta: '{"title": "Test", "tags": ["a", "b"]}' },
+      };
 
-      const result = client.deepMerge(target, source)
+      const result = client.deepMerge(target, source);
 
-      expect(result.settings.meta).toEqual({ title: 'Test', tags: ['a', 'b'] })
-    })
+      expect(result.settings.meta).toEqual({ title: "Test", tags: ["a", "b"] });
+    });
 
-    test('handles null values', () => {
-      const client = buildClient()
-      const target = { a: 1, b: null }
-      const source = { b: 2, c: null }
+    test("handles null values", () => {
+      const client = buildClient();
+      const target = { a: 1, b: null };
+      const source = { b: 2, c: null };
 
-      const result = client.deepMerge(target, source)
+      const result = client.deepMerge(target, source);
 
-      expect(result).toEqual({ a: 1, b: 2, c: null })
-    })
+      expect(result).toEqual({ a: 1, b: 2, c: null });
+    });
 
-    test('does not modify target object', () => {
-      const client = buildClient()
-      const target = { nested: { value: 'original' } }
-      const source = { nested: { value: 'modified' } }
+    test("does not modify target object", () => {
+      const client = buildClient();
+      const target = { nested: { value: "original" } };
+      const source = { nested: { value: "modified" } };
 
-      client.deepMerge(target, source)
+      client.deepMerge(target, source);
 
-      expect(target.nested.value).toBe('original')
-    })
+      expect(target.nested.value).toBe("original");
+    });
 
-    test('handles deeply nested JSON strings', () => {
-      const client = buildClient()
+    test("handles deeply nested JSON strings", () => {
+      const client = buildClient();
       const target = {
         data: {
           user: {
             preferences: {},
           },
         },
-      }
+      };
       const source = {
         data: {
           user: {
             preferences: '{"theme": "dark", "language": "en"}',
           },
         },
-      }
+      };
 
-      const result = client.deepMerge(target, source)
+      const result = client.deepMerge(target, source);
 
       expect(result.data.user.preferences).toEqual({
-        theme: 'dark',
-        language: 'en',
-      })
-    })
-
-    test('handles array of objects with JSON strings', () => {
-      const client = buildClient()
-      const target = { items: [] }
+        theme: "dark",
+        language: "en",
+      });
+    });
+
+    test("handles array of objects with JSON strings", () => {
+      const client = buildClient();
+      const target = { items: [] };
       const source = {
-        items: [{ id: 1, data: '{"active": true}' }, { id: 2, data: '{"active": false}' }],
-      }
+        items: [
+          { id: 1, data: '{"active": true}' },
+          { id: 2, data: '{"active": false}' },
+        ],
+      };
 
-      const result = client.deepMerge(target, source)
+      const result = client.deepMerge(target, source);
 
-      expect(result.items[0].data).toEqual({ active: true })
-      expect(result.items[1].data).toEqual({ active: false })
-    })
+      expect(result.items[0].data).toEqual({ active: true });
+      expect(result.items[1].data).toEqual({ active: false });
+    });
 
-    test('preserves non-JSON strings', () => {
-      const client = buildClient()
-      const target = { title: 'old' }
-      const source = { title: 'new title', description: 'just a string' }
+    test("preserves non-JSON strings", () => {
+      const client = buildClient();
+      const target = { title: "old" };
+      const source = { title: "new title", description: "just a string" };
 
-      const result = client.deepMerge(target, source)
+      const result = client.deepMerge(target, source);
 
       expect(result).toEqual({
-        title: 'new title',
-        description: 'just a string',
-      })
-    })
-
-    test('handles empty objects', () => {
-      const client = buildClient()
-
-      expect(client.deepMerge({}, { a: 1 })).toEqual({ a: 1 })
-      expect(client.deepMerge({ a: 1 }, {})).toEqual({ a: 1 })
-      expect(client.deepMerge({}, {})).toEqual({})
-    })
-  })
-})
+        title: "new title",
+        description: "just a string",
+      });
+    });
+
+    test("handles empty objects", () => {
+      const client = buildClient();
+
+      expect(client.deepMerge({}, { a: 1 })).toEqual({ a: 1 });
+      expect(client.deepMerge({ a: 1 }, {})).toEqual({ a: 1 });
+      expect(client.deepMerge({}, {})).toEqual({});
+    });
+  });
+});