merchi_sdk_ts 0.0.1

package/src/entities/company_invitation.ts

@@ -0,0 +1,33 @@
+import { Company } from './company';
+import { Entity } from '../entity';
+import { User } from './user';
+
+export class CompanyInvitation extends Entity {
+  protected static resourceName = 'company_invitations';
+  protected static singularName = 'companyInvitation';
+  protected static pluralName = 'companyInvitations';
+
+  @CompanyInvitation.property({type: Date})
+  public archived?: Date | null;
+
+  @CompanyInvitation.property()
+  public id?: number;
+
+  @CompanyInvitation.property()
+  public userName?: string;
+
+  @CompanyInvitation.property()
+  public userEmail?: string;
+
+  @CompanyInvitation.property()
+  public inviteAsAdmin?: boolean;
+
+  @CompanyInvitation.property()
+  public token?: string;
+
+  @CompanyInvitation.property()
+  public company?: Company;
+
+  @CompanyInvitation.property()
+  public sender?: User;
+}

package/src/entities/component.test.ts

@@ -0,0 +1,14 @@
+import { Merchi } from '../merchi';
+
+test('can make Component', () => {
+  const merchi = new Merchi();
+  const component = new merchi.Component();
+  expect(component).toBeTruthy();
+});
+
+test('can convert to react component', () => {
+  const merchi = new Merchi();
+  const component = new merchi.Component();
+  component.compiled = 'return 1;';
+  component.toReact({});
+});

package/src/entities/component.ts

@@ -0,0 +1,92 @@
+import { ComponentTag } from './component_tag';
+import { ComponentVersion } from './component_version';
+import { Entity } from '../entity';
+import { MerchiFile } from './file';
+import { User } from './user';
+
+export class Component extends Entity {
+  protected static resourceName = 'components';
+  protected static singularName = 'component';
+  protected static pluralName = 'components';
+
+  @Component.property({type: Date})
+  public archived?: Date | null;
+
+  @Component.property({type: Date})
+  public created?: Date;
+
+  @Component.property({type: Date})
+  public updated?: Date;
+
+  @Component.property()
+  public id?: number;
+
+  @Component.property()
+  public isClassBased?: boolean;
+
+  @Component.property()
+  public outOfSyncWithOriginal?: boolean;
+
+  @Component.property()
+  public needsUpdate?: boolean;
+
+  @Component.property()
+  public hasImports?: number;
+
+  @Component.property()
+  public isClone?: boolean;
+
+  @Component.property()
+  public warnings?: boolean;
+
+  @Component.property()
+  public name?: string;
+
+  @Component.property()
+  public body?: string;
+
+  @Component.property()
+  public description?: string;
+
+  @Component.property()
+  public compiled?: string;
+
+  @Component.property({type: 'Component'})
+  public componentExport?: Component;
+
+  @Component.property({arrayType: 'Component'})
+  public componentExports?: Component[];
+
+  @Component.property({arrayType: 'Component'})
+  public componentImports?: Component[];
+
+  @Component.property({type: 'Component'})
+  public originalComponent?: Component;
+
+  @Component.property({arrayType: 'MerchiFile'})
+  public images?: MerchiFile[];
+
+  @Component.property({type: MerchiFile})
+  public featureImage?: MerchiFile | null;
+
+  @Component.property({arrayType: 'ComponentTag'})
+  public tags?: ComponentTag[];
+
+  @Component.property({type: 'User'})
+  public createdBy?: User | null;
+
+  @Component.property({type: 'User'})
+  public updatedBy?: User | null;
+
+  @Component.property({arrayType: 'ComponentVersion'})
+  public versions?: ComponentVersion[];
+
+  public toReact = (context: any) => {
+    const componentCode = 'with (this) { ' + this.compiled + ' return ' +
+      this.name + ';}';
+    const proxy = new Proxy(context, {});
+    const callable = new Function(componentCode);
+    return callable.call(proxy);
+  };
+
+}

package/src/entities/component_tag.test.ts

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

package/src/entities/component_tag.ts

@@ -0,0 +1,17 @@
+import { Component } from './component';
+import { Entity } from '../entity';
+
+export class ComponentTag extends Entity {
+  protected static resourceName = 'component_tags';
+  protected static singularName = 'componentTag';
+  protected static pluralName = 'componentTags';
+
+  @ComponentTag.property()
+  public id?: number;
+
+  @ComponentTag.property()
+  public name?: string;
+
+  @ComponentTag.property()
+  public component?: Component;
+}

package/src/entities/component_version.test.ts

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

package/src/entities/component_version.ts

@@ -0,0 +1,30 @@
+import { Component } from './component';
+import { Entity } from '../entity';
+
+export class ComponentVersion extends Entity {
+  protected static resourceName = 'component_versions';
+  protected static singularName = 'componentVersion';
+  protected static pluralName = 'componentVersions';
+
+  @ComponentVersion.property({type: Date})
+  public archived?: Date | null;
+
+  @ComponentVersion.property({type: Date})
+  public created?: Date | null;
+
+  @ComponentVersion.property()
+  public id?: number;
+
+  @ComponentVersion.property()
+  public body?: string;
+
+  @ComponentVersion.property()
+  public description?: string;
+
+  @ComponentVersion.property()
+  public isClassBased?: boolean;
+
+  @ComponentVersion.property({type: 'Component'})
+  public component?: Component;
+
+}

package/src/entities/country_tax.test.ts

@@ -0,0 +1,13 @@
+import { Merchi } from '../merchi';
+
+test('can make CountryTax', () => {
+  const merchi = new Merchi();
+  const countryTax = new merchi.CountryTax();
+  expect(countryTax).toBeTruthy();
+});
+
+test('getNoTax', () => {
+  const merchi = new Merchi();
+  const noTax = merchi.CountryTax.getNoTax();
+  expect(noTax.id).toBe(3);
+});

package/src/entities/country_tax.ts

@@ -0,0 +1,46 @@
+import { Company } from './company';
+import { Entity } from '../entity';
+import { Item } from './item';
+import { Job } from './job';
+import { Shipment } from './shipment';
+
+export class CountryTax extends Entity {
+  protected static resourceName = 'country_taxes';
+  protected static singularName = 'countryTax';
+  protected static pluralName = 'countryTaxes';
+
+  @CountryTax.property({type: Date})
+  public archived?: Date | null;
+
+  @CountryTax.property()
+  public id?: number;
+
+  @CountryTax.property({type: String})
+  public country?: string | null;
+
+  @CountryTax.property()
+  public taxName?: string;
+
+  @CountryTax.property({type: Number})
+  public taxPercent?: number | null;
+
+  @CountryTax.property({arrayType: 'Shipment'})
+  public shipments?: Shipment[];
+
+  @CountryTax.property({type: 'Company'})
+  public company?: Company;
+
+  @CountryTax.property({arrayType: 'Job'})
+  public jobs?: Job[];
+
+  @CountryTax.property({arrayType: 'Item'})
+  public items?: Item[];
+
+  public static getNoTax() {
+    const result = new this.merchi.CountryTax();
+    result.id = 3;  // 3 is a reserved id for 'no tax' by the backend
+    result.taxName = 'No tax';
+    result.taxPercent = 0;
+    return result;
+  }
+}

package/src/entities/discount.test.ts

@@ -0,0 +1,18 @@
+import { Merchi } from '../merchi';
+
+test('can make Discount', () => {
+  const merchi = new Merchi();
+  const discount = new merchi.Discount();
+  expect(discount).toBeTruthy();
+});
+
+test('discountedUnitCost', () => {
+  const merchi = new Merchi();
+  const discount = new merchi.Discount();
+  const product = new merchi.Product();
+  expect(() => discount.discountedUnitCost(product.unitPrice)).toThrow();
+  product.unitPrice = 200.8; 
+  expect(() => discount.discountedUnitCost(product.unitPrice)).toThrow();
+  discount.amount = 94.6;
+  expect(discount.discountedUnitCost(product.unitPrice)).toEqual('10.843');
+});

package/src/entities/discount.ts

@@ -0,0 +1,34 @@
+import { Entity } from '../entity';
+import { DiscountGroup } from './discount_group';
+
+export class Discount extends Entity {
+  protected static resourceName = 'discounts';
+  protected static singularName = 'discount';
+  protected static pluralName = 'discounts';
+
+  @Discount.property({type: Date})
+  public archived?: Date | null;
+
+  @Discount.property()
+  public id?: number;
+
+  @Discount.property()
+  public lowerLimit?: number;
+
+  @Discount.property()
+  public amount?: number;
+
+  @Discount.property({type: DiscountGroup})
+  public discountGroup?: DiscountGroup | null;
+
+  public discountedUnitCost = (unitPrice: number | undefined) => {
+    if (unitPrice === undefined) {
+      throw 'unitPrice is undefined, did you forget to embed it?';
+    }
+    if (this.amount === undefined) {
+      throw 'amount is undefined, did you forget to embed it?';
+    }
+    const discount = 100 - this.amount;
+    return (unitPrice * discount / 100).toFixed(3);
+  };
+}

package/src/entities/discount_group.test.ts

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

package/src/entities/discount_group.ts

@@ -0,0 +1,28 @@
+import { Entity } from '../entity';
+import { Product } from './product';
+import { Discount } from './discount';
+
+export class DiscountGroup extends Entity {
+  protected static resourceName = 'discount_groups';
+  protected static singularName = 'discountGroup';
+  protected static pluralName = 'discountGroups';
+
+  @DiscountGroup.property({type: Date})
+  public archived?: Date | null;
+
+  @DiscountGroup.property()
+  public id?: number;
+
+  @DiscountGroup.property()
+  public discountType?: number;
+
+  @DiscountGroup.property({arrayType: 'Discount'})
+  public discounts?: Discount[];
+
+  @DiscountGroup.property()
+  public name?: string;
+
+  @DiscountGroup.property({type: 'Product'})
+  public product?: Product | null;
+
+}

package/src/entities/domain.test.ts

@@ -0,0 +1,79 @@
+import { Merchi } from '../merchi';
+import { setup, mockFetch } from '../test_util';
+
+setup();
+
+test('can make domain', () => {
+  const merchi = new Merchi();
+  const domain = new merchi.Domain();
+  expect(domain).toBeTruthy();
+});
+
+test('can get and set id', () => {
+  const merchi = new Merchi();
+  const domain = new merchi.Domain();
+  domain.id = 2;
+  expect(domain.id).toBe(2);
+});
+
+test('can get and set domain', () => {
+  const merchi = new Merchi();
+  const domain = new merchi.Domain();
+  domain.domain = 'example.com';
+  expect(domain.domain).toBe('example.com');
+});
+
+test('can create domain on server', () => {
+  const merchi = new Merchi();
+  const domain = new merchi.Domain();
+  domain.domain = 'example.com';
+  const data = Array.from((domain.toFormData() as any).entries());
+  const fetch = mockFetch(true, {}, 201);
+  domain.create();
+  const sentToServer = Array.from(fetch.mock.calls[0][1]['body'].entries());
+  expect(sentToServer).toEqual(data);
+});
+
+test('can delete domain', () => {
+  const merchi = new Merchi();
+  const domain = new merchi.Domain();
+  domain.id = 1;
+  const fetch = mockFetch(true, {}, 204);
+  domain.delete();
+  expect(fetch.mock.calls[0][1].method).toBe('DELETE');
+});
+
+test('taxType', () => {
+  const merchi = new Merchi();
+  const domain = new merchi.Domain();
+  expect(domain.defaultTaxType).toThrow();
+  domain.company = new merchi.Company();
+  expect(domain.defaultTaxType).toThrow();
+  const tax = new merchi.CountryTax();
+  domain.company.defaultTaxType = tax;
+  expect(domain.defaultTaxType()).toBe(tax);
+  domain.company.defaultTaxType = null;
+  expect(domain.defaultTaxType()).toBe(null);
+});
+
+test('can get domain active theme', () => {
+  const merchi = new Merchi();
+  const domain = new merchi.Domain();
+
+  // throw error if active theme is undefined which seems to be an embed issue
+  expect(() => {domain.getActiveTheme();}).toThrow(Error);
+
+  const theme = new merchi.Theme();
+  domain.activeTheme = theme;
+  expect(domain.getActiveTheme()).toEqual(theme);
+});
+
+test('fail to delete non-existant domain', () => {
+  const merchi = new Merchi('YrDwzmh8&QGtAfg9quh(4QfSlE^RPXWl');
+  const domain = new merchi.Domain();
+  domain.id = -1;
+  const fetch = mockFetch(true, {statusCode: 404}, 404);
+  const invocation = domain.delete();
+  expect(fetch.mock.calls[0][1].method).toBe('DELETE');
+  return invocation.catch(e => expect(e.statusCode).toEqual(404));
+});

package/src/entities/domain.ts

@@ -0,0 +1,246 @@
+import { Cart } from './cart';
+import { Category } from './category';
+import { Company } from './company';
+import { DomainInvitation } from './domain_invitation';
+import { DomainTag } from './domain_tag';
+import { EnrolledDomain } from './enrolled_domain';
+import { Entity } from '../entity';
+import { MerchiFile } from './file';
+import { InternalTag } from './internal_tag';
+import { Invoice } from './invoice';
+import { Job } from './job';
+import { Menu } from './menu';
+import { User } from './user';
+import { Notification } from './notification';
+import { Product } from './product';
+import { Session } from './session';
+import { SupplyDomain } from './supply_domain';
+import { SeoDomainPage } from './seo_domain_page';
+import { Theme } from './theme';
+import { DomainType } from '../constants/domain_types';
+
+export class Domain extends Entity {
+  protected static resourceName = 'domains';
+  protected static singularName = 'domain';
+  protected static pluralName = 'domains';
+
+  @Domain.property({type: Date})
+  public archived?: Date | null;
+
+  @Domain.property()
+  public id?: number;
+
+  @Domain.property()
+  public domain?: string;
+
+  @Domain.property()
+  public country?: string;
+
+  @Domain.property()
+  public currency?: string;
+
+  @Domain.property()
+  public callToActions?: string;
+
+  @Domain.property()
+  public callToActionDetails?: any[];
+
+  @Domain.property()
+  public isMaster?: boolean;
+
+  @Domain.property()
+  public internalUseNotes?: string;
+
+  @Domain.property()
+  public internalUseAiContext?: string;
+
+  @Domain.property()
+  public aiContext?: string;
+
+  @Domain.property()
+  public domainType?: DomainType;
+
+  @Domain.property()
+  public subDomain?: string;
+
+  @Domain.property()
+  public emailDomain?: string;
+
+  @Domain.property()
+  public smsName?: string;
+
+  @Domain.property()
+  public showDomainPublicly?: boolean;
+
+  @Domain.property()
+  public publicAccessRestricted?: boolean;
+
+  @Domain.property()
+  public showDomainToAccessibleEntitiesOnly?: boolean;
+
+  @Domain.property()
+  public enableEmailNotifications?: boolean;
+
+  @Domain.property()
+  public enableSmsNotifications?: boolean;
+
+  @Domain.property()
+  public mailgunRecords?: any[];
+
+  @Domain.property()
+  public enableNotifications?: boolean;
+
+  @Domain.property({type: String})
+  public trackingCodeGoogleConversion?: string | null;
+
+  @Domain.property({type: String})
+  public trackingCodeGoogleGlobal?: string | null;
+
+  @Domain.property({type: String})
+  public apiSecret?: string | null;
+
+  @Domain.property({type: String})
+  public webflowApiKey?: string | null;
+
+  @Domain.property({type: String})
+  public shopifyShopUrl?: string | null;
+
+  @Domain.property()
+  public shopifyIsActive?: boolean;
+
+  @Domain.property({type: String})
+  public qrShopQrCode?: string | null;
+
+  @Domain.property({type: String})
+  public unltdAiApiOrganizationId?: string;
+
+  @Domain.property({type: String})
+  public unltdAiApiSecretKey?: string;
+
+  @Domain.property({type: String})
+  public socialBitchute?: string | null;
+
+  @Domain.property({type: String})
+  public socialDiscord?: string | null;
+
+  @Domain.property({type: String})
+  public socialFacebook?: string | null;
+
+  @Domain.property({type: String})
+  public socialGoogle?: string | null;
+
+  @Domain.property({type: String})
+  public socialInstagram?: string | null;
+
+  @Domain.property({type: String})
+  public socialLinkedin?: string | null;
+
+  @Domain.property({type: String})
+  public socialRumble?: string | null;
+
+  @Domain.property({type: String})
+  public socialTelegram?: string | null;
+
+  @Domain.property({type: String})
+  public socialTiktok?: string | null;
+
+  @Domain.property({type: String})
+  public socialX?: string | null;
+
+  @Domain.property({type: String})
+  public socialYoutube?: string | null;
+
+  @Domain.property()
+  public ownedBy?: Company;
+
+  @Domain.property()
+  public company?: Company;
+
+  @Domain.property({type: MerchiFile})
+  public logo?: MerchiFile | null;
+
+  @Domain.property({type: MerchiFile})
+  public favicon?: MerchiFile | null;
+
+  @Domain.property()
+  public activeTheme?: Theme;
+
+  @Domain.property({arrayType: 'InternalTag'})
+  public internalTags?: InternalTag[];
+
+  @Domain.property({arrayType: 'DomainTag'})
+  public tags?: DomainTag[];
+
+  @Domain.property({arrayType: 'Domain'})
+  public canSupply?: Domain[];
+
+  @Domain.property({arrayType: 'Domain'})
+  public suppliedBy?: Domain[];
+
+  @Domain.property({arrayType: 'User'})
+  public accessibleClients?: User[];
+
+  @Domain.property({arrayType: 'Company'})
+  public accessibleClientCompanies?: Company[];
+
+  @Domain.property({arrayType: 'Menu'})
+  public menus?: Menu[];
+
+  @Domain.property({arrayType: 'Session'})
+  public sessions?: Session[];
+
+  @Domain.property({arrayType: 'Category'})
+  public categories?: Category[];
+
+  @Domain.property({arrayType: 'Notification'})
+  public notifications?: Notification[];
+
+  @Domain.property({arrayType: 'Product'})
+  public products?: Product[];
+
+  @Domain.property({arrayType: 'SupplyDomain'})
+  public supplyProducts?: SupplyDomain[];
+
+  @Domain.property({arrayType: 'Job'})
+  public jobs?: Job[];
+
+  @Domain.property({arrayType: 'User'})
+  public jobsAssignees?: User[];
+
+  @Domain.property({arrayType: 'Cart'})
+  public carts?: Cart[];
+
+  @Domain.property({arrayType: 'EnrolledDomain'})
+  public enrollments?: EnrolledDomain[];
+
+  @Domain.property({arrayType: 'Invoice'})
+  public invoices?: Invoice[];
+
+  @Domain.property({arrayType: 'DomainInvitation'})
+  public domainInvitations?: DomainInvitation[];
+
+  @Domain.property({arrayType: 'SeoDomainPage'})
+  public seoDomainPages?: SeoDomainPage[];
+
+  @Domain.property({arrayType: 'Theme'})
+  public themes?: Theme[];
+
+  public defaultTaxType = () => {
+    if (this.company === undefined) {
+      throw new Error('company is undefined, did you forget to embed it?');
+    }
+    if (this.company.defaultTaxType === undefined) {
+      const err = 'company.defaultTaxType is undefined, did you forget to' +
+        ' embed it?';
+      throw new Error(err);
+    }
+    return this.company.defaultTaxType;
+  };
+
+  public getActiveTheme = (): Theme => {
+    if (this.activeTheme === undefined) {
+      throw new Error('activeTheme is undefined, did you forget to embed it?');
+    }
+    return this.activeTheme!;
+  };
+}

package/src/entities/domain_invitation.test.ts

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