@merchi/sdk 1.40.2

package/src/entities/domain_chat_settings.test.ts

@@ -0,0 +1,16 @@
+import { Merchi } from '../merchi.js';
+
+test('can make DomainChatSettings', () => {
+  const merchi = new Merchi();
+  const settings = new merchi.DomainChatSettings();
+  expect(settings).toBeTruthy();
+});
+
+test('can set assignedUsers', () => {
+  const merchi = new Merchi();
+  const settings = new merchi.DomainChatSettings();
+  const user = new merchi.User();
+  user.id = 11;
+  settings.assignedUsers = [user];
+  expect(settings.assignedUsers?.map((u) => u.id)).toEqual([11]);
+});

package/src/entities/domain_chat_settings.ts

@@ -0,0 +1,82 @@
+import { Domain } from './domain.js';
+import { Entity } from '../entity.js';
+import { MerchiFile } from './file.js';
+import { User } from './user.js';
+
+export class DomainChatSettings extends Entity {
+  protected static resourceName = 'domain_chat_settings';
+  protected static singularName = 'domainChatSettings';
+  protected static pluralName = 'domainChatSettingsList';
+
+  @DomainChatSettings.property()
+  public id?: number;
+
+  @DomainChatSettings.property()
+  public domain?: Domain;
+
+  @DomainChatSettings.property()
+  public enabled?: boolean;
+
+  @DomainChatSettings.property()
+  public displayName?: string | null;
+
+  @DomainChatSettings.property({ type: MerchiFile })
+  public avatar?: MerchiFile | null;
+
+  @DomainChatSettings.property()
+  public welcomeMessage?: string | null;
+
+  @DomainChatSettings.property()
+  public privacyPolicyUrl?: string | null;
+
+  @DomainChatSettings.property()
+  public workingHours?: any | null;
+
+  @DomainChatSettings.property()
+  public awayMessage?: string | null;
+
+  @DomainChatSettings.property()
+  public notifyEmailNewConversation?: boolean;
+
+  @DomainChatSettings.property()
+  public notifyEmailNewMessage?: boolean;
+
+  @DomainChatSettings.property()
+  public telegramChatId?: string | null;
+
+  @DomainChatSettings.property({ arrayType: 'User' })
+  public assignedUsers?: User[];
+
+  @DomainChatSettings.property()
+  public requireGuestContact?: boolean;
+
+  @DomainChatSettings.property()
+  public embedTestMode?: boolean;
+
+  @DomainChatSettings.property()
+  public autoOpenDelay?: number | null;
+
+  @DomainChatSettings.property()
+  public autoOpenMessage?: string | null;
+
+  @DomainChatSettings.property()
+  public autoOpenMode?: string | null;
+
+  @DomainChatSettings.property()
+  public aiFallbackEnabled?: boolean;
+
+  @DomainChatSettings.property()
+  public aiFallbackScope?: 'faq_only' | 'faq_and_status' | 'collect_and_escalate' | 'full_support_limited' | null;
+
+  @DomainChatSettings.property()
+  public aiDisclosureMode?: 'on' | 'off' | null;
+
+  @DomainChatSettings.property()
+  public aiMaxRepliesPerConversation?: number | null;
+
+  @DomainChatSettings.property()
+  public aiCooldownSeconds?: number;
+
+  @DomainChatSettings.property()
+  public aiEscalationMessage?: string | null;
+}

package/src/entities/domain_invitation.test.ts

@@ -0,0 +1,7 @@
+import { Merchi } from '../merchi.js';
+
+test('can make DomainInvitation', () => {
+  const merchi = new Merchi();
+  const domainInvitation = new merchi.DomainInvitation();
+  expect(domainInvitation).toBeTruthy();
+});

package/src/entities/domain_invitation.ts

@@ -0,0 +1,36 @@
+import { Domain } from './domain.js';
+import { Entity } from '../entity.js';
+import { User } from './user.js';
+
+export class DomainInvitation extends Entity {
+  protected static resourceName = 'domain_invitations';
+  protected static singularName = 'domainInvitation';
+  protected static pluralName = 'domainInvitations';
+
+  @DomainInvitation.property({type: Date})
+  public archived?: Date | null;
+
+  @DomainInvitation.property()
+  public id?: number;
+
+  @DomainInvitation.property()
+  public userName?: string;
+
+  @DomainInvitation.property()
+  public userEmail?: string;
+
+  @DomainInvitation.property()
+  public role?: number;
+
+  @DomainInvitation.property()
+  public token?: string;
+
+  @DomainInvitation.property()
+  public domain?: Domain;
+
+  @DomainInvitation.property()
+  public sender?: User;
+
+  @DomainInvitation.property({type: Date})
+  public user?: User | null;
+}

package/src/entities/domain_tag.test.ts

@@ -0,0 +1,7 @@
+import { Merchi } from '../merchi.js';
+
+test('can make DomainTag', () => {
+  const merchi = new Merchi();
+  const domainTag = new merchi.DomainTag();
+  expect(domainTag).toBeTruthy();
+});

package/src/entities/domain_tag.ts

@@ -0,0 +1,42 @@
+import { Domain } from './domain.js';
+import { Entity } from '../entity.js';
+import { Invoice } from './invoice.js';
+import { Job } from './job.js';
+import { Product } from './product.js';
+import { Shipment } from './shipment.js';
+
+export class DomainTag extends Entity {
+  protected static resourceName = 'domain_tags';
+  protected static singularName = 'domainTag';
+  protected static pluralName = 'domainTags';
+
+  @DomainTag.property()
+  public id?: number;
+
+  @DomainTag.property()
+  public colour?: number;
+
+  @DomainTag.property()
+  public name?: string;
+
+  @DomainTag.property()
+  public description?: string;
+
+  @DomainTag.property()
+  public showPublic?: boolean;
+
+  @DomainTag.property()
+  public domain?: Domain;
+
+  @DomainTag.property({arrayType: 'Job'})
+  public jobs?: Job[];
+
+  @DomainTag.property({arrayType: 'Product'})
+  public products?: Product[];
+
+  @DomainTag.property({arrayType: 'Invoice'})
+  public invoices?: Invoice[];
+
+  @DomainTag.property({arrayType: 'Shipment'})
+  public shipments?: Shipment[];
+}

package/src/entities/draft.test.ts

@@ -0,0 +1,29 @@
+import { Merchi } from '../merchi.js';
+
+test('can make Draft', () => {
+  const merchi = new Merchi();
+  const draft = new merchi.Draft();
+  expect(draft).toBeTruthy();
+});
+
+test('commentsYoungestToEldest', () => {
+  const merchi = new Merchi();
+  const draft = new merchi.Draft();
+  expect(draft.commentsYoungestToEldest).toThrow();
+  draft.comments = [];
+  expect(draft.commentsYoungestToEldest()).toEqual([]);
+  draft.comments = [new merchi.DraftComment(), new merchi.DraftComment()];
+  expect(draft.commentsYoungestToEldest).toThrow();
+  draft.comments[0].id = 2;
+  draft.comments[1].id = 1;
+  expect(draft.commentsYoungestToEldest()[0].id).toEqual(1);
+});
+
+test('draft accepted serialised to milliseconds', () => {
+  const merchi = new Merchi();
+  const draft = new merchi.Draft();
+  draft.accepted = new Date('Feb 28 2013 19:00:00 GMT-0500');
+  const correct = [['accepted', '1362096000']];
+  const backData = Array.from((draft.toFormData() as any).entries());
+  expect(backData).toEqual(correct);
+});

package/src/entities/draft.ts

@@ -0,0 +1,79 @@
+import { DraftComment } from './draft_comment.js';
+import { Entity } from '../entity.js';
+import { MerchiFile } from './file.js';
+import { Job } from './job.js';
+import { Notification } from './notification.js';
+import { User } from './user.js';
+import { DraftTemplate } from './draft_template.js';
+
+export class Draft extends Entity {
+  protected static resourceName = 'drafts';
+  protected static singularName = 'draft';
+  protected static pluralName = 'drafts';
+
+  @Draft.property({type: Date})
+  public archived?: Date | null;
+
+  @Draft.property()
+  public id?: number;
+
+  @Draft.property({type: Date})
+  public date?: Date | null;
+
+  @Draft.property({type: Date})
+  public accepted?: Date | null;
+
+  @Draft.property({type: Date})
+  public resendDate?: Date | null;
+
+  @Draft.property()
+  public viewed?: boolean;
+
+  @Draft.property()
+  public sendSms?: boolean;
+
+  @Draft.property()
+  public sendWhatsapp?: boolean;
+
+  @Draft.property()
+  public sendEmail?: boolean;
+
+  @Draft.property({arrayType: 'DraftComment'})
+  public comments?: DraftComment[];
+
+  @Draft.property({arrayType: 'DraftTemplate'})
+  public draftTemplates?: DraftTemplate[];
+
+  @Draft.property()
+  public commentsCount?: number;
+
+  @Draft.property()
+  public changesRequested?: boolean;
+
+  @Draft.property()
+  public designer?: User;
+
+  @Draft.property({arrayType: 'MerchiFile'})
+  public images?: MerchiFile[];
+
+  @Draft.property({arrayType: 'Notification'})
+  public notification?: Notification[];
+
+  @Draft.property()
+  public job?: Job;
+
+  @Draft.property({arrayType: 'Job'})
+  public sharedWithJobs?: Job[];
+
+  public commentsYoungestToEldest = () => {
+    if (this.comments === undefined) {
+      throw 'comments is undefined. did you forget to embed it?';
+    }
+    return this.comments.sort((a, b) => {
+      if (a.id === undefined || b.id === undefined) {
+        throw 'comment id is undefined. did you forget to embed it?';
+      }
+      return a.id - b.id;
+    });
+  };
+}

package/src/entities/draft_comment.test.ts

@@ -0,0 +1,7 @@
+import { Merchi } from '../merchi.js';
+
+test('can make DraftComment', () => {
+  const merchi = new Merchi();
+  const draftComment = new merchi.DraftComment();
+  expect(draftComment).toBeTruthy();
+});

package/src/entities/draft_comment.ts

@@ -0,0 +1,63 @@
+import { Draft } from './draft.js';
+import { Entity } from '../entity.js';
+import { MerchiFile } from './file.js';
+import { Job } from './job.js';
+import { Notification } from './notification.js';
+import { User } from './user.js';
+
+export class DraftComment extends Entity {
+  protected static resourceName = 'draft_comments';
+  protected static singularName = 'draftComment';
+  protected static pluralName = 'draftComments';
+
+  @DraftComment.property({type: Date})
+  public archived?: Date | null;
+
+  @DraftComment.property()
+  public id?: number;
+
+  @DraftComment.property({type: Date})
+  public date?: Date | null;
+
+  @DraftComment.property({type: Date})
+  public lastEditedTime?: Date | null;
+
+  @DraftComment.property()
+  public urgency?: number;
+
+  @DraftComment.property()
+  public text?: string;
+
+  @DraftComment.property()
+  public changeRequest?: boolean;
+
+  @DraftComment.property()
+  public sendSms?: boolean;
+
+  @DraftComment.property()
+  public sendEmail?: boolean;
+
+  @DraftComment.property()
+  public sendWhatsapp?: boolean;
+
+  @DraftComment.property()
+  public user?: User;
+
+  @DraftComment.property()
+  public lastEditedBy?: User;
+
+  @DraftComment.property({arrayType: 'MerchiFile'})
+  public files?: MerchiFile[];
+
+  @DraftComment.property({arrayType: 'User'})
+  public forwards?: User[];
+
+  @DraftComment.property({arrayType: 'Notification'})
+  public notifications?: Notification[];
+
+  @DraftComment.property({type: Draft})
+  public draft?: Draft | null;
+
+  @DraftComment.property({type: Job})
+  public job?: Job | null;
+}

package/src/entities/draft_preview.test.ts

@@ -0,0 +1,42 @@
+import { setup, mockFetch } from '../test_util.js';
+import { DraftPreview } from './draft_preview.js';
+
+setup();
+
+test('can create draft preview from json', () => {
+  const mockData = {
+    draft_preview: {
+      id: 1,
+      name: 'Test Preview',
+      description: 'Test Description',
+      date: '2024-03-26T10:00:00Z',
+      height: 800,
+      width: 600
+    }
+  };
+
+  const draftPreview = new DraftPreview();
+  draftPreview.fromJson(mockData.draft_preview);
+
+  expect(draftPreview.id).toBe(1);
+  expect(draftPreview.name).toBe('Test Preview');
+  expect(draftPreview.description).toBe('Test Description');
+  expect(draftPreview.date).toBeInstanceOf(Date);
+  expect(draftPreview.height).toBe(800);
+  expect(draftPreview.width).toBe(600);
+});
+
+test('can fetch draft preview from server', () => {
+  const mockData = {
+    draft_preview: {
+      id: 1,
+      name: 'Test Preview'
+    }
+  };
+
+  mockFetch(true, mockData, 200);
+  return DraftPreview.get(1).then(draftPreview => {
+    expect(draftPreview.id).toBe(1);
+    expect(draftPreview.name).toBe('Test Preview');
+  });
+});

package/src/entities/draft_preview.ts

@@ -0,0 +1,37 @@
+import { Entity } from '../entity.js';
+import { MerchiFile } from './file.js';
+import { Product } from './product.js';
+import { DraftPreviewLayer } from './draft_preview_layer.js';
+
+export class DraftPreview extends Entity {
+  protected static resourceName = 'draft_previews';
+  protected static singularName = 'draftPreview';
+  protected static pluralName = 'draftPreviews';
+
+  @DraftPreview.property()
+  public id?: number;
+
+  @DraftPreview.property({type: MerchiFile})
+  public file?: MerchiFile;
+
+  @DraftPreview.property({type: Product})
+  public product?: Product;
+
+  @DraftPreview.property({type: String})
+  public description?: string | null;
+
+  @DraftPreview.property({type: String})
+  public name?: string | null;
+
+  @DraftPreview.property({type: Date})
+  public date?: Date | null;
+
+  @DraftPreview.property()
+  public height?: number;
+
+  @DraftPreview.property()
+  public width?: number;
+
+  @DraftPreview.property({arrayType: 'DraftPreviewLayer'})
+  public draftPreviewLayers?: DraftPreviewLayer[];
+}

package/src/entities/draft_preview_layer.test.ts

@@ -0,0 +1,7 @@
+import { Merchi } from '../merchi.js';
+
+test('can make DraftPreviewLayer', () => {
+  const merchi = new Merchi();
+  const draftPreviewLayer = new merchi.DraftPreviewLayer();
+  expect(draftPreviewLayer).toBeTruthy();
+});

package/src/entities/draft_preview_layer.ts

@@ -0,0 +1,21 @@
+import { Entity } from '../entity.js';
+import { DraftPreview } from './draft_preview.js';
+import { DraftTemplate } from './draft_template.js';
+
+export class DraftPreviewLayer extends Entity {
+  protected static resourceName = 'draft_preview_layers';
+  protected static singularName = 'draftPreviewLayer';
+  protected static pluralName = 'draftPreviewLayers';
+
+  @DraftPreviewLayer.property()
+  public id?: number;
+
+  @DraftPreviewLayer.property({type: String})
+  public layerName?: string;
+
+  @DraftPreviewLayer.property({type: DraftPreview})
+  public draftPreview?: DraftPreview;
+
+  @DraftPreviewLayer.property({type: DraftTemplate})
+  public draftTemplate?: DraftTemplate;
+}

package/src/entities/draft_template.test.ts

@@ -0,0 +1,14 @@
+import { Merchi } from '../merchi.js';
+
+test('can make DraftTemplate', () => {
+  const merchi = new Merchi();
+  const draftTemplate = new merchi.DraftTemplate();
+  expect(draftTemplate).toBeTruthy();
+});
+
+test('customisationMap accepts JSON object from server', () => {
+  const merchi = new Merchi();
+  const draftTemplate = new merchi.DraftTemplate();
+  draftTemplate.fromJson({ customisationMap: { regions: [] } });
+  expect(draftTemplate.customisationMap).toEqual({ regions: [] });
+});

package/src/entities/draft_template.ts

@@ -0,0 +1,81 @@
+import { DraftPreviewLayer } from './draft_preview_layer.js';
+import { Entity } from '../entity.js';
+import { MerchiFile } from './file.js';
+import { Job } from './job.js';
+import { Product } from './product.js';
+import { VariationField } from './variation_field.js';
+import { VariationFieldsOption } from './variation_fields_option.js';
+
+/**
+ * Runtime type tag only. The API returns `customisationMap` as arbitrary JSON;
+ * the entity layer refuses `Object` from decorator metadata, so we cannot use
+ * `any` / plain object without an explicit `type` option here. A const class
+ * expression is used so `noUnusedLocals` counts the symbol as used (a named
+ * class referenced only from decorators can trigger TS6196).
+ */
+const customisationMapPropertyType = class {};
+
+export class DraftTemplate extends Entity {
+  protected static resourceName = 'draft_templates';
+  protected static singularName = 'draftTemplate';
+  protected static pluralName = 'draftTemplates';
+
+  @DraftTemplate.property({type: Date})
+  public archived?: Date | null;
+
+  @DraftTemplate.property()
+  public id?: number;
+
+  @DraftTemplate.property({type: Date})
+  public date?: Date | null;
+
+  @DraftTemplate.property()
+  public description?: string;
+
+  @DraftTemplate.property()
+  public name?: string;
+
+  @DraftTemplate.property()
+  public height?: number;
+
+  @DraftTemplate.property()
+  public width?: number;
+
+  @DraftTemplate.property({type: MerchiFile})
+  public file?: MerchiFile;
+
+  @DraftTemplate.property({type: 'MerchiFile'})
+  public design?: MerchiFile;
+
+  @DraftTemplate.property({type: Product})
+  public product?: Product | null;
+
+  @DraftTemplate.property({type: Job})
+  public job?: Job | null;
+
+  @DraftTemplate.property({arrayType: 'VariationFieldsOption'})
+  public selectedByVariationFieldOptions?: VariationFieldsOption[];
+
+  @DraftTemplate.property({arrayType: 'VariationField'})
+  public editedByVariationFields?: VariationField[];
+
+  @DraftTemplate.property({arrayType: 'DraftPreviewLayer'})
+  public draftPreviewLayers?: DraftPreviewLayer[];
+
+  // Cached template customisation map -- which regions of the template
+  // image are editable (text placeholders, body colour fill, print
+  // area) versus preserved. Populated lazily by the backend when a
+  // template is first rendered, or set manually by an operator (in
+  // which case ``customisationMapSource === 'manual'`` and the auto
+  // analyser leaves it alone). ``customisationMapFileId`` records the
+  // ``file.id`` the cached map was generated from so the analyser
+  // knows when to re-run after the template image is replaced.
+  @DraftTemplate.property({type: customisationMapPropertyType})
+  public customisationMap?: Record<string, unknown> | null;
+
+  @DraftTemplate.property({type: String})
+  public customisationMapSource?: string | null;
+
+  @DraftTemplate.property({type: String})
+  public customisationMapFileId?: string | null;
+}

package/src/entities/email_address.test.ts

@@ -0,0 +1,7 @@
+import { Merchi } from '../merchi.js';
+
+test('can make EmailAddress', () => {
+  const merchi = new Merchi();
+  const emailAddress = new merchi.EmailAddress();
+  expect(emailAddress).toBeTruthy();
+});

package/src/entities/email_address.ts

@@ -0,0 +1,24 @@
+import { Company } from './company.js';
+import { Entity } from '../entity.js';
+import { User } from './user.js';
+
+export class EmailAddress extends Entity {
+  protected static resourceName = 'email_addresses';
+  protected static singularName = 'emailAddress';
+  protected static pluralName = 'emailAddresses';
+
+  @EmailAddress.property({type: Date})
+  public archived?: Date | null;
+
+  @EmailAddress.property()
+  public id?: number;
+
+  @EmailAddress.property()
+  public emailAddress?: string;
+
+  @EmailAddress.property({arrayType: 'User'})
+  public users?: User[];
+
+  @EmailAddress.property({arrayType: 'Company'})
+  public companies?: Company[];
+}

package/src/entities/email_counter.test.ts

@@ -0,0 +1,7 @@
+import { Merchi } from '../merchi.js';
+
+test('can make EmailCounter', () => {
+  const merchi = new Merchi();
+  const emailCounter = new merchi.EmailCounter();
+  expect(emailCounter).toBeTruthy();
+});

package/src/entities/email_counter.ts

@@ -0,0 +1,20 @@
+import { Entity } from '../entity.js';
+
+export class EmailCounter extends Entity {
+  protected static resourceName = 'email_counters';
+  protected static singularName = 'emailCounter';
+  protected static pluralName = 'emailCounters';
+  protected static primaryKey = 'emailAddress';
+
+  @EmailCounter.property()
+  public emailAddress?: string;
+
+  @EmailCounter.property()
+  public unsubscribed?: boolean;
+
+  @EmailCounter.property()
+  public silenced?: boolean;
+
+  @EmailCounter.property()
+  public tokens?: number;
+}

package/src/entities/enrolled_domain.test.ts

@@ -0,0 +1,7 @@
+import { Merchi } from '../merchi.js';
+
+test('can make EnrolledDomain', () => {
+  const merchi = new Merchi();
+  const enrolledDomain = new merchi.EnrolledDomain();
+  expect(enrolledDomain).toBeTruthy();
+});