@medusajs/search 0.0.1 → 2.18.0

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

@@ -1,126 +0,0 @@
-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 {};

package/dist/services/postgres-provider.js

@@ -1,441 +0,0 @@
-"use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _PostgresProvider_isReady_;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgresProvider = void 0;
-const utils_1 = require("@medusajs/utils");
-const _models_1 = require("../models");
-const utils_2 = require("../utils");
-class PostgresProvider {
-    get remoteQuery_() {
-        return this.container_.remoteQuery;
-    }
-    constructor(container, options, moduleOptions) {
-        _PostgresProvider_isReady_.set(this, void 0);
-        this.eventActionToMethodMap_ = {
-            created: "onCreate",
-            updated: "onUpdate",
-            deleted: "onDelete",
-            attached: "onAttach",
-            detached: "onDetach",
-        };
-        this.container_ = container;
-        this.moduleOptions_ = moduleOptions;
-        this.schemaObjectRepresentation_ = options.schemaObjectRepresentation;
-        this.schemaEntitiesMap_ = options.entityMap;
-        // Add a new column for each key that can be found in the jsonb data column to perform indexes and query on it.
-        // So far, the execution time is about the same
-        /*;(async () => {
-          const query = [
-            ...new Set(
-              Object.keys(this.schemaObjectRepresentation_)
-                .filter(
-                  (key) =>
-                    ![
-                      "_serviceNameModuleConfigMap",
-                      "_schemaPropertiesMap",
-                    ].includes(key)
-                )
-                .map((key) => {
-                  return this.schemaObjectRepresentation_[key].fields.filter(
-                    (field) => !field.includes(".")
-                  )
-                })
-                .flat()
-            ),
-          ].map(
-            (field) =>
-              "ALTER TABLE catalog ADD IF NOT EXISTS " +
-              field +
-              " text GENERATED ALWAYS AS (NEW.data->>'" +
-              field +
-              "') STORED"
-          )
-          await this.container_.manager.execute(query.join(";"))
-        })()*/
-    }
-    async onApplicationStart() {
-        let initalizedOk = () => { };
-        let initalizedNok = () => { };
-        __classPrivateFieldSet(this, _PostgresProvider_isReady_, new Promise((resolve, reject) => {
-            initalizedOk = resolve;
-            initalizedNok = reject;
-        }), "f");
-        await (0, utils_2.createPartitions)(this.schemaObjectRepresentation_, this.container_.manager)
-            .then(initalizedOk)
-            .catch(initalizedNok);
-    }
-    static parseData(data, schemaEntityObjectRepresentation) {
-        const data_ = Array.isArray(data) ? data : [data];
-        // Always keep the id in the entity properties
-        const entityProperties = ["id"];
-        const parentsProperties = {};
-        /**
-         * Split fields into entity properties and parents properties
-         */
-        schemaEntityObjectRepresentation.fields.forEach((field) => {
-            var _a;
-            if (field.includes(".")) {
-                const parentAlias = field.split(".")[0];
-                const parentSchemaObjectRepresentation = schemaEntityObjectRepresentation.parents.find((parent) => parent.ref.alias === parentAlias);
-                if (!parentSchemaObjectRepresentation) {
-                    throw new Error(`SearchModule error, unable to parse data for ${schemaEntityObjectRepresentation.entity}. The parent schema object representation could not be found for the alias ${parentAlias} for the entity ${schemaEntityObjectRepresentation.entity}.`);
-                }
-                parentsProperties[_a = parentSchemaObjectRepresentation.ref.entity] ?? (parentsProperties[_a] = []);
-                parentsProperties[parentSchemaObjectRepresentation.ref.entity].push(field);
-            }
-            else {
-                entityProperties.push(field);
-            }
-        });
-        return {
-            data: data_,
-            entityProperties,
-            parentsProperties,
-        };
-    }
-    static parseMessageData(message) {
-        const isMessageShape = (0, utils_1.isDefined)(message?.body);
-        if (!isMessageShape) {
-            return;
-        }
-        const result = {
-            action: "",
-            data: [],
-            ids: [],
-        };
-        result.action = message.body.metadata.action;
-        result.data = message.body.data;
-        result.data = Array.isArray(result.data) ? result.data : [result.data];
-        result.ids = result.data.map((d) => d.id);
-        return result;
-    }
-    async query(selection, options) {
-        await __classPrivateFieldGet(this, _PostgresProvider_isReady_, "f");
-        let hasPagination = false;
-        if (typeof options?.take === "number" ||
-            typeof options?.skip === "number") {
-            hasPagination = true;
-        }
-        const connection = this.container_.manager.getConnection();
-        const qb = new utils_2.QueryBuilder({
-            schema: this.schemaObjectRepresentation_,
-            entityMap: this.schemaEntitiesMap_,
-            knex: connection.getKnex(),
-            selector: selection,
-            options,
-        });
-        const sql = qb.buildQuery(hasPagination, !!options?.keepFilteredEntities);
-        let resultset = await connection.execute(sql);
-        if (options?.keepFilteredEntities) {
-            const mainEntity = Object.keys(selection.select)[0];
-            const ids = resultset.map((r) => r[`${mainEntity}.id`]);
-            if (ids.length) {
-                const selection_ = {
-                    select: selection.select,
-                    joinWhere: selection.joinWhere,
-                    where: {
-                        [`${mainEntity}.id`]: ids,
-                    },
-                };
-                return await this.query(selection_);
-            }
-        }
-        return qb.buildObjectFromResultset(resultset);
-    }
-    async queryAndCount(selection, options) {
-        await __classPrivateFieldGet(this, _PostgresProvider_isReady_, "f");
-        const connection = this.container_.manager.getConnection();
-        const qb = new utils_2.QueryBuilder({
-            schema: this.schemaObjectRepresentation_,
-            entityMap: this.schemaEntitiesMap_,
-            knex: connection.getKnex(),
-            selector: selection,
-            options,
-        });
-        const sql = qb.buildQuery(true, !!options?.keepFilteredEntities);
-        let resultset = await connection.execute(sql);
-        const count = +(resultset[0]?.count ?? 0);
-        if (options?.keepFilteredEntities) {
-            const mainEntity = Object.keys(selection.select)[0];
-            const ids = resultset.map((r) => r[`${mainEntity}.id`]);
-            if (ids.length) {
-                const selection_ = {
-                    select: selection.select,
-                    joinWhere: selection.joinWhere,
-                    where: {
-                        [`${mainEntity}.id`]: ids,
-                    },
-                };
-                return [await this.query(selection_), count];
-            }
-        }
-        return [qb.buildObjectFromResultset(resultset), count];
-    }
-    consumeEvent(schemaEntityObjectRepresentation) {
-        return async (data, eventName) => {
-            await __classPrivateFieldGet(this, _PostgresProvider_isReady_, "f");
-            const data_ = Array.isArray(data) ? data : [data];
-            let ids = data_.map((d) => d.id);
-            let action = eventName.split(".").pop() || "";
-            const parsedMessage = PostgresProvider.parseMessageData(data);
-            if (parsedMessage) {
-                action = parsedMessage.action;
-                ids = parsedMessage.ids;
-            }
-            const { fields, alias } = schemaEntityObjectRepresentation;
-            const entityData = await this.remoteQuery_((0, utils_1.remoteQueryObjectFromString)({
-                entryPoint: alias,
-                variables: {
-                    filters: {
-                        id: ids,
-                    },
-                },
-                fields,
-            }));
-            const argument = {
-                entity: schemaEntityObjectRepresentation.entity,
-                data: entityData,
-                schemaEntityObjectRepresentation,
-            };
-            const targetMethod = this.eventActionToMethodMap_[action];
-            if (!targetMethod) {
-                return;
-            }
-            await this[targetMethod](argument);
-        };
-    }
-    /**
-     * Create the catalog entry and the catalog relation entry when this event is emitted.
-     * @param entity
-     * @param data
-     * @param schemaEntityObjectRepresentation
-     * @protected
-     */
-    async onCreate({ entity, data, schemaEntityObjectRepresentation, }) {
-        await this.container_.manager.transactional(async (em) => {
-            const catalogRepository = em.getRepository(_models_1.Catalog);
-            const catalogRelationRepository = em.getRepository(_models_1.CatalogRelation);
-            const { data: data_, entityProperties, parentsProperties, } = PostgresProvider.parseData(data, schemaEntityObjectRepresentation);
-            /**
-             * Loop through the data and create catalog entries for each entity as well as the
-             * catalog relation entries if the entity has parents
-             */
-            for (const entityData of data_) {
-                /**
-                 * Clean the entity data to only keep the properties that are defined in the schema
-                 */
-                const cleanedEntityData = entityProperties.reduce((acc, property) => {
-                    acc[property] = entityData[property];
-                    return acc;
-                }, {});
-                await catalogRepository.upsert({
-                    id: cleanedEntityData.id,
-                    name: entity,
-                    data: cleanedEntityData,
-                });
-                /**
-                 * Retrieve the parents to attach it to the catalog entry.
-                 */
-                for (const [parentEntity, parentProperties] of Object.entries(parentsProperties)) {
-                    const parentAlias = parentProperties[0].split(".")[0];
-                    const parentData = entityData[parentAlias];
-                    if (!parentData) {
-                        continue;
-                    }
-                    const parentDataCollection = Array.isArray(parentData)
-                        ? parentData
-                        : [parentData];
-                    for (const parentData_ of parentDataCollection) {
-                        await catalogRepository.upsert({
-                            id: parentData_.id,
-                            name: parentEntity,
-                            data: parentData_,
-                        });
-                        const parentCatalogRelationEntry = catalogRelationRepository.create({
-                            parent_id: parentData_.id,
-                            parent_name: parentEntity,
-                            child_id: cleanedEntityData.id,
-                            child_name: entity,
-                            pivot: `${parentEntity}-${entity}`,
-                        });
-                        catalogRelationRepository.persist(parentCatalogRelationEntry);
-                    }
-                }
-            }
-            await em.flush();
-        });
-    }
-    /**
-     * Update the catalog entry when this event is emitted.
-     * @param entity
-     * @param data
-     * @param schemaEntityObjectRepresentation
-     * @protected
-     */
-    async onUpdate({ entity, data, schemaEntityObjectRepresentation, }) {
-        await this.container_.manager.transactional(async (em) => {
-            const catalogRepository = em.getRepository(_models_1.Catalog);
-            const { data: data_, entityProperties } = PostgresProvider.parseData(data, schemaEntityObjectRepresentation);
-            await catalogRepository.upsertMany(data_.map((entityData) => {
-                return {
-                    id: entityData.id,
-                    name: entity,
-                    data: entityProperties.reduce((acc, property) => {
-                        acc[property] = entityData[property];
-                        return acc;
-                    }, {}),
-                };
-            }));
-        });
-    }
-    /**
-     * Delete the catalog entry when this event is emitted.
-     * @param entity
-     * @param data
-     * @param schemaEntityObjectRepresentation
-     * @protected
-     */
-    async onDelete({ entity, data, schemaEntityObjectRepresentation, }) {
-        await this.container_.manager.transactional(async (em) => {
-            const catalogRepository = em.getRepository(_models_1.Catalog);
-            const catalogRelationRepository = em.getRepository(_models_1.CatalogRelation);
-            const { data: data_ } = PostgresProvider.parseData(data, schemaEntityObjectRepresentation);
-            const ids = data_.map((entityData) => entityData.id);
-            await catalogRepository.nativeDelete({
-                id: { $in: ids },
-                name: entity,
-            });
-            await catalogRelationRepository.nativeDelete({
-                $or: [
-                    {
-                        parent_id: { $in: ids },
-                        parent_name: entity,
-                    },
-                    {
-                        child_id: { $in: ids },
-                        child_name: entity,
-                    },
-                ],
-            });
-        });
-    }
-    /**
-     * 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
-     */
-    async onAttach({ entity, data, schemaEntityObjectRepresentation, }) {
-        await this.container_.manager.transactional(async (em) => {
-            const catalogRepository = em.getRepository(_models_1.Catalog);
-            const catalogRelationRepository = em.getRepository(_models_1.CatalogRelation);
-            const { data: data_, entityProperties } = PostgresProvider.parseData(data, schemaEntityObjectRepresentation);
-            /**
-             * Retrieve the property that represent the foreign key related to the parent entity of the link entity.
-             * Then from the service name of the parent entity, retrieve the entity name using the linkable keys.
-             */
-            const parentPropertyId = schemaEntityObjectRepresentation.moduleConfig.relationships[0]
-                .foreignKey;
-            const parentServiceName = schemaEntityObjectRepresentation.moduleConfig.relationships[0]
-                .serviceName;
-            const parentEntityName = this.schemaObjectRepresentation_._serviceNameModuleConfigMap[parentServiceName].linkableKeys?.[parentPropertyId];
-            if (!parentEntityName) {
-                throw new Error(`SearchModule error, unable to handle attach event for ${entity}. The parent entity name could not be found using the linkable keys from the module ${parentServiceName}.`);
-            }
-            /**
-             * Retrieve the property that represent the foreign key related to the child entity of the link entity.
-             * Then from the service name of the child entity, retrieve the entity name using the linkable keys.
-             */
-            const childPropertyId = schemaEntityObjectRepresentation.moduleConfig.relationships[1]
-                .foreignKey;
-            const childServiceName = schemaEntityObjectRepresentation.moduleConfig.relationships[1]
-                .serviceName;
-            const childEntityName = this.schemaObjectRepresentation_._serviceNameModuleConfigMap[childServiceName].linkableKeys?.[childPropertyId];
-            if (!childEntityName) {
-                throw new Error(`SearchModule error, unable to handle attach event for ${entity}. The child entity name could not be found using the linkable keys from the module ${childServiceName}.`);
-            }
-            for (const entityData of data_) {
-                /**
-                 * Clean the link entity data to only keep the properties that are defined in the schema
-                 */
-                const cleanedEntityData = entityProperties.reduce((acc, property) => {
-                    acc[property] = entityData[property];
-                    return acc;
-                }, {});
-                const catalogEntry = catalogRepository.create({
-                    id: cleanedEntityData.id,
-                    name: entity,
-                    data: cleanedEntityData,
-                });
-                catalogRepository.persist(catalogEntry);
-                /**
-                 * Create the catalog relation entries for the parent entity and the child entity
-                 */
-                const parentCatalogRelationEntry = catalogRelationRepository.create({
-                    parent_id: entityData[parentPropertyId],
-                    parent_name: parentEntityName,
-                    child_id: cleanedEntityData.id,
-                    child_name: entity,
-                    pivot: `${parentEntityName}-${entity}`,
-                });
-                const childCatalogRelationEntry = catalogRelationRepository.create({
-                    parent_id: cleanedEntityData.id,
-                    parent_name: entity,
-                    child_id: entityData[childPropertyId],
-                    child_name: childEntityName,
-                    pivot: `${entity}-${childEntityName}`,
-                });
-                catalogRelationRepository.persist([
-                    parentCatalogRelationEntry,
-                    childCatalogRelationEntry,
-                ]);
-            }
-            await em.flush();
-        });
-    }
-    /**
-     * 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
-     */
-    async onDetach({ entity, data, schemaEntityObjectRepresentation, }) {
-        await this.container_.manager.transactional(async (em) => {
-            const catalogRepository = em.getRepository(_models_1.Catalog);
-            const catalogRelationRepository = em.getRepository(_models_1.CatalogRelation);
-            const { data: data_ } = PostgresProvider.parseData(data, schemaEntityObjectRepresentation);
-            const ids = data_.map((entityData) => entityData.id);
-            await catalogRepository.nativeDelete({
-                id: { $in: ids },
-                name: entity,
-            });
-            await catalogRelationRepository.nativeDelete({
-                $or: [
-                    {
-                        parent_id: { $in: ids },
-                        parent_name: entity,
-                    },
-                    {
-                        child_id: { $in: ids },
-                        child_name: entity,
-                    },
-                ],
-            });
-        });
-    }
-}
-exports.PostgresProvider = PostgresProvider;
-_PostgresProvider_isReady_ = new WeakMap();

package/dist/utils/build-config.d.ts

@@ -1,21 +0,0 @@
-import { SchemaObjectRepresentation } from "../types";
-export declare const CustomDirectives: {
-    Listeners: {
-        configurationPropertyName: string;
-        isRequired: boolean;
-        name: string;
-        directive: string;
-        definition: string;
-    };
-};
-/**
- * This util build an internal representation object from the provided schema.
- * It will resolve all modules, fields, link module representation to build
- * the appropriate representation for the catalog module.
- *
- * This representation will be used to re construct the expected output object from a search
- * but can also be used for anything since the relation tree is available through ref.
- *
- * @param schema
- */
-export declare function buildSchemaObjectRepresentation(schema: any): [SchemaObjectRepresentation, Record<string, any>];