@doswiftly/storefront-sdk 4.0.0

package/src/__tests__/unit/helpers.test.ts

@@ -0,0 +1,377 @@
+/**
+ * Unit tests for helper utilities.
+ *
+ * Tests: assertNoUserErrors, hashQuery, getOperationName,
+ * cache strategies, StorefrontError, TypedDocumentString.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { assertNoUserErrors } from '../../core/helpers/assert-no-user-errors';
+import { hashQuery } from '../../core/client/hash';
+import { getOperationName } from '../../core/client/operation-name';
+import { compose } from '../../core/client/compose';
+import { StorefrontError, ErrorCodes } from '../../core/errors';
+import { TypedDocumentString } from '../../core/client/types';
+import {
+  cacheLong,
+  cacheShort,
+  cacheNone,
+  cachePrivate,
+  cacheCustom,
+  generateCacheControlHeader,
+} from '../../core/cache';
+import type { ExecuteFn, GraphQLRequest, Middleware } from '../../core/client/types';
+
+// ---------------------------------------------------------------------------
+// assertNoUserErrors
+// ---------------------------------------------------------------------------
+
+describe('assertNoUserErrors', () => {
+  it('should not throw when userErrors is empty', () => {
+    expect(() => assertNoUserErrors({ userErrors: [] })).not.toThrow();
+  });
+
+  it('should not throw when userErrors is null', () => {
+    expect(() => assertNoUserErrors({ userErrors: null })).not.toThrow();
+  });
+
+  it('should not throw when userErrors is undefined', () => {
+    expect(() => assertNoUserErrors({})).not.toThrow();
+  });
+
+  it('should throw StorefrontError with USER_ERROR code', () => {
+    try {
+      assertNoUserErrors({
+        userErrors: [{ message: 'Invalid email', field: ['email'] }],
+      });
+      expect.fail('Should have thrown');
+    } catch (err) {
+      expect(err).toBeInstanceOf(StorefrontError);
+      const sfErr = err as StorefrontError;
+      expect(sfErr.code).toBe(ErrorCodes.USER_ERROR);
+      expect(sfErr.message).toBe('Invalid email');
+      expect(sfErr.userErrors).toHaveLength(1);
+      expect(sfErr.hasUserErrors).toBe(true);
+    }
+  });
+
+  it('should use first error message', () => {
+    try {
+      assertNoUserErrors({
+        userErrors: [
+          { message: 'First error' },
+          { message: 'Second error' },
+        ],
+      });
+    } catch (err) {
+      expect((err as StorefrontError).message).toBe('First error');
+      expect((err as StorefrontError).userErrors).toHaveLength(2);
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// hashQuery
+// ---------------------------------------------------------------------------
+
+describe('hashQuery', () => {
+  it('should produce consistent hash for same query', () => {
+    const h1 = hashQuery('{ shop { id } }');
+    const h2 = hashQuery('{ shop { id } }');
+    expect(h1).toBe(h2);
+  });
+
+  it('should produce different hashes for different queries', () => {
+    const h1 = hashQuery('{ shop { id } }');
+    const h2 = hashQuery('{ product { id } }');
+    expect(h1).not.toBe(h2);
+  });
+
+  it('should produce same hash regardless of variable key order', () => {
+    const h1 = hashQuery('query Q', { a: 1, b: 2 });
+    const h2 = hashQuery('query Q', { b: 2, a: 1 });
+    expect(h1).toBe(h2);
+  });
+
+  it('should produce different hashes for different variables', () => {
+    const h1 = hashQuery('query Q', { handle: 'a' });
+    const h2 = hashQuery('query Q', { handle: 'b' });
+    expect(h1).not.toBe(h2);
+  });
+
+  it('should handle nested objects in variables', () => {
+    const h1 = hashQuery('query Q', { filter: { a: 1, b: 2 } });
+    const h2 = hashQuery('query Q', { filter: { b: 2, a: 1 } });
+    expect(h1).toBe(h2);
+  });
+
+  it('should handle undefined variables', () => {
+    const h1 = hashQuery('{ shop { id } }');
+    const h2 = hashQuery('{ shop { id } }', undefined);
+    expect(h1).toBe(h2);
+  });
+
+  it('should trim whitespace in query', () => {
+    const h1 = hashQuery('  { shop { id } }  ');
+    const h2 = hashQuery('{ shop { id } }');
+    expect(h1).toBe(h2);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getOperationName
+// ---------------------------------------------------------------------------
+
+describe('getOperationName', () => {
+  it('should extract query name', () => {
+    expect(getOperationName('query Product($id: ID!) { product(id: $id) { id } }')).toBe('Product');
+  });
+
+  it('should extract mutation name', () => {
+    expect(getOperationName('mutation CartCreate($input: CartInput!) { cartCreate(input: $input) { cart { id } } }')).toBe('CartCreate');
+  });
+
+  it('should extract subscription name', () => {
+    expect(getOperationName('subscription OrderUpdated { orderUpdated { id } }')).toBe('OrderUpdated');
+  });
+
+  it('should return "anonymous" for unnamed operations', () => {
+    expect(getOperationName('{ shop { id } }')).toBe('anonymous');
+  });
+
+  it('should return "anonymous" for empty string', () => {
+    expect(getOperationName('')).toBe('anonymous');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// compose
+// ---------------------------------------------------------------------------
+
+describe('compose', () => {
+  it('should execute middleware in order', async () => {
+    const order: number[] = [];
+
+    const m1: Middleware = async (req, next) => { order.push(1); return next(req); };
+    const m2: Middleware = async (req, next) => { order.push(2); return next(req); };
+    const m3: Middleware = async (req, next) => { order.push(3); return next(req); };
+
+    const execute: ExecuteFn = async () => ({
+      data: {},
+      status: 200,
+      headers: new Headers(),
+    });
+
+    const pipeline = compose([m1, m2, m3], execute);
+    await pipeline({ query: '', headers: {}, isMutation: false });
+
+    expect(order).toEqual([1, 2, 3]);
+  });
+
+  it('should return execute directly when no middleware', async () => {
+    const execute: ExecuteFn = async () => ({
+      data: { test: true },
+      status: 200,
+      headers: new Headers(),
+    });
+
+    const pipeline = compose([], execute);
+    const result = await pipeline({ query: '', headers: {}, isMutation: false });
+
+    expect(result.data).toEqual({ test: true });
+  });
+
+  it('should allow middleware to modify response', async () => {
+    const addField: Middleware = async (req, next) => {
+      const response = await next(req);
+      return { ...response, data: { ...response.data as object, added: true } };
+    };
+
+    const execute: ExecuteFn = async () => ({
+      data: { original: true },
+      status: 200,
+      headers: new Headers(),
+    });
+
+    const pipeline = compose([addField], execute);
+    const result = await pipeline({ query: '', headers: {}, isMutation: false });
+
+    expect(result.data).toEqual({ original: true, added: true });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// StorefrontError
+// ---------------------------------------------------------------------------
+
+describe('StorefrontError', () => {
+  it('should be instance of Error', () => {
+    const err = new StorefrontError({ code: 'TEST', message: 'test' });
+    expect(err).toBeInstanceOf(Error);
+    expect(err).toBeInstanceOf(StorefrontError);
+  });
+
+  it('should have correct name', () => {
+    const err = new StorefrontError({ code: 'TEST', message: 'test' });
+    expect(err.name).toBe('StorefrontError');
+  });
+
+  it('should default status to 0', () => {
+    const err = new StorefrontError({ code: 'TEST', message: 'test' });
+    expect(err.status).toBe(0);
+  });
+
+  it('should default arrays to empty', () => {
+    const err = new StorefrontError({ code: 'TEST', message: 'test' });
+    expect(err.graphqlErrors).toEqual([]);
+    expect(err.userErrors).toEqual([]);
+  });
+
+  it('should preserve all fields', () => {
+    const err = new StorefrontError({
+      code: ErrorCodes.GRAPHQL_ERROR,
+      message: 'Field not found',
+      status: 200,
+      graphqlErrors: [{ message: 'Field not found', path: ['product', 'nonexistent'] }],
+      userErrors: [{ message: 'Invalid', field: ['email'] }],
+    });
+
+    expect(err.code).toBe(ErrorCodes.GRAPHQL_ERROR);
+    expect(err.message).toBe('Field not found');
+    expect(err.status).toBe(200);
+    expect(err.graphqlErrors).toHaveLength(1);
+    expect(err.userErrors).toHaveLength(1);
+  });
+
+  it('hasUserErrors should be true when userErrors exist', () => {
+    const err = new StorefrontError({
+      code: ErrorCodes.USER_ERROR,
+      message: 'test',
+      userErrors: [{ message: 'Error' }],
+    });
+    expect(err.hasUserErrors).toBe(true);
+  });
+
+  it('hasUserErrors should be false when userErrors are empty', () => {
+    const err = new StorefrontError({ code: 'TEST', message: 'test' });
+    expect(err.hasUserErrors).toBe(false);
+  });
+
+  it('isNetworkError should be true for NETWORK_ERROR code', () => {
+    const err = new StorefrontError({ code: ErrorCodes.NETWORK_ERROR, message: 'fetch failed' });
+    expect(err.isNetworkError).toBe(true);
+    expect(err.isTimeout).toBe(false);
+  });
+
+  it('isTimeout should be true for TIMEOUT code', () => {
+    const err = new StorefrontError({ code: ErrorCodes.TIMEOUT, message: 'timeout' });
+    expect(err.isTimeout).toBe(true);
+    expect(err.isNetworkError).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// TypedDocumentString
+// ---------------------------------------------------------------------------
+
+describe('TypedDocumentString', () => {
+  it('should extend String', () => {
+    const doc = new TypedDocumentString('query { shop { id } }');
+    expect(doc).toBeInstanceOf(String);
+  });
+
+  it('should return query string via toString()', () => {
+    const query = 'query Product { product { id } }';
+    const doc = new TypedDocumentString(query);
+    expect(doc.toString()).toBe(query);
+  });
+
+  it('should return query string via valueOf()', () => {
+    const query = 'query Product { product { id } }';
+    const doc = new TypedDocumentString(query);
+    expect(doc.valueOf()).toBe(query);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Cache strategies
+// ---------------------------------------------------------------------------
+
+describe('cache strategies', () => {
+  describe('cacheNone', () => {
+    it('should return no-store mode', () => {
+      const cache = cacheNone();
+      expect(cache.mode).toBe('no-store');
+      expect(cache.maxAge).toBe(0);
+    });
+
+    it('should accept tags override', () => {
+      const cache = cacheNone({ tags: ['cart'] });
+      expect(cache.tags).toEqual(['cart']);
+    });
+  });
+
+  describe('cacheShort', () => {
+    it('should default to 1s max-age, 9s swr', () => {
+      const cache = cacheShort();
+      expect(cache.maxAge).toBe(1);
+      expect(cache.staleWhileRevalidate).toBe(9);
+      expect(cache.mode).toBe('public');
+    });
+
+    it('should accept overrides', () => {
+      const cache = cacheShort({ maxAge: 5, staleWhileRevalidate: 30, tags: ['products'] });
+      expect(cache.maxAge).toBe(5);
+      expect(cache.staleWhileRevalidate).toBe(30);
+      expect(cache.tags).toEqual(['products']);
+    });
+  });
+
+  describe('cacheLong', () => {
+    it('should default to 1h max-age, 23h swr', () => {
+      const cache = cacheLong();
+      expect(cache.maxAge).toBe(3600);
+      expect(cache.staleWhileRevalidate).toBe(82800);
+      expect(cache.mode).toBe('public');
+    });
+
+    it('should accept tags', () => {
+      const cache = cacheLong({ tags: ['product', 'cool-shirt'] });
+      expect(cache.tags).toEqual(['product', 'cool-shirt']);
+    });
+  });
+
+  describe('cachePrivate', () => {
+    it('should return private mode', () => {
+      const cache = cachePrivate();
+      expect(cache.mode).toBe('private');
+      expect(cache.maxAge).toBe(1);
+    });
+  });
+
+  describe('cacheCustom', () => {
+    it('should pass through all options', () => {
+      const cache = cacheCustom({ maxAge: 300, staleWhileRevalidate: 600, mode: 'public', tags: ['custom'] });
+      expect(cache.maxAge).toBe(300);
+      expect(cache.staleWhileRevalidate).toBe(600);
+      expect(cache.mode).toBe('public');
+      expect(cache.tags).toEqual(['custom']);
+    });
+  });
+
+  describe('generateCacheControlHeader', () => {
+    it('should generate no-store for cacheNone', () => {
+      expect(generateCacheControlHeader(cacheNone())).toBe('no-store, no-cache, must-revalidate');
+    });
+
+    it('should generate public max-age for cacheLong', () => {
+      const header = generateCacheControlHeader(cacheLong());
+      expect(header).toBe('public, max-age=3600, stale-while-revalidate=82800');
+    });
+
+    it('should generate private max-age for cachePrivate', () => {
+      const header = generateCacheControlHeader(cachePrivate());
+      expect(header).toBe('private, max-age=1, stale-while-revalidate=9');
+    });
+  });
+});