@medusajs/search 0.0.1

package/dist/utils/query-builder.js

@@ -0,0 +1,375 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilder = void 0;
+const utils_1 = require("@medusajs/utils");
+class QueryBuilder {
+    constructor(args) {
+        this.schema = args.schema;
+        this.entityMap = args.entityMap;
+        this.selector = args.selector;
+        this.options = args.options;
+        this.knex = args.knex;
+        this.structure = this.selector.select;
+    }
+    getStructureKeys(structure) {
+        return Object.keys(structure ?? {}).filter((key) => key !== "entity");
+    }
+    getEntity(path) {
+        if (!this.schema._schemaPropertiesMap[path]) {
+            throw new Error(`Could not find entity for path: ${path}`);
+        }
+        return this.schema._schemaPropertiesMap[path];
+    }
+    getGraphQLType(path, field) {
+        const entity = this.getEntity(path)?.ref?.entity;
+        const fieldRef = this.entityMap[entity]._fields[field];
+        if (!fieldRef) {
+            throw new Error(`Field ${field} not found in the entityMap.`);
+        }
+        let currentType = fieldRef.type;
+        while (currentType.ofType) {
+            currentType = currentType.ofType;
+        }
+        return currentType.name;
+    }
+    transformValueToType(path, field, value) {
+        const typeToFn = {
+            Int: (val) => parseInt(val, 10),
+            Float: (val) => parseFloat(val),
+            String: (val) => String(val),
+            Boolean: (val) => Boolean(val),
+            ID: (val) => String(val),
+            Date: (val) => new Date(val).toISOString(),
+            Time: (val) => new Date(`1970-01-01T${val}Z`).toISOString(),
+        };
+        const graphqlType = this.getGraphQLType(path, field);
+        const fn = typeToFn[graphqlType];
+        if (Array.isArray(value)) {
+            return value.map((v) => (!fn ? v : fn(v)));
+        }
+        return !fn ? value : fn(value);
+    }
+    getPostgresCastType(path, field) {
+        const graphqlToPostgresTypeMap = {
+            Int: "::integer",
+            Float: "::double precision",
+            Boolean: "::boolean",
+            Date: "::timestamp",
+            Time: "::time",
+        };
+        const graphqlType = this.getGraphQLType(path, field);
+        return graphqlToPostgresTypeMap[graphqlType] ?? "";
+    }
+    parseWhere(aliasMapping, obj, builder) {
+        const OPERATOR_MAP = {
+            $eq: "=",
+            $lt: "<",
+            $gt: ">",
+            $lte: "<=",
+            $gte: ">=",
+            $ne: "!=",
+            $in: "IN",
+            $like: "LIKE",
+            $ilike: "ILIKE",
+        };
+        const keys = Object.keys(obj);
+        keys.forEach((key) => {
+            let value = obj[key];
+            if ((key === "$and" || key === "$or") && !Array.isArray(value)) {
+                value = [value];
+            }
+            if (key === "$and" && Array.isArray(value)) {
+                builder.where((qb) => {
+                    value.forEach((cond) => {
+                        qb.andWhere((subBuilder) => this.parseWhere(aliasMapping, cond, subBuilder));
+                    });
+                });
+            }
+            else if (key === "$or" && Array.isArray(value)) {
+                builder.where((qb) => {
+                    value.forEach((cond) => {
+                        qb.orWhere((subBuilder) => this.parseWhere(aliasMapping, cond, subBuilder));
+                    });
+                });
+            }
+            else if ((0, utils_1.isObject)(value) && !Array.isArray(value)) {
+                const subKeys = Object.keys(value);
+                subKeys.forEach((subKey) => {
+                    let operator = OPERATOR_MAP[subKey];
+                    if (operator) {
+                        const path = key.split(".");
+                        const field = path.pop();
+                        const attr = path.join(".");
+                        const subValue = this.transformValueToType(attr, field, value[subKey]);
+                        const castType = this.getPostgresCastType(attr, field);
+                        const val = operator === "IN" ? subValue : [subValue];
+                        builder.whereRaw(`(${aliasMapping[attr]}.data->>?)${castType} ${operator} ?`, [field, ...val]);
+                    }
+                    else {
+                        throw new Error(`Unsupported operator: ${subKey}`);
+                    }
+                });
+            }
+            else {
+                const path = key.split(".");
+                const field = path.pop();
+                const attr = path.join(".");
+                value = this.transformValueToType(attr, field, value);
+                if (Array.isArray(value)) {
+                    const castType = this.getPostgresCastType(attr, field);
+                    builder.whereRaw(`(${aliasMapping[attr]}.data->>?)${castType} IN (?)`, [field, ...value]);
+                }
+                else {
+                    const castType = this.getPostgresCastType(attr, field);
+                    builder.whereRaw(`(${aliasMapping[attr]}.data->>?)${castType} = ?`, [
+                        field,
+                        value,
+                    ]);
+                }
+            }
+        });
+        return builder;
+    }
+    buildQueryParts(structure, parentAlias, parentEntity, parentProperty, aliasPath = [], level = 0, aliasMapping = {}) {
+        const currentAliasPath = [...aliasPath, parentProperty].join(".");
+        const entities = this.getEntity(currentAliasPath);
+        const mainEntity = entities.ref.entity;
+        const mainAlias = mainEntity.toLowerCase() + level;
+        const allEntities = [];
+        if (!entities.shortCutOf) {
+            allEntities.push({
+                entity: mainEntity,
+                parEntity: parentEntity,
+                parAlias: parentAlias,
+                alias: mainAlias,
+            });
+        }
+        else {
+            const intermediateAlias = entities.shortCutOf.split(".");
+            for (let i = intermediateAlias.length - 1, x = 0; i >= 0; i--, x++) {
+                const intermediateEntity = this.getEntity(intermediateAlias.join("."));
+                intermediateAlias.pop();
+                if (intermediateEntity.ref.entity === parentEntity) {
+                    break;
+                }
+                const parentIntermediateEntity = this.getEntity(intermediateAlias.join("."));
+                const alias = intermediateEntity.ref.entity.toLowerCase() + level + "_" + x;
+                const parAlias = parentIntermediateEntity.ref.entity === parentEntity
+                    ? parentAlias
+                    : parentIntermediateEntity.ref.entity.toLowerCase() +
+                        level +
+                        "_" +
+                        (x + 1);
+                if (x === 0) {
+                    aliasMapping[currentAliasPath] = alias;
+                }
+                allEntities.unshift({
+                    entity: intermediateEntity.ref.entity,
+                    parEntity: parentIntermediateEntity.ref.entity,
+                    parAlias,
+                    alias,
+                });
+            }
+        }
+        let queryParts = [];
+        for (const join of allEntities) {
+            const { alias, entity, parEntity, parAlias } = join;
+            aliasMapping[currentAliasPath] = alias;
+            if (level > 0) {
+                const subQuery = this.knex.queryBuilder();
+                const knex = this.knex;
+                subQuery
+                    .select(`${alias}.id`, `${alias}.data`)
+                    .from("catalog AS " + alias)
+                    .join(`catalog_relation AS ${alias}_ref`, function () {
+                    this.on(`${alias}_ref.pivot`, "=", knex.raw("?", [`${parEntity}-${entity}`]))
+                        .andOn(`${alias}_ref.parent_id`, "=", `${parAlias}.id`)
+                        .andOn(`${alias}.id`, "=", `${alias}_ref.child_id`);
+                })
+                    .where(`${alias}.name`, "=", knex.raw("?", [entity]));
+                const joinWhere = this.selector.joinWhere ?? {};
+                const joinKey = Object.keys(joinWhere).find((key) => {
+                    const k = key.split(".");
+                    k.pop();
+                    return k.join(".") === currentAliasPath;
+                });
+                if (joinKey) {
+                    this.parseWhere(aliasMapping, { [joinKey]: joinWhere[joinKey] }, subQuery);
+                }
+                queryParts.push(`LEFT JOIN LATERAL (
+          ${subQuery.toQuery()}
+        ) ${alias} ON TRUE`);
+            }
+        }
+        const children = this.getStructureKeys(structure);
+        for (const child of children) {
+            const childStructure = structure[child];
+            queryParts = queryParts.concat(this.buildQueryParts(childStructure, mainAlias, mainEntity, child, aliasPath.concat(parentProperty), level + 1, aliasMapping));
+        }
+        return queryParts;
+    }
+    buildSelectParts(structure, parentProperty, aliasMapping, aliasPath = [], selectParts = {}) {
+        const currentAliasPath = [...aliasPath, parentProperty].join(".");
+        const alias = aliasMapping[currentAliasPath];
+        selectParts[currentAliasPath] = `${alias}.data`;
+        selectParts[currentAliasPath + ".id"] = `${alias}.id`;
+        const children = this.getStructureKeys(structure);
+        for (const child of children) {
+            const childStructure = structure[child];
+            this.buildSelectParts(childStructure, child, aliasMapping, aliasPath.concat(parentProperty), selectParts);
+        }
+        return selectParts;
+    }
+    transformOrderBy(arr) {
+        const result = {};
+        const map = new Map();
+        map.set(true, "ASC");
+        map.set(1, "ASC");
+        map.set("ASC", "ASC");
+        map.set(false, "DESC");
+        map.set(-1, "DESC");
+        map.set("DESC", "DESC");
+        function nested(obj, prefix = "") {
+            const keys = Object.keys(obj);
+            if (!keys.length) {
+                return;
+            }
+            else if (keys.length > 1) {
+                throw new Error("Order by only supports one key per object.");
+            }
+            const key = keys[0];
+            let value = obj[key];
+            if ((0, utils_1.isObject)(value)) {
+                nested(value, prefix + key + ".");
+            }
+            else {
+                if ((0, utils_1.isString)(value)) {
+                    value = value.toUpperCase();
+                }
+                result[prefix + key] = map.get(value) ?? "ASC";
+            }
+        }
+        arr.forEach((obj) => nested(obj));
+        return result;
+    }
+    buildQuery(countAllResults = true, returnIdOnly = false) {
+        const queryBuilder = this.knex.queryBuilder();
+        const structure = this.structure;
+        const filter = this.selector.where ?? {};
+        const { orderBy: order, skip, take } = this.options ?? {};
+        const orderBy = this.transformOrderBy((order && !Array.isArray(order) ? [order] : order) ?? []);
+        const rootKey = this.getStructureKeys(structure)[0];
+        const rootStructure = structure[rootKey];
+        const entity = this.getEntity(rootKey).ref.entity;
+        const rootEntity = entity.toLowerCase();
+        const aliasMapping = {};
+        const joinParts = this.buildQueryParts(rootStructure, "", entity, rootKey, [], 0, aliasMapping);
+        const rootAlias = aliasMapping[rootKey];
+        const selectParts = !returnIdOnly
+            ? this.buildSelectParts(rootStructure, rootKey, aliasMapping)
+            : { [rootKey + ".id"]: `${rootAlias}.id` };
+        if (countAllResults) {
+            selectParts["offset_"] = this.knex.raw(`DENSE_RANK() OVER (ORDER BY ${rootEntity}0.id)`);
+        }
+        queryBuilder.select(selectParts);
+        queryBuilder.from(`catalog AS ${rootEntity}0`);
+        joinParts.forEach((joinPart) => {
+            queryBuilder.joinRaw(joinPart);
+        });
+        queryBuilder.where(`${aliasMapping[rootEntity]}.name`, "=", entity);
+        // WHERE clause
+        this.parseWhere(aliasMapping, filter, queryBuilder);
+        // ORDER BY clause
+        for (const aliasPath in orderBy) {
+            const path = aliasPath.split(".");
+            const field = path.pop();
+            const attr = path.join(".");
+            const alias = aliasMapping[attr];
+            const direction = orderBy[aliasPath];
+            queryBuilder.orderByRaw(`${alias}.data->>'${field}' ${direction}`);
+        }
+        let sql = `WITH data AS (${queryBuilder.toQuery()})
+    SELECT * ${countAllResults ? ", (SELECT max(offset_) FROM data) AS count" : ""}
+    FROM data`;
+        let take_ = !isNaN(+take) ? +take : 15;
+        let skip_ = !isNaN(+skip) ? +skip : 0;
+        if (typeof take === "number" || typeof skip === "number") {
+            sql += `
+        WHERE offset_ > ${skip_}
+          AND offset_ <= ${skip_ + take_}
+      `;
+        }
+        return sql;
+    }
+    buildObjectFromResultset(resultSet) {
+        const structure = this.structure;
+        const rootKey = this.getStructureKeys(structure)[0];
+        const maps = {};
+        const isListMap = {};
+        const referenceMap = {};
+        const pathDetails = {};
+        const initializeMaps = (structure, path) => {
+            const currentPath = path.join(".");
+            maps[currentPath] = {};
+            if (path.length > 1) {
+                const property = path[path.length - 1];
+                const parents = path.slice(0, -1);
+                const parentPath = parents.join(".");
+                isListMap[currentPath] = !!this.getEntity(currentPath).ref.parents.find((p) => p.targetProp === property)?.isList;
+                pathDetails[currentPath] = { property, parents, parentPath };
+            }
+            const children = this.getStructureKeys(structure);
+            for (const key of children) {
+                initializeMaps(structure[key], [...path, key]);
+            }
+        };
+        initializeMaps(structure[rootKey], [rootKey]);
+        function buildReferenceKey(path, id, row) {
+            let current = "";
+            let key = "";
+            for (const p of path) {
+                current += `${p}`;
+                key += row[`${current}.id`] + ".";
+                current += ".";
+            }
+            return key + id;
+        }
+        resultSet.forEach((row) => {
+            for (const path in maps) {
+                const id = row[`${path}.id`];
+                // root level
+                if (!pathDetails[path]) {
+                    if (!maps[path][id]) {
+                        maps[path][id] = row[path] || undefined;
+                    }
+                    continue;
+                }
+                const { property, parents, parentPath } = pathDetails[path];
+                const referenceKey = buildReferenceKey(parents, id, row);
+                if (referenceMap[referenceKey]) {
+                    continue;
+                }
+                maps[path][id] = row[path] || undefined;
+                const parentObj = maps[parentPath][row[`${parentPath}.id`]];
+                if (!parentObj) {
+                    continue;
+                }
+                const isList = isListMap[parentPath + "." + property];
+                if (isList) {
+                    parentObj[property] ?? (parentObj[property] = []);
+                }
+                if (maps[path][id] !== undefined) {
+                    if (isList) {
+                        parentObj[property].push(maps[path][id]);
+                    }
+                    else {
+                        parentObj[property] = maps[path][id];
+                    }
+                }
+                referenceMap[referenceKey] = true;
+            }
+        });
+        return Object.values(maps[rootKey] ?? {});
+    }
+}
+exports.QueryBuilder = QueryBuilder;

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@medusajs/search",
+  "version": "0.0.1",
+  "description": "Medusa Search module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "medusa-search-migrations-down": "dist/scripts/bin/run-migration-down.js",
+    "medusa-search-migrations-up": "dist/scripts/bin/run-migration-up.js",
+    "medusa-search-seed": "dist/scripts/bin/run-seed.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/medusajs/medusa",
+    "directory": "packages/search"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Medusa",
+  "license": "MIT",
+  "scripts": {
+    "watch": "tsc --build --watch",
+    "watch:test": "tsc --build tsconfig.spec.json --watch",
+    "prepublishOnly": "cross-env NODE_ENV=production tsc --build && tsc-alias -p tsconfig.json",
+    "build": "rimraf dist && tsc --build && tsc-alias -p tsconfig.json",
+    "test": "jest --runInBand --bail --passWithNoTests --forceExit -- ./src/__tests__/**/*.ts",
+    "test:integration": "jest --runInBand --passWithNoTests --forceExit -- ./integration-tests/**/__tests__/**/*.ts",
+    "migration:generate": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm migration:generate",
+    "migration:initial": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm migration:create --initial",
+    "migration:create": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm migration:create",
+    "migration:up": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm migration:up",
+    "orm:cache:clear": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm cache:clear",
+    "experiment": "ts-node src/_experiments/experiment.ts"
+  },
+  "devDependencies": {
+    "@faker-js/faker": "^8.2.0",
+    "@medusajs/types": "^1.11.1",
+    "@mikro-orm/cli": "5.7.12",
+    "cross-env": "^5.2.1",
+    "jest": "^29.6.3",
+    "medusa-test-utils": "^1.1.40",
+    "pg-god": "^1.0.12",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "tsc-alias": "^1.8.6",
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "@graphql-tools/merge": "^9.0.0",
+    "@graphql-tools/schema": "^10.0.0",
+    "@medusajs/modules-sdk": "^1.11.0",
+    "@medusajs/utils": "^1.10.1",
+    "@mikro-orm/core": "5.7.12",
+    "@mikro-orm/migrations": "5.7.12",
+    "@mikro-orm/postgresql": "5.7.12",
+    "awilix": "^8.0.0",
+    "dotenv": "^16.1.4",
+    "graphql": "^16.8.1",
+    "knex": "2.4.2",
+    "lodash": "^4.17.21"
+  }
+}