518925158

Build Type

push

github

Committed by GitHub

Commit Message

Increase Flexibility (#60)

Run Details

457 of 697 branches covered (65.57%)

Branch coverage included in aggregate %.

19 of 27 new or added lines in 4 files covered. (70.37%)

96 existing lines in 12 files now uncovered.

1850 of 2176 relevant lines covered (85.02%)

23.47 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.93

/src/internal/orders/order-app.ts

import { AcknowledgeOrders, AppType, Connect, ErrorCode, GetSalesOrdersByDate, OrderAppDefinition, SalesOrders as SalesOrdersPOJO, ShipmentCreated } from "../../public";
import { AppPOJO, ConnectionApp, error, FormPOJO, hideAndFreeze, Joi, SystemErrorCode, Transaction, TransactionPOJO, validate, _internal, OAuthConfigPOJO } from "../common";
import { AcknowledgedSalesOrder } from "./acknowledged-sales-order";
import { SalesOrderNotification, SalesOrderNotificationPOJO } from "./sales-order-notification";
import { SalesOrderTimeRange, SalesOrderTimeRangePOJO } from "./sales-order-time-range";
import { SalesOrders } from "./sales-orders";
import { SalesOrderShipment, SalesOrderShipmentPOJO } from "./shipments/sales-order-shipment";

const _private = Symbol("private fields");


export interface OrderAppPOJO extends OrderAppDefinition, AppPOJO {
  connectionForm: FormPOJO;
  settingsForm?: FormPOJO;
  connect?: Connect;
  oauthConfig?: OAuthConfigPOJO;
  getSalesOrdersByDate?: GetSalesOrdersByDate;
  shipmentCreated?: ShipmentCreated;
  acknowledgeOrders?: AcknowledgeOrders;
}


export class OrderApp extends ConnectionApp {
  public static readonly [_internal] = {
    label: "ShipEngine Connect order app",
    schema: ConnectionApp[_internal].schema.keys({
      getSalesOrdersByDate: Joi.function(),
      shipmentCreated: Joi.function(),
      acknowledgeOrders: Joi.function(),
      sendMail: Joi.boolean(),
      canConfigureTimeZone: Joi.boolean()
    }),
  };

  private readonly [_private]: {
    readonly getSalesOrdersByDate?: GetSalesOrdersByDate;
    readonly shipmentCreated?: ShipmentCreated;
    readonly acknowledgeOrders?: AcknowledgeOrders;
  };

  public readonly type: AppType;
  public readonly sendMail: boolean;
  public readonly canConfigureTimeZone: boolean;


  public constructor(pojo: OrderAppPOJO) {

    super(pojo);

    this.type = AppType.Order;
    this.sendMail = pojo.sendMail || false;
    this.canConfigureTimeZone = pojo.canConfigureTimeZone || false;

    this[_private] = {
      getSalesOrdersByDate:
        pojo.getSalesOrdersByDate ? pojo.getSalesOrdersByDate : (this.getSalesOrdersByDate = undefined),
      shipmentCreated: pojo.shipmentCreated ? pojo.shipmentCreated : (this.shipmentCreated = undefined),
      acknowledgeOrders: pojo.acknowledgeOrders ? pojo.acknowledgeOrders : (this.acknowledgeOrders = undefined),
    };

    // Make this object immutable
    hideAndFreeze(this);

    this[_internal].references.add(this);
    this[_internal].references.finishedLoading();
  }

  public async getSalesOrdersByDate?(
    transaction: TransactionPOJO, range: SalesOrderTimeRangePOJO): Promise<SalesOrders> {

    let _transaction, _range;
    const { getSalesOrdersByDate } = this[_private];

    try {
      _transaction = new Transaction(transaction);
      _range = new SalesOrderTimeRange(range);
    }
    catch (originalError: unknown) {
      throw error(SystemErrorCode.InvalidInput, "Invalid input to the getSalesOrdersByDate method.", { originalError });
    }

    try {
      const salesOrders = await getSalesOrdersByDate!(_transaction, _range);

      // Make sure to preserve the paging data returned from the app
      let salesOrderArrayPOJO: SalesOrdersPOJO = salesOrders;
      if (salesOrders && salesOrders.paging) {
        salesOrderArrayPOJO = Object.assign(salesOrders, { paging: salesOrders.paging });
      }

      return new SalesOrders(salesOrderArrayPOJO);
    }
    catch (originalError: unknown) {
      const transactionID = _transaction.id;
      throw error(ErrorCode.AppError, "Error in the getSalesOrdersByDate method.", { originalError, transactionID });
    }
  }

  public async shipmentCreated?(transaction: TransactionPOJO, shipment: SalesOrderShipmentPOJO): Promise<void> {
    let _transaction, _shipment;
    const { shipmentCreated } = this[_private];

    try {
      _transaction = new Transaction(transaction);
      _shipment = new SalesOrderShipment(shipment);
    }
    catch (originalError: unknown) {
      throw error(SystemErrorCode.InvalidInput, "Invalid input to the shipmentCreated method.", { originalError });
    }

    try {
      await shipmentCreated!(_transaction, _shipment);
    }
    catch (originalError: unknown) {
      const transactionID = _transaction.id;
      throw error(ErrorCode.AppError, "Error in the shipmentCreated method.", { originalError, transactionID });
    }
  }

  public async acknowledgeOrders?(transaction: TransactionPOJO, notifications: SalesOrderNotificationPOJO[]): Promise<AcknowledgedSalesOrder[]> {
    let _transaction;
    const _notifications: SalesOrderNotification[] = [];
    const { acknowledgeOrders } = this[_private];

    try {
      _transaction = new Transaction(transaction);

      if (notifications.length === 0) {
        throw error(SystemErrorCode.InvalidInput, "Sales Order Notifications are required");
      }

      for (const notification of notifications) {
        _notifications.push(new SalesOrderNotification(notification));
      }
    }
    catch (originalError: unknown) {
      throw error(SystemErrorCode.InvalidInput, "Invalid input to the acknowledgeOrders method.", { originalError });
    }

    try {
      const acknowledgedOrdersPOJO = await acknowledgeOrders!(_transaction, _notifications);
      const acknowledgedOrders: AcknowledgedSalesOrder[] = [];

      for (const acknowledgedOrderPOJO of acknowledgedOrdersPOJO) {
        acknowledgedOrders.push(new AcknowledgedSalesOrder(acknowledgedOrderPOJO));
      }

      return acknowledgedOrders;
    }
    catch (originalError: unknown) {
      const transactionID = _transaction.id;
      throw error(ErrorCode.AppError, "Error in the acknowledgeOrders method.", { originalError, transactionID });
    }
  }
}

1	import { AcknowledgeOrders, AppType, Connect, ErrorCode, GetSalesOrdersByDate, OrderAppDefinition, SalesOrders as SalesOrdersPOJO, ShipmentCreated } from "../../public";	1✔
2	import { AppPOJO, ConnectionApp, error, FormPOJO, hideAndFreeze, Joi, SystemErrorCode, Transaction, TransactionPOJO, validate, _internal, OAuthConfigPOJO } from "../common";	1✔
3	import { AcknowledgedSalesOrder } from "./acknowledged-sales-order";	1✔
4	import { SalesOrderNotification, SalesOrderNotificationPOJO } from "./sales-order-notification";	1✔
5	import { SalesOrderTimeRange, SalesOrderTimeRangePOJO } from "./sales-order-time-range";	1✔
6	import { SalesOrders } from "./sales-orders";	1✔
7	import { SalesOrderShipment, SalesOrderShipmentPOJO } from "./shipments/sales-order-shipment";	1✔
8
9	const _private = Symbol("private fields");	1✔
10
11
12	export interface OrderAppPOJO extends OrderAppDefinition, AppPOJO {
13	connectionForm: FormPOJO;
14	settingsForm?: FormPOJO;
15	connect?: Connect;
16	oauthConfig?: OAuthConfigPOJO;
17	getSalesOrdersByDate?: GetSalesOrdersByDate;
18	shipmentCreated?: ShipmentCreated;
19	acknowledgeOrders?: AcknowledgeOrders;
20	}
21
22
23	export class OrderApp extends ConnectionApp {	1✔
24	public static readonly [_internal] = {	1✔
25	label: "ShipEngine Connect order app",
26	schema: ConnectionApp[_internal].schema.keys({
27	getSalesOrdersByDate: Joi.function(),
28	shipmentCreated: Joi.function(),
29	acknowledgeOrders: Joi.function(),
30	sendMail: Joi.boolean(),
31	canConfigureTimeZone: Joi.boolean()
32	}),
33	};
34
35	private readonly [_private]: {
36	readonly getSalesOrdersByDate?: GetSalesOrdersByDate;
37	readonly shipmentCreated?: ShipmentCreated;
38	readonly acknowledgeOrders?: AcknowledgeOrders;
39	};
40
41	public readonly type: AppType;
42	public readonly sendMail: boolean;
43	public readonly canConfigureTimeZone: boolean;
44
45
46	public constructor(pojo: OrderAppPOJO) {
47
48	super(pojo);	8✔
49
50	this.type = AppType.Order;	8✔
51	this.sendMail = pojo.sendMail \|\| false;	8✔
52	this.canConfigureTimeZone = pojo.canConfigureTimeZone \|\| false;	8✔
53
54	this[_private] = {	8✔
55	getSalesOrdersByDate:
56	pojo.getSalesOrdersByDate ? pojo.getSalesOrdersByDate : (this.getSalesOrdersByDate = undefined),	8✔
57	shipmentCreated: pojo.shipmentCreated ? pojo.shipmentCreated : (this.shipmentCreated = undefined),	8✔
58	acknowledgeOrders: pojo.acknowledgeOrders ? pojo.acknowledgeOrders : (this.acknowledgeOrders = undefined),	8✔
59	};
60
61	// Make this object immutable
62	hideAndFreeze(this);	8✔
63
64	this[_internal].references.add(this);	8✔
65	this[_internal].references.finishedLoading();	8✔
66	}
67
68	public async getSalesOrdersByDate?(
69	transaction: TransactionPOJO, range: SalesOrderTimeRangePOJO): Promise<SalesOrders> {
70
71	let _transaction, _range;
72	const { getSalesOrdersByDate } = this[_private];	3✔
73
74	try {	3✔
75	_transaction = new Transaction(transaction);	3✔
76	_range = new SalesOrderTimeRange(range);	3✔
77	}
78	catch (originalError: unknown) {
UNCOV 79	throw error(SystemErrorCode.InvalidInput, "Invalid input to the getSalesOrdersByDate method.", { originalError });	×
80	}
81
82	try {	3✔
83	const salesOrders = await getSalesOrdersByDate!(_transaction, _range);	3✔
84
85	// Make sure to preserve the paging data returned from the app
86	let salesOrderArrayPOJO: SalesOrdersPOJO = salesOrders;	3✔
87	if (salesOrders && salesOrders.paging) {	3✔
88	salesOrderArrayPOJO = Object.assign(salesOrders, { paging: salesOrders.paging });	2✔
89	}
90
91	return new SalesOrders(salesOrderArrayPOJO);	3✔
92	}
93	catch (originalError: unknown) {
UNCOV 94	const transactionID = _transaction.id;	×
UNCOV 95	throw error(ErrorCode.AppError, "Error in the getSalesOrdersByDate method.", { originalError, transactionID });	×
96	}
97	}
98
99	public async shipmentCreated?(transaction: TransactionPOJO, shipment: SalesOrderShipmentPOJO): Promise<void> {
100	let _transaction, _shipment;
101	const { shipmentCreated } = this[_private];	1✔
102
103	try {	1✔
104	_transaction = new Transaction(transaction);	1✔
105	_shipment = new SalesOrderShipment(shipment);	1✔
106	}
107	catch (originalError: unknown) {
UNCOV 108	throw error(SystemErrorCode.InvalidInput, "Invalid input to the shipmentCreated method.", { originalError });	×
109	}
110
111	try {	1✔
112	await shipmentCreated!(_transaction, _shipment);	1✔
113	}
114	catch (originalError: unknown) {
115	const transactionID = _transaction.id;	×
116	throw error(ErrorCode.AppError, "Error in the shipmentCreated method.", { originalError, transactionID });	×
117	}
118	}
119
120	public async acknowledgeOrders?(transaction: TransactionPOJO, notifications: SalesOrderNotificationPOJO[]): Promise<AcknowledgedSalesOrder[]> {
121	let _transaction;
122	const _notifications: SalesOrderNotification[] = [];	1✔
123	const { acknowledgeOrders } = this[_private];	1✔
124
125	try {	1✔
126	_transaction = new Transaction(transaction);	1✔
127
128	if (notifications.length === 0) {	1!
UNCOV 129	throw error(SystemErrorCode.InvalidInput, "Sales Order Notifications are required");	×
130	}
131
132	for (const notification of notifications) {	1✔
133	_notifications.push(new SalesOrderNotification(notification));	1✔
134	}
135	}
136	catch (originalError: unknown) {
UNCOV 137	throw error(SystemErrorCode.InvalidInput, "Invalid input to the acknowledgeOrders method.", { originalError });	×
138	}
139
140	try {	1✔
141	const acknowledgedOrdersPOJO = await acknowledgeOrders!(_transaction, _notifications);	1✔
142	const acknowledgedOrders: AcknowledgedSalesOrder[] = [];	1✔
143
144	for (const acknowledgedOrderPOJO of acknowledgedOrdersPOJO) {	1✔
145	acknowledgedOrders.push(new AcknowledgedSalesOrder(acknowledgedOrderPOJO));	1✔
146	}
147
148	return acknowledgedOrders;	1✔
149	}
150	catch (originalError: unknown) {
151	const transactionID = _transaction.id;	×
152	throw error(ErrorCode.AppError, "Error in the acknowledgeOrders method.", { originalError, transactionID });	×
153	}
154	}
155	}

ShipEngine / connect-sdk / 518925158

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous