@merchi/sdk 1.40.2

package/src/pricing/visibility.ts

@@ -0,0 +1,111 @@
+import { PricingRules, PricingField, PricingOption, Selections } from './types.js';
+
+function collectSelectedOptionIds(selections: Selections): number[] {
+  const ids: number[] = [];
+  const addFrom = (fieldValues: Record<number, { selectedOptionIds?: number[] }>) => {
+    for (const key of Object.keys(fieldValues)) {
+      const sel = fieldValues[Number(key)];
+      if (sel && sel.selectedOptionIds) ids.push(...sel.selectedOptionIds);
+    }
+  };
+  addFrom(selections.fieldValues || {});
+  for (const group of selections.groups || []) addFrom(group.fieldValues || {});
+  return ids;
+}
+
+interface Resolver {
+  allFields: PricingField[];
+  fieldsToConsider: PricingField[];
+  isFulfilled: (selectedBy: number[], checked: number[]) => boolean;
+}
+
+// Shared machinery for both field- and option-level conditional visibility.
+// Mirrors the server's `check_selected_by_fullfilled` recursion: a `selectedBy`
+// list is fulfilled when any of its trigger option ids is currently selected
+// AND that selecting option is itself fulfilled (its own `selectedBy` and its
+// owning field's `selectedBy`), with a `checked` accumulator to break cycles.
+function buildResolver(rules: PricingRules, selections: Selections): Resolver {
+  const allFields: PricingField[] = [...rules.fields, ...rules.groupFields];
+  const optionsById = new Map<number, PricingOption>();
+  const fieldByOptionId = new Map<number, PricingField>();
+  for (const f of allFields) {
+    for (const o of f.options) {
+      optionsById.set(o.id, o);
+      fieldByOptionId.set(o.id, f);
+      if (o.originalId != null) {
+        optionsById.set(o.originalId, o);
+        fieldByOptionId.set(o.originalId, f);
+      }
+    }
+  }
+
+  const selectedOptionIds = collectSelectedOptionIds(selections);
+
+  const sameOption = (a: number, b: number): boolean => {
+    const oa = optionsById.get(a);
+    return oa != null && oa === optionsById.get(b);
+  };
+
+  const isFulfilled = (selectedBy: number[], checked: number[]): boolean => {
+    if (!selectedBy || selectedBy.length === 0) return true;
+    for (const triggerId of selectedBy) {
+      for (const selId of selectedOptionIds) {
+        if (!sameOption(triggerId, selId)) continue;
+        if (checked.includes(selId)) return true;
+        // sameOption only returns true for ids present in optionsById, and
+        // fieldByOptionId is populated in the same loop, so both lookups are
+        // guaranteed non-null here (mirrors server dereferencing directly).
+        const opt = optionsById.get(selId) as PricingOption;
+        const field = fieldByOptionId.get(selId) as PricingField;
+        const nextChecked = [...checked, selId];
+        if (
+          isFulfilled(opt.selectedBy, nextChecked) &&
+          isFulfilled(field.selectedBy, nextChecked)
+        ) {
+          return true;
+        }
+      }
+    }
+    return false;
+  };
+
+  // Group variation fields only materialise as variations when the job
+  // actually has groups (the server builds them inside each `variations_group`
+  // via `VariationsGroups.mapper_variations`; with no groups there are no group
+  // variations at all). Independent fields are always in play. This mirrors the
+  // server, where a non-group job exposes no group fields.
+  const hasGroups = Boolean(selections.groups && selections.groups.length > 0);
+  const fieldsToConsider = hasGroups ? allFields : rules.fields;
+
+  return { allFields, fieldsToConsider, isFulfilled };
+}
+
+export function resolveVisibleFields(
+  rules: PricingRules,
+  selections: Selections
+): Set<number> {
+  const { fieldsToConsider, isFulfilled } = buildResolver(rules, selections);
+  const visible = new Set<number>();
+  for (const f of fieldsToConsider) {
+    if (isFulfilled(f.selectedBy, [])) visible.add(f.id);
+  }
+  return visible;
+}
+
+// Returns the set of option ids whose own `selectedBy` is fulfilled — i.e. the
+// options that should be visible/selectable given the current selections.
+// Mirrors the server's per-option `isVisible = check_selected_by_fullfilled(
+// option.selected_by)`. Options with no `selectedBy` are always visible.
+export function resolveVisibleOptionIds(
+  rules: PricingRules,
+  selections: Selections
+): Set<number> {
+  const { fieldsToConsider, isFulfilled } = buildResolver(rules, selections);
+  const visible = new Set<number>();
+  for (const f of fieldsToConsider) {
+    for (const o of f.options) {
+      if (isFulfilled(o.selectedBy, [])) visible.add(o.id);
+    }
+  }
+  return visible;
+}

package/src/request.test.ts

@@ -0,0 +1,79 @@
+import { apiFetch } from './request.js';
+import { ErrorType } from './constants/errors.js';
+import { setup, mockFetch } from './test_util.js';
+
+setup();
+
+test('can pass through data from server', () => {
+  mockFetch(true, {'animal': 'turtle'}, 200);
+  return apiFetch('https://api.merchi.co/', '/test').then(data => {
+    expect(data.animal).toBe('turtle');
+  });
+});
+
+test('can pass through data from server with override url', () => {
+  (window as any).merchiBackendUri = 'http://override.example.com/';
+  mockFetch(true, {'animal': 'turtle'}, 200);
+  return apiFetch('https://api.merchi.co/', '/test').then(data => {
+    expect(data.animal).toBe('turtle');
+  });
+});
+
+test('404 creates ApiError', () => {
+  mockFetch(false, {'statusCode': 404, 'errorCode': ErrorType.RESOURCE_NOT_FOUND}, 404);
+  apiFetch('https://api.merchi.co/', '/test').catch(e => {
+    expect(e.statusCode).toBe(404);
+    expect(e.name).toBe('ApiError');
+    expect(e.errorCode).toBe(ErrorType.RESOURCE_NOT_FOUND);
+    expect(e.errorMessage).toBe('No error message');
+  });
+});
+
+test('will get default errorCode', () => {
+  mockFetch(false,
+    {'statusCode': 404,
+      'errorCode': -1,
+      'message': 'just a test'}, 404);
+  apiFetch('https://api.merchi.co/', '/test').catch(e => {
+    expect(e.statusCode).toBe(404);
+    expect(e.name).toBe('ApiError');
+    expect(e.errorCode).toBe(ErrorType.UNKNOWN_ERROR);
+    expect(e.errorMessage).toBe('just a test');
+  });
+});
+
+test('ApiError exposes details when the server supplies them', () => {
+  const details = {
+    relation: 'file',
+    parentType: 'variation',
+    id: 'abc123',
+    index: 0,
+    provided: {
+      id: 'abc123',
+      uploadId: 'upload-xyz',
+      creationDate: '1776978388',
+    },
+  };
+  mockFetch(false, {
+    'statusCode': 404,
+    'errorCode': ErrorType.RESOURCE_NOT_FOUND,
+    'message': 'no such file #abc123 on variation',
+    'details': details,
+  }, 404);
+  return apiFetch('https://api.merchi.co/', '/test').catch(e => {
+    expect(e.name).toBe('ApiError');
+    expect(e.details).toEqual(details);
+    expect(e.details.provided.uploadId).toBe('upload-xyz');
+  });
+});
+
+test('ApiError leaves details undefined when the server omits them', () => {
+  mockFetch(false,
+    {'statusCode': 400,
+      'errorCode': ErrorType.RESOURCE_NOT_FOUND,
+      'message': 'plain error'}, 400);
+  return apiFetch('https://api.merchi.co/', '/test').catch(e => {
+    expect(e.name).toBe('ApiError');
+    expect(e.details).toBeUndefined();
+  });
+});

package/src/request.ts

@@ -0,0 +1,196 @@
+// eslint-disable-next-line no-unused-vars
+import { ErrorType, getErrorFromCode } from './constants/errors.js';
+
+export interface RequestOptions extends RequestInit {
+  query?: string[][];
+}
+
+export interface ApiErrorDetails {
+  /**
+   * The json_name of the missing / disallowed related entity type
+   * (e.g. 'file', 'product', 'domain').
+   */
+  relation?: string;
+  /**
+   * The json_name of the parent entity the relation was being
+   * attached to (e.g. 'variation', 'job').
+   */
+  parentType?: string;
+  /**
+   * The id the client supplied for the missing / disallowed entity.
+   * May be a numeric id as a number, or a string id depending on
+   * the model.
+   */
+  id?: number | string;
+  /**
+   * The form-data index the client sent the entity under (i.e. the
+   * ``N`` in ``parent-N-id``).
+   */
+  index?: number;
+  /**
+   * The fields the client sent for the missing entity, with noisy
+   * keys (signed URLs, their expiries) stripped and long string
+   * values truncated. Useful when debugging uploads where the
+   * client knows the uploadId but the server has no matching row.
+   */
+  provided?: { [key: string]: any };
+  // Backend may add new keys over time; keep the type permissive.
+  [key: string]: any;
+}
+
+export class ApiError extends Error {
+  public statusCode?: number;
+  public errorCode?: ErrorType;
+  public errorMessage: string;
+  /**
+   * Structured context the API may include alongside the error
+   * message (e.g. the missing entity id and payload echo). Present
+   * only when the backend chooses to populate it - most error
+   * responses still carry just ``statusCode``, ``errorCode`` and
+   * ``message``.
+   */
+  public details?: ApiErrorDetails;
+  public original: any;
+  public constructor(err: any) {
+    const message = JSON.stringify(err);
+    /* istanbul ignore next */
+    super(message);
+    this.statusCode = err.statusCode;
+    this.errorCode = getErrorFromCode(err.errorCode);
+    this.errorMessage = err.message ?
+      err.message : 'No error message';
+    this.details = err.details;
+    this.name = 'ApiError';
+    this.original = err;
+  }
+}
+
+export const version = 'v6';
+
+interface UriComponents {
+  baseUrl: string;
+  version: string;
+}
+
+function ensureVersionInUri(baseUrl: string): UriComponents {
+  // Ensure baseUrl ends with a slash
+  let uri = baseUrl;
+  if (!uri.endsWith('/')) {
+    uri += '/';
+  }
+
+  // Check if the URI already includes a version
+  const versionPattern = new RegExp('/v\\d+/?$');
+  const match = uri.match(versionPattern);
+  
+  if (match) {
+    // Extract the version and remove it from the URI
+    const foundVersion = match[0].replace(/\//g, '');
+    const strippedUri = uri.replace(versionPattern, '/');
+    return {
+      baseUrl: strippedUri,
+      version: foundVersion
+    };
+  }
+
+  return {
+    baseUrl: uri,
+    version: version
+  };
+}
+
+export function backendFetch(baseUrl: string, resource: string, options?: RequestOptions) {
+  const { baseUrl: cleanBaseUrl, version: apiVersion } = ensureVersionInUri(baseUrl);
+  // Remove leading slash from resource if it exists to prevent double slashes
+  const cleanResource = resource.startsWith('/') ? resource.slice(1) : resource;
+  const url = new URL(cleanBaseUrl + apiVersion + '/' + cleanResource);
+  if (options && options.query) {
+    for (const entry of options.query) {
+      url.searchParams.append(entry[0], entry[1]);
+    }
+  }
+  return fetch(url.toString(), options);
+}
+
+export function apiFetch(
+  baseUrl: string,
+  resource: string,
+  options?: RequestOptions,
+  expectEmptyResponse?: boolean
+) {
+  return backendFetch(baseUrl, resource, options as RequestInit | undefined).then(
+    function (response) {
+      if (response.status < 200 || response.status > 299) {
+        return response.json().then(function (json) {
+          const err = new ApiError(json);
+          return Promise.reject(err);
+        });
+      } else {
+        return expectEmptyResponse ? '' : response.json();
+      }
+    }
+  );
+}
+
+/* istanbul ignore next */
+export function apiFetchWithProgress(
+  baseUrl: string,
+  resource: string,
+  options?: RequestOptions,
+  progressCallback?: (progress: number) => void
+) {
+  return backendFetch(baseUrl, resource, options as RequestInit | undefined).then(
+    function (response) {
+      if (!response.body) {
+        const err = new ApiError('empty response');
+        return Promise.reject(err);
+      }
+      const reader = response.body.getReader();
+      let bodyText = '';
+      let errorText = '';
+      let haveError = false;
+      const expected = '{"loadingBar": "' + '.'.repeat(100) + '"}';
+      function readChunk(): any {
+        return reader.read().then(({done, value}) => {
+          if (done) {
+            if (response.status < 200 || response.status > 299) {
+              const err = new ApiError('Unknown error');
+              return Promise.reject(err);
+            } else if(haveError) {
+              try {
+                const jsonText = JSON.parse(errorText);
+                return Promise.reject(new ApiError(jsonText));
+              } catch (e) {
+                return Promise.reject(new ApiError(errorText));
+              }
+            } else {
+              return bodyText;
+            }
+          } else {
+            const chunk = new TextDecoder().decode(value);
+            if (haveError) {
+              errorText += chunk;
+            } else {
+              for (let i = 0; i < chunk.length; ++i) {
+                const char = chunk[i];
+                const expectedChar = expected[bodyText.length];
+                if (expectedChar == char && !haveError) {
+                  bodyText += char;
+                } else {
+                  haveError = true;
+                  errorText += char;
+                }
+              }
+            }
+            if (!haveError && progressCallback) {
+              const progress = Math.min(Math.max(0, bodyText.length - 16), 100);
+              progressCallback(progress);
+            }
+            return readChunk();
+          }
+        });
+      }
+      return readChunk();
+    }
+  );
+}

package/src/test_util.ts

@@ -0,0 +1,18 @@
+export function setup() {
+  beforeAll(function() {
+    (global as any).BACKEND_URI = 'http://example.com/';
+  });
+}
+
+export function mockFetch(ok: boolean, data: any, status: number) {
+  const mock = jest.fn();
+  mock.mockImplementation(() =>
+    Promise.resolve({
+      status: status,
+      ok: ok,
+      json: () => Promise.resolve(data)
+    })
+  );
+  (global as any).fetch = mock;
+  return mock;
+}

package/src/toasts.test.ts

@@ -0,0 +1,38 @@
+import { setup, mockFetch } from './test_util.js';
+import { toastNotifications } from './toasts.js';
+import { Merchi } from './merchi.js';
+import { NotificationSection } from './constants/notification_sections.js';
+import { NotificationType } from './constants/notification_types.js';
+
+
+setup();
+
+test('fetch toast of jobs', () => {
+  const merchi = new Merchi();
+  const fetch = mockFetch(
+    true, {'notifications': [{id: 1, message: 'test'}]}, 200);
+  const entities = [{id: 1, type: 'job'}];
+  const sections = [NotificationSection.JOB_NOTIFICATIONS];
+  const notificationTypes = {[NotificationType.JOB_PAID]: true};
+
+  const options = {entities, sections, notificationTypes};
+  const invocation = toastNotifications(merchi, options as any);
+  const expectUrl = `${(global as any).BACKEND_URI}v6/notifications-check-update/`;
+  expect(fetch.mock.calls[0][0]).toEqual(expectUrl);
+  expect(fetch.mock.calls[0][1].method).toEqual('POST');
+  expect(JSON.parse(fetch.mock.calls[0][1].body.get('entities'))).toEqual(
+    [{id: 1, type: 'job'}]);
+  expect(fetch.mock.calls[0][1].body.get('sections')).toEqual(
+    `[${NotificationSection.JOB_NOTIFICATIONS}]`);
+  expect(
+    JSON.parse(fetch.mock.calls[0][1].body.get('notificationTypes'))
+  ).toEqual(
+    {[NotificationType.JOB_PAID]: true}
+  );
+  invocation.then(notifications => {
+    expect(notifications.length).toBe(1);
+    expect(notifications[0].id).toBe(1);
+    expect(notifications[0].message).toBe('test');
+  });
+  return invocation;
+});

package/src/toasts.ts

@@ -0,0 +1,34 @@
+// eslint-disable-next-line no-unused-vars
+import { RequestOptions } from './request.js';
+// eslint-disable-next-line no-unused-vars
+import { Merchi } from './merchi.js';
+// eslint-disable-next-line no-unused-vars
+import { NotificationSection } from './constants/notification_sections.js';
+// eslint-disable-next-line no-unused-vars
+import { NotificationType } from './constants/notification_types.js';
+
+interface RelatedObj {
+  id: number;
+  type: string;
+}
+
+interface ToastOptions {
+  entities: RelatedObj[];
+  sections: NotificationSection[];
+  notificationTypes?: Record<NotificationType, boolean>;
+}
+
+export const toastNotifications = (merchi: Merchi, options: ToastOptions) => {
+  const resource = '/notifications-check-update/';
+  const data = new FormData();
+  const { entities, sections, notificationTypes } = options;
+  data.set('entities', JSON.stringify(entities));
+  data.set('sections', JSON.stringify(sections));
+  data.set('notificationTypes', JSON.stringify(notificationTypes));
+  const fetchOptions: RequestOptions = { method: 'POST', body: data };
+  return merchi
+    .authenticatedFetch(resource, fetchOptions)
+    .then((data: any) =>
+      data.notifications.map((n: any) => new merchi.Notification().fromJson(n))
+    );
+};

package/src/util/float.ts

@@ -0,0 +1,12 @@
+export function kahanSum(values: Iterable<number>) {
+  /* Return the kahan summation of the input number array */
+  let accumulator = 0;
+  let compensation = 0;
+  for (const value of values) {
+    const y = value - compensation;
+    const t = accumulator + y;
+    compensation = (t - accumulator) - y; 
+    accumulator = t; 
+  }
+  return accumulator;
+}

package/src/util/index.ts

@@ -0,0 +1,7 @@
+import * as query_string from './query_string.js';
+import * as validation from './validation.js';
+
+export {
+  query_string,
+  validation,
+}

package/src/util/query_string.test.ts

@@ -0,0 +1,7 @@
+import { getQueryStringValue } from './query_string.js';
+
+test('lol', () => {
+  expect(getQueryStringValue('a')).toBe(undefined);
+  history.replaceState({}, 'Test', '/test?a=3');
+  expect(getQueryStringValue('a')).toBe('3');
+});

package/src/util/query_string.ts

@@ -0,0 +1,13 @@
+export function getQueryStringValue(name: string) {
+  if ((window as any) && typeof window !== 'undefined') {
+    const query = (window as any).location.search.substring(1);
+    const vars = query.split('&');
+    for (let i = 0; i < vars.length; i++) {
+      const pair = vars[i].split('=');
+      if (pair[0] === name) {
+        return decodeURIComponent(pair[1]);
+      }
+    }
+  }
+  return undefined;
+}

package/src/util/validation.test.ts

@@ -0,0 +1,16 @@
+import { isUndefinedOrNull } from './validation.js';
+
+
+test('return true if value is null', () => {
+  expect(isUndefinedOrNull(null)).toBe(true);
+});
+
+test('return true if value is undefined', () => {
+  expect(isUndefinedOrNull(undefined)).toBe(true);
+});
+
+test('return false if value other than undefined or null', () => {
+  expect(isUndefinedOrNull(false)).toBe(false);
+  expect(isUndefinedOrNull('')).toBe(false);
+  expect(isUndefinedOrNull(0)).toBe(false);
+});

package/src/util/validation.ts

@@ -0,0 +1,2 @@
+export const isUndefinedOrNull = (value: any) =>
+  value === undefined || value === null;

package/src/uuid.test.ts

@@ -0,0 +1,15 @@
+import { generateUUID } from './uuid.js';
+
+test('can generate UUID', () => {
+  const realRandom = global.Math.random;
+  const randomStub = jest.fn(() => 0.4);
+  global.Math.random = randomStub;
+
+  const correct = '66666666-6666-4666-a666-666666666666';
+  const attempt = generateUUID();
+
+  expect(randomStub).toHaveBeenCalled();
+  expect(attempt).toBe(correct);
+
+  global.Math.random = realRandom;
+});

package/src/uuid.ts

@@ -0,0 +1,8 @@
+export function generateUUID(): string {
+  let uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
+  uuid = uuid.replace(/[xy]/g, function (c): string {
+    const r = (Math.random() * 16) % 16 | 0;
+    return (c === 'x' ? r : r & 0x3 | 0x8).toString(16);
+  });
+  return uuid;
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "target": "ES5",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "downlevelIteration": true,
+    "lib": ["es2017", "DOM", "ES6"],
+    "moduleResolution": "node",
+    "rootDir": "./src",
+    "outDir": "dist",
+    "module": "ES6",
+    "types": ["node", "jest"],
+    "baseUrl": ".",
+    "ignoreDeprecations": "6.0",
+    "noImplicitAny": true,
+    "noImplicitReturns": true,
+    "noImplicitThis": true,
+    "noUnusedLocals": true,
+    "strictBindCallApply": true,
+    "strictFunctionTypes": true,
+    "strictPropertyInitialization": true,
+    "strictNullChecks": true,
+    "esModuleInterop": true,
+    "pretty": true,
+    "alwaysStrict": true,
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test"]
+}