@medusajs/product 0.0.1

package/dist/repositories/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductCategoryRepository = exports.ProductCollectionRepository = exports.ProductVariantRepository = exports.ProductTagRepository = exports.ProductRepository = void 0;
+var product_1 = require("./product");
+Object.defineProperty(exports, "ProductRepository", { enumerable: true, get: function () { return product_1.ProductRepository; } });
+var product_tag_1 = require("./product-tag");
+Object.defineProperty(exports, "ProductTagRepository", { enumerable: true, get: function () { return product_tag_1.ProductTagRepository; } });
+var product_variant_1 = require("./product-variant");
+Object.defineProperty(exports, "ProductVariantRepository", { enumerable: true, get: function () { return product_variant_1.ProductVariantRepository; } });
+var product_collection_1 = require("./product-collection");
+Object.defineProperty(exports, "ProductCollectionRepository", { enumerable: true, get: function () { return product_collection_1.ProductCollectionRepository; } });
+var product_category_1 = require("./product-category");
+Object.defineProperty(exports, "ProductCategoryRepository", { enumerable: true, get: function () { return product_category_1.ProductCategoryRepository; } });

package/dist/repositories/product-category.d.ts

@@ -0,0 +1,16 @@
+import { SqlEntityManager } from "@mikro-orm/postgresql";
+import { ProductCategory } from "../models";
+import { DAL, ProductCategoryTransformOptions } from "@medusajs/types";
+export declare class ProductCategoryRepository implements DAL.RepositoryService<ProductCategory> {
+    protected readonly manager_: SqlEntityManager;
+    constructor({ manager }: {
+        manager: any;
+    });
+    find(findOptions?: DAL.FindOptions<ProductCategory>, transformOptions?: ProductCategoryTransformOptions, context?: {
+        transaction?: any;
+    }): Promise<ProductCategory[]>;
+    buildProductCategoriesWithDescendants(productCategories: ProductCategory[], findOptions?: DAL.FindOptions<ProductCategory>): Promise<ProductCategory[]>;
+    findAndCount(findOptions?: DAL.FindOptions<ProductCategory>, transformOptions?: ProductCategoryTransformOptions, context?: {
+        transaction?: any;
+    }): Promise<[ProductCategory[], number]>;
+}

package/dist/repositories/product-category.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductCategoryRepository = void 0;
+const core_1 = require("@mikro-orm/core");
+const utils_1 = require("../utils");
+const _models_1 = require("../models");
+const groupBy_1 = __importDefault(require("lodash/groupBy"));
+class ProductCategoryRepository {
+    constructor({ manager }) {
+        this.manager_ = manager.fork();
+    }
+    async find(findOptions = { where: {} }, transformOptions = {}, context = {}) {
+        var _a, _b;
+        // Spread is used to copy the options in case of manipulation to prevent side effects
+        const findOptions_ = { ...findOptions };
+        const { includeDescendantsTree } = transformOptions;
+        findOptions_.options ?? (findOptions_.options = {});
+        const fields = ((_a = findOptions_.options).fields ?? (_a.fields = []));
+        (_b = findOptions_.options).limit ?? (_b.limit = 15);
+        // Ref: Building descendants
+        // mpath and parent_category_id needs to be added to the query for the tree building to be done accurately
+        if (includeDescendantsTree) {
+            fields.indexOf("mpath") === -1 && fields.push("mpath");
+            fields.indexOf("parent_category_id") === -1 &&
+                fields.push("parent_category_id");
+        }
+        if (findOptions_.options.populate) {
+            (0, utils_1.deduplicateIfNecessary)(findOptions_.options.populate);
+        }
+        if (context.transaction) {
+            Object.assign(findOptions_.options, { ctx: context.transaction });
+        }
+        Object.assign(findOptions_.options, {
+            strategy: core_1.LoadStrategy.SELECT_IN,
+        });
+        const productCategories = await this.manager_.find(_models_1.ProductCategory, findOptions_.where, findOptions_.options);
+        if (!includeDescendantsTree) {
+            return productCategories;
+        }
+        return this.buildProductCategoriesWithDescendants(productCategories, findOptions_);
+    }
+    async buildProductCategoriesWithDescendants(productCategories, findOptions = { where: {} }) {
+        for (let productCategory of productCategories) {
+            const whereOptions = {
+                ...findOptions.where,
+                mpath: {
+                    $like: `${productCategory.mpath}%`,
+                },
+            };
+            delete whereOptions.parent_category_id;
+            const descendantsForCategory = await this.manager_.find(_models_1.ProductCategory, whereOptions, findOptions.options);
+            const descendantsByParentId = (0, groupBy_1.default)(descendantsForCategory, (pc) => pc.parent_category_id);
+            const addChildrenToCategory = (category, children) => {
+                category.category_children = (children || []).map((categoryChild) => {
+                    const moreChildren = descendantsByParentId[categoryChild.id] || [];
+                    return addChildrenToCategory(categoryChild, moreChildren);
+                });
+                return category;
+            };
+            let children = descendantsByParentId[productCategory.id] || [];
+            productCategory = addChildrenToCategory(productCategory, children);
+        }
+        return productCategories;
+    }
+    async findAndCount(findOptions = { where: {} }, transformOptions = {}, context = {}) {
+        var _a;
+        // Spread is used to copy the options in case of manipulation to prevent side effects
+        const findOptions_ = { ...findOptions };
+        findOptions_.options ?? (findOptions_.options = {});
+        (_a = findOptions_.options).limit ?? (_a.limit = 15);
+        if (findOptions_.options.populate) {
+            (0, utils_1.deduplicateIfNecessary)(findOptions_.options.populate);
+        }
+        if (context.transaction) {
+            Object.assign(findOptions_.options, { ctx: context.transaction });
+        }
+        Object.assign(findOptions_.options, {
+            strategy: core_1.LoadStrategy.SELECT_IN,
+        });
+        return await this.manager_.findAndCount(_models_1.ProductCategory, findOptions_.where, findOptions_.options);
+    }
+}
+exports.ProductCategoryRepository = ProductCategoryRepository;

package/dist/repositories/product-collection.d.ts

@@ -0,0 +1,15 @@
+import { SqlEntityManager } from "@mikro-orm/postgresql";
+import { ProductCollection } from "../models";
+import { DAL } from "@medusajs/types";
+export declare class ProductCollectionRepository implements DAL.RepositoryService {
+    protected readonly manager_: SqlEntityManager;
+    constructor({ manager }: {
+        manager: any;
+    });
+    find<T = ProductCollection>(findOptions?: DAL.FindOptions<T>, context?: {
+        transaction?: any;
+    }): Promise<T[]>;
+    findAndCount<T = ProductCollection>(findOptions?: DAL.FindOptions<T>, context?: {
+        transaction?: any;
+    }): Promise<[T[], number]>;
+}

package/dist/repositories/product-collection.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductCollectionRepository = void 0;
+const _models_1 = require("../models");
+const core_1 = require("@mikro-orm/core");
+const utils_1 = require("../utils");
+class ProductCollectionRepository {
+    constructor({ manager }) {
+        this.manager_ = manager.fork();
+    }
+    async find(findOptions = { where: {} }, context = {}) {
+        var _a;
+        // Spread is used to copy the options in case of manipulation to prevent side effects
+        const findOptions_ = { ...findOptions };
+        findOptions_.options ?? (findOptions_.options = {});
+        (_a = findOptions_.options).limit ?? (_a.limit = 15);
+        if (findOptions_.options.populate) {
+            (0, utils_1.deduplicateIfNecessary)(findOptions_.options.populate);
+        }
+        if (context.transaction) {
+            Object.assign(findOptions_.options, { ctx: context.transaction });
+        }
+        Object.assign(findOptions_.options, {
+            strategy: core_1.LoadStrategy.SELECT_IN,
+        });
+        return (await this.manager_.find(_models_1.ProductCollection, findOptions_.where, findOptions_.options));
+    }
+    async findAndCount(findOptions = { where: {} }, context = {}) {
+        var _a;
+        // Spread is used to copy the options in case of manipulation to prevent side effects
+        const findOptions_ = { ...findOptions };
+        findOptions_.options ?? (findOptions_.options = {});
+        (_a = findOptions_.options).limit ?? (_a.limit = 15);
+        if (findOptions_.options.populate) {
+            (0, utils_1.deduplicateIfNecessary)(findOptions_.options.populate);
+        }
+        if (context.transaction) {
+            Object.assign(findOptions_.options, { ctx: context.transaction });
+        }
+        Object.assign(findOptions_.options, {
+            strategy: core_1.LoadStrategy.SELECT_IN,
+        });
+        return (await this.manager_.findAndCount(_models_1.ProductCollection, findOptions_.where, findOptions_.options));
+    }
+}
+exports.ProductCollectionRepository = ProductCollectionRepository;

package/dist/repositories/product-tag.d.ts

@@ -0,0 +1,15 @@
+import { SqlEntityManager } from "@mikro-orm/postgresql";
+import { ProductTag } from "../models";
+import { DAL } from "@medusajs/types";
+export declare class ProductTagRepository implements DAL.RepositoryService {
+    protected readonly manager_: SqlEntityManager;
+    constructor({ manager }: {
+        manager: any;
+    });
+    find<T = ProductTag>(findOptions?: DAL.FindOptions<T>, context?: {
+        transaction?: any;
+    }): Promise<T[]>;
+    findAndCount<T = ProductTag>(findOptions?: DAL.FindOptions<T>, context?: {
+        transaction?: any;
+    }): Promise<[T[], number]>;
+}

package/dist/repositories/product-tag.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductTagRepository = void 0;
+const core_1 = require("@mikro-orm/core");
+const utils_1 = require("../utils");
+const _models_1 = require("../models");
+class ProductTagRepository {
+    constructor({ manager }) {
+        this.manager_ = manager.fork();
+    }
+    async find(findOptions = { where: {} }, context = {}) {
+        var _a;
+        // Spread is used to copy the options in case of manipulation to prevent side effects
+        const findOptions_ = { ...findOptions };
+        findOptions_.options ?? (findOptions_.options = {});
+        (_a = findOptions_.options).limit ?? (_a.limit = 15);
+        if (findOptions_.options.populate) {
+            (0, utils_1.deduplicateIfNecessary)(findOptions_.options.populate);
+        }
+        if (context.transaction) {
+            Object.assign(findOptions_.options, { ctx: context.transaction });
+        }
+        Object.assign(findOptions_.options, {
+            strategy: core_1.LoadStrategy.SELECT_IN,
+        });
+        return (await this.manager_.find(_models_1.ProductTag, findOptions_.where, findOptions_.options));
+    }
+    async findAndCount(findOptions = { where: {} }, context = {}) {
+        var _a;
+        // Spread is used to copy the options in case of manipulation to prevent side effects
+        const findOptions_ = { ...findOptions };
+        findOptions_.options ?? (findOptions_.options = {});
+        (_a = findOptions_.options).limit ?? (_a.limit = 15);
+        if (findOptions_.options.populate) {
+            (0, utils_1.deduplicateIfNecessary)(findOptions_.options.populate);
+        }
+        if (context.transaction) {
+            Object.assign(findOptions_.options, { ctx: context.transaction });
+        }
+        Object.assign(findOptions_.options, {
+            strategy: core_1.LoadStrategy.SELECT_IN,
+        });
+        return (await this.manager_.findAndCount(_models_1.ProductTag, findOptions_.where, findOptions_.options));
+    }
+}
+exports.ProductTagRepository = ProductTagRepository;

package/dist/repositories/product-variant.d.ts

@@ -0,0 +1,15 @@
+import { SqlEntityManager } from "@mikro-orm/postgresql";
+import { ProductVariant } from "../models";
+import { DAL } from "@medusajs/types";
+export declare class ProductVariantRepository implements DAL.RepositoryService {
+    protected readonly manager_: SqlEntityManager;
+    constructor({ manager }: {
+        manager: any;
+    });
+    find<T = ProductVariant>(findOptions?: DAL.FindOptions<T>, context?: {
+        transaction?: any;
+    }): Promise<T[]>;
+    findAndCount<T = ProductVariant>(findOptions?: DAL.FindOptions<T>, context?: {
+        transaction?: any;
+    }): Promise<[T[], number]>;
+}

package/dist/repositories/product-variant.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductVariantRepository = void 0;
+const core_1 = require("@mikro-orm/core");
+const utils_1 = require("../utils");
+const _models_1 = require("../models");
+class ProductVariantRepository {
+    constructor({ manager }) {
+        this.manager_ = manager.fork();
+    }
+    async find(findOptions = { where: {} }, context = {}) {
+        var _a;
+        // Spread is used to copy the options in case of manipulation to prevent side effects
+        const findOptions_ = { ...findOptions };
+        findOptions_.options ?? (findOptions_.options = {});
+        (_a = findOptions_.options).limit ?? (_a.limit = 15);
+        if (findOptions_.options.populate) {
+            (0, utils_1.deduplicateIfNecessary)(findOptions_.options.populate);
+        }
+        if (context.transaction) {
+            Object.assign(findOptions_.options, { ctx: context.transaction });
+        }
+        Object.assign(findOptions_.options, {
+            strategy: core_1.LoadStrategy.SELECT_IN,
+        });
+        return (await this.manager_.find(_models_1.ProductVariant, findOptions_.where, findOptions_.options));
+    }
+    async findAndCount(findOptions = { where: {} }, context = {}) {
+        var _a;
+        // Spread is used to copy the options in case of manipulation to prevent side effects
+        const findOptions_ = { ...findOptions };
+        findOptions_.options ?? (findOptions_.options = {});
+        (_a = findOptions_.options).limit ?? (_a.limit = 15);
+        if (findOptions_.options.populate) {
+            (0, utils_1.deduplicateIfNecessary)(findOptions_.options.populate);
+        }
+        if (context.transaction) {
+            Object.assign(findOptions_.options, { ctx: context.transaction });
+        }
+        Object.assign(findOptions_.options, {
+            strategy: core_1.LoadStrategy.SELECT_IN,
+        });
+        return (await this.manager_.findAndCount(_models_1.ProductVariant, findOptions_.where, findOptions_.options));
+    }
+}
+exports.ProductVariantRepository = ProductVariantRepository;

package/dist/repositories/product.d.ts

@@ -0,0 +1,21 @@
+import { SqlEntityManager } from "@mikro-orm/postgresql";
+import { Product } from "../models";
+import { DAL } from "@medusajs/types";
+export declare class ProductRepository implements DAL.RepositoryService<Product> {
+    protected readonly manager_: SqlEntityManager;
+    constructor({ manager }: {
+        manager: any;
+    });
+    find(findOptions?: DAL.FindOptions<Product>, context?: {
+        transaction?: any;
+    }): Promise<Product[]>;
+    findAndCount(findOptions?: DAL.FindOptions<Product>, context?: {
+        transaction?: any;
+    }): Promise<[Product[], number]>;
+    /**
+     * In order to be able to have a strict not in categories, and prevent a product
+     * to be return in the case it also belongs to other categories, we need to
+     * first find all products that are in the categories, and then exclude them
+     */
+    private mutateNotInCategoriesConstraints;
+}

package/dist/repositories/product.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductRepository = void 0;
+const _models_1 = require("../models");
+const core_1 = require("@mikro-orm/core");
+const utils_1 = require("../utils");
+class ProductRepository {
+    constructor({ manager }) {
+        this.manager_ = manager.fork();
+    }
+    async find(findOptions = { where: {} }, context = {}) {
+        var _a;
+        // Spread is used to cssopy the options in case of manipulation to prevent side effects
+        const findOptions_ = { ...findOptions };
+        findOptions_.options ?? (findOptions_.options = {});
+        (_a = findOptions_.options).limit ?? (_a.limit = 15);
+        if (findOptions_.options.populate) {
+            (0, utils_1.deduplicateIfNecessary)(findOptions_.options.populate);
+        }
+        if (context.transaction) {
+            Object.assign(findOptions_.options, { ctx: context.transaction });
+        }
+        Object.assign(findOptions_.options, {
+            strategy: core_1.LoadStrategy.SELECT_IN,
+        });
+        await this.mutateNotInCategoriesConstraints(findOptions_);
+        return await this.manager_.find(_models_1.Product, findOptions_.where, findOptions_.options);
+    }
+    async findAndCount(findOptions = { where: {} }, context = {}) {
+        var _a;
+        // Spread is used to copy the options in case of manipulation to prevent side effects
+        const findOptions_ = { ...findOptions };
+        findOptions_.options ?? (findOptions_.options = {});
+        (_a = findOptions_.options).limit ?? (_a.limit = 15);
+        if (findOptions_.options.populate) {
+            (0, utils_1.deduplicateIfNecessary)(findOptions_.options.populate);
+        }
+        if (context.transaction) {
+            Object.assign(findOptions_.options, { ctx: context.transaction });
+        }
+        Object.assign(findOptions_.options, {
+            strategy: core_1.LoadStrategy.SELECT_IN,
+        });
+        await this.mutateNotInCategoriesConstraints(findOptions_);
+        return await this.manager_.findAndCount(_models_1.Product, findOptions_.where, findOptions_.options);
+    }
+    /**
+     * In order to be able to have a strict not in categories, and prevent a product
+     * to be return in the case it also belongs to other categories, we need to
+     * first find all products that are in the categories, and then exclude them
+     */
+    async mutateNotInCategoriesConstraints(findOptions = { where: {} }) {
+        if (findOptions.where.categories?.id?.["$nin"]) {
+            const productsInCategories = await this.manager_.find(_models_1.Product, {
+                categories: {
+                    id: { $in: findOptions.where.categories.id["$nin"] },
+                },
+            }, {
+                fields: ["id"],
+            });
+            const productIds = productsInCategories.map((product) => product.id);
+            if (productIds.length) {
+                findOptions.where.id = { $nin: productIds };
+                delete findOptions.where.categories?.id;
+                if (Object.keys(findOptions.where.categories).length === 0) {
+                    delete findOptions.where.categories;
+                }
+            }
+        }
+    }
+}
+exports.ProductRepository = ProductRepository;

package/dist/scripts/bin/run-migration-down.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Promise<void>;
+export default _default;

package/dist/scripts/bin/run-migration-down.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const migration_down_1 = require("../migration-down");
+exports.default = (async () => {
+    const { config } = await Promise.resolve().then(() => __importStar(require("dotenv")));
+    config();
+    await (0, migration_down_1.revertMigration)();
+})();

package/dist/scripts/bin/run-migration-up.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Promise<void>;
+export default _default;

package/dist/scripts/bin/run-migration-up.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const migration_up_1 = require("../migration-up");
+exports.default = (async () => {
+    const { config } = await Promise.resolve().then(() => __importStar(require("dotenv")));
+    config();
+    await (0, migration_up_1.runMigrations)();
+})();

package/dist/scripts/bin/run-seed.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Promise<void>;
+export default _default;

package/dist/scripts/bin/run-seed.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const seed_1 = require("../seed");
+const os_1 = require("os");
+const args = process.argv;
+const path = args.pop();
+exports.default = (async () => {
+    const { config } = await Promise.resolve().then(() => __importStar(require("dotenv")));
+    config();
+    if (!path) {
+        throw new Error(`filePath is required.${os_1.EOL}Example: node_modules/@medusajs/product/dist/scripts/bin/run-seed.js <filePath>`);
+    }
+    await (0, seed_1.run)({ path });
+})();

package/dist/scripts/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./migration-up";
+export * from "./migration-down";

package/dist/scripts/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./migration-up"), exports);
+__exportStar(require("./migration-down"), exports);

package/dist/scripts/migration-down.d.ts

@@ -0,0 +1,10 @@
+import { LoaderOptions } from "@medusajs/types";
+import { ProductServiceInitializeCustomDataLayerOptions, ProductServiceInitializeOptions } from "../types";
+/**
+ * This script is only valid for mikro orm managers. If a user provide a custom manager
+ * he is in charge of reverting the migrations.
+ * @param options
+ * @param logger
+ * @param moduleDeclaration
+ */
+export declare function revertMigration({ options, logger, }?: Pick<LoaderOptions<ProductServiceInitializeOptions | ProductServiceInitializeCustomDataLayerOptions>, "options" | "logger">): Promise<void>;

package/dist/scripts/migration-down.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.revertMigration = void 0;
+const utils_1 = require("../utils");
+const ProductModels = __importStar(require("../models"));
+/**
+ * This script is only valid for mikro orm managers. If a user provide a custom manager
+ * he is in charge of reverting the migrations.
+ * @param options
+ * @param logger
+ * @param moduleDeclaration
+ */
+async function revertMigration({ options, logger, } = {}) {
+    logger ?? (logger = console);
+    const dbData = (0, utils_1.loadDatabaseConfig)(options);
+    const entities = Object.values(ProductModels);
+    const orm = await (0, utils_1.createConnection)(dbData, entities);
+    try {
+        const migrator = orm.getMigrator();
+        await migrator.down();
+        logger?.info("Product module migration executed");
+    }
+    catch (error) {
+        logger?.error(`Product module migration failed to run - Error: ${error}`);
+    }
+    await orm.close();
+}
+exports.revertMigration = revertMigration;

package/dist/scripts/migration-up.d.ts

@@ -0,0 +1,10 @@
+import { LoaderOptions } from "@medusajs/types";
+import { ProductServiceInitializeCustomDataLayerOptions, ProductServiceInitializeOptions } from "../types";
+/**
+ * This script is only valid for mikro orm managers. If a user provide a custom manager
+ * he is in charge of running the migrations.
+ * @param options
+ * @param logger
+ * @param moduleDeclaration
+ */
+export declare function runMigrations({ options, logger, }?: Pick<LoaderOptions<ProductServiceInitializeOptions | ProductServiceInitializeCustomDataLayerOptions>, "options" | "logger">): Promise<void>;