@medusajs/index 0.0.1

package/dist/utils/gql-to-types.js

@@ -0,0 +1,89 @@
+"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.gqlSchemaToTypes = void 0;
+const path_1 = require("path");
+const build_config_1 = require("./build-config");
+const modules_sdk_1 = require("@medusajs/modules-sdk");
+const utils_1 = require("@medusajs/utils");
+const process = __importStar(require("process"));
+async function gqlSchemaToTypes(schema) {
+    const augmentedSchema = build_config_1.CustomDirectives.Listeners.definition + schema;
+    const executableSchema = (0, build_config_1.makeSchemaExecutable)(augmentedSchema);
+    const filename = "index-service-entry-points";
+    const filenameWithExt = filename + ".d.ts";
+    const dir = (0, path_1.join)(process.cwd(), ".medusa");
+    await (0, modules_sdk_1.gqlSchemaToTypes)({
+        schema: executableSchema,
+        filename,
+        outputDir: dir,
+    });
+    const fileSystem = new utils_1.FileSystem(dir);
+    let content = await fileSystem.contents(filenameWithExt);
+    await fileSystem.remove(filenameWithExt);
+    const entryPoints = buildEntryPointsTypeMap(content);
+    const indexEntryPoints = `
+declare module '@medusajs/types' {
+  interface IndexServiceEntryPoints  {
+${entryPoints
+        .map((entry) => `    ${entry.entryPoint}: ${entry.entityType}`)
+        .join("\n")}
+  }
+}`;
+    const contentToReplaceMatcher = new RegExp(`declare\\s+module\\s+['"][^'"]+['"]\\s*{([^}]*?)}\\s+}`, "gm");
+    content = content.replace(contentToReplaceMatcher, indexEntryPoints);
+    await fileSystem.create(filenameWithExt, content);
+}
+exports.gqlSchemaToTypes = gqlSchemaToTypes;
+function buildEntryPointsTypeMap(schema) {
+    // build map entry point to there type to be merged and used by the remote query
+    const joinerConfigs = modules_sdk_1.MedusaModule.getAllJoinerConfigs();
+    return joinerConfigs
+        .flatMap((config) => {
+        const aliases = Array.isArray(config.alias)
+            ? config.alias
+            : config.alias
+                ? [config.alias]
+                : [];
+        return aliases.flatMap((alias) => {
+            const names = Array.isArray(alias.name) ? alias.name : [alias.name];
+            const entity = alias?.["entity"];
+            return names.map((aliasItem) => {
+                if (!schema.includes(`export type ${entity} `)) {
+                    return;
+                }
+                return {
+                    entryPoint: aliasItem,
+                    entityType: entity
+                        ? schema.includes(`export type ${entity} `)
+                            ? alias?.["entity"]
+                            : "any"
+                        : "any",
+                };
+            });
+        });
+    })
+        .filter(Boolean);
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./query-builder";
+export * from "./create-partitions";
+export * from "./build-config";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,qBAAqB,CAAA;AACnC,cAAc,gBAAgB,CAAA"}

package/dist/utils/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./query-builder"), exports);
+__exportStar(require("./create-partitions"), exports);
+__exportStar(require("./build-config"), exports);

package/dist/utils/normalize-fields-selection.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeFieldsSelection(fields: string[]): Record<string, any>;
+//# sourceMappingURL=normalize-fields-selection.d.ts.map

package/dist/utils/normalize-fields-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-fields-selection.d.ts","sourceRoot":"","sources":["../../src/utils/normalize-fields-selection.ts"],"names":[],"mappings":"AAEA,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,uBAIxD"}

package/dist/utils/normalize-fields-selection.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeFieldsSelection = void 0;
+const utils_1 = require("@medusajs/utils");
+function normalizeFieldsSelection(fields) {
+    const normalizedFields = fields.map((field) => field.replace(/\.\*/g, ""));
+    const fieldsObject = (0, utils_1.objectFromStringPath)(normalizedFields);
+    return fieldsObject;
+}
+exports.normalizeFieldsSelection = normalizeFieldsSelection;

package/dist/utils/query-builder.d.ts

@@ -0,0 +1,42 @@
+import { IndexTypes } from "@medusajs/types";
+import { Knex } from "knex";
+import { QueryFormat, QueryOptions } from "../types";
+export declare const OPERATOR_MAP: {
+    $eq: string;
+    $lt: string;
+    $gt: string;
+    $lte: string;
+    $gte: string;
+    $ne: string;
+    $in: string;
+    $is: string;
+    $like: string;
+    $ilike: string;
+};
+export declare class QueryBuilder {
+    private readonly structure;
+    private readonly entityMap;
+    private readonly knex;
+    private readonly selector;
+    private readonly options?;
+    private readonly schema;
+    constructor(args: {
+        schema: IndexTypes.SchemaObjectRepresentation;
+        entityMap: Record<string, any>;
+        knex: Knex;
+        selector: QueryFormat;
+        options?: QueryOptions;
+    });
+    private getStructureKeys;
+    private getEntity;
+    private getGraphQLType;
+    private transformValueToType;
+    private getPostgresCastType;
+    private parseWhere;
+    private buildQueryParts;
+    private buildSelectParts;
+    private transformOrderBy;
+    buildQuery(countAllResults?: boolean, returnIdOnly?: boolean): string;
+    buildObjectFromResultset(resultSet: Record<string, any>[]): Record<string, any>[];
+}
+//# sourceMappingURL=query-builder.d.ts.map

package/dist/utils/query-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-builder.d.ts","sourceRoot":"","sources":["../../src/utils/query-builder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAE5C,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAC3B,OAAO,EAAW,WAAW,EAAE,YAAY,EAAU,MAAM,QAAQ,CAAA;AAEnE,eAAO,MAAM,YAAY;;;;;;;;;;;CAWxB,CAAA;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqB;IAC/C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAM;IAC3B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAa;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAc;IACvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuC;gBAElD,IAAI,EAAE;QAChB,MAAM,EAAE,UAAU,CAAC,0BAA0B,CAAA;QAC7C,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QAC9B,IAAI,EAAE,IAAI,CAAA;QACV,QAAQ,EAAE,WAAW,CAAA;QACrB,OAAO,CAAC,EAAE,YAAY,CAAA;KACvB;IASD,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,SAAS;IAQjB,OAAO,CAAC,cAAc;IAoBtB,OAAO,CAAC,oBAAoB;IA2B5B,OAAO,CAAC,mBAAmB;IAsB3B,OAAO,CAAC,UAAU;IAoIlB,OAAO,CAAC,eAAe;IA8HvB,OAAO,CAAC,gBAAgB;IA8BxB,OAAO,CAAC,gBAAgB;IAiCjB,UAAU,CAAC,eAAe,UAAO,EAAE,YAAY,UAAQ,GAAG,MAAM;IAiFhE,wBAAwB,CAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAC/B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE;CA+FzB"}

package/dist/utils/query-builder.js

@@ -0,0 +1,420 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilder = exports.OPERATOR_MAP = void 0;
+const utils_1 = require("@medusajs/utils");
+const graphql_1 = require("graphql");
+exports.OPERATOR_MAP = {
+    $eq: "=",
+    $lt: "<",
+    $gt: ">",
+    $lte: "<=",
+    $gte: ">=",
+    $ne: "!=",
+    $in: "IN",
+    $is: "IS",
+    $like: "LIKE",
+    $ilike: "ILIKE",
+};
+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;
+        let isArray = false;
+        while (currentType.ofType) {
+            if (currentType instanceof graphql_1.GraphQLList) {
+                isArray = true;
+            }
+            currentType = currentType.ofType;
+        }
+        return currentType.name + (isArray ? "[]" : "");
+    }
+    transformValueToType(path, field, value) {
+        if (value === null) {
+            return null;
+        }
+        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 fullPath = [path, ...field];
+        const prop = fullPath.pop();
+        const fieldPath = fullPath.join(".");
+        const graphqlType = this.getGraphQLType(fieldPath, prop).replace("[]", "");
+        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: "::int",
+            Float: "::double precision",
+            Boolean: "::boolean",
+            Date: "::timestamp",
+            Time: "::time",
+            "": "",
+        };
+        const fullPath = [path, ...field];
+        const prop = fullPath.pop();
+        const fieldPath = fullPath.join(".");
+        let graphqlType = this.getGraphQLType(fieldPath, prop);
+        const isList = graphqlType.endsWith("[]");
+        graphqlType = graphqlType.replace("[]", "");
+        return ((graphqlToPostgresTypeMap[graphqlType] ?? "") + (isList ? "[]" : "") ?? "");
+    }
+    parseWhere(aliasMapping, obj, builder) {
+        const keys = Object.keys(obj);
+        const getPathAndField = (key) => {
+            const path = key.split(".");
+            const field = [path.pop()];
+            while (!aliasMapping[path.join(".")] && path.length > 0) {
+                field.unshift(path.pop());
+            }
+            const attr = path.join(".");
+            return { field, attr };
+        };
+        const getPathOperation = (attr, path, value) => {
+            const partialPath = path.length > 1 ? path.slice(0, -1) : path;
+            const val = this.transformValueToType(attr, partialPath, value);
+            const result = path.reduceRight((acc, key) => {
+                return { [key]: acc };
+            }, val);
+            return JSON.stringify(result);
+        };
+        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 = exports.OPERATOR_MAP[subKey];
+                    if (operator) {
+                        const { field, attr } = getPathAndField(key);
+                        const nested = new Array(field.length).join("->?");
+                        const subValue = this.transformValueToType(attr, field, value[subKey]);
+                        const castType = this.getPostgresCastType(attr, field);
+                        const val = operator === "IN" ? subValue : [subValue];
+                        if (operator === "=" && subValue === null) {
+                            operator = "IS";
+                        }
+                        if (operator === "=") {
+                            builder.whereRaw(`${aliasMapping[attr]}.data @> '${getPathOperation(attr, field, subValue)}'::jsonb`);
+                        }
+                        else {
+                            builder.whereRaw(`(${aliasMapping[attr]}.data${nested}->>?)${castType} ${operator} ?`, [...field, ...val]);
+                        }
+                    }
+                    else {
+                        throw new Error(`Unsupported operator: ${subKey}`);
+                    }
+                });
+            }
+            else {
+                const { field, attr } = getPathAndField(key);
+                const nested = new Array(field.length).join("->?");
+                value = this.transformValueToType(attr, field, value);
+                if (Array.isArray(value)) {
+                    const castType = this.getPostgresCastType(attr, field);
+                    const inPlaceholders = value.map(() => "?").join(",");
+                    builder.whereRaw(`(${aliasMapping[attr]}.data${nested}->>?)${castType} IN (${inPlaceholders})`, [...field, ...value]);
+                }
+                else {
+                    const operator = value === null ? "IS" : "=";
+                    if (operator === "=") {
+                        builder.whereRaw(`${aliasMapping[attr]}.data @> '${getPathOperation(attr, field, value)}'::jsonb`);
+                    }
+                    else {
+                        const castType = this.getPostgresCastType(attr, field);
+                        builder.whereRaw(`(${aliasMapping[attr]}.data${nested}->>?)${castType} ${operator} ?`, [...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("index_data AS " + alias)
+                    .join(`index_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(`index_data 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] ??= [];
+                }
+                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,55 @@
+{
+  "name": "@medusajs/index",
+  "version": "0.0.1",
+  "description": "Medusa Index module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/medusajs/medusa",
+    "directory": "packages/index"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Medusa",
+  "license": "MIT",
+  "scripts": {
+    "watch": "tsc --build --watch",
+    "watch:test": "tsc --build tsconfig.spec.json --watch",
+    "build": "rimraf dist && tsc -p ./tsconfig.spec.json --noEmit && tsc -p ./tsconfig.build.json && tsc-alias -p ./tsconfig.build.json",
+    "test": "jest --passWithNoTests ./src",
+    "test:integration": "jest --runInBand --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"
+  },
+  "devDependencies": {
+    "@medusajs/types": "^1.11.16",
+    "@mikro-orm/cli": "5.9.7",
+    "cross-env": "^5.2.1",
+    "jest": "^29.7.0",
+    "medusa-test-utils": "^1.1.44",
+    "rimraf": "^3.0.2",
+    "ts-node": "^10.9.1",
+    "tsc-alias": "^1.8.6",
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "@medusajs/utils": "^1.11.9"
+  },
+  "peerDependencies": {
+    "@mikro-orm/core": "5.9.7",
+    "@mikro-orm/migrations": "5.9.7",
+    "@mikro-orm/postgresql": "5.9.7",
+    "awilix": "^8.0.1"
+  }
+}