@medusajs/product 0.0.1

package/dist/scripts/migration-up.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.runMigrations = 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 running the migrations.
+ * @param options
+ * @param logger
+ * @param moduleDeclaration
+ */
+async function runMigrations({ 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.up();
+        logger?.info("Product module migration executed");
+    }
+    catch (error) {
+        logger?.error(`Product module migration failed to run - Error: ${error}`);
+    }
+    await orm.close();
+}
+exports.runMigrations = runMigrations;

package/dist/scripts/seed.d.ts

@@ -0,0 +1,5 @@
+import { LoaderOptions } from "@medusajs/types";
+import { ProductServiceInitializeCustomDataLayerOptions, ProductServiceInitializeOptions } from "../types";
+export declare function run({ options, logger, path, }: Partial<Pick<LoaderOptions<ProductServiceInitializeOptions | ProductServiceInitializeCustomDataLayerOptions>, "options" | "logger">> & {
+    path: string;
+}): Promise<void>;

package/dist/scripts/seed.js

@@ -0,0 +1,87 @@
+"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.run = void 0;
+const utils_1 = require("../utils");
+const ProductModels = __importStar(require("../models"));
+const _models_1 = require("../models");
+const os_1 = require("os");
+const path_1 = require("path");
+async function run({ options, logger, path, }) {
+    logger?.info(`Loading seed data from ${path}...`);
+    const { productCategoriesData, productsData, variantsData } = await Promise.resolve().then(() => __importStar(require((0, path_1.resolve)(process.cwd(), path)))).catch((e) => {
+        logger?.error(`Failed to load seed data from ${path}. Please, provide a relative path and check that you export the following productCategoriesData, productsData, variantsData.${os_1.EOL}${e}`);
+        throw e;
+    });
+    logger ?? (logger = console);
+    const dbData = (0, utils_1.loadDatabaseConfig)(options);
+    const entities = Object.values(ProductModels);
+    const orm = await (0, utils_1.createConnection)(dbData, entities);
+    const manager = orm.em.fork();
+    try {
+        logger?.info("Inserting product categories, products and variants...");
+        await createProductCategories(manager, productCategoriesData);
+        await createProducts(manager, productsData);
+        await createProductVariants(manager, variantsData);
+    }
+    catch (e) {
+        logger?.error(`Failed to insert the seed data in the PostgreSQL database ${dbData.clientUrl}.${os_1.EOL}${e}`);
+    }
+    await orm.close(true);
+}
+exports.run = run;
+async function createProductCategories(manager, categoriesData) {
+    const categories = [];
+    for (let categoryData of categoriesData) {
+        let categoryDataClone = { ...categoryData };
+        let parentCategory = null;
+        const parentCategoryId = categoryDataClone.parent_category_id;
+        delete categoryDataClone.parent_category_id;
+        if (parentCategoryId) {
+            parentCategory = await manager.findOne(_models_1.ProductCategory, parentCategoryId);
+        }
+        const category = await manager.create(_models_1.ProductCategory, {
+            ...categoryDataClone,
+            parent_category: parentCategory,
+        });
+        categories.push(category);
+    }
+    await manager.persistAndFlush(categories);
+    return categories;
+}
+async function createProducts(manager, data) {
+    const products = data.map((productData) => {
+        return manager.create(_models_1.Product, productData);
+    });
+    await manager.persistAndFlush(products);
+    return products;
+}
+async function createProductVariants(manager, data) {
+    const variants = data.map((variantsData) => {
+        return manager.create(_models_1.ProductVariant, variantsData);
+    });
+    await manager.persistAndFlush(variants);
+    return variants;
+}

package/dist/services/index.d.ts

@@ -0,0 +1,6 @@
+export { default as ProductModuleService } from "./product-module-service";
+export { default as ProductService } from "./product";
+export { default as ProductTagService } from "./product-tag";
+export { default as ProductVariantService } from "./product-variant";
+export { default as ProductCollectionService } from "./product-collection";
+export { default as ProductCategoryService } from "./product-category";

package/dist/services/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductCategoryService = exports.ProductCollectionService = exports.ProductVariantService = exports.ProductTagService = exports.ProductService = exports.ProductModuleService = void 0;
+var product_module_service_1 = require("./product-module-service");
+Object.defineProperty(exports, "ProductModuleService", { enumerable: true, get: function () { return __importDefault(product_module_service_1).default; } });
+var product_1 = require("./product");
+Object.defineProperty(exports, "ProductService", { enumerable: true, get: function () { return __importDefault(product_1).default; } });
+var product_tag_1 = require("./product-tag");
+Object.defineProperty(exports, "ProductTagService", { enumerable: true, get: function () { return __importDefault(product_tag_1).default; } });
+var product_variant_1 = require("./product-variant");
+Object.defineProperty(exports, "ProductVariantService", { enumerable: true, get: function () { return __importDefault(product_variant_1).default; } });
+var product_collection_1 = require("./product-collection");
+Object.defineProperty(exports, "ProductCollectionService", { enumerable: true, get: function () { return __importDefault(product_collection_1).default; } });
+var product_category_1 = require("./product-category");
+Object.defineProperty(exports, "ProductCategoryService", { enumerable: true, get: function () { return __importDefault(product_category_1).default; } });

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

@@ -0,0 +1,11 @@
+import { ProductCategory } from "../models";
+import { DAL, FindConfig, ProductTypes, SharedContext } from "@medusajs/types";
+declare type InjectedDependencies = {
+    productCategoryRepository: DAL.RepositoryService;
+};
+export default class ProductCategoryService<TEntity = ProductCategory> {
+    protected readonly productCategoryRepository_: DAL.RepositoryService;
+    constructor({ productCategoryRepository }: InjectedDependencies);
+    list(filters?: ProductTypes.FilterableProductCategoryProps, config?: FindConfig<ProductTypes.ProductCategoryDTO>, sharedContext?: SharedContext): Promise<TEntity[]>;
+}
+export {};

package/dist/services/product-category.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+class ProductCategoryService {
+    constructor({ productCategoryRepository }) {
+        this.productCategoryRepository_ = productCategoryRepository;
+    }
+    async list(filters = {}, config = {}, sharedContext) {
+        const transformOptions = {
+            includeDescendantsTree: filters?.include_descendants_tree || false
+        };
+        delete filters.include_descendants_tree;
+        const queryOptions = (0, utils_1.buildQuery)(filters, config);
+        queryOptions.where ?? (queryOptions.where = {});
+        return await this.productCategoryRepository_.find(queryOptions, transformOptions);
+    }
+}
+exports.default = ProductCategoryService;

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

@@ -0,0 +1,11 @@
+import { ProductCollection } from "../models";
+import { DAL, FindConfig, ProductTypes, SharedContext } from "@medusajs/types";
+declare type InjectedDependencies = {
+    productCollectionRepository: DAL.RepositoryService;
+};
+export default class ProductCollectionService<TEntity = ProductCollection> {
+    protected readonly productCollectionRepository_: DAL.RepositoryService<TEntity>;
+    constructor({ productCollectionRepository }: InjectedDependencies);
+    list(filters?: ProductTypes.FilterableProductCollectionProps, config?: FindConfig<ProductTypes.ProductCollectionDTO>, sharedContext?: SharedContext): Promise<TEntity[]>;
+}
+export {};

package/dist/services/product-collection.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+class ProductCollectionService {
+    constructor({ productCollectionRepository }) {
+        this.productCollectionRepository_ = productCollectionRepository;
+    }
+    async list(filters = {}, config = {}, sharedContext) {
+        const queryOptions = (0, utils_1.buildQuery)(filters, config);
+        queryOptions.where ?? (queryOptions.where = {});
+        if (filters.title) {
+            queryOptions.where["title"] = { $like: filters.title };
+        }
+        return await this.productCollectionRepository_.find(queryOptions);
+    }
+}
+exports.default = ProductCollectionService;

package/dist/services/product-module-service.d.ts

@@ -0,0 +1,25 @@
+import { ProductCategoryService, ProductCollectionService, ProductService, ProductTagService, ProductVariantService } from ".";
+import { Product, ProductCategory, ProductCollection, ProductTag, ProductVariant } from "../models";
+import { FindConfig, ProductTypes, SharedContext } from "@medusajs/types";
+declare type InjectedDependencies = {
+    productService: ProductService<any>;
+    productVariantService: ProductVariantService<any>;
+    productTagService: ProductTagService<any>;
+    productCategoryService: ProductCategoryService<any>;
+    productCollectionService: ProductCollectionService<any>;
+};
+export default class ProductModuleService<TProduct = Product, TProductVariant = ProductVariant, TProductTag = ProductTag, TProductCollection = ProductCollection, TProductCategory = ProductCategory> implements ProductTypes.IProductModuleService<TProduct, TProductVariant, TProductTag, TProductCollection, TProductCategory> {
+    protected readonly productService_: ProductService<TProduct>;
+    protected readonly productVariantService: ProductVariantService<TProductVariant>;
+    protected readonly productCategoryService: ProductCategoryService<TProductCategory>;
+    protected readonly productTagService: ProductTagService<TProductTag>;
+    protected readonly productCollectionService: ProductCollectionService<TProductCollection>;
+    constructor({ productService, productVariantService, productTagService, productCategoryService, productCollectionService, }: InjectedDependencies);
+    list(filters?: ProductTypes.FilterableProductProps, config?: FindConfig<ProductTypes.ProductDTO>, sharedContext?: SharedContext): Promise<ProductTypes.ProductDTO[]>;
+    listAndCount(filters?: ProductTypes.FilterableProductProps, config?: FindConfig<ProductTypes.ProductDTO>, sharedContext?: SharedContext): Promise<[ProductTypes.ProductDTO[], number]>;
+    listVariants(filters?: ProductTypes.FilterableProductVariantProps, config?: FindConfig<ProductTypes.ProductVariantDTO>, sharedContext?: SharedContext): Promise<ProductTypes.ProductVariantDTO[]>;
+    listTags(filters?: ProductTypes.FilterableProductTagProps, config?: FindConfig<ProductTypes.ProductTagDTO>, sharedContext?: SharedContext): Promise<ProductTypes.ProductTagDTO[]>;
+    listCollections(filters?: ProductTypes.FilterableProductCollectionProps, config?: FindConfig<ProductTypes.ProductCollectionDTO>, sharedContext?: SharedContext): Promise<ProductTypes.ProductCollectionDTO[]>;
+    listCategories(filters?: ProductTypes.FilterableProductCategoryProps, config?: FindConfig<ProductTypes.ProductCategoryDTO>, sharedContext?: SharedContext): Promise<ProductTypes.ProductCategoryDTO[]>;
+}
+export {};

package/dist/services/product-module-service.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ProductModuleService {
+    constructor({ productService, productVariantService, productTagService, productCategoryService, productCollectionService, }) {
+        this.productService_ = productService;
+        this.productVariantService = productVariantService;
+        this.productTagService = productTagService;
+        this.productCategoryService = productCategoryService;
+        this.productCollectionService = productCollectionService;
+    }
+    async list(filters = {}, config = {}, sharedContext) {
+        const products = await this.productService_.list(filters, config, sharedContext);
+        return JSON.parse(JSON.stringify(products));
+    }
+    async listAndCount(filters = {}, config = {}, sharedContext) {
+        const [products, count] = await this.productService_.listAndCount(filters, config, sharedContext);
+        return [JSON.parse(JSON.stringify(products)), count];
+    }
+    async listVariants(filters = {}, config = {}, sharedContext) {
+        const variants = await this.productVariantService.list(filters, config, sharedContext);
+        return JSON.parse(JSON.stringify(variants));
+    }
+    async listTags(filters = {}, config = {}, sharedContext) {
+        const tags = await this.productTagService.list(filters, config, sharedContext);
+        return JSON.parse(JSON.stringify(tags));
+    }
+    async listCollections(filters = {}, config = {}, sharedContext) {
+        const collections = await this.productCollectionService.list(filters, config, sharedContext);
+        return JSON.parse(JSON.stringify(collections));
+    }
+    async listCategories(filters = {}, config = {}, sharedContext) {
+        const categories = await this.productCategoryService.list(filters, config, sharedContext);
+        return JSON.parse(JSON.stringify(categories));
+    }
+}
+exports.default = ProductModuleService;

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

@@ -0,0 +1,11 @@
+import { ProductTag } from "../models";
+import { DAL, FindConfig, ProductTypes, SharedContext } from "@medusajs/types";
+declare type InjectedDependencies = {
+    productTagRepository: DAL.RepositoryService;
+};
+export default class ProductTagService<TEntity = ProductTag> {
+    protected readonly productTagRepository_: DAL.RepositoryService<TEntity>;
+    constructor({ productTagRepository }: InjectedDependencies);
+    list(filters?: ProductTypes.FilterableProductTagProps, config?: FindConfig<ProductTypes.ProductTagDTO>, sharedContext?: SharedContext): Promise<TEntity[]>;
+}
+export {};

package/dist/services/product-tag.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+class ProductTagService {
+    constructor({ productTagRepository }) {
+        this.productTagRepository_ = productTagRepository;
+    }
+    async list(filters = {}, config = {}, sharedContext) {
+        const queryOptions = (0, utils_1.buildQuery)(filters, config);
+        if (filters.value) {
+            queryOptions.where["value"] = { $ilike: filters.value };
+        }
+        return await this.productTagRepository_.find(queryOptions);
+    }
+}
+exports.default = ProductTagService;

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

@@ -0,0 +1,11 @@
+import { ProductVariant } from "../models";
+import { DAL, FindConfig, ProductTypes, SharedContext } from "@medusajs/types";
+declare type InjectedDependencies = {
+    productVariantRepository: DAL.RepositoryService;
+};
+export default class ProductVariantService<TEntity = ProductVariant> {
+    protected readonly productVariantRepository_: DAL.RepositoryService<TEntity>;
+    constructor({ productVariantRepository }: InjectedDependencies);
+    list(filters?: ProductTypes.FilterableProductVariantProps, config?: FindConfig<ProductTypes.ProductVariantDTO>, sharedContext?: SharedContext): Promise<TEntity[]>;
+}
+export {};

package/dist/services/product-variant.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+class ProductVariantService {
+    constructor({ productVariantRepository }) {
+        this.productVariantRepository_ = productVariantRepository;
+    }
+    async list(filters = {}, config = {}, sharedContext) {
+        const queryOptions = (0, utils_1.buildQuery)(filters, config);
+        return await this.productVariantRepository_.find(queryOptions);
+    }
+}
+exports.default = ProductVariantService;

package/dist/services/product.d.ts

@@ -0,0 +1,15 @@
+import { ProductTagService, ProductVariantService } from ".";
+import { Product } from "../models";
+import { DAL, FindConfig, ProductTypes, SharedContext } from "@medusajs/types";
+declare type InjectedDependencies = {
+    productRepository: DAL.RepositoryService;
+    productVariantService: ProductVariantService;
+    productTagService: ProductTagService;
+};
+export default class ProductService<TEntity = Product> {
+    protected readonly productRepository_: DAL.RepositoryService<TEntity>;
+    constructor({ productRepository }: InjectedDependencies);
+    list(filters?: ProductTypes.FilterableProductProps, config?: FindConfig<ProductTypes.ProductDTO>, sharedContext?: SharedContext): Promise<TEntity[]>;
+    listAndCount(filters?: ProductTypes.FilterableProductProps, config?: FindConfig<ProductTypes.ProductDTO>, sharedContext?: SharedContext): Promise<[TEntity[], number]>;
+}
+export {};

package/dist/services/product.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+class ProductService {
+    constructor({ productRepository }) {
+        this.productRepository_ = productRepository;
+    }
+    async list(filters = {}, config = {}, sharedContext) {
+        if (filters.category_ids) {
+            if (Array.isArray(filters.category_ids)) {
+                filters.categories = {
+                    id: { $in: filters.category_ids },
+                };
+            }
+            else {
+                filters.categories = {
+                    id: filters.category_ids,
+                };
+            }
+            delete filters.category_ids;
+        }
+        const queryOptions = (0, utils_1.buildQuery)(filters, config);
+        return await this.productRepository_.find(queryOptions);
+    }
+    async listAndCount(filters = {}, config = {}, sharedContext) {
+        if (filters.category_ids) {
+            if (Array.isArray(filters.category_ids)) {
+                filters.categories = {
+                    id: { $in: filters.category_ids },
+                };
+            }
+            else {
+                filters.categories = {
+                    id: filters.category_ids,
+                };
+            }
+            delete filters.category_ids;
+        }
+        const queryOptions = (0, utils_1.buildQuery)(filters, config);
+        return await this.productRepository_.findAndCount(queryOptions);
+    }
+}
+exports.default = ProductService;

package/dist/types/index.d.ts

@@ -0,0 +1,17 @@
+import { Constructor, DAL, IEventBusService } from "@medusajs/types";
+export declare type ProductServiceInitializeOptions = {
+    database: {
+        clientUrl: string;
+        schema?: string;
+        driverOptions?: Record<string, unknown>;
+    };
+};
+export declare type ProductServiceInitializeCustomDataLayerOptions = {
+    manager?: any;
+    repositories?: {
+        [key: string]: Constructor<DAL.RepositoryService>;
+    };
+};
+export declare type InitializeModuleInjectableDependencies = {
+    eventBusService?: IEventBusService;
+};

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/create-connection.d.ts

@@ -0,0 +1,3 @@
+import { PostgreSqlDriver } from "@mikro-orm/postgresql";
+import { ProductServiceInitializeOptions } from "../types";
+export declare function createConnection(database: ProductServiceInitializeOptions["database"], entities: any[]): Promise<import("@mikro-orm/core").MikroORM<PostgreSqlDriver>>;

package/dist/utils/create-connection.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConnection = void 0;
+const path_1 = require("path");
+const postgresql_1 = require("@mikro-orm/postgresql");
+const migrations_1 = require("@mikro-orm/migrations");
+async function createConnection(database, entities) {
+    const orm = await postgresql_1.MikroORM.init({
+        discovery: { disableDynamicFileAccess: true },
+        entities,
+        debug: process.env.NODE_ENV === "development",
+        baseDir: process.cwd(),
+        clientUrl: database.clientUrl,
+        schema: database.schema ?? "public",
+        driverOptions: database.driverOptions ?? {
+            connection: { ssl: true },
+        },
+        tsNode: process.env.APP_ENV === "development",
+        type: "postgresql",
+        migrations: {
+            path: (0, path_1.resolve)(__dirname, "../../dist/migrations"),
+            pathTs: (0, path_1.resolve)(__dirname, "../../src/migrations"),
+            glob: "!(*.d).{js,ts}",
+            disableForeignKeys: false,
+            silent: false,
+            dropTables: false,
+            transactional: true,
+            allOrNothing: true,
+            safe: true,
+            generator: migrations_1.TSMigrationGenerator,
+        },
+    });
+    return orm;
+}
+exports.createConnection = createConnection;

package/dist/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./query";
+export * from "./create-connection";
+export * from "./load-database-config";

package/dist/utils/index.js

@@ -0,0 +1,19 @@
+"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("./query"), exports);
+__exportStar(require("./create-connection"), exports);
+__exportStar(require("./load-database-config"), exports);

package/dist/utils/load-database-config.d.ts

@@ -0,0 +1,7 @@
+import { ProductServiceInitializeCustomDataLayerOptions, ProductServiceInitializeOptions } from "../types";
+/**
+ * Load the config for the database connection. The options can be retrieved
+ * through PRODUCT_* (e.g PRODUCT_POSTGRES_URL) or * (e.g POSTGRES_URL) environment variables or the options object.
+ * @param options
+ */
+export declare function loadDatabaseConfig(options?: ProductServiceInitializeOptions | ProductServiceInitializeCustomDataLayerOptions): ProductServiceInitializeOptions["database"];

package/dist/utils/load-database-config.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadDatabaseConfig = void 0;
+const utils_1 = require("@medusajs/utils");
+function getEnv(key) {
+    const value = process.env[`PRODUCT_${key}`] ?? process.env[`${key}`];
+    return value ?? "";
+}
+function isProductServiceInitializeOptions(obj) {
+    return !!obj?.database;
+}
+function getDefaultDriverOptions(clientUrl) {
+    const localOptions = {
+        connection: {
+            ssl: false,
+        },
+    };
+    const remoteOptions = {
+        connection: {
+            ssl: {
+                rejectUnauthorized: false,
+            },
+        },
+    };
+    if (clientUrl) {
+        return clientUrl.match(/localhost/i) ? localOptions : remoteOptions;
+    }
+    return process.env.NODE_ENV?.match(/prod/i)
+        ? remoteOptions
+        : process.env.NODE_ENV?.match(/dev/i)
+            ? localOptions
+            : {};
+}
+/**
+ * Load the config for the database connection. The options can be retrieved
+ * through PRODUCT_* (e.g PRODUCT_POSTGRES_URL) or * (e.g POSTGRES_URL) environment variables or the options object.
+ * @param options
+ */
+function loadDatabaseConfig(options) {
+    const clientUrl = getEnv("POSTGRES_URL");
+    const database = {
+        clientUrl: getEnv("POSTGRES_URL"),
+        schema: getEnv("POSTGRES_SCHEMA") ?? "public",
+        driverOptions: JSON.parse(getEnv("POSTGRES_DRIVER_OPTIONS") ||
+            JSON.stringify(getDefaultDriverOptions(clientUrl))),
+    };
+    if (isProductServiceInitializeOptions(options)) {
+        database.clientUrl = options.database.clientUrl ?? database.clientUrl;
+        database.schema = options.database.schema ?? database.schema;
+        database.driverOptions =
+            options.database.driverOptions ??
+                getDefaultDriverOptions(database.clientUrl);
+    }
+    if (!database.clientUrl) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_ARGUMENT, "No database clientUrl provided. Please provide the clientUrl through the PRODUCT_POSTGRES_URL or POSTGRES_URL environment variable or the options object in the initialize function.");
+    }
+    return database;
+}
+exports.loadDatabaseConfig = loadDatabaseConfig;

package/dist/utils/query/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Move to a new build query utils
+ */
+import { DAL, FindConfig } from "@medusajs/types";
+export declare function deduplicateIfNecessary<T = any>(collection: T | T[]): T | T[];
+export declare function buildQuery<T = any, TDto = any>(filters?: Record<string, any>, config?: FindConfig<TDto>): DAL.FindOptions<T>;

package/dist/utils/query/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildQuery = exports.deduplicateIfNecessary = void 0;
+const utils_1 = require("@medusajs/utils");
+function deduplicateIfNecessary(collection) {
+    return Array.isArray(collection) ? [...new Set(collection)] : collection;
+}
+exports.deduplicateIfNecessary = deduplicateIfNecessary;
+function buildQuery(filters = {}, config = {}) {
+    const where = {};
+    buildWhere(filters, where);
+    const findOptions = {
+        populate: config.relations ?? [],
+        fields: config.select,
+        limit: config.take,
+        offset: config.skip,
+    };
+    return { where, options: findOptions };
+}
+exports.buildQuery = buildQuery;
+function buildWhere(filters = {}, where = {}) {
+    for (let [prop, value] of Object.entries(filters)) {
+        if (Array.isArray(value)) {
+            value = deduplicateIfNecessary(value);
+            where[prop] = ["$in", "$nin"].includes(prop) ? value : { $in: value };
+            continue;
+        }
+        if ((0, utils_1.isObject)(value)) {
+            where[prop] = {};
+            buildWhere(value, where[prop]);
+            continue;
+        }
+        where[prop] = value;
+    }
+}