@merchi/sdk 1.42.20 → 1.42.22

package/dist/constants/errors.d.ts

@@ -23,4 +23,4 @@ export declare enum ErrorType {
     BAD_SMS_TOKEN = 21,
     DOMAIN_NOT_FOUND = 22
 }
-export declare function getErrorFromCode(code: number): ErrorType;
+export declare function getErrorFromCode(code: unknown): number;

package/dist/constants/errors.js

@@ -25,7 +25,9 @@ export var ErrorType;
     ErrorType[ErrorType["DOMAIN_NOT_FOUND"] = 22] = "DOMAIN_NOT_FOUND";
 })(ErrorType || (ErrorType = {}));
 export function getErrorFromCode(code) {
-    if (code in ErrorType) {
+    // The API can add error codes before this SDK's named constants are updated.
+    // Preserve those numeric diagnostics instead of turning them into UNKNOWN.
+    if (typeof code === 'number' && Number.isSafeInteger(code) && code >= 0) {
         return code;
     }
     return ErrorType.UNKNOWN_ERROR;

package/dist/constants/errors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/constants/errors.test.js

@@ -0,0 +1,16 @@
+import { ErrorType, getErrorFromCode } from './errors.js';
+test.each([ErrorType.UNKNOWN_ERROR, ErrorType.INVALID_PHONE_NUMBER, ErrorType.DOMAIN_NOT_FOUND])('preserves known API error code %s', function (code) {
+    expect(getErrorFromCode(code)).toBe(code);
+});
+// INVALID_HCAPTCHA and SPAM_DETECTED exist in the API's Python SDK but not
+// this SDK's legacy enum. Future codes must remain diagnosable too.
+test.each([226, 227, 1000, Number.MAX_SAFE_INTEGER])('preserves forward-compatible numeric API error code %s', function (code) {
+    expect(getErrorFromCode(code)).toBe(code);
+});
+test.each([
+    undefined, null, -1, 1.5, NaN, Infinity, -Infinity,
+    Number.MAX_SAFE_INTEGER + 1, '227', 'INVALID_PHONE_NUMBER',
+    'toString', '__proto__', true, {}, [],
+])('uses UNKNOWN_ERROR for malformed API code %p', function (code) {
+    expect(getErrorFromCode(code)).toBe(ErrorType.UNKNOWN_ERROR);
+});

package/dist/entities/cart.test.js

@@ -1,3 +1,18 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 import { Merchi } from '../merchi.js';
 import { setup, mockFetch } from '../test_util.js';
 setup();
@@ -55,6 +70,60 @@ test('preserves isTest', function () {
     entity.fromJson({ id: 1, isTest: true });
     expect(entity.toJson()).toMatchObject({ isTest: true });
 });
+test('serialises a new cart when FormData has no set', function () {
+    var AppendOnlyFormData = /** @class */ (function () {
+        function AppendOnlyFormData() {
+            this.fields = new Map();
+        }
+        AppendOnlyFormData.prototype.append = function (name, value) {
+            this.fields.set(name, String(value));
+        };
+        AppendOnlyFormData.prototype.get = function (name) {
+            return this.fields.has(name) ? this.fields.get(name) : null;
+        };
+        AppendOnlyFormData.prototype.entries = function () {
+            return this.fields.entries();
+        };
+        return AppendOnlyFormData;
+    }());
+    var ReplacingFormData = /** @class */ (function (_super) {
+        __extends(ReplacingFormData, _super);
+        function ReplacingFormData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.ready = false;
+            return _this;
+        }
+        ReplacingFormData.prototype.append = function (name, value) {
+            if (!this.ready) {
+                throw new Error("delete was not called before append(".concat(name, ")"));
+            }
+            this.ready = false;
+            _super.prototype.append.call(this, name, value);
+        };
+        ReplacingFormData.prototype.delete = function () {
+            this.ready = true;
+        };
+        return ReplacingFormData;
+    }(AppendOnlyFormData));
+    var serialise = function (form) {
+        var merchi = new Merchi();
+        var cart = new merchi.Cart();
+        cart.isTest = false;
+        var domain = new merchi.Domain();
+        domain.id = 9;
+        cart.domain = domain;
+        cart.toFormData({ existing: form });
+        return form;
+    };
+    var appended = serialise(new AppendOnlyFormData());
+    expect(appended.get('isTest')).toBe('false');
+    expect(appended.get('domain-0-id')).toBe('9');
+    expect(appended.get('domain-count')).toBe('1');
+    var replaced = serialise(new ReplacingFormData());
+    expect(replaced.get('isTest')).toBe('false');
+    expect(replaced.get('domain-0-id')).toBe('9');
+    expect(replaced.get('domain-count')).toBe('1');
+});
 test('preserves source attribution', function () {
     var merchi = new Merchi();
     var entity = new merchi.Cart();

package/dist/entity.js

@@ -302,6 +302,19 @@ var Entity = /** @class */ (function () {
             if (fileIndex === undefined) {
                 fileIndex = { value: 0 };
             }
+            // Prefer set so a repeated key is replaced. Fall back to append for
+            // FormData implementations that never added set.
+            var writeField = function (target, name, value) {
+                if (typeof target.set === 'function') {
+                    target.set(name, value);
+                    return;
+                }
+                var legacy = target;
+                if (typeof legacy.delete === 'function') {
+                    legacy.delete(name);
+                }
+                target.append(name, value);
+            };
             var appendData = function (name, value) {
                 /* istanbul ignore next */
                 if (name === undefined || value === undefined) {
@@ -311,10 +324,10 @@ var Entity = /** @class */ (function () {
                 if (prefix) {
                     name = prefix + '-' + name;
                 }
-                result.set(name, value);
+                writeField(result, name, value);
             };
             if (_this.fileData !== undefined) {
-                result.set(String(fileIndex.value), _this.fileData);
+                writeField(result, String(fileIndex.value), _this.fileData);
                 appendData('fileDataIndex', fileIndex.value);
                 fileIndex.value++;
             }

package/dist/request.d.ts

@@ -1,4 +1,3 @@
-import { ErrorType } from './constants/errors.js';
 export interface RequestOptions extends RequestInit {
     query?: string[][];
 }
@@ -37,7 +36,8 @@ export interface ApiErrorDetails {
 }
 export declare class ApiError extends Error {
     statusCode?: number;
-    errorCode?: ErrorType;
+    /** Numeric API code, including values added after this SDK was published. */
+    errorCode?: number;
     errorMessage: string;
     /**
      * Structured context the API may include alongside the error

package/dist/request.js

@@ -71,7 +71,6 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
-// eslint-disable-next-line no-unused-vars
 import { getErrorFromCode } from './constants/errors.js';
 function resolveApiErrorMessage(err) {
     if (err && typeof err === 'object' && typeof err.message === 'string' && err.message) {

package/dist/request.test.js

@@ -83,6 +83,41 @@ test('will get default errorCode', function () {
         expect(e.message).toBe('just a test');
     });
 });
+test('lead spam rejection keeps its API code through apiFetch', function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                mockFetch(false, {
+                    statusCode: 400,
+                    errorCode: 227,
+                    message: 'Invalid submission',
+                }, 400);
+                return [4 /*yield*/, expect(apiFetch('https://api.merchi.co/', '/create_new_lead/', {
+                        method: 'POST',
+                    })).rejects.toMatchObject({
+                        name: 'ApiError',
+                        statusCode: 400,
+                        errorCode: 227,
+                        message: 'Invalid submission',
+                        errorMessage: 'Invalid submission',
+                    })];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });
+test.each([226, 1000])('ApiError preserves new numeric API code %s', function (errorCode) {
+    var error = new ApiError({ statusCode: 400, errorCode: errorCode, message: 'Rejected' });
+    expect(error.errorCode).toBe(errorCode);
+    expect(error.original.errorCode).toBe(errorCode);
+});
+test.each(['227', 'INVALID_PHONE_NUMBER', NaN, -1])('ApiError rejects malformed API code %p', function (errorCode) {
+    var error = new ApiError({ statusCode: 400, errorCode: errorCode, message: 'Rejected' });
+    expect(error.errorCode).toBe(ErrorType.UNKNOWN_ERROR);
+    expect(error.statusCode).toBe(400);
+    expect(error.message).toBe('Rejected');
+});
 test('ApiError keeps plain string messages', function () {
     var e = new ApiError('empty response');
     expect(e.message).toBe('empty response');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@merchi/sdk",
-  "version": "1.42.20",
+  "version": "1.42.22",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/src/constants/errors.test.ts

@@ -0,0 +1,23 @@
+import { ErrorType, getErrorFromCode } from './errors.js';
+
+test.each([ErrorType.UNKNOWN_ERROR, ErrorType.INVALID_PHONE_NUMBER, ErrorType.DOMAIN_NOT_FOUND])(
+  'preserves known API error code %s', code => {
+    expect(getErrorFromCode(code)).toBe(code);
+  },
+);
+
+// INVALID_HCAPTCHA and SPAM_DETECTED exist in the API's Python SDK but not
+// this SDK's legacy enum. Future codes must remain diagnosable too.
+test.each([226, 227, 1000, Number.MAX_SAFE_INTEGER])(
+  'preserves forward-compatible numeric API error code %s', code => {
+    expect(getErrorFromCode(code)).toBe(code);
+  },
+);
+
+test.each([
+  undefined, null, -1, 1.5, NaN, Infinity, -Infinity,
+  Number.MAX_SAFE_INTEGER + 1, '227', 'INVALID_PHONE_NUMBER',
+  'toString', '__proto__', true, {}, [],
+])('uses UNKNOWN_ERROR for malformed API code %p', code => {
+  expect(getErrorFromCode(code)).toBe(ErrorType.UNKNOWN_ERROR);
+});

package/src/constants/errors.ts

@@ -24,8 +24,10 @@ export enum ErrorType {
   DOMAIN_NOT_FOUND = 22,
 }
 
-export function getErrorFromCode(code: number): ErrorType {
-  if (code in ErrorType) {
+export function getErrorFromCode(code: unknown): number {
+  // The API can add error codes before this SDK's named constants are updated.
+  // Preserve those numeric diagnostics instead of turning them into UNKNOWN.
+  if (typeof code === 'number' && Number.isSafeInteger(code) && code >= 0) {
     return code;
   }
   return ErrorType.UNKNOWN_ERROR;

package/src/entities/cart.test.ts

@@ -63,6 +63,54 @@ test('preserves isTest', () => {
   expect(entity.toJson()).toMatchObject({ isTest: true });
 });
 
+test('serialises a new cart when FormData has no set', () => {
+  class AppendOnlyFormData {
+    fields = new Map<string, string>();
+    append(name: string, value: any) {
+      this.fields.set(name, String(value));
+    }
+    get(name: string) {
+      return this.fields.has(name) ? this.fields.get(name) : null;
+    }
+    entries() {
+      return this.fields.entries();
+    }
+  }
+  class ReplacingFormData extends AppendOnlyFormData {
+    private ready = false;
+    append(name: string, value: any) {
+      if (!this.ready) {
+        throw new Error(`delete was not called before append(${name})`);
+      }
+      this.ready = false;
+      super.append(name, value);
+    }
+    delete() {
+      this.ready = true;
+    }
+  }
+  const serialise = (form: AppendOnlyFormData) => {
+    const merchi = new Merchi();
+    const cart = new merchi.Cart();
+    cart.isTest = false;
+    const domain = new merchi.Domain();
+    domain.id = 9;
+    cart.domain = domain;
+    cart.toFormData({existing: form as unknown as FormData});
+    return form;
+  };
+
+  const appended = serialise(new AppendOnlyFormData());
+  expect(appended.get('isTest')).toBe('false');
+  expect(appended.get('domain-0-id')).toBe('9');
+  expect(appended.get('domain-count')).toBe('1');
+
+  const replaced = serialise(new ReplacingFormData());
+  expect(replaced.get('isTest')).toBe('false');
+  expect(replaced.get('domain-0-id')).toBe('9');
+  expect(replaced.get('domain-count')).toBe('1');
+});
+
 test('preserves source attribution', () => {
   const merchi = new Merchi();
   const entity = new merchi.Cart();

package/src/entity.ts

@@ -928,6 +928,19 @@ export class Entity {
     if (fileIndex === undefined) {
       fileIndex = {value: 0};
     }
+    // Prefer set so a repeated key is replaced. Fall back to append for
+    // FormData implementations that never added set.
+    const writeField = (target: FormData, name: string, value: any) => {
+      if (typeof target.set === 'function') {
+        target.set(name, value);
+        return;
+      }
+      const legacy = target as FormData & {delete?: (field: string) => void};
+      if (typeof legacy.delete === 'function') {
+        legacy.delete(name);
+      }
+      target.append(name, value);
+    };
     const appendData = (name: string, value: any) => {
       /* istanbul ignore next */
       if (name === undefined || value === undefined) {
@@ -937,10 +950,10 @@ export class Entity {
       if (prefix) {
         name = prefix + '-' + name;
       }
-      result.set(name, value);
+      writeField(result, name, value);
     };
     if ((this as any).fileData !== undefined) {
-      result.set(String(fileIndex.value), (this as any).fileData);
+      writeField(result, String(fileIndex.value), (this as any).fileData);
       appendData('fileDataIndex', fileIndex.value);
       fileIndex.value++;
     }

package/src/request.test.ts

@@ -43,6 +43,38 @@ test('will get default errorCode', () => {
   });
 });
 
+test('lead spam rejection keeps its API code through apiFetch', async () => {
+  mockFetch(false, {
+    statusCode: 400,
+    errorCode: 227,
+    message: 'Invalid submission',
+  }, 400);
+  await expect(apiFetch('https://api.merchi.co/', '/create_new_lead/', {
+    method: 'POST',
+  })).rejects.toMatchObject({
+    name: 'ApiError',
+    statusCode: 400,
+    errorCode: 227,
+    message: 'Invalid submission',
+    errorMessage: 'Invalid submission',
+  });
+});
+
+test.each([226, 1000])('ApiError preserves new numeric API code %s', errorCode => {
+  const error = new ApiError({ statusCode: 400, errorCode, message: 'Rejected' });
+  expect(error.errorCode).toBe(errorCode);
+  expect(error.original.errorCode).toBe(errorCode);
+});
+
+test.each(['227', 'INVALID_PHONE_NUMBER', NaN, -1])(
+  'ApiError rejects malformed API code %p', errorCode => {
+    const error = new ApiError({ statusCode: 400, errorCode, message: 'Rejected' });
+    expect(error.errorCode).toBe(ErrorType.UNKNOWN_ERROR);
+    expect(error.statusCode).toBe(400);
+    expect(error.message).toBe('Rejected');
+  },
+);
+
 test('ApiError keeps plain string messages', () => {
   const e = new ApiError('empty response');
   expect(e.message).toBe('empty response');

package/src/request.ts

@@ -1,5 +1,4 @@
-// eslint-disable-next-line no-unused-vars
-import { ErrorType, getErrorFromCode } from './constants/errors.js';
+import { getErrorFromCode } from './constants/errors.js';
 
 export interface RequestOptions extends RequestInit {
   query?: string[][];
@@ -50,7 +49,8 @@ function resolveApiErrorMessage(err: any): string {
 
 export class ApiError extends Error {
   public statusCode?: number;
-  public errorCode?: ErrorType;
+  /** Numeric API code, including values added after this SDK was published. */
+  public errorCode?: number;
   public errorMessage: string;
   /**
    * Structured context the API may include alongside the error