@medusajs/medusa 1.3.2 → 1.3.3

package/dist/services/product.d.ts

@@ -1,129 +1,124 @@
-export default ProductService;
-declare const ProductService_base: any;
-/**
- * Provides layer to manipulate products.
- * @extends BaseService
- */
-declare class ProductService extends ProductService_base {
-    [x: string]: any;
-    static IndexName: string;
-    static Events: {
+import { EntityManager } from "typeorm";
+import { SearchService } from ".";
+import { TransactionBaseService } from "../interfaces";
+import { Product, ProductTag, ProductType, ProductVariant } from "../models";
+import { ImageRepository } from "../repositories/image";
+import { FindWithoutRelationsOptions, ProductRepository } from "../repositories/product";
+import { ProductOptionRepository } from "../repositories/product-option";
+import { ProductTagRepository } from "../repositories/product-tag";
+import { ProductTypeRepository } from "../repositories/product-type";
+import { ProductVariantRepository } from "../repositories/product-variant";
+import { Selector } from "../types/common";
+import { CreateProductInput, FilterableProductProps, FindProductConfig, ProductOptionInput, UpdateProductInput } from "../types/product";
+import EventBusService from "./event-bus";
+import ProductVariantService from "./product-variant";
+declare type InjectedDependencies = {
+    manager: EntityManager;
+    productOptionRepository: typeof ProductOptionRepository;
+    productRepository: typeof ProductRepository;
+    productVariantRepository: typeof ProductVariantRepository;
+    productTypeRepository: typeof ProductTypeRepository;
+    productTagRepository: typeof ProductTagRepository;
+    imageRepository: typeof ImageRepository;
+    productVariantService: ProductVariantService;
+    searchService: SearchService;
+    eventBusService: EventBusService;
+};
+declare class ProductService extends TransactionBaseService<ProductService> {
+    protected manager_: EntityManager;
+    protected transactionManager_: EntityManager | undefined;
+    protected readonly productOptionRepository_: typeof ProductOptionRepository;
+    protected readonly productRepository_: typeof ProductRepository;
+    protected readonly productVariantRepository_: typeof ProductVariantRepository;
+    protected readonly productTypeRepository_: typeof ProductTypeRepository;
+    protected readonly productTagRepository_: typeof ProductTagRepository;
+    protected readonly imageRepository_: typeof ImageRepository;
+    protected readonly productVariantService_: ProductVariantService;
+    protected readonly searchService_: SearchService;
+    protected readonly eventBus_: EventBusService;
+    static readonly IndexName = "products";
+    static readonly Events: {
         UPDATED: string;
         CREATED: string;
         DELETED: string;
     };
-    constructor({ manager, productRepository, productVariantRepository, productOptionRepository, eventBusService, productVariantService, productCollectionService, productTypeRepository, productTagRepository, imageRepository, searchService, cartRepository, priceSelectionStrategy, }: {
-        manager: any;
-        productRepository: any;
-        productVariantRepository: any;
-        productOptionRepository: any;
-        eventBusService: any;
-        productVariantService: any;
-        productCollectionService: any;
-        productTypeRepository: any;
-        productTagRepository: any;
-        imageRepository: any;
-        searchService: any;
-        cartRepository: any;
-        priceSelectionStrategy: any;
-    });
-    /** @private @const {EntityManager} */
-    private manager_;
-    /** @private @const {ProductOption} */
-    private productOptionRepository_;
-    /** @private @const {Product} */
-    private productRepository_;
-    /** @private @const {ProductVariant} */
-    private productVariantRepository_;
-    /** @private @const {EventBus} */
-    private eventBus_;
-    /** @private @const {ProductVariantService} */
-    private productVariantService_;
-    /** @private @const {ProductCollectionService} */
-    private productCollectionService_;
-    /** @private @const {ProductCollectionService} */
-    private productTypeRepository_;
-    /** @private @const {ProductCollectionService} */
-    private productTagRepository_;
-    /** @private @const {ImageRepository} */
-    private imageRepository_;
-    /** @private @const {SearchService} */
-    private searchService_;
-    /** @private @const {CartRepository} */
-    private cartRepository_;
-    /** @private @const {IPriceSelectionStrategy} */
-    private priceSelectionStrategy_;
-    withTransaction(transactionManager: any): ProductService;
+    constructor({ manager, productRepository, productVariantRepository, productOptionRepository, eventBusService, productVariantService, productTypeRepository, productTagRepository, imageRepository, searchService, }: InjectedDependencies);
     /**
      * Lists products based on the provided parameters.
-     * @param {object} selector - an object that defines rules to filter products
+     * @param selector - an object that defines rules to filter products
      *   by
-     * @param {object} config - object that defines the scope for what should be
+     * @param config - object that defines the scope for what should be
      *   returned
-     * @return {Promise<Product[]>} the result of the find operation
+     * @return the result of the find operation
      */
-    list(selector?: object, config?: object): Promise<Product[]>;
+    list(selector?: FilterableProductProps | Selector<Product>, config?: FindProductConfig): Promise<Product[]>;
     /**
      * Lists products based on the provided parameters and includes the count of
      * products that match the query.
-     * @param {object} selector - an object that defines rules to filter products
+     * @param selector - an object that defines rules to filter products
      *   by
-     * @param {object} config - object that defines the scope for what should be
+     * @param config - object that defines the scope for what should be
      *   returned
-     * @return {Promise<[Product[], number]>} an array containing the products as
+     * @return an array containing the products as
      *   the first element and the total count of products that matches the query
      *   as the second element.
      */
-    listAndCount(selector?: object, config?: object): Promise<[Product[], number]>;
+    listAndCount(selector: FilterableProductProps | Selector<Product>, config?: FindProductConfig): Promise<[Product[], number]>;
     /**
      * Return the total number of documents in database
      * @param {object} selector - the selector to choose products by
      * @return {Promise} the result of the count operation
      */
-    count(selector?: object): Promise<any>;
+    count(selector?: Selector<Product>): Promise<number>;
     /**
      * Gets a product by id.
      * Throws in case of DB Error and if product was not found.
-     * @param {string} productId - id of the product to get.
-     * @param {object} config - object that defines what should be included in the
+     * @param productId - id of the product to get.
+     * @param config - object that defines what should be included in the
      *   query response
-     * @return {Promise<Product>} the result of the find one operation.
+     * @return the result of the find one operation.
      */
-    retrieve(productId: string, config?: object): Promise<Product>;
+    retrieve(productId: string, config?: FindProductConfig): Promise<Product>;
     /**
      * Gets a product by handle.
      * Throws in case of DB Error and if product was not found.
-     * @param {string} productHandle - handle of the product to get.
-     * @param {object} config - details about what to get from the product
-     * @return {Promise<Product>} the result of the find one operation.
+     * @param productHandle - handle of the product to get.
+     * @param config - details about what to get from the product
+     * @return the result of the find one operation.
      */
-    retrieveByHandle(productHandle: string, config?: object): Promise<Product>;
+    retrieveByHandle(productHandle: string, config?: FindProductConfig): Promise<Product>;
     /**
      * Gets a product by external id.
      * Throws in case of DB Error and if product was not found.
-     * @param {string} externalId - handle of the product to get.
-     * @param {object} config - details about what to get from the product
-     * @return {Promise<Product>} the result of the find one operation.
+     * @param externalId - handle of the product to get.
+     * @param config - details about what to get from the product
+     * @return the result of the find one operation.
+     */
+    retrieveByExternalId(externalId: string, config?: FindProductConfig): Promise<Product>;
+    /**
+     * Gets a product by selector.
+     * Throws in case of DB Error and if product was not found.
+     * @param selector - selector object
+     * @param config - object that defines what should be included in the
+     *   query response
+     * @return the result of the find one operation.
      */
-    retrieveByExternalId(externalId: string, config?: object): Promise<Product>;
+    retrieve_(selector: Selector<Product>, config?: FindProductConfig): Promise<Product>;
     /**
      * Gets all variants belonging to a product.
-     * @param {string} productId - the id of the product to get variants from.
-     * @param {FindConfig<Product>} config - The config to select and configure relations etc...
-     * @return {Promise} an array of variants
+     * @param productId - the id of the product to get variants from.
+     * @param config - The config to select and configure relations etc...
+     * @return an array of variants
      */
-    retrieveVariants(productId: string, config?: FindConfig<Product>): Promise<any>;
-    listTypes(): Promise<any>;
-    listTagsByUsage(count?: number): Promise<any>;
-    upsertProductType_(type: any): Promise<any>;
-    upsertProductTags_(tags: any): Promise<any[]>;
+    retrieveVariants(productId: string, config?: FindProductConfig): Promise<ProductVariant[]>;
+    listTypes(): Promise<ProductType[]>;
+    listTagsByUsage(count?: number): Promise<ProductTag[]>;
     /**
      * Creates a product.
-     * @param {object} productObject - the product to create
-     * @return {Promise} resolves to the creation result.
+     * @param productObject - the product to create
+     * @return resolves to the creation result.
      */
-    create(productObject: object): Promise<any>;
-    upsertImages_(images: any): Promise<any[]>;
+    create(productObject: CreateProductInput): Promise<Product>;
     /**
      * Updates a product. Product variant updates should use dedicated methods,
      * e.g. `addVariant`, etc. The function will throw errors if metadata or
@@ -133,85 +128,52 @@ declare class ProductService extends ProductService_base {
      * @param {object} update - an object with the update values.
      * @return {Promise} resolves to the update result.
      */
-    update(productId: string, update: object): Promise<any>;
+    update(productId: string, update: UpdateProductInput): Promise<Product>;
     /**
      * Deletes a product from a given product id. The product's associated
      * variants will also be deleted.
-     * @param {string} productId - the id of the product to delete. Must be
+     * @param productId - the id of the product to delete. Must be
      *   castable as an ObjectId
-     * @return {Promise} empty promise
+     * @return empty promise
      */
-    delete(productId: string): Promise<any>;
+    delete(productId: string): Promise<void>;
     /**
      * Adds an option to a product. Options can, for example, be "Size", "Color",
      * etc. Will update all the products variants with a dummy value for the newly
      * created option. The same option cannot be added more than once.
-     * @param {string} productId - the product to apply the new option to
-     * @param {string} optionTitle - the display title of the option, e.g. "Size"
-     * @return {Promise} the result of the model update operation
-     */
-    addOption(productId: string, optionTitle: string): Promise<any>;
-    reorderVariants(productId: any, variantOrder: any): Promise<any>;
-    /**
-     * Changes the order of a product's options. Will throw if the length of
-     * optionOrder and the length of the product's options are different. Will
-     * throw optionOrder contains an id not associated with the product.
-     * @param {string} productId - the product whose options we are reordering
-     * @param {string[]} optionOrder - the ids of the product's options in the
-     *    new order
-     * @return {Promise} the result of the update operation
+     * @param productId - the product to apply the new option to
+     * @param optionTitle - the display title of the option, e.g. "Size"
+     * @return the result of the model update operation
      */
-    reorderOptions(productId: string, optionOrder: string[]): Promise<any>;
+    addOption(productId: string, optionTitle: string): Promise<Product>;
+    reorderVariants(productId: string, variantOrder: string[]): Promise<Product>;
     /**
      * Updates a product's option. Throws if the call tries to update an option
      * not associated with the product. Throws if the updated title already exists.
-     * @param {string} productId - the product whose option we are updating
-     * @param {string} optionId - the id of the option we are updating
-     * @param {object} data - the data to update the option with
-     * @return {Promise} the updated product
+     * @param productId - the product whose option we are updating
+     * @param optionId - the id of the option we are updating
+     * @param data - the data to update the option with
+     * @return the updated product
      */
-    updateOption(productId: string, optionId: string, data: object): Promise<any>;
+    updateOption(productId: string, optionId: string, data: ProductOptionInput): Promise<Product>;
     /**
      * Delete an option from a product.
-     * @param {string} productId - the product to delete an option from
-     * @param {string} optionId - the option to delete
-     * @return {Promise} the updated product
+     * @param productId - the product to delete an option from
+     * @param optionId - the option to delete
+     * @return the updated product
      */
-    deleteOption(productId: string, optionId: string): Promise<any>;
-    /**
-     * Decorates a product with product variants.
-     * @param {string} productId - the productId to decorate.
-     * @param {string[]} fields - the fields to include.
-     * @param {string[]} expandFields - fields to expand.
-     * @param {object} config - retrieve config for price calculation.
-     * @return {Product} return the decorated product.
-     */
-    decorate(productId: string, fields?: string[], expandFields?: string[], config?: object): Product;
+    deleteOption(productId: string, optionId: string): Promise<Product | void>;
     /**
      * Creates a query object to be used for list queries.
-     * @param {object} selector - the selector to create the query from
-     * @param {object} config - the config to use for the query
-     * @return {object} an object containing the query, relations and free-text
+     * @param selector - the selector to create the query from
+     * @param config - the config to use for the query
+     * @return an object containing the query, relations and free-text
      *   search param.
      */
-    prepareListQuery_(selector: object, config: object): object;
-    /**
-     * Creates a QueryBuilder that can fetch products based on free text.
-     * @param {ProductRepository} productRepo - an instance of a ProductRepositry
-     * @param {FindOptions<Product>} query - the query to get products by
-     * @param {string} q - the text to perform free text search from
-     * @return {QueryBuilder<Product>} a query builder that can fetch products
-     */
-    getFreeTextQueryBuilder_(productRepo: ProductRepository, query: FindOptions<Product>, q: string): QueryBuilder<Product>;
-    /**
-     * Set additional prices on a list of products.
-     * @param {Product[] | Product} products list of products on which to set additional prices
-     * @param {string} currency_code currency code to fetch prices for
-     * @param {string} region_id region to fetch prices for
-     * @param {string} cart_id string of cart to use as a basis for getting currency and region
-     * @param {string} customer_id id of potentially logged in customer, used to get prices valid for their customer groups
-     * @param {boolean} include_discount_prices indication wether or not to include sales prices in result
-     * @return {Promise<Product[]>} A list of products with variants decorated with "additional_prices"
-     */
-    setAdditionalPrices(products: Product[] | Product, currency_code: string, region_id: string, cart_id: string, customer_id: string, include_discount_prices?: boolean): Promise<Product[]>;
+    protected prepareListQuery_(selector: FilterableProductProps | Selector<Product>, config: FindProductConfig): {
+        q: string;
+        relations: (keyof Product)[];
+        query: FindWithoutRelationsOptions;
+    };
 }
+export default ProductService;