@medusajs/search 0.0.1

package/dist/services/postgres-provider.js

@@ -0,0 +1,441 @@
+"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/services/search-module-service.d.ts

@@ -0,0 +1,31 @@
+import { IEventBusModuleService, InternalModuleDeclaration, ModuleJoinerConfig, RemoteJoinerQuery, SearchModuleTypes } from "@medusajs/types";
+import { SchemaObjectRepresentation, StorageProvider } from "../types";
+type InjectedDependencies = {
+    eventBusModuleService: IEventBusModuleService;
+    storageProviderCtr: StorageProvider;
+    storageProviderCtrOptions: unknown;
+    remoteQuery: (query: string | RemoteJoinerQuery | object, variables?: Record<string, unknown>) => Promise<any>;
+};
+export default class SearchModuleService implements SearchModuleTypes.ISearchModuleService {
+    protected readonly moduleDeclaration: InternalModuleDeclaration;
+    private readonly container_;
+    private readonly moduleOptions_;
+    protected readonly eventBusModuleService_: IEventBusModuleService;
+    protected schemaObjectRepresentation_: SchemaObjectRepresentation;
+    protected schemaEntitiesMap_: Record<string, any>;
+    protected storageProviderInstance_: StorageProvider;
+    protected readonly storageProviderCtr_: StorageProvider;
+    protected readonly storageProviderCtrOptions_: unknown;
+    protected storageProvider_: StorageProvider;
+    constructor(container: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
+    __hooks: {
+        onApplicationStart(this: SearchModuleService): Promise<void>;
+    };
+    __joinerConfig(): ModuleJoinerConfig;
+    protected onApplicationStart_(): Promise<void>;
+    query(...args: any[]): Promise<any>;
+    queryAndCount(...args: any[]): Promise<any>;
+    protected registerListeners(): void;
+    private buildSchemaObjectRepresentation_;
+}
+export {};

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../types");
+const build_config_1 = require("../utils/build-config");
+const joiner_config_1 = require("./../joiner-config");
+class SearchModuleService {
+    constructor(container, moduleDeclaration) {
+        this.moduleDeclaration = moduleDeclaration;
+        this.__hooks = {
+            onApplicationStart() {
+                return this.onApplicationStart_();
+            },
+        };
+        this.container_ = container;
+        this.moduleOptions_ = (moduleDeclaration.options ??
+            moduleDeclaration);
+        const { eventBusModuleService, storageProviderCtr, storageProviderCtrOptions, } = container;
+        this.eventBusModuleService_ = eventBusModuleService;
+        this.storageProviderCtr_ = storageProviderCtr;
+        this.storageProviderCtrOptions_ = storageProviderCtrOptions;
+        if (!this.eventBusModuleService_) {
+            throw new Error("EventBusModuleService is required for the SearchModule to work");
+        }
+    }
+    __joinerConfig() {
+        return joiner_config_1.joinerConfig;
+    }
+    async onApplicationStart_() {
+        this.buildSchemaObjectRepresentation_();
+        this.storageProvider_ = new this.storageProviderCtr_(this.container_, Object.assign(this.storageProviderCtrOptions_ ?? {}, {
+            schemaObjectRepresentation: this.schemaObjectRepresentation_,
+            entityMap: this.schemaEntitiesMap_,
+        }), this.moduleOptions_);
+        this.registerListeners();
+        if (this.storageProvider_.onApplicationStart) {
+            await this.storageProvider_.onApplicationStart();
+        }
+    }
+    async query(...args) {
+        return await this.storageProvider_.query.apply(this.storageProvider_, args);
+    }
+    async queryAndCount(...args) {
+        return await this.storageProvider_.queryAndCount.apply(this.storageProvider_, args);
+    }
+    registerListeners() {
+        const schemaObjectRepresentation = this.schemaObjectRepresentation_ ?? {};
+        for (const [entityName, schemaEntityObjectRepresentation] of Object.entries(schemaObjectRepresentation)) {
+            if (types_1.schemaObjectRepresentationPropertiesToOmit.includes(entityName)) {
+                continue;
+            }
+            schemaEntityObjectRepresentation.listeners.forEach((listener) => {
+                this.eventBusModuleService_.subscribe(listener, this.storageProvider_.consumeEvent(schemaEntityObjectRepresentation));
+            });
+        }
+    }
+    buildSchemaObjectRepresentation_() {
+        if (this.schemaObjectRepresentation_) {
+            return this.schemaObjectRepresentation_;
+        }
+        const [objectRepresentation, entityMap] = (0, build_config_1.buildSchemaObjectRepresentation)(this.moduleOptions_.schema);
+        this.schemaObjectRepresentation_ = objectRepresentation;
+        this.schemaEntitiesMap_ = entityMap;
+        return this.schemaObjectRepresentation_;
+    }
+}
+exports.default = SearchModuleService;

package/dist/types/index.d.ts

@@ -0,0 +1,122 @@
+import { ModuleJoinerConfig, ModulesSdkTypes, Subscriber } from "@medusajs/types";
+/**
+ * Represents the module options that can be provided
+ */
+export interface SearchModuleOptions {
+    customAdapter?: {
+        constructor: new (...args: any[]) => any;
+        options: any;
+    };
+    defaultAdapterOptions?: ModulesSdkTypes.ModuleServiceInitializeOptions;
+    schema: string;
+}
+export type SchemaObjectEntityRepresentation = {
+    /**
+     * The name of the type/entity in the schema
+     */
+    entity: string;
+    /**
+     * All parents a type/entity refers to in the schema
+     * or through links
+     */
+    parents: {
+        /**
+         * The reference to the schema object representation
+         * of the parent
+         */
+        ref: SchemaObjectEntityRepresentation;
+        /**
+         * When a link is inferred between two types/entities
+         * we are configuring the link tree, and therefore we are
+         * storing the reference to the parent type/entity within the
+         * schema which defer from the true parent from a pure entity
+         * point of view
+         */
+        inSchemaRef?: SchemaObjectEntityRepresentation;
+        /**
+         * The property the data should be assigned to in the parent
+         */
+        targetProp: string;
+        /**
+         * Are the data expected to be a list or not
+         */
+        isList?: boolean;
+    }[];
+    /**
+     * The default fields to query for the type/entity
+     */
+    fields: string[];
+    /**
+     * @Listerners directive is required and all listeners found
+     * for the type will be stored here
+     */
+    listeners: string[];
+    /**
+     * The alias for the type/entity retrieved in the corresponding
+     * module
+     */
+    alias: string;
+    /**
+     * The module joiner config corresponding to the module the type/entity
+     * refers to
+     */
+    moduleConfig: ModuleJoinerConfig;
+};
+export type SchemaPropertiesMap = {
+    [key: string]: {
+        shortCutOf?: string;
+        ref: SchemaObjectEntityRepresentation;
+    };
+};
+export type EntityNameModuleConfigMap = {
+    [key: string]: ModuleJoinerConfig;
+};
+/**
+ * Represents the schema objects representation once the schema has been processed
+ */
+export type SchemaObjectRepresentation = {
+    [key: string]: SchemaObjectEntityRepresentation;
+} | {
+    _schemaPropertiesMap: SchemaPropertiesMap;
+    _serviceNameModuleConfigMap: EntityNameModuleConfigMap;
+};
+export declare const schemaObjectRepresentationPropertiesToOmit: string[];
+/**
+ * Represents the storage provider interface, TODO: move this to @medusajs/types once we are settled on the interface
+ */
+export interface StorageProvider {
+    new (container: {
+        [key: string]: any;
+    }, storageProviderOptions: unknown & {
+        schemaObjectRepresentation: SchemaObjectRepresentation;
+    }, moduleOptions: SearchModuleOptions): StorageProvider;
+    onApplicationStart?(): Promise<void>;
+    query(...args: any[]): unknown;
+    queryAndCount(...args: any[]): unknown;
+    consumeEvent(schemaEntityObjectRepresentation: SchemaObjectEntityRepresentation): Subscriber;
+}
+export type Select = {
+    [key: string]: boolean | Select | Select[];
+};
+export type Where = {
+    [key: string]: any;
+};
+export type OrderBy = {
+    [path: string]: OrderBy | "ASC" | "DESC" | 1 | -1 | true | false;
+};
+export type QueryFormat = {
+    select: Select;
+    where?: Where;
+    joinWhere?: Where;
+};
+export type QueryOptions = {
+    skip?: number;
+    take?: number;
+    orderBy?: OrderBy | OrderBy[];
+    keepFilteredEntities?: boolean;
+};
+type ResultSetLimit = [never | 0 | 1 | 2];
+export type Resultset<Select, Prev extends number = 3> = Prev extends never ? never : {
+    [key in keyof Select]: Select[key] extends boolean ? string : Select[key] extends Select[] ? Resultset<Select[key][0], ResultSetLimit[Prev]>[] : Select[key] extends {} ? Resultset<Select[key], ResultSetLimit[Prev]> : unknown;
+};
+export {};

package/dist/types/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaObjectRepresentationPropertiesToOmit = void 0;
+exports.schemaObjectRepresentationPropertiesToOmit = [
+    "_schemaPropertiesMap",
+    "_serviceNameModuleConfigMap",
+];