@medusajs/medusa 1.3.4 → 1.3.5

package/dist/services/order.d.ts

@@ -1,8 +1,49 @@
-export default OrderService;
-declare const OrderService_base: any;
-declare class OrderService extends OrderService_base {
-    [x: string]: any;
-    static Events: {
+import { EntityManager } from "typeorm";
+import CustomerService from "./customer";
+import { OrderRepository } from "../repositories/order";
+import PaymentProviderService from "./payment-provider";
+import ShippingOptionService from "./shipping-option";
+import ShippingProfileService from "./shipping-profile";
+import DiscountService from "./discount";
+import FulfillmentProviderService from "./fulfillment-provider";
+import FulfillmentService from "./fulfillment";
+import LineItemService from "./line-item";
+import TotalsService from "./totals";
+import RegionService from "./region";
+import CartService from "./cart";
+import { AddressRepository } from "../repositories/address";
+import GiftCardService from "./gift-card";
+import DraftOrderService from "./draft-order";
+import InventoryService from "./inventory";
+import EventBusService from "./event-bus";
+import { TransactionBaseService } from "../interfaces";
+import { FindConfig, QuerySelector, Selector } from "../types/common";
+import { Address, LineItem, Order, Return, TrackingLink } from "../models";
+import { UpdateOrderInput } from "../types/orders";
+import { CreateShippingMethodDto } from "../types/shipping-options";
+import { FulFillmentItemType } from "../types/fulfillment";
+declare type InjectedDependencies = {
+    manager: EntityManager;
+    orderRepository: typeof OrderRepository;
+    customerService: CustomerService;
+    paymentProviderService: PaymentProviderService;
+    shippingOptionService: ShippingOptionService;
+    shippingProfileService: ShippingProfileService;
+    discountService: DiscountService;
+    fulfillmentProviderService: FulfillmentProviderService;
+    fulfillmentService: FulfillmentService;
+    lineItemService: LineItemService;
+    totalsService: TotalsService;
+    regionService: RegionService;
+    cartService: CartService;
+    addressRepository: typeof AddressRepository;
+    giftCardService: GiftCardService;
+    draftOrderService: DraftOrderService;
+    inventoryService: InventoryService;
+    eventBusService: EventBusService;
+};
+declare class OrderService extends TransactionBaseService<OrderService> {
+    static readonly Events: {
         GIFT_CARD_CREATED: string;
         PAYMENT_CAPTURED: string;
         PAYMENT_CAPTURE_FAILED: string;
@@ -20,249 +61,193 @@ declare class OrderService extends OrderService_base {
         CANCELED: string;
         COMPLETED: string;
     };
-    constructor({ manager, orderRepository, customerService, paymentProviderService, shippingOptionService, shippingProfileService, discountService, fulfillmentProviderService, fulfillmentService, lineItemService, totalsService, regionService, cartService, addressRepository, giftCardService, draftOrderService, inventoryService, eventBusService, }: {
-        manager: any;
-        orderRepository: any;
-        customerService: any;
-        paymentProviderService: any;
-        shippingOptionService: any;
-        shippingProfileService: any;
-        discountService: any;
-        fulfillmentProviderService: any;
-        fulfillmentService: any;
-        lineItemService: any;
-        totalsService: any;
-        regionService: any;
-        cartService: any;
-        addressRepository: any;
-        giftCardService: any;
-        draftOrderService: any;
-        inventoryService: any;
-        eventBusService: any;
-    });
-    /** @private @constant {EntityManager} */
-    private manager_;
-    /** @private @constant {OrderRepository} */
-    private orderRepository_;
-    /** @private @constant {CustomerService} */
-    private customerService_;
-    /** @private @constant {PaymentProviderService} */
-    private paymentProviderService_;
-    /** @private @constant {ShippingProvileService} */
-    private shippingProfileService_;
-    /** @private @constant {FulfillmentProviderService} */
-    private fulfillmentProviderService_;
-    /** @private @constant {LineItemService} */
-    private lineItemService_;
-    /** @private @constant {TotalsService} */
-    private totalsService_;
-    /** @private @constant {RegionService} */
-    private regionService_;
-    /** @private @constant {FulfillmentService} */
-    private fulfillmentService_;
-    /** @private @constant {DiscountService} */
-    private discountService_;
-    /** @private @constant {DiscountService} */
-    private giftCardService_;
-    /** @private @constant {EventBus} */
-    private eventBus_;
-    /** @private @constant {ShippingOptionService} */
-    private shippingOptionService_;
-    /** @private @constant {CartService} */
-    private cartService_;
-    /** @private @constant {AddressRepository} */
-    private addressRepository_;
-    /** @private @constant {DraftOrderService} */
-    private draftOrderService_;
-    /** @private @constant {InventoryService} */
-    private inventoryService_;
-    withTransaction(manager: any): OrderService;
-    /**
-     * Used to validate order ids. Throws an error if the cast fails
-     * @param {string} rawId - the raw order id to validate.
-     * @return {string} the validated id
-     */
-    validateId_(rawId: string): string;
+    protected manager_: EntityManager;
+    protected transactionManager_: EntityManager;
+    protected readonly orderRepository_: typeof OrderRepository;
+    protected readonly customerService_: CustomerService;
+    protected readonly paymentProviderService_: PaymentProviderService;
+    protected readonly shippingOptionService_: ShippingOptionService;
+    protected readonly shippingProfileService_: ShippingProfileService;
+    protected readonly discountService_: DiscountService;
+    protected readonly fulfillmentProviderService_: FulfillmentProviderService;
+    protected readonly fulfillmentService_: FulfillmentService;
+    protected readonly lineItemService_: LineItemService;
+    protected readonly totalsService_: TotalsService;
+    protected readonly regionService_: RegionService;
+    protected readonly cartService_: CartService;
+    protected readonly addressRepository_: typeof AddressRepository;
+    protected readonly giftCardService_: GiftCardService;
+    protected readonly draftOrderService_: DraftOrderService;
+    protected readonly inventoryService_: InventoryService;
+    protected readonly eventBus_: EventBusService;
+    constructor({ manager, orderRepository, customerService, paymentProviderService, shippingOptionService, shippingProfileService, discountService, fulfillmentProviderService, fulfillmentService, lineItemService, totalsService, regionService, cartService, addressRepository, giftCardService, draftOrderService, inventoryService, eventBusService, }: InjectedDependencies);
     /**
-     * @param {Object} selector - the query object for find
-     * @param {Object} config - the config to be used for find
-     * @return {Promise} the result of the find operation
+     * @param selector the query object for find
+     * @param config the config to be used for find
+     * @return the result of the find operation
      */
-    list(selector: any, config?: any): Promise<any>;
-    listAndCount(selector: any, config?: {
-        skip: number;
-        take: number;
-        order: {
-            created_at: string;
-        };
-    }): Promise<any[]>;
-    transformQueryForTotals_(config: any): {
-        select: any;
-        relations: any;
-        totalsToSelect: never[];
-    } | {
-        relations: any;
-        select: any[];
-        totalsToSelect: any;
+    list(selector: Selector<Order>, config?: FindConfig<Order>): Promise<Order[]>;
+    listAndCount(selector: QuerySelector<Order>, config?: FindConfig<Order>): Promise<[Order[], number]>;
+    protected transformQueryForTotals(config: FindConfig<Order>): {
+        relations: string[] | undefined;
+        select: FindConfig<Order>["select"];
+        totalsToSelect: FindConfig<Order>["select"];
     };
     /**
      * Gets an order by id.
-     * @param {string} orderId - id of order to retrieve
-     * @param {Object} config - config of order to retrieve
-     * @return {Promise<Order>} the order document
+     * @param orderId - id of order to retrieve
+     * @param config - config of order to retrieve
+     * @return the order document
      */
-    retrieve(orderId: string, config?: any): Promise<Order>;
+    retrieve(orderId: string, config?: FindConfig<Order>): Promise<Order>;
     /**
      * Gets an order by cart id.
-     * @param {string} cartId - cart id to find order
-     * @param {Object} config - the config to be used to find order
-     * @return {Promise<Order>} the order document
+     * @param cartId - cart id to find order
+     * @param config - the config to be used to find order
+     * @return the order document
      */
-    retrieveByCartId(cartId: string, config?: any): Promise<Order>;
+    retrieveByCartId(cartId: string, config?: FindConfig<Order>): Promise<Order>;
     /**
      * Gets an order by id.
-     * @param {string} externalId - id of order to retrieve
-     * @param {object} config - query config to get order by
-     * @return {Promise<Order>} the order document
+     * @param externalId - id of order to retrieve
+     * @param config - query config to get order by
+     * @return the order document
      */
-    retrieveByExternalId(externalId: string, config?: object): Promise<Order>;
+    retrieveByExternalId(externalId: string, config?: FindConfig<Order>): Promise<Order>;
     /**
      * Checks the existence of an order by cart id.
-     * @param {string} cartId - cart id to find order
-     * @return {Promise<Order>} the order document
+     * @param cartId - cart id to find order
+     * @return the order document
      */
-    existsByCartId(cartId: string): Promise<Order>;
+    existsByCartId(cartId: string): Promise<boolean>;
     /**
-     * @param {string} orderId - id of the order to complete
-     * @return {Promise} the result of the find operation
+     * @param orderId - id of the order to complete
+     * @return the result of the find operation
      */
-    completeOrder(orderId: string): Promise<any>;
+    completeOrder(orderId: string): Promise<Order>;
     /**
      * Creates an order from a cart
-     * @param {string} cartId - id of the cart to create an order from
-     * @return {Promise} resolves to the creation result.
+     * @param cartId - id of the cart to create an order from
+     * @return resolves to the creation result.
      */
-    createFromCart(cartId: string): Promise<any>;
+    createFromCart(cartId: string): Promise<Order | never>;
     /**
      * Adds a shipment to the order to indicate that an order has left the
      * warehouse. Will ask the fulfillment provider for any documents that may
      * have been created in regards to the shipment.
-     * @param {string} orderId - the id of the order that has been shipped
-     * @param {string} fulfillmentId - the fulfillment that has now been shipped
-     * @param {TrackingLink[] | undefined} trackingLinks - array of tracking numebers
+     * @param orderId - the id of the order that has been shipped
+     * @param fulfillmentId - the fulfillment that has now been shipped
+     * @param trackingLinks - array of tracking numebers
      *   associated with the shipment
-     * @param {Object} config - the config of the order that has been shipped
-     * @param {Dictionary<String, String>} metadata - optional metadata to add to
-     *   the fulfillment
-     * @return {order} the resulting order following the update.
-     */
-    createShipment(orderId: string, fulfillmentId: string, trackingLinks: TrackingLink[] | undefined, config?: any): order;
-    /**
-     * Creates an order
-     * @param {object} data - the data to create an order
-     * @return {Promise} resolves to the creation result.
+     * @param config - the config of the order that has been shipped
+     * @return the resulting order following the update.
      */
-    create(data: object): Promise<any>;
+    createShipment(orderId: string, fulfillmentId: string, trackingLinks?: TrackingLink[], config?: {
+        no_notification?: boolean;
+        metadata: Record<string, unknown>;
+    }): Promise<Order>;
     /**
      * Updates the order's billing address.
-     * @param {object} order - the order to update
-     * @param {object} address - the value to set the billing address to
-     * @return {Promise} the result of the update operation
+     * @param order - the order to update
+     * @param address - the value to set the billing address to
+     * @return the result of the update operation
      */
-    updateBillingAddress_(order: object, address: object): Promise<any>;
+    protected updateBillingAddress(order: Order, address: Address): Promise<void>;
     /**
      * Updates the order's shipping address.
-     * @param {object} order - the order to update
-     * @param {object} address - the value to set the shipping address to
-     * @return {Promise} the result of the update operation
+     * @param order - the order to update
+     * @param address - the value to set the shipping address to
+     * @return the result of the update operation
      */
-    updateShippingAddress_(order: object, address: object): Promise<any>;
-    addShippingMethod(orderId: any, optionId: any, data: any, config?: {}): Promise<any>;
+    protected updateShippingAddress(order: Order, address: Address): Promise<void>;
+    addShippingMethod(orderId: string, optionId: string, data?: Record<string, unknown>, config?: CreateShippingMethodDto): Promise<Order>;
     /**
      * Updates an order. Metadata updates should
      * use dedicated method, e.g. `setMetadata` etc. The function
      * will throw errors if metadata updates are attempted.
-     * @param {string} orderId - the id of the order. Must be a string that
+     * @param orderId - the id of the order. Must be a string that
      *   can be casted to an ObjectId
-     * @param {object} update - an object with the update values.
-     * @return {Promise} resolves to the update result.
+     * @param update - an object with the update values.
+     * @return resolves to the update result.
      */
-    update(orderId: string, update: object): Promise<any>;
+    update(orderId: string, update: UpdateOrderInput): Promise<Order>;
     /**
      * Cancels an order.
      * Throws if fulfillment process has been initiated.
      * Throws if payment process has been initiated.
-     * @param {string} orderId - id of order to cancel.
-     * @return {Promise} result of the update operation.
+     * @param orderId - id of order to cancel.
+     * @return result of the update operation.
      */
-    cancel(orderId: string): Promise<any>;
+    cancel(orderId: string): Promise<Order>;
     /**
      * Captures payment for an order.
-     * @param {string} orderId - id of order to capture payment for.
-     * @return {Promise} result of the update operation.
+     * @param orderId - id of order to capture payment for.
+     * @return result of the update operation.
      */
-    capturePayment(orderId: string): Promise<any>;
+    capturePayment(orderId: string): Promise<Order>;
     /**
      * Checks that a given quantity of a line item can be fulfilled. Fails if the
      * fulfillable quantity is lower than the requested fulfillment quantity.
      * Fulfillable quantity is calculated by subtracting the already fulfilled
      * quantity from the quantity that was originally purchased.
-     * @param {LineItem} item - the line item to check has sufficient fulfillable
+     * @param item - the line item to check has sufficient fulfillable
      *   quantity.
-     * @param {number} quantity - the quantity that is requested to be fulfilled.
-     * @return {LineItem} a line item that has the requested fulfillment quantity
+     * @param quantity - the quantity that is requested to be fulfilled.
+     * @return a line item that has the requested fulfillment quantity
      *   set.
      */
-    validateFulfillmentLineItem_(item: LineItem, quantity: number): LineItem;
+    protected validateFulfillmentLineItem(item: LineItem, quantity: number): LineItem | null;
     /**
      * Creates fulfillments for an order.
      * In a situation where the order has more than one shipping method,
      * we need to partition the order items, such that they can be sent
      * to their respective fulfillment provider.
-     * @param {string} orderId - id of order to cancel.
-     * @param {Object} itemsToFulfill - items to fulfil.
-     * @param {Object} config - the config to cancel.
-     * @return {Promise} result of the update operation.
+     * @param orderId - id of order to cancel.
+     * @param itemsToFulfill - items to fulfil.
+     * @param config - the config to cancel.
+     * @return result of the update operation.
      */
-    createFulfillment(orderId: string, itemsToFulfill: any, config?: any): Promise<any>;
+    createFulfillment(orderId: string, itemsToFulfill: FulFillmentItemType[], config?: {
+        no_notification?: boolean;
+        metadata?: Record<string, unknown>;
+    }): Promise<Order>;
     /**
      * Cancels a fulfillment (if related to an order)
-     * @param {string} fulfillmentId - the ID of the fulfillment to cancel
-     * @return {Promise} updated order
+     * @param fulfillmentId - the ID of the fulfillment to cancel
+     * @return updated order
      */
-    cancelFulfillment(fulfillmentId: string): Promise<any>;
+    cancelFulfillment(fulfillmentId: string): Promise<Order>;
     /**
      * Retrieves the order line items, given an array of items.
-     * @param {Order} order - the order to get line items from
-     * @param {{ item_id: string, quantity: number }} items - the items to get
-     * @param {function} transformer - a function to apply to each of the items
+     * @param order - the order to get line items from
+     * @param items - the items to get
+     * @param transformer - a function to apply to each of the items
      *    retrieved from the order, should return a line item. If the transformer
      *    returns an undefined value the line item will be filtered from the
      *    returned array.
-     * @return {Promise<Array<LineItem>>} the line items generated by the transformer.
+     * @return the line items generated by the transformer.
      */
-    getFulfillmentItems_(order: Order, items: {
-        item_id: string;
-        quantity: number;
-    }, transformer: Function): Promise<Array<LineItem>>;
+    protected getFulfillmentItems(order: Order, items: FulFillmentItemType[], transformer: (item: LineItem | undefined, quantity: number) => unknown): Promise<LineItem[]>;
     /**
      * Archives an order. It only alloved, if the order has been fulfilled
      * and payment has been captured.
-     * @param {string} orderId - the order to archive
-     * @return {Promise} the result of the update operation
+     * @param orderId - the order to archive
+     * @return the result of the update operation
      */
-    archive(orderId: string): Promise<any>;
+    archive(orderId: string): Promise<Order>;
     /**
      * Refunds a given amount back to the customer.
-     * @param {string} orderId - id of the order to refund.
-     * @param {float} refundAmount - the amount to refund.
-     * @param {string} reason - the reason to refund.
-     * @param {string | undefined} note - note for refund.
-     * @param {Object} config - the config for refund.
-     * @return {Promise} the result of the refund operation.
+     * @param orderId - id of the order to refund.
+     * @param refundAmount - the amount to refund.
+     * @param reason - the reason to refund.
+     * @param note - note for refund.
+     * @param config - the config for refund.
+     * @return the result of the refund operation.
      */
-    createRefund(orderId: string, refundAmount: float, reason: string, note: string | undefined, config?: any): Promise<any>;
-    decorateTotals_(order: any, totalsFields?: any[]): Promise<any>;
+    createRefund(orderId: string, refundAmount: number, reason: string, note?: string, config?: {
+        no_notification?: boolean;
+    }): Promise<Order>;
+    protected decorateTotals(order: Order, totalsFields?: string[]): Promise<Order>;
     /**
      * Handles receiving a return. This will create a
      * refund to the customer. If the returned items don't match the requested
@@ -271,17 +256,11 @@ declare class OrderService extends OrderService_base {
      * retuned items are not matching the requested items. Setting the
      * allowMismatch argument to true, will process the return, ignoring any
      * mismatches.
-     * @param {string} orderId - the order to return.
-     * @param {object} receivedReturn - the received return
-     * @param {float} customRefundAmount - the custom refund amount return
-     * @return {Promise} the result of the update operation
-     */
-    registerReturnReceived(orderId: string, receivedReturn: object, customRefundAmount: float): Promise<any>;
-    /**
-     * Dedicated method to delete metadata for an order.
-     * @param {string} orderId - the order to delete metadata from.
-     * @param {string} key - key for metadata field
-     * @return {Promise} resolves to the updated result.
+     * @param orderId - the order to return.
+     * @param receivedReturn - the received return
+     * @param customRefundAmount - the custom refund amount return
+     * @return the result of the update operation
      */
-    deleteMetadata(orderId: string, key: string): Promise<any>;
+    registerReturnReceived(orderId: string, receivedReturn: Return, customRefundAmount?: number): Promise<Order>;
 }
+export default OrderService;