merchi_sdk_ts 0.0.1

package/src/entities/cart.test.ts

@@ -0,0 +1,50 @@
+import { Merchi } from '../merchi';
+import { setup, mockFetch } from '../test_util';
+
+setup();
+
+test('can make Cart', () => {
+  const merchi = new Merchi();
+  const cart = new merchi.Cart();
+  expect(cart).toBeTruthy();
+});
+
+test('cart token supported by merchi', () => {
+  const merchi = new Merchi(undefined, undefined, undefined, 'c');
+  const correct = [['skip_rights', 'y'], ['cart_token', 'c']];
+  const fetch = mockFetch(true, {'invoice': {'id': 1}}, 200);
+  const invocation = merchi.Invoice.get(1);
+  expect(fetch.mock.calls[0][1]['query']).toEqual(correct);
+  return invocation;
+});
+
+test('requiresShipment', () => {
+  const merchi = new Merchi();
+  const cart = new merchi.Cart();
+  expect(cart.requiresShipment).toThrow();
+  cart.cartItems = [];
+  expect(cart.requiresShipment()).toBe(false);
+  cart.cartItems = [new merchi.CartItem()];
+  cart.cartItems[0].product = new merchi.Product();
+  cart.cartItems[0].product.needsShipping = true;
+  expect(cart.requiresShipment()).toBe(true);
+  cart.cartItems[0].product.needsShipping = false;
+  expect(cart.requiresShipment()).toBe(false);
+});
+
+test('pass cookie tokens to query string', () => {
+  const cookie = 'cart_token=c;';
+  Object.defineProperty(document, 'cookie', {
+    get: jest.fn().mockImplementation(() => { return cookie; }),
+    set: jest.fn().mockImplementation(() => {}),
+  });
+  const correct = [
+    ['skip_rights', 'y'],
+    ['cart_token', 'c'],
+  ];
+  const fetch = mockFetch(true, {'cart': {'id': 1}}, 200);
+  const merchi = new Merchi();
+  const invocation = merchi.Cart.get(1);
+  expect(fetch.mock.calls[0][1]['query']).toEqual(correct);
+  return invocation;
+});

package/src/entities/cart.ts

@@ -0,0 +1,89 @@
+import { Address } from './address';
+import { CartItem } from './cart_item';
+import { CartShipmentGroup } from './cart_shipment_group';
+import { Company } from './company';
+import { Domain } from './domain';
+import { Entity } from '../entity';
+import { Invoice } from './invoice';
+import { User } from './user';
+
+export class Cart extends Entity {
+  protected static resourceName = 'carts';
+  protected static singularName = 'cart';
+  protected static pluralName = 'carts';
+
+  @Cart.property({type: Date})
+  public archived?: Date | null;
+
+  @Cart.property()
+  public id?: number;
+
+  @Cart.property()
+  public creationDate?: Date;
+
+  @Cart.property({type: Date})
+  public ip?: string | null;
+
+  @Cart.property({type: String})
+  public token?: string | null;
+
+  @Cart.property({type: String})
+  public receiverNotes?: string | null;
+
+  @Cart.property()
+  public currency?: string;
+
+  @Cart.property()
+  public cartItemsSubtotalCost?: number;
+
+  @Cart.property()
+  public cartItemsTaxAmount?: number;
+
+  @Cart.property()
+  public cartItemsTotalCost?: number;
+
+  @Cart.property()
+  public shipmentTotalCost?: number;
+
+  @Cart.property()
+  public subtotalCost?: number;
+
+  @Cart.property()
+  public taxAmount?: number;
+
+  @Cart.property()
+  public totalCost?: number;
+
+  @Cart.property({type: 'User'})
+  public client?: User | null;
+
+  @Cart.property({type: Company})
+  public clientCompany?: Company | null;
+
+  @Cart.property()
+  public domain?: Domain;
+
+  @Cart.property({type: 'Invoice'})
+  public invoice?: Invoice | null;
+
+  @Cart.property({type: Address})
+  public receiverAddress?: Address | null;
+
+  @Cart.property({arrayType: 'CartItem'})
+  public cartItems?: CartItem[];
+
+  @Cart.property({arrayType: 'CartShipmentGroup'})
+  public shipmentGroups?: CartShipmentGroup[];
+
+  public requiresShipment = () => {
+    if (this.cartItems === undefined) {
+      throw 'cartItems is undefined, did you forget to embed it?';
+    }
+    for (const cartItem of this.cartItems) {
+      if (cartItem.requiresShipment()) {
+        return true;
+      }
+    }
+    return false;
+  };
+}

package/src/entities/cart_item.test.ts

@@ -0,0 +1,33 @@
+import { Merchi } from '../merchi';
+import { setup, mockFetch } from '../test_util';
+
+setup();
+
+test('can make CartItem', () => {
+  const merchi = new Merchi();
+  const cartItem = new merchi.CartItem();
+  expect(cartItem).toBeTruthy();
+});
+
+test('requiresShipment', () => {
+  const merchi = new Merchi();
+  const cartItem = new merchi.CartItem();
+  expect(cartItem.requiresShipment).toThrow(); 
+  cartItem.product = new merchi.Product();
+  expect(cartItem.requiresShipment).toThrow(); 
+  cartItem.product.needsShipping = false;
+  expect(cartItem.requiresShipment()).toBe(false);
+  cartItem.product.needsShipping = true;
+  expect(cartItem.requiresShipment()).toBe(true);
+});
+
+test('Get quote update job cost', () => {
+  const merchi = new Merchi();
+  const cartItem = new merchi.CartItem().fromJson(
+    {'quantity': 10, 'totalCost': 0});
+  mockFetch(true, {'quantity': 10, 'totalCost': 100}, 200);
+  cartItem.calculate().then(item => {
+    expect(item.quantity).toEqual(10);
+    expect(item.totalCost).toEqual(100);
+  });
+});

package/src/entities/cart_item.ts

@@ -0,0 +1,77 @@
+import { Cart } from './cart';
+import { CountryTax } from './country_tax';
+import { Entity } from '../entity';
+import { Product } from './product';
+import { RequestOptions } from '../request';
+import { Variation } from './variation';
+import { VariationsGroup } from './variations_group';
+
+export class CartItem extends Entity {
+  protected static resourceName = 'cart_items';
+  protected static singularName = 'cartItem';
+  protected static pluralName = 'cartItems';
+
+  @CartItem.property({type: Date})
+  public archived?: Date | null;
+
+  @CartItem.property()
+  public id?: number;
+
+  @CartItem.property()
+  public quantity?: number;
+
+  @CartItem.property({type: String})
+  public notes?: string | null;
+
+  @CartItem.property()
+  public creationDate?: Date;
+
+  @CartItem.property()
+  public currency?: string;
+
+  @CartItem.property()
+  public subtotalCost?: number;
+
+  @CartItem.property()
+  public taxAmount?: number;
+
+  @CartItem.property()
+  public totalCost?: number;
+
+  @CartItem.property()
+  public product?: Product;
+
+  @CartItem.property()
+  public cart?: Cart;
+
+  @CartItem.property({embeddedByDefault: false})
+  public taxType?: CountryTax;
+
+  @CartItem.property({arrayType: 'VariationsGroup'})
+  public variationsGroups?: VariationsGroup[];
+
+  @CartItem.property({arrayType: 'Variation'})
+  public variations?: Variation[];
+
+  public requiresShipment = () => {
+    if (this.product === undefined) {
+      throw 'product is undefined, did you forget to embed it?';
+    }
+    if (this.product.needsShipping === undefined) {
+      throw 'needsShipping is undefined, did you forget to embed it?';
+    }
+    return this.product.needsShipping;
+  };
+
+  public calculate = () => {
+    const resource = '/cart-item-cost-estimate/';
+    const data = this.toFormData({excludeOld: false});
+    const fetchOptions: RequestOptions = {method: 'POST', body: data};
+    fetchOptions.query = [];
+    fetchOptions.query.push(['skip_rights', 'y']);
+
+    return this.merchi.authenticatedFetch(resource, fetchOptions).
+      then((data: any) => { this.fromJson(data, {makeDirty: true});
+        return this;});
+  };
+}

package/src/entities/cart_shipment_group.ts

@@ -0,0 +1,21 @@
+import { CartItem } from './cart_item';
+import { CartShipmentQuote } from './cart_shipment_quote';
+import { Entity } from '../entity';
+
+export class CartShipmentGroup extends Entity {
+  protected static resourceName = 'cart_shipment_groups';
+  protected static singularName = 'cartShipmentGroup';
+  protected static pluralName = 'cartShipmentGroups';
+
+  @CartShipmentGroup.property()
+  public id?: number;
+
+  @CartShipmentGroup.property({arrayType: 'CartItem'})
+  public cartItems?: CartItem[];
+
+  @CartShipmentGroup.property({arrayType: 'CartShipmentQuote'})
+  public quotes?: CartShipmentQuote[];
+
+  @CartShipmentGroup.property({type: 'CartShipmentQuote'})
+  public selectedQuote?: CartShipmentQuote;
+}

package/src/entities/cart_shipment_quote.ts

@@ -0,0 +1,33 @@
+import { ShipmentMethod } from './shipment_method';
+import { Entity } from '../entity';
+import { ShipmentService } from '../constants/shipment_services';
+
+export class CartShipmentQuote extends Entity {
+  protected static resourceName = 'cart_shipment_quotes';
+  protected static singularName = 'cartShipmentQuote';
+  protected static pluralName = 'cartShipmentQuotes';
+
+  @CartShipmentQuote.property()
+  public id?: number;
+
+  @CartShipmentQuote.property()
+  public name?: string;
+
+  @CartShipmentQuote.property()
+  public subtotalCost?: number;
+
+  @CartShipmentQuote.property()
+  public taxAmount?: number;
+
+  @CartShipmentQuote.property()
+  public totalCost?: number;
+
+  @CartShipmentQuote.property({type: ShipmentService})
+  public shipmentService?: ShipmentService | null;
+
+  @CartShipmentQuote.property()
+  public shipmentServiceQuote?: string;
+
+  @CartShipmentQuote.property({type: 'ShipmentMethod'})
+  public shipmentMethod?: ShipmentMethod;
+}

package/src/entities/category.test.ts

@@ -0,0 +1,57 @@
+import { Merchi } from '../merchi';
+
+test('can make category', () => {
+  const merchi = new Merchi();
+  const category = new merchi.Category();
+  expect(category).toBeTruthy();
+});
+
+test('can get and set id', () => {
+  const merchi = new Merchi();
+  const category = new merchi.Category();
+  category.id = 2;
+  expect(category.id).toBe(2);
+});
+
+test('can get and set name', () => {
+  const merchi = new Merchi();
+  const category = new merchi.Category();
+  category.name = 'example';
+  expect(category.name).toBe('example');
+});
+
+test('can get and set product', () => {
+  const merchi = new Merchi();
+  const c1 = new merchi.Category();
+  const c2 = new merchi.Category();
+  const p1 = new merchi.Product();
+  const p2 = new merchi.Product();
+  const cs = [c1, c2];
+  const ps = [p1, p2];
+  c1.products = ps;
+  expect(c1.products).toBe(ps);
+  expect(c2.products).toBe(undefined);
+  expect(p1.categories).toBe(undefined);
+  p1.categories = cs;
+  expect(p1.categories).toBe(cs);
+  p1.categories = undefined;
+  expect(p1.categories).toBe(undefined);
+});
+
+test('independence of entities', () => {
+  const merchi = new Merchi();
+  const c1 = new merchi.Category();
+  const c2 = new merchi.Category();
+  const p = new merchi.Product();
+  const name = 'vMjssEhwpHtMT';
+  const products = [p];
+  c1.name = name;
+  c1.products = products;
+  expect(c1.name).toBe(name);
+  expect(c1.products).toBe(products);
+  expect(c1.isDirty).toBe(true);
+  // c2 is a different object, and therefore totally unnaffected
+  expect(c2.name).toBe(undefined);
+  expect(c2.products).toBe(undefined);
+  expect(c2.isDirty).toBe(false);
+});

package/src/entities/category.ts

@@ -0,0 +1,37 @@
+import { Domain } from './domain';
+import { Entity } from '../entity';
+import { Product } from './product';
+import { User } from './user';
+
+export class Category extends Entity {
+  protected static resourceName = 'categories';
+  protected static singularName = 'category';
+  protected static pluralName = 'categories';
+
+  @Category.property({type: Date})
+  public archived?: Date | null;
+
+  @Category.property()
+  public id?: number;
+
+  @Category.property()
+  public name?: string;
+
+  @Category.property()
+  public showDashboard?: boolean;
+
+  @Category.property()
+  public showPublic?: boolean;
+
+  @Category.property()
+  public showPublicSupplierResell?: boolean;
+
+  @Category.property()
+  public domain?: Domain;
+
+  @Category.property({arrayType: 'Product'})
+  public products?: Product[];
+
+  @Category.property({arrayType: 'User'})
+  public users?: User[];
+}

package/src/entities/company.test.ts

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

package/src/entities/company.ts

@@ -0,0 +1,275 @@
+import { Address } from './address';
+import { AutomaticPaymentRelationship } from './automatic_payment_relationship';
+import { Bank } from './bank';
+import { Cart } from './cart';
+import { CompanyInvitation } from './company_invitation';
+import { CountryTax } from './country_tax';
+import { Domain } from './domain';
+import { EmailAddress } from './email_address';
+import { Entity } from '../entity';
+import { MerchiFile } from './file';
+import { InternalTag } from './internal_tag';
+import { Invoice } from './invoice';
+import { Job } from './job';
+import { PhoneNumber } from './phone_number';
+import { Product } from './product';
+import { Shipment } from './shipment';
+import { User } from './user';
+import { UserCompany } from './user_company';
+import { SubscriptionPlan } from './subscription_plan';
+import { PaymentDevice } from './payment_device';
+
+export class Company extends Entity {
+  protected static resourceName = 'companies';
+  protected static singularName = 'company';
+  protected static pluralName = 'companies';
+
+  @Company.property({type: Date})
+  public archived?: Date | null;
+
+  @Company.property()
+  public id?: number;
+
+  @Company.property()
+  public name?: string;
+
+  @Company.property()
+  public callToActions?: string;
+
+  @Company.property()
+  public callToActionDetails?: any[];
+
+  @Company.property({type: String})
+  public website?: string | null;
+
+  @Company.property()
+  public ownershipUnconfirmed?: boolean;
+
+  @Company.property({type: String})
+  public taxNumber?: string | null;
+
+  @Company.property({type: String})
+  public taxNumberType?: string | null;
+
+  @Company.property({type: String})
+  public paypalAccount?: string | null;
+
+  @Company.property({type: String})
+  public paypalPassword?: string | null;
+
+  @Company.property({type: String})
+  public paypalSignature?: string | null;
+
+  @Company.property()
+  public isPaypalValid?: boolean;
+
+  @Company.property({embeddedByDefault: false})
+  public isStripeAccountEnabled?: boolean;
+
+  @Company.property()
+  public stripeAccountId?: string;
+
+  @Company.property({type: String})
+  public stripeCustomerId?: string;
+
+  @Company.property()
+  public sendleActive?: boolean;
+
+  @Company.property({type: String})
+  public sendleApiKey?: string;
+
+  @Company.property({type: String})
+  public sendleId?: string;
+
+  @Company.property({type: String})
+  public unltdAiApiOrganizationId?: string;
+
+  @Company.property({type: String})
+  public unltdAiApiSecretKey?: string;
+
+  @Company.property({type: String})
+  public internalUseNotes?: string;
+
+  @Company.property({type: String})
+  public internalUseAiContext?: string;
+
+  @Company.property({type: String})
+  public aiContext?: string;
+
+  @Company.property()
+  public isNew?: boolean;
+
+  @Company.property()
+  public subscriptionOutstanding?: boolean;
+
+  @Company.property({type: Date})
+  public trialEndDate?: Date | null;
+
+  @Company.property({type: Date})
+  public trialEndDateUpdated?: Date | null;
+
+  @Company.property({type: 'User'})
+  public trialEndDateSetBy?: User;
+
+  @Company.property()
+  public isBlocked?: boolean;
+
+  @Company.property()
+  public isTesting?: boolean;
+
+  @Company.property({type: String})
+  public squareAccessToken?: string | null;
+
+  @Company.property({type: String})
+  public squareRefreshToken?: string | null;
+
+  @Company.property({type: Date})
+  public squareExpiresAt?: Date | null;
+
+  @Company.property()
+  public squareIsValid?: boolean;
+
+  @Company.property({type: String})
+  public squareMerchantId?: string | null;
+
+  @Company.property({type: String})
+  public squareWebLocationId?: string | null;
+
+  @Company.property({type: String})
+  public stripePublishableTestKey?: string | null;
+
+  @Company.property({type: String})
+  public stripeApiTestKey?: string | null;
+
+  @Company.property({type: String})
+  public stripePublishableKey?: string | null;
+
+  @Company.property({type: String})
+  public stripeApiKey?: string | null;
+
+  @Company.property()
+  public stripeConnectDisabled?: boolean;
+
+  @Company.property()
+  public isPayingCompany?: boolean;
+
+  @Company.property()
+  public isStripeValid?: boolean;
+
+  @Company.property()
+  public acceptSquare?: boolean;
+
+  @Company.property()
+  public acceptStripe?: boolean;
+
+  @Company.property()
+  public acceptPaypal?: boolean;
+
+  @Company.property()
+  public acceptUtrust?: boolean;
+
+  @Company.property({type: String})
+  public utrustApiKey?: string | null;
+
+  @Company.property({type: String})
+  public utrustWebhookKey?: string | null;
+
+  @Company.property()
+  public isUtrustValid?: boolean;
+
+  @Company.property()
+  public acceptBankTransfer?: boolean;
+
+  @Company.property()
+  public acceptPhonePayment?: boolean;
+
+  @Company.property()
+  public defaultCurrency?: string;
+
+  @Company.property()
+  public country?: string;
+
+  @Company.property({arrayType: 'InternalTag'})
+  public internalTags?: InternalTag[];
+
+  @Company.property({type: MerchiFile})
+  public logo?: MerchiFile | null;
+
+  @Company.property({type: 'CountryTax'})
+  public defaultTaxType?: CountryTax | null;
+
+  @Company.property({arrayType: 'AutomaticPaymentRelationship'})
+  public automaticPaymentRelationships?: AutomaticPaymentRelationship[];
+
+  @Company.property({arrayType: 'CountryTax'})
+  public taxTypes?: CountryTax[];
+
+  @Company.property({arrayType: 'PaymentDevice'})
+  public paymentDevices?: PaymentDevice[];
+
+  @Company.property({type: SubscriptionPlan})
+  public subscriptionPlan?: SubscriptionPlan | null;
+
+  @Company.property({arrayType: 'EmailAddress'})
+  public _emailAddresses?: EmailAddress[];
+
+  @Company.property({arrayType: 'PhoneNumber'})
+  public _paymentPhoneNumbers?: PhoneNumber[];
+
+  @Company.property({arrayType: 'PhoneNumber'})
+  public _phoneNumbers?: PhoneNumber[];
+
+  @Company.property({arrayType: 'Address'})
+  public _addresses?: Address[];
+
+  @Company.property({arrayType: 'UserCompany'})
+  public _users?: UserCompany[];
+
+  @Company.property({arrayType: 'Shipment'})
+  public shipmentsAsSender?: Shipment[];
+
+  @Company.property({arrayType: 'Shipment'})
+  public shipmentsAsReceiver?: Shipment[];
+
+  @Company.property({arrayType: 'Product'})
+  public savedProducts?: Product[];
+
+  @Company.property({arrayType: 'Bank'})
+  public banks?: Bank[];
+
+  @Company.property({arrayType: 'UserCompany'})
+  public userCompanies?: UserCompany[];
+
+  @Company.property({arrayType: 'CompanyInvitation'})
+  public companyInvitations?: CompanyInvitation[];
+
+  @Company.property({arrayType: 'Job'})
+  public appliedJobs?: Job[];
+
+  @Company.property({arrayType: 'Cart'})
+  public carts?: Cart[];
+
+  @Company.property({arrayType: 'Domain'})
+  public domains?: Domain[];
+
+  @Company.property({arrayType: 'Domain'})
+  public accessibleDomainsAsClientCompany?: Domain[];
+
+  @Company.property({arrayType: 'EmailAddress'})
+  public emailAddresses?: EmailAddress[];
+
+  @Company.property({arrayType: 'PhoneNumber'})
+  public phoneNumbers?: PhoneNumber[];
+
+  @Company.property({arrayType: 'PhoneNumber'})
+  public paymentPhoneNumbers?: PhoneNumber[];
+
+  @Company.property({arrayType: 'Invoice'})
+  public invoicesHas?: Invoice[];
+
+  @Company.property({arrayType: 'Invoice'})
+  public subscriptionInvoices?: Invoice[];
+
+  @Company.property({arrayType: 'Address'})
+  public addresses?: Address[];
+}

package/src/entities/company_invitation.test.ts

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