@medusajs/medusa 1.3.2 → 1.3.3

package/dist/services/file.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="multer" />
+/// <reference types="node" />
+import { EntityManager } from "typeorm";
+import { AbstractFileService, FileServiceGetUploadStreamResult, FileServiceUploadResult, GetUploadedFileType, UploadStreamDescriptorType } from "../interfaces";
+declare class DefaultFileService extends AbstractFileService<any> {
+    upload(fileData: Express.Multer.File): Promise<FileServiceUploadResult>;
+    delete(fileData: Record<string, any>): Promise<void>;
+    getUploadStreamDescriptor(fileData: UploadStreamDescriptorType): Promise<FileServiceGetUploadStreamResult>;
+    getDownloadStream(fileData: GetUploadedFileType): Promise<NodeJS.ReadableStream>;
+    getPresignedDownloadUrl(fileData: GetUploadedFileType): Promise<string>;
+    protected manager_: EntityManager;
+    protected transactionManager_: EntityManager | undefined;
+}
+export default DefaultFileService;

package/dist/services/file.js

@@ -0,0 +1,43 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var medusa_core_utils_1 = require("medusa-core-utils");
+var interfaces_1 = require("../interfaces");
+var DefaultFileService = /** @class */ (function (_super) {
+    __extends(DefaultFileService, _super);
+    function DefaultFileService() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DefaultFileService.prototype.upload = function (fileData) {
+        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.UNEXPECTED_STATE, "Please add a file service plugin in order to manipulate files in Medusa");
+    };
+    DefaultFileService.prototype.delete = function (fileData) {
+        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.UNEXPECTED_STATE, "Please add a file service plugin in order to manipulate files in Medusa");
+    };
+    DefaultFileService.prototype.getUploadStreamDescriptor = function (fileData) {
+        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.UNEXPECTED_STATE, "Please add a file service plugin in order to manipulate files in Medusa");
+    };
+    DefaultFileService.prototype.getDownloadStream = function (fileData) {
+        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.UNEXPECTED_STATE, "Please add a file service plugin in order to manipulate files in Medusa");
+    };
+    DefaultFileService.prototype.getPresignedDownloadUrl = function (fileData) {
+        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.UNEXPECTED_STATE, "Please add a file service plugin in order to manipulate files in Medusa");
+    };
+    return DefaultFileService;
+}(interfaces_1.AbstractFileService));
+exports.default = DefaultFileService;
+//# sourceMappingURL=file.js.map

package/dist/services/file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.js","sourceRoot":"","sources":["../../src/services/file.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,uDAA+C;AAE/C,4CAMsB;AAEtB;IAAiC,sCAAwB;IAAzD;;IAqCA,CAAC;IApCC,mCAAM,GAAN,UAAO,QAA6B;QAClC,MAAM,IAAI,+BAAW,CACnB,+BAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,yEAAyE,CAC1E,CAAA;IACH,CAAC;IACD,mCAAM,GAAN,UAAO,QAA6B;QAClC,MAAM,IAAI,+BAAW,CACnB,+BAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,yEAAyE,CAC1E,CAAA;IACH,CAAC;IACD,sDAAyB,GAAzB,UACE,QAAoC;QAEpC,MAAM,IAAI,+BAAW,CACnB,+BAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,yEAAyE,CAC1E,CAAA;IACH,CAAC;IACD,8CAAiB,GAAjB,UACE,QAA6B;QAE7B,MAAM,IAAI,+BAAW,CACnB,+BAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,yEAAyE,CAC1E,CAAA;IACH,CAAC;IACD,oDAAuB,GAAvB,UAAwB,QAA6B;QACnD,MAAM,IAAI,+BAAW,CACnB,+BAAW,CAAC,KAAK,CAAC,gBAAgB,EAClC,yEAAyE,CAC1E,CAAA;IACH,CAAC;IAGH,yBAAC;AAAD,CAAC,AArCD,CAAiC,gCAAmB,GAqCnD;AAED,kBAAe,kBAAkB,CAAA"}

package/dist/services/fulfillment.d.ts

@@ -1,101 +1,100 @@
-export default FulfillmentService;
-declare const FulfillmentService_base: any;
+import { EntityManager } from "typeorm";
+import { ShippingProfileService } from ".";
+import { TransactionBaseService } from "../interfaces";
+import { Fulfillment, LineItem, ShippingMethod } from "../models";
+import { FulfillmentRepository } from "../repositories/fulfillment";
+import { LineItemRepository } from "../repositories/line-item";
+import { TrackingLinkRepository } from "../repositories/tracking-link";
+import { FindConfig } from "../types/common";
+import { CreateFulfillmentOrder, CreateShipmentConfig, FulfillmentItemPartition, FulFillmentItemType } from "../types/fulfillment";
+import FulfillmentProviderService from "./fulfillment-provider";
+import LineItemService from "./line-item";
+import TotalsService from "./totals";
+declare type InjectedDependencies = {
+    manager: EntityManager;
+    totalsService: TotalsService;
+    shippingProfileService: ShippingProfileService;
+    lineItemService: LineItemService;
+    fulfillmentProviderService: FulfillmentProviderService;
+    fulfillmentRepository: typeof FulfillmentRepository;
+    trackingLinkRepository: typeof TrackingLinkRepository;
+    lineItemRepository: typeof LineItemRepository;
+};
 /**
  * Handles Fulfillments
- * @extends BaseService
  */
-declare class FulfillmentService extends FulfillmentService_base {
-    [x: string]: any;
-    constructor({ manager, totalsService, fulfillmentRepository, trackingLinkRepository, shippingProfileService, lineItemService, fulfillmentProviderService, }: {
-        manager: any;
-        totalsService: any;
-        fulfillmentRepository: any;
-        trackingLinkRepository: any;
-        shippingProfileService: any;
-        lineItemService: any;
-        fulfillmentProviderService: any;
-    });
-    /** @private @const {EntityManager} */
-    private manager_;
-    /** @private @const {TotalsService} */
-    private totalsService_;
-    /** @private @const {FulfillmentRepository} */
-    private fulfillmentRepository_;
-    /** @private @const {TrackingLinkRepository} */
-    private trackingLinkRepository_;
-    /** @private @const {ShippingProfileService} */
-    private shippingProfileService_;
-    /** @private @const {LineItemService} */
-    private lineItemService_;
-    /** @private @const {FulfillmentProviderService} */
-    private fulfillmentProviderService_;
-    withTransaction(transactionManager: any): FulfillmentService;
-    partitionItems_(shippingMethods: any, items: any): {
-        shipping_method: any;
-    }[];
+declare class FulfillmentService extends TransactionBaseService<FulfillmentService> {
+    protected manager_: EntityManager;
+    protected transactionManager_: EntityManager | undefined;
+    protected readonly totalsService_: TotalsService;
+    protected readonly lineItemService_: LineItemService;
+    protected readonly shippingProfileService_: ShippingProfileService;
+    protected readonly fulfillmentProviderService_: FulfillmentProviderService;
+    protected readonly fulfillmentRepository_: typeof FulfillmentRepository;
+    protected readonly trackingLinkRepository_: typeof TrackingLinkRepository;
+    protected readonly lineItemRepository_: typeof LineItemRepository;
+    constructor({ manager, totalsService, fulfillmentRepository, trackingLinkRepository, shippingProfileService, lineItemService, fulfillmentProviderService, lineItemRepository, }: InjectedDependencies);
+    partitionItems_(shippingMethods: ShippingMethod[], items: LineItem[]): FulfillmentItemPartition[];
     /**
      * 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>>;
+    getFulfillmentItems_(order: CreateFulfillmentOrder, items: FulFillmentItemType[]): Promise<(LineItem | null)[]>;
     /**
      * 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;
+    validateFulfillmentLineItem_(item: LineItem | undefined, quantity: number): LineItem | null;
     /**
      * Retrieves a fulfillment by its id.
-     * @param {string} id - the id of the fulfillment to retrieve
-     * @param {object} config - optional values to include with fulfillmentRepository query
-     * @return {Fulfillment} the fulfillment
+     * @param id - the id of the fulfillment to retrieve
+     * @param config - optional values to include with fulfillmentRepository query
+     * @return the fulfillment
      */
-    retrieve(id: string, config?: object): Fulfillment;
+    retrieve(id: string, config?: FindConfig<Fulfillment>): Promise<Fulfillment>;
     /**
      * Creates an order fulfillment
      * If items needs to be fulfilled by different provider, we make
      * sure to partition those items, and create fulfillment for
      * those partitions.
-     * @param {Order} order - order to create fulfillment for
-     * @param {{ item_id: string, quantity: number}[]} itemsToFulfill - the items in the order to fulfill
-     * @param {object} custom - potential custom values to add
-     * @return {Fulfillment[]} the created fulfillments
+     * @param order - order to create fulfillment for
+     * @param itemsToFulfill - the items in the order to fulfill
+     * @param custom - potential custom values to add
+     * @return the created fulfillments
      */
-    createFulfillment(order: Order, itemsToFulfill: {
-        item_id: string;
-        quantity: number;
-    }[], custom?: object): Fulfillment[];
+    createFulfillment(order: CreateFulfillmentOrder, itemsToFulfill: FulFillmentItemType[], custom?: Partial<Fulfillment>): Promise<Fulfillment[]>;
     /**
      * Cancels a fulfillment with the fulfillment provider. Will decrement the
      * fulfillment_quantity on the line items associated with the fulfillment.
      * Throws if the fulfillment has already been shipped.
-     * @param {Fulfillment|string} fulfillmentOrId - the fulfillment object or id.
-     * @return {Promise} the result of the save operation
+     * @param fulfillmentOrId - the fulfillment object or id.
+     * @return the result of the save operation
      *
      */
-    cancelFulfillment(fulfillmentOrId: Fulfillment | string): Promise<any>;
+    cancelFulfillment(fulfillmentOrId: Fulfillment | string): Promise<Fulfillment>;
     /**
      * Creates a shipment by marking a fulfillment as shipped. Adds
      * tracking links and potentially more metadata.
-     * @param {Order} fulfillmentId - the fulfillment to ship
-     * @param {TrackingLink[]} trackingLinks - tracking links for the shipment
-     * @param {object} config - potential configuration settings, such as no_notification and metadata
-     * @return {Fulfillment} the shipped fulfillment
+     * @param fulfillmentId - the fulfillment to ship
+     * @param trackingLinks - tracking links for the shipment
+     * @param config - potential configuration settings, such as no_notification and metadata
+     * @return  the shipped fulfillment
      */
-    createShipment(fulfillmentId: Order, trackingLinks: TrackingLink[], config?: object): Fulfillment;
+    createShipment(fulfillmentId: string, trackingLinks: {
+        tracking_number: string;
+    }[], config?: CreateShipmentConfig): Promise<Fulfillment>;
 }
+export default FulfillmentService;