@medusajs/search 0.0.1

package/dist/scripts/migration-up.js

@@ -0,0 +1,56 @@
+"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("@medusajs/utils");
+const SearchModels = __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 = utils_1.ModulesSdkUtils.loadDatabaseConfig("search", options?.defaultAdapterOptions);
+    const entities = Object.values(SearchModels);
+    const pathToMigrations = __dirname + "/../migrations";
+    const orm = await utils_1.DALUtils.mikroOrmCreateConnection(dbData, entities, pathToMigrations);
+    try {
+        const migrator = orm.getMigrator();
+        const pendingMigrations = await migrator.getPendingMigrations();
+        logger.info(`Running pending migrations: ${pendingMigrations}`);
+        await migrator.up({
+            migrations: pendingMigrations.map((m) => m.name),
+        });
+        logger.info("Search module migration executed");
+    }
+    catch (error) {
+        logger.error(`Search module migration failed to run - Error: ${error}`);
+    }
+    await orm.close();
+}
+exports.runMigrations = runMigrations;

package/dist/scripts/seed-data/index.d.ts

@@ -0,0 +1,8 @@
+export declare function createRandomEntries(): {
+    catalogEntries: any[];
+    catalogRelationEntries: any[];
+};
+export declare const searchData: {
+    catalogEntries: any[];
+    catalogRelationEntries: any[];
+}[];

package/dist/scripts/seed-data/index.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchData = exports.createRandomEntries = void 0;
+// ESM
+const faker_1 = require("@faker-js/faker");
+function createRandomEntries() {
+    const productId = faker_1.faker.string.uuid();
+    const catalogEntries = [];
+    const catalogRelationEntries = [];
+    /**
+     * build product entry
+     */
+    const productEntry = {
+        id: productId,
+        name: "Product",
+        data: {
+            id: productId,
+            title: faker_1.faker.commerce.productName(),
+        },
+    };
+    catalogEntries.push(productEntry);
+    /**
+     * build 10 variant entries
+     */
+    for (let i = 0; i < 10; i++) {
+        const variantId = faker_1.faker.string.uuid();
+        const variantEntry = {
+            id: variantId,
+            name: "ProductVariant",
+            data: {
+                id: variantId,
+                title: faker_1.faker.commerce.productName(),
+                product_id: productId,
+                sku: faker_1.faker.commerce.productName(),
+            },
+        };
+        catalogEntries.push(variantEntry);
+        /**
+         * build relation between product and variant
+         */
+        const productVariantRelationEntry = {
+            parent_id: productId,
+            parent_name: "Product",
+            child_id: variantId,
+            child_name: "ProductVariant",
+            pivot: "Product-ProductVariant",
+        };
+        catalogRelationEntries.push(productVariantRelationEntry);
+        const priceSetId = faker_1.faker.string.uuid();
+        const linkProductPriceSetId = faker_1.faker.string.uuid();
+        /**
+         * build link entry between variant and price set
+         */
+        const linkProductPriceSetEntry = {
+            id: linkProductPriceSetId,
+            name: "LinkProductVariantPriceSet",
+            data: {
+                id: linkProductPriceSetId,
+                variant_id: variantId,
+                price_set_id: priceSetId,
+            },
+        };
+        catalogEntries.push(linkProductPriceSetEntry);
+        /**
+         * build relation between variant and link entry
+         */
+        const variantLinkRelationEntry = {
+            parent_id: variantId,
+            parent_name: "ProductVariant",
+            child_id: linkProductPriceSetId,
+            child_name: "LinkProductVariantPriceSet",
+            pivot: "ProductVariant-LinkProductVariantPriceSet",
+        };
+        catalogRelationEntries.push(variantLinkRelationEntry);
+        /**
+         * build price set entry
+         */
+        const priceSetEntry = {
+            id: priceSetId,
+            name: "PriceSet",
+            data: {
+                id: priceSetId,
+            },
+        };
+        catalogEntries.push(priceSetEntry);
+        /**
+         * build relation between link entry and price set
+         */
+        const linkPriceSetRelationEntry = {
+            parent_id: linkProductPriceSetId,
+            parent_name: "LinkProductVariantPriceSet",
+            child_id: priceSetId,
+            child_name: "PriceSet",
+            pivot: "LinkProductVariantPriceSet-PriceSet",
+        };
+        catalogRelationEntries.push(linkPriceSetRelationEntry);
+        /**
+         * build 3 money amount entries
+         */
+        for (let j = 0; j < 3; j++) {
+            const moneyAmountId = faker_1.faker.string.uuid();
+            /**
+             * build money amount entry
+             */
+            const moneyAmountEntry = {
+                id: moneyAmountId,
+                name: "MoneyAmount",
+                data: {
+                    id: moneyAmountId,
+                    amount: faker_1.faker.commerce.price({
+                        dec: 0,
+                    }),
+                    //currency_code: faker.finance.currencyCode(),
+                },
+            };
+            catalogEntries.push(moneyAmountEntry);
+            /**
+             * build relation between price set and money amount
+             */
+            const moneyAmountPriceSetRelationEntry = {
+                parent_id: priceSetId,
+                parent_name: "PriceSet",
+                child_id: moneyAmountId,
+                child_name: "MoneyAmount",
+                pivot: "PriceSet-MoneyAmount",
+            };
+            catalogRelationEntries.push(moneyAmountPriceSetRelationEntry);
+        }
+    }
+    return {
+        catalogEntries,
+        catalogRelationEntries,
+    };
+}
+exports.createRandomEntries = createRandomEntries;
+exports.searchData = faker_1.faker.helpers.multiple(createRandomEntries, {
+    count: 10000,
+});

package/dist/scripts/seed.d.ts

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

package/dist/scripts/seed.js

@@ -0,0 +1,65 @@
+"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("@medusajs/utils");
+const SearchModels = __importStar(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 { searchData } = await Promise.resolve(`${(0, path_1.resolve)(process.cwd(), path)}`).then(s => __importStar(require(s))).catch((e) => {
+        logger?.warn(`Failed to load seed data from ${path}. Please, provide a relative path and check that you export the following searchData.${os_1.EOL}${e}`);
+        logger?.warn(`Fallback to the default seed data from ${__dirname}/seed-data/index.ts`);
+        throw e;
+    });
+    logger ?? (logger = console);
+    const dbData = utils_1.ModulesSdkUtils.loadDatabaseConfig("search", options?.defaultAdapterOptions);
+    const entities = Object.values(SearchModels);
+    const pathToMigrations = __dirname + "/../migrations";
+    const orm = await utils_1.DALUtils.mikroOrmCreateConnection(dbData, entities, pathToMigrations);
+    const manager = orm.em.fork();
+    try {
+        logger?.info("Inserting search data...");
+        await createSearchData(manager, searchData);
+    }
+    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 createSearchData(manager, searchData) {
+    const catalogEntries = [];
+    const catalogRelationEntries = [];
+    const catalogRepository = manager.getRepository(SearchModels.Catalog);
+    const catalogRelationRepository = manager.getRepository(SearchModels.CatalogRelation);
+    for (const searchItems of searchData) {
+        catalogEntries.push(...searchItems.catalogEntries.map((item) => catalogRepository.create(item)));
+        catalogRelationEntries.push(...searchItems.catalogRelationEntries.map((item) => catalogRelationRepository.create(item)));
+    }
+    await manager.persistAndFlush(catalogEntries);
+    await manager.persistAndFlush(catalogRelationEntries);
+}

package/dist/services/index.d.ts

@@ -0,0 +1 @@
+export { default as SearchModuleService } from "./search-module-service";

package/dist/services/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchModuleService = void 0;
+var search_module_service_1 = require("./search-module-service");
+Object.defineProperty(exports, "SearchModuleService", { enumerable: true, get: function () { return __importDefault(search_module_service_1).default; } });

package/dist/services/postgres-provider.d.ts

@@ -0,0 +1,126 @@
+import { IEventBusModuleService, Message, RemoteJoinerQuery, Subscriber } from "@medusajs/types";
+import { EntityManager } from "@mikro-orm/postgresql";
+import { QueryFormat, QueryOptions, SchemaObjectEntityRepresentation, SchemaObjectRepresentation, SearchModuleOptions, StorageProvider } from "../types";
+type InjectedDependencies = {
+    manager: EntityManager;
+    eventBusModuleService: IEventBusModuleService;
+    storageProviderCtr: StorageProvider;
+    storageProviderOptions: unknown;
+    remoteQuery: (query: string | RemoteJoinerQuery | object, variables?: Record<string, unknown>) => Promise<any>;
+};
+export declare class PostgresProvider {
+    #private;
+    protected readonly eventActionToMethodMap_: {
+        created: string;
+        updated: string;
+        deleted: string;
+        attached: string;
+        detached: string;
+    };
+    protected container_: InjectedDependencies;
+    protected readonly schemaObjectRepresentation_: SchemaObjectRepresentation;
+    protected readonly schemaEntitiesMap_: Record<string, any>;
+    protected readonly moduleOptions_: SearchModuleOptions;
+    protected get remoteQuery_(): (query: string | RemoteJoinerQuery | object, variables?: Record<string, unknown>) => Promise<any>;
+    constructor(container: any, options: {
+        schemaObjectRepresentation: SchemaObjectRepresentation;
+        entityMap: Record<string, any>;
+    }, moduleOptions: SearchModuleOptions);
+    onApplicationStart(): Promise<void>;
+    protected static parseData<TData extends {
+        id: string;
+        [key: string]: unknown;
+    }>(data: TData | TData[], schemaEntityObjectRepresentation: SchemaObjectEntityRepresentation): {
+        data: TData[];
+        entityProperties: string[];
+        parentsProperties: {
+            [entity: string]: string[];
+        };
+    };
+    protected static parseMessageData<T>(message?: Message<T>): {
+        action: string;
+        data: {
+            id: string;
+        }[];
+        ids: string[];
+    } | void;
+    query(selection: QueryFormat, options?: QueryOptions): any;
+    queryAndCount(selection: QueryFormat, options?: QueryOptions): Promise<any[]>;
+    consumeEvent(schemaEntityObjectRepresentation: SchemaObjectEntityRepresentation): Subscriber;
+    /**
+     * Create the catalog entry and the catalog relation entry when this event is emitted.
+     * @param entity
+     * @param data
+     * @param schemaEntityObjectRepresentation
+     * @protected
+     */
+    protected onCreate<TData extends {
+        id: string;
+        [key: string]: unknown;
+    }>({ entity, data, schemaEntityObjectRepresentation, }: {
+        entity: string;
+        data: TData | TData[];
+        schemaEntityObjectRepresentation: SchemaObjectEntityRepresentation;
+    }): Promise<void>;
+    /**
+     * Update the catalog entry when this event is emitted.
+     * @param entity
+     * @param data
+     * @param schemaEntityObjectRepresentation
+     * @protected
+     */
+    protected onUpdate<TData extends {
+        id: string;
+        [key: string]: unknown;
+    }>({ entity, data, schemaEntityObjectRepresentation, }: {
+        entity: string;
+        data: TData | TData[];
+        schemaEntityObjectRepresentation: SchemaObjectEntityRepresentation;
+    }): Promise<void>;
+    /**
+     * Delete the catalog entry when this event is emitted.
+     * @param entity
+     * @param data
+     * @param schemaEntityObjectRepresentation
+     * @protected
+     */
+    protected onDelete<TData extends {
+        id: string;
+        [key: string]: unknown;
+    }>({ entity, data, schemaEntityObjectRepresentation, }: {
+        entity: string;
+        data: TData | TData[];
+        schemaEntityObjectRepresentation: SchemaObjectEntityRepresentation;
+    }): Promise<void>;
+    /**
+     * event emitted from the link modules to attach a link entity to its parent and child entities from the linked modules.
+     * @param entity
+     * @param data
+     * @param schemaEntityObjectRepresentation
+     * @protected
+     */
+    protected onAttach<TData extends {
+        id: string;
+        [key: string]: unknown;
+    }>({ entity, data, schemaEntityObjectRepresentation, }: {
+        entity: string;
+        data: TData | TData[];
+        schemaEntityObjectRepresentation: SchemaObjectEntityRepresentation;
+    }): Promise<void>;
+    /**
+     * Event emitted from the link modules to detach a link entity from its parent and child entities from the linked modules.
+     * @param entity
+     * @param data
+     * @param schemaEntityObjectRepresentation
+     * @protected
+     */
+    protected onDetach<TData extends {
+        id: string;
+        [key: string]: unknown;
+    }>({ entity, data, schemaEntityObjectRepresentation, }: {
+        entity: string;
+        data: TData | TData[];
+        schemaEntityObjectRepresentation: SchemaObjectEntityRepresentation;
+    }): Promise<void>;
+}
+export {};