@merchi/sdk 1.40.2

package/src/entities/supply_domain.ts

@@ -0,0 +1,27 @@
+import { Domain } from './domain.js';
+import { Entity } from '../entity.js';
+import { Product } from './product.js';
+
+export class SupplyDomain extends Entity {
+  protected static resourceName = 'supply_domains';
+  protected static singularName = 'supplyDomain';
+  protected static pluralName = 'supplyDomains';
+
+  @SupplyDomain.property({type: Date})
+  public archived?: Date | null;
+
+  @SupplyDomain.property()
+  public id?: number;
+
+  @SupplyDomain.property()
+  public needsDrafting?: boolean;
+
+  @SupplyDomain.property()
+  public product?: Product;
+
+  @SupplyDomain.property({type: Product})
+  public supplyProduct?: Product | null;
+
+  @SupplyDomain.property()
+  public domain?: Domain;
+}

package/src/entities/support_conversation.test.ts

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

package/src/entities/support_conversation.ts

@@ -0,0 +1,65 @@
+import { Domain } from './domain.js';
+import { DomainTag } from './domain_tag.js';
+import { Entity } from '../entity.js';
+import { User } from './user.js';
+import { SupportMessage } from './support_message.js';
+
+export class SupportConversation extends Entity {
+  protected static resourceName = 'support_conversations';
+  protected static singularName = 'supportConversation';
+  protected static pluralName = 'supportConversations';
+
+  @SupportConversation.property()
+  public id?: number;
+
+  @SupportConversation.property({ type: Date })
+  public creationDate?: Date | null;
+
+  @SupportConversation.property({ type: Date })
+  public lastMessageAt?: Date | null;
+
+  @SupportConversation.property({ type: Date })
+  public archivedAt?: Date | null;
+
+  @SupportConversation.property({ type: Domain })
+  public domain?: Domain;
+
+  @SupportConversation.property({ arrayType: 'DomainTag' })
+  public tags?: DomainTag[];
+
+  @SupportConversation.property({ type: String })
+  public guestId?: string | null;
+
+  @SupportConversation.property({ type: String })
+  public guestContactEmail?: string | null;
+
+  @SupportConversation.property({ type: String })
+  public guestContactName?: string | null;
+
+  /** Opaque client fingerprint for repeat-visitor / spam correlation (max 512 chars). */
+  @SupportConversation.property({ type: String })
+  public clientFingerprint?: string | null;
+
+  /** Manager-assigned display name for this conversation. */
+  @SupportConversation.property({ type: String })
+  public name?: string | null;
+
+  /** Freeform internal notes written by managers (not visible to guests). */
+  @SupportConversation.property({ type: String })
+  public notes?: string | null;
+
+  @SupportConversation.property({ type: User })
+  public user?: User | null;
+
+  @SupportConversation.property({ type: User })
+  public assignedUser?: User | null;
+
+  @SupportConversation.property({ type: Boolean })
+  public aiAutoReply?: boolean;
+
+  @SupportConversation.property({ arrayType: 'SupportMessage' })
+  public messages?: SupportMessage[];
+
+  @SupportConversation.property()
+  public messagesCount?: number;
+}

package/src/entities/support_message.test.ts

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

package/src/entities/support_message.ts

@@ -0,0 +1,30 @@
+import { Entity } from '../entity.js';
+import { SupportConversation } from './support_conversation.js';
+import { User } from './user.js';
+
+export class SupportMessage extends Entity {
+  protected static resourceName = 'support_messages';
+  protected static singularName = 'supportMessage';
+  protected static pluralName = 'supportMessages';
+
+  @SupportMessage.property()
+  public id?: number;
+
+  @SupportMessage.property({ type: SupportConversation })
+  public conversation?: SupportConversation;
+
+  @SupportMessage.property({ type: String })
+  public senderType?: string;  // 'guest' | 'manager'
+
+  @SupportMessage.property({ type: User })
+  public user?: User | null;
+
+  @SupportMessage.property({ type: String })
+  public content?: string;
+
+  @SupportMessage.property({ type: Date })
+  public creationDate?: Date | null;
+
+  @SupportMessage.property({ type: Boolean })
+  public isAiReply?: boolean;
+}

package/src/entities/system_role.test.ts

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

package/src/entities/system_role.ts

@@ -0,0 +1,17 @@
+import { Entity } from '../entity.js';
+import { User } from './user.js';
+
+export class SystemRole extends Entity {
+  protected static resourceName = 'system_roles';
+  protected static singularName = 'systemRole';
+  protected static pluralName = 'systemRoles';
+
+  @SystemRole.property()
+  public id?: number;
+
+  @SystemRole.property()
+  public role?: number;
+
+  @SystemRole.property()
+  public user?: User;
+}

package/src/entities/theme.test.ts

@@ -0,0 +1,38 @@
+import { Merchi } from '../merchi.js';
+
+test('can make Theme', () => {
+  const merchi = new Merchi();
+  const theme = new merchi.Theme();
+  expect(theme).toBeTruthy();
+});
+
+test('can be activated', () => {
+  const merchi = new Merchi();
+  const theme = new merchi.Theme();
+  expect(theme.canBeActivated).toThrow();
+  theme.mainCssStatus = 3;
+  theme.emailCssStatus = 3;
+  expect(theme.canBeActivated()).toBe(true);
+  theme.mainCssStatus = 1;
+  expect(theme.canBeActivated()).toBe(false);
+});
+
+test('is active on domain', () => {
+  const merchi = new Merchi();
+  const theme = new merchi.Theme();
+  theme.id = 3;
+  const otherTheme = new merchi.Theme();
+  otherTheme.id = 4;
+  const domain = new merchi.Domain();
+  domain.id = 1;
+  expect(() => theme.isActiveOnDomain(1)).toThrow();
+  theme.domain = null;
+  expect(theme.isActiveOnDomain(1)).toBe(false);
+  theme.domain = domain; 
+  expect(() => theme.isActiveOnDomain(1)).toThrow();
+  domain.activeTheme = otherTheme;
+  expect(theme.isActiveOnDomain(1)).toBe(false);
+  domain.activeTheme = theme;
+  expect(theme.isActiveOnDomain(1)).toBe(true);
+  expect(theme.isActiveOnDomain(2)).toBe(false);
+});

package/src/entities/theme.ts

@@ -0,0 +1,82 @@
+import { Domain } from './domain.js';
+import { Entity } from '../entity.js';
+import { User } from './user.js';
+import { ThemeStatus } from '../constants/theme_status.js';
+
+export class Theme extends Entity {
+  protected static resourceName = 'themes';
+  protected static singularName = 'theme';
+  protected static pluralName = 'themes';
+
+  @Theme.property({type: Date})
+  public archived?: Date | null;
+
+  @Theme.property()
+  public id?: number;
+
+  @Theme.property()
+  public mainCssStatus?: number;
+
+  @Theme.property({type: String})
+  public mainCssErrorMessage?: string | null;
+
+  @Theme.property()
+  public emailCssStatus?: number;
+
+  @Theme.property({type: String})
+  public emailCssErrorMessage?: string | null;
+
+  @Theme.property()
+  public lastUpdated?: Date;
+
+  @Theme.property({embeddedByDefault: false, type: String})
+  public mainCss?: string | null;
+
+  @Theme.property({embeddedByDefault: false, type: String})
+  public mainCssTemplateUsing?: string | null;
+
+  @Theme.property({embeddedByDefault: false, type: String})
+  public mainCssTemplateEditing?: string | null;
+
+  @Theme.property({embeddedByDefault: false, type: String})
+  public emailCss?: string | null;
+
+  @Theme.property({embeddedByDefault: false, type: String})
+  public emailCssTemplateUsing?: string | null;
+
+  @Theme.property({embeddedByDefault: false, type: String})
+  public emailCssTemplateEditing?: string | null;
+
+  @Theme.property({type: 'Domain'})
+  public domain?: Domain | null;
+
+  @Theme.property({type: User})
+  public author?: User | null;
+
+  @Theme.property({arrayType: 'Domain'})
+  public domains?: Domain[];
+
+  public canBeActivated = () => {
+    const validStatus = ThemeStatus.VALID_BUT_NOT_UPDATED;
+    if (this.mainCssStatus === undefined || this.emailCssStatus === undefined) {
+      throw new Error('status is unknown');
+    }
+    return this.mainCssStatus >= validStatus &&
+      this.emailCssStatus >= validStatus;
+  };
+
+  public isActiveOnDomain = (domainId: number) => {
+    const domain = this.domain;
+    if (domain === undefined) {
+      throw new Error('domain is unknown');
+    }
+    if (domain === null) {
+      return false;
+    }
+    const activeTheme = domain.activeTheme;
+    if (activeTheme === undefined) {
+      throw new Error('activeTheme is unknown');
+    }
+    return domain.id == domainId && activeTheme.id === this.id;
+  };
+}

package/src/entities/theme_css_setting.test.ts

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

package/src/entities/theme_css_setting.ts

@@ -0,0 +1,23 @@
+import { Entity } from '../entity.js';
+import { User } from './user.js';
+
+export class ThemeCssSetting extends Entity {
+  protected static resourceName = 'theme_css_settings';
+  protected static singularName = 'themeCssSetting';
+  protected static pluralName = 'themeCssSettings';
+
+  @ThemeCssSetting.property()
+  public id?: number;
+
+  @ThemeCssSetting.property({type: Date})
+  public created?: Date | null;
+
+  @ThemeCssSetting.property({type: User})
+  public createdBy?: User | null;
+
+  @ThemeCssSetting.property()
+  public allowedAttributes?: string;
+
+  @ThemeCssSetting.property()
+  public notAllowedAttributes?: string;
+}

package/src/entities/user.test.ts

@@ -0,0 +1,154 @@
+import { Merchi } from '../merchi.js';
+import { Role } from '../constants/roles.js';
+import { SystemRoles } from '../constants/system_roles.js';
+import { DomainType } from '../constants/domain_types.js';
+import { setup, mockFetch } from '../test_util.js';
+import { every } from 'lodash';
+
+setup();
+
+test('can make User', () => {
+  const merchi = new Merchi();
+  const user = new merchi.User();
+  expect(user).toBeTruthy();
+});
+
+test('can issue public create request to server', () => {
+  const merchi = new Merchi();
+  const user = new merchi.User();
+  user.name = 'Test User';
+  const data = Array.from((user.toFormData() as any).entries());
+  const fetch = mockFetch(true, {}, 201);
+  user.publicCreate();
+  const fetchUrl = fetch.mock.calls[0][0];
+  const sentToServer = Array.from(fetch.mock.calls[0][1]['body'].entries());
+  expect(sentToServer).toEqual(data);
+  expect(fetchUrl).toMatch('public_user_create');
+});
+
+test('role helper function', () => {
+  const merchi = new Merchi();
+  const user = new merchi.User();
+  const userSupplier = new merchi.User();
+  const domain1 = new merchi.Domain();
+  const domain2 = new merchi.Domain();
+  const enrolledDomain = new merchi.EnrolledDomain();
+  const enrolledDomainSupplier = new merchi.EnrolledDomain();
+  domain1.id = 1;
+  domain2.id = 2;
+  enrolledDomain.role = Role.ADMIN;
+  enrolledDomainSupplier.role = Role.SUPPLIER;
+  // throw error if enrolledDomains is undefined which seems to be an embed issue
+  expect(() => {user.roleInDomain(domain1);}).toThrow(Error);
+
+  // throw error if enrolledDomain.domain is undefined which seems to be an embed issue
+  user.enrolledDomains = [enrolledDomain];
+  expect(() => {user.roleInDomain(domain1);}).toThrow(Error);
+
+  userSupplier.enrolledDomains = [enrolledDomainSupplier];
+
+  enrolledDomain.domain = domain1;
+  enrolledDomainSupplier.domain = domain1;
+  expect(user.roleInDomain(domain1)).toBe(Role.ADMIN);
+  expect(userSupplier.roleInDomain(domain1)).toBe(Role.SUPPLIER);
+  expect(user.roleInDomain(domain2)).toBe(Role.PUBLIC);
+
+  expect(user.isManagementTeam(domain1)).toBe(true);
+  expect(user.isManagementTeam(domain2)).toBe(false);
+  expect(user.isDomainManager(domain1)).toBe(true);
+  expect(user.isDomainManager(domain2)).toBe(false);
+  expect(user.isNotClient(domain1)).toBe(true);
+  expect(userSupplier.isManagementTeam(domain1)).toBe(false);
+  expect(userSupplier.isNotClient(domain1)).toBe(true);
+
+  // have two match enrolled domain is invalid data, but we should return
+  // the highest permission
+  const enrolledDomainClient = new merchi.EnrolledDomain();
+  enrolledDomainClient.role = Role.CLIENT;
+  enrolledDomainClient.domain = domain1;
+
+  user.enrolledDomains = [enrolledDomain, enrolledDomainClient];
+  expect(user.roleInDomain(domain1)).toBe(Role.ADMIN);
+});
+
+test('companies', () => {
+  const merchi = new Merchi();
+  const user = new merchi.User();
+  // user.userCompanies not embeded yet will throw a error as it suppose to
+  // be a embed issue
+  expect(() => user.companies()).toThrow();
+
+  const userCompany1 = new merchi.UserCompany();
+  const userCompany2 = new merchi.UserCompany();
+  user.userCompanies = [userCompany1, userCompany2];
+  expect(() => user.companies()).toThrow();
+
+  const company1 = new merchi.Company();
+  const company2 = new merchi.Company();
+  userCompany1.company = company1;
+  userCompany2.company = company2;
+  expect(user.companies()).toEqual([company1, company2]);
+});
+
+test('hasRoles', () => {
+  const merchi = new Merchi();
+  const user = new merchi.User();
+  // EnrolledDomains has not been specified yet likely to be a embed issue
+  expect(() => user.hasRoles([Role.ADMIN])).toThrow();
+  const enrollment = new merchi.EnrolledDomain();
+  user.enrolledDomains = [enrollment];
+  // EnrolledDomains.domain has not been specified yet likely to be
+  // a embed issue
+  expect(() => user.hasRoles([Role.PUBLIC])).toThrow();
+
+  enrollment.domain = new merchi.Domain();
+  expect(user.hasRoles([Role.PUBLIC])).toBeTruthy();
+
+  enrollment.role = Role.ADMIN;
+  user.enrolledDomains = [enrollment];
+  expect(user.hasRoles([Role.ADMIN, Role.MANAGER])).toBeTruthy();
+  expect(user.hasRoles([Role.ADMIN, Role.MANAGER], every)).toBeFalsy();
+
+  // for internal supplier domain, role can be maximumly interpreted
+  // as supplier
+  enrollment.domain.domainType = DomainType.DOMAIN_SUPPLIER;
+  expect(user.hasRoles([Role.ADMIN])).toBeFalsy();
+  expect(user.hasRoles([Role.SUPPLIER])).toBeTruthy();
+});
+
+test('testHasSystemRoles', () => {
+  const merchi = new Merchi();
+  const user = new merchi.User();
+  // SystemRole has not been specified yet likely to be a embed issue
+  expect(
+    () => user.hasSystemRole(SystemRoles.SYSTEM_COMPONENT_BUILDER)).toThrow();
+  user.systemRoles = [];
+  expect(user.hasSystemRole(SystemRoles.SYSTEM_COMPONENT_BUILDER)).toBeFalsy();
+  const systemRole = new merchi.SystemRole();
+  systemRole.role = SystemRoles.SYSTEM_COMPONENT_BUILDER;
+  user.systemRoles = [systemRole];
+  expect(user.hasSystemRole(SystemRoles.SYSTEM_COMPONENT_BUILDER)).toBeTruthy();
+});
+
+test('domainsByRoles', () => {
+  const merchi = new Merchi();
+  const user = new merchi.User();
+  expect(() => user.domainsByRoles([])).toThrow();
+  user.enrolledDomains = [];
+  expect(user.domainsByRoles([])).toEqual([]);
+  const ed = new merchi.EnrolledDomain();
+  user.enrolledDomains = [ed];
+  expect(() => user.domainsByRoles([])).toThrow();
+  const d = new merchi.Domain();
+  ed.domain = d;
+  expect(() => user.domainsByRoles([])).toThrow();
+  user.isSuperUser = false;
+  expect(user.domainsByRoles([])).toEqual([]);
+  user.isSuperUser = true;
+  expect(user.domainsByRoles([])).toEqual([d]);
+  user.isSuperUser = false;
+  ed.role = Role.MANAGER;
+  expect(user.domainsByRoles([Role.MANAGER])).toEqual([d]);
+  ed.role = Role.DESIGNER;
+  expect(user.domainsByRoles([Role.MANAGER])).toEqual([]);
+});