medusa-product-helper 0.0.13 → 0.0.16

package/.medusa/server/src/services/filter-provider-loader.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFilterProviders = loadFilterProviders;
+const base_filter_provider_1 = require("../providers/filter-providers/base-filter-provider");
+/**
+ * Load filter providers from configuration.
+ *
+ * This function loads custom filter providers from file paths or module references.
+ * Supports both:
+ * - File paths (relative to baseDir or absolute)
+ * - Module references (npm package names)
+ *
+ * @param configs - Array of filter provider configurations
+ * @param options - Loading options
+ * @returns Array of instantiated filter provider instances
+ * @throws Error if provider cannot be loaded or instantiated
+ *
+ * @example
+ * ```ts
+ * // Load from file path
+ * const providers = await loadFilterProviders([
+ *   "./src/providers/margin-provider.ts"
+ * ])
+ *
+ * // Load from module
+ * const providers = await loadFilterProviders([
+ *   "@my-org/custom-filters/margin-provider"
+ * ])
+ *
+ * // Load with options
+ * const providers = await loadFilterProviders([
+ *   { path: "./src/providers/margin-provider.ts", options: { minMargin: 10 } }
+ * ])
+ * ```
+ */
+async function loadFilterProviders(configs, options = {}) {
+    const providers = [];
+    const baseDir = options.baseDir || process.cwd();
+    for (const config of configs) {
+        try {
+            let providerModule;
+            let providerPath;
+            // Resolve config to path
+            if (typeof config === "string") {
+                providerPath = config;
+            }
+            else {
+                providerPath = config.path;
+            }
+            // Try to load as module first (npm package)
+            try {
+                providerModule = await import(providerPath);
+            }
+            catch (moduleError) {
+                // If module import fails, try as file path
+                const path = require("path");
+                const fs = require("fs");
+                // Resolve absolute path
+                const absolutePath = path.isAbsolute(providerPath)
+                    ? providerPath
+                    : path.resolve(baseDir, providerPath);
+                // Check if file exists
+                if (!fs.existsSync(absolutePath)) {
+                    throw new Error(`Filter provider file not found: ${absolutePath}`);
+                }
+                // Try dynamic import with file:// protocol for absolute paths
+                try {
+                    providerModule = await import(absolutePath);
+                }
+                catch (fileError) {
+                    // Try with require for CommonJS modules
+                    try {
+                        providerModule = require(absolutePath);
+                    }
+                    catch (requireError) {
+                        throw new Error(`Failed to load filter provider from ${providerPath}: ${String(moduleError)}`);
+                    }
+                }
+            }
+            // Extract provider class from module
+            // Support both default export and named export
+            let ProviderClass;
+            if (providerModule && typeof providerModule === "object") {
+                // Try default export first
+                if ("default" in providerModule &&
+                    typeof providerModule.default === "function") {
+                    ProviderClass = providerModule.default;
+                }
+                else {
+                    // Try to find a class that extends BaseFilterProvider
+                    // Look for exported classes
+                    for (const [key, value] of Object.entries(providerModule)) {
+                        if (typeof value === "function" &&
+                            value.prototype &&
+                            Object.getPrototypeOf(value.prototype)?.constructor ===
+                                base_filter_provider_1.BaseFilterProvider) {
+                            ProviderClass = value;
+                            break;
+                        }
+                    }
+                }
+            }
+            if (!ProviderClass) {
+                throw new Error(`No filter provider class found in ${providerPath}. ` +
+                    `Expected a class extending BaseFilterProvider as default export or named export.`);
+            }
+            // Validate that it's a BaseFilterProvider subclass
+            // Check for required static properties
+            if (!("identifier" in ProviderClass) ||
+                typeof ProviderClass.identifier !== "string") {
+                throw new Error(`Class in ${providerPath} does not appear to extend BaseFilterProvider. ` +
+                    `Missing static 'identifier' property.`);
+            }
+            // Check for displayName
+            if (!("displayName" in ProviderClass) ||
+                typeof ProviderClass.displayName !== "string") {
+                throw new Error(`Class in ${providerPath} does not appear to extend BaseFilterProvider. ` +
+                    `Missing static 'displayName' property.`);
+            }
+            // Instantiate provider
+            // If config has options, pass them to constructor (if supported)
+            const providerConfig = typeof config === "object" && config.options
+                ? config.options
+                : undefined;
+            // Instantiate provider
+            // We've validated that ProviderClass extends BaseFilterProvider and has required properties
+            // TypeScript sees it as abstract, but at runtime it's a concrete class
+            // Use type assertion to allow instantiation
+            let provider;
+            if (providerConfig) {
+                // Try to instantiate with options
+                try {
+                    // @ts-expect-error - ProviderClass is validated at runtime to be a concrete subclass
+                    provider = new ProviderClass(providerConfig);
+                }
+                catch {
+                    // If constructor doesn't accept options, instantiate without
+                    // @ts-expect-error - ProviderClass is validated at runtime to be a concrete subclass
+                    provider = new ProviderClass();
+                }
+            }
+            else {
+                // @ts-expect-error - ProviderClass is validated at runtime to be a concrete subclass
+                provider = new ProviderClass();
+            }
+            providers.push(provider);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to load filter provider from config ${JSON.stringify(config)}: ${errorMessage}`);
+        }
+    }
+    return providers;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/services/filter-provider-registry.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterProviderRegistry = void 0;
+/**
+ * Service for managing filter provider registration and retrieval.
+ *
+ * The registry maintains a map of filter providers keyed by their identifiers,
+ * ensuring uniqueness and providing fast lookup. Providers are registered
+ * at plugin initialization and can be retrieved by their identifier when
+ * applying filters.
+ *
+ * @example
+ * ```ts
+ * const registry = new FilterProviderRegistry()
+ * registry.register(new CategoryFilterProvider())
+ *
+ * const provider = registry.get("category_id")
+ * if (provider) {
+ *   const filters = provider.apply({}, ["cat_123"])
+ * }
+ * ```
+ */
+class FilterProviderRegistry {
+    constructor() {
+        this.providers = new Map();
+    }
+    /**
+     * Register a filter provider.
+     *
+     * Throws an error if a provider with the same identifier is already registered.
+     *
+     * @param provider - Filter provider instance to register
+     * @throws Error if provider identifier is already registered
+     *
+     * @example
+     * ```ts
+     * registry.register(new CategoryFilterProvider())
+     * ```
+     */
+    register(provider) {
+        const identifier = provider.constructor
+            .identifier;
+        if (!identifier) {
+            throw new Error("Filter provider must have a static 'identifier' property");
+        }
+        if (this.providers.has(identifier)) {
+            const existingProvider = this.providers.get(identifier);
+            const existingDisplayName = (existingProvider?.constructor)
+                .displayName || "Unknown";
+            throw new Error(`Filter provider with identifier "${identifier}" (${existingDisplayName}) is already registered. ` +
+                `Cannot register ${provider.constructor.displayName || "Unknown"}.`);
+        }
+        this.providers.set(identifier, provider);
+    }
+    /**
+     * Get a provider by identifier.
+     *
+     * @param identifier - Provider identifier to look up
+     * @returns Provider instance if found, undefined otherwise
+     *
+     * @example
+     * ```ts
+     * const provider = registry.get("category_id")
+     * if (provider) {
+     *   // Use provider
+     * }
+     * ```
+     */
+    get(identifier) {
+        return this.providers.get(identifier);
+    }
+    /**
+     * Check if a provider is registered.
+     *
+     * @param identifier - Provider identifier to check
+     * @returns true if provider is registered, false otherwise
+     *
+     * @example
+     * ```ts
+     * if (registry.has("category_id")) {
+     *   // Provider exists
+     * }
+     * ```
+     */
+    has(identifier) {
+        return this.providers.has(identifier);
+    }
+    /**
+     * Get all registered providers.
+     *
+     * @returns Array of all registered provider instances
+     *
+     * @example
+     * ```ts
+     * const allProviders = registry.getAll()
+     * allProviders.forEach(provider => {
+     *   console.log(provider.constructor.identifier)
+     * })
+     * ```
+     */
+    getAll() {
+        return Array.from(this.providers.values());
+    }
+    /**
+     * Get all provider identifiers.
+     *
+     * @returns Array of all registered provider identifiers
+     *
+     * @example
+     * ```ts
+     * const identifiers = registry.getIdentifiers()
+     * // ["category_id", "collection_id", "price_range", ...]
+     * ```
+     */
+    getIdentifiers() {
+        return Array.from(this.providers.keys());
+    }
+    /**
+     * Clear all registered providers.
+     *
+     * Useful for testing or resetting the registry state.
+     *
+     * @example
+     * ```ts
+     * registry.clear()
+     * // All providers removed
+     * ```
+     */
+    clear() {
+        this.providers.clear();
+    }
+    /**
+     * Get the number of registered providers.
+     *
+     * @returns Number of registered providers
+     */
+    size() {
+        return this.providers.size;
+    }
+}
+exports.FilterProviderRegistry = FilterProviderRegistry;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLXByb3ZpZGVyLXJlZ2lzdHJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3NlcnZpY2VzL2ZpbHRlci1wcm92aWRlci1yZWdpc3RyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFQTs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBa0JHO0FBQ0gsTUFBYSxzQkFBc0I7SUFBbkM7UUFDVSxjQUFTLEdBQW9DLElBQUksR0FBRyxFQUFFLENBQUE7SUFrSWhFLENBQUM7SUFoSUM7Ozs7Ozs7Ozs7OztPQVlHO0lBQ0gsUUFBUSxDQUFDLFFBQTRCO1FBQ25DLE1BQU0sVUFBVSxHQUFJLFFBQVEsQ0FBQyxXQUF5QzthQUNuRSxVQUFVLENBQUE7UUFFYixJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7WUFDaEIsTUFBTSxJQUFJLEtBQUssQ0FDYiwwREFBMEQsQ0FDM0QsQ0FBQTtRQUNILENBQUM7UUFFRCxJQUFJLElBQUksQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxFQUFFLENBQUM7WUFDbkMsTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsQ0FBQTtZQUN2RCxNQUFNLG1CQUFtQixHQUN2QixDQUFDLGdCQUFnQixFQUFFLFdBQXlDLENBQUE7aUJBQ3pELFdBQVcsSUFBSSxTQUFTLENBQUE7WUFFN0IsTUFBTSxJQUFJLEtBQUssQ0FDYixvQ0FBb0MsVUFBVSxNQUFNLG1CQUFtQiwyQkFBMkI7Z0JBQ2hHLG1CQUFvQixRQUFRLENBQUMsV0FBeUMsQ0FBQyxXQUFXLElBQUksU0FBUyxHQUFHLENBQ3JHLENBQUE7UUFDSCxDQUFDO1FBRUQsSUFBSSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsVUFBVSxFQUFFLFFBQVEsQ0FBQyxDQUFBO0lBQzFDLENBQUM7SUFFRDs7Ozs7Ozs7Ozs7OztPQWFHO0lBQ0gsR0FBRyxDQUFDLFVBQWtCO1FBQ3BCLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsVUFBVSxDQUFDLENBQUE7SUFDdkMsQ0FBQztJQUVEOzs7Ozs7Ozs7Ozs7T0FZRztJQUNILEdBQUcsQ0FBQyxVQUFrQjtRQUNwQixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxDQUFBO0lBQ3ZDLENBQUM7SUFFRDs7Ozs7Ozs7Ozs7O09BWUc7SUFDSCxNQUFNO1FBQ0osT0FBTyxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQTtJQUM1QyxDQUFDO0lBRUQ7Ozs7Ozs7Ozs7T0FVRztJQUNILGNBQWM7UUFDWixPQUFPLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFBO0lBQzFDLENBQUM7SUFFRDs7Ozs7Ozs7OztPQVVHO0lBQ0gsS0FBSztRQUNILElBQUksQ0FBQyxTQUFTLENBQUMsS0FBSyxFQUFFLENBQUE7SUFDeEIsQ0FBQztJQUVEOzs7O09BSUc7SUFDSCxJQUFJO1FBQ0YsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQTtJQUM1QixDQUFDO0NBQ0Y7QUFuSUQsd0RBbUlDIn0=

package/.medusa/server/src/services/product-filter-service.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductFilterService = void 0;
+const dynamic_filter_service_1 = require("./dynamic-filter-service");
+const index_1 = require("../index");
+/**
+ * Service that integrates DynamicFilterService with the existing ProductFilterPlan structure.
+ *
+ * This service bridges the gap between the legacy filter plan system and the new
+ * provider-based filter system, maintaining backward compatibility while enabling
+ * the new provider architecture.
+ *
+ * @example
+ * ```ts
+ * const service = new ProductFilterService(container)
+ * const result = await service.applyFilterPlan(plan, options)
+ * ```
+ */
+class ProductFilterService {
+    constructor(container) {
+        // Try to resolve DynamicFilterService from container, create if not found
+        try {
+            this.dynamicFilterService = container.resolve(index_1.DYNAMIC_FILTER_SERVICE);
+        }
+        catch {
+            // Service not registered, create new instance
+            this.dynamicFilterService = new dynamic_filter_service_1.DynamicFilterService(container);
+        }
+    }
+    /**
+     * Apply filters using Medusa's request context (queryConfig, filterableFields, pricingContext).
+     *
+     * This method integrates with Medusa's official store products API format,
+     * merging custom filter providers with Medusa's built-in filterableFields.
+     *
+     * @param context - Medusa request context
+     * @param options - Plugin options
+     * @returns Products, count, and metadata matching Medusa's format
+     */
+    async applyFilterPlanWithMedusaContext(context, options) {
+        // Extract custom filter parameters from query (for price_range, etc.)
+        const customFilterParams = {};
+        // Parse price_range from query if present (price_range[min], price_range[max], price_range[currency_code])
+        if (context.query?.price_range && typeof context.query.price_range === "object" && !Array.isArray(context.query.price_range)) {
+            const priceRange = context.query.price_range;
+            const min = typeof priceRange.min === "string" || typeof priceRange.min === "number"
+                ? (typeof priceRange.min === "string" ? Number(priceRange.min) : priceRange.min)
+                : undefined;
+            const max = typeof priceRange.max === "string" || typeof priceRange.max === "number"
+                ? (typeof priceRange.max === "string" ? Number(priceRange.max) : priceRange.max)
+                : undefined;
+            if ((min !== undefined && !Number.isNaN(min)) || (max !== undefined && !Number.isNaN(max))) {
+                customFilterParams.price_range = {
+                    min: min !== undefined && !Number.isNaN(min) ? min : undefined,
+                    max: max !== undefined && !Number.isNaN(max) ? max : undefined,
+                    currency_code: typeof priceRange.currency_code === "string" ? priceRange.currency_code : undefined,
+                };
+            }
+        }
+        // Parse promotion from query if present (promotion[min_discount_percentage], promotion[promotion_type], etc.)
+        if (context.query?.promotion && typeof context.query.promotion === "object" && !Array.isArray(context.query.promotion)) {
+            const promotion = context.query.promotion;
+            const promotionFilter = {};
+            // Parse min_discount_percentage
+            if (promotion.min_discount_percentage !== undefined) {
+                const minDiscount = typeof promotion.min_discount_percentage === "string"
+                    ? Number(promotion.min_discount_percentage)
+                    : typeof promotion.min_discount_percentage === "number"
+                        ? promotion.min_discount_percentage
+                        : undefined;
+                if (minDiscount !== undefined && !Number.isNaN(minDiscount) && minDiscount >= 0 && minDiscount <= 100) {
+                    promotionFilter.min_discount_percentage = minDiscount;
+                }
+            }
+            // Parse promotion_type
+            if (promotion.promotion_type !== undefined && typeof promotion.promotion_type === "string") {
+                promotionFilter.promotion_type = promotion.promotion_type;
+            }
+            // Parse starts_at
+            if (promotion.starts_at !== undefined) {
+                if (promotion.starts_at instanceof Date) {
+                    promotionFilter.starts_at = promotion.starts_at;
+                }
+                else if (typeof promotion.starts_at === "string") {
+                    const startsAt = new Date(promotion.starts_at);
+                    if (!Number.isNaN(startsAt.getTime())) {
+                        promotionFilter.starts_at = startsAt;
+                    }
+                }
+            }
+            // Parse ends_at
+            if (promotion.ends_at !== undefined) {
+                if (promotion.ends_at instanceof Date) {
+                    promotionFilter.ends_at = promotion.ends_at;
+                }
+                else if (typeof promotion.ends_at === "string") {
+                    const endsAt = new Date(promotion.ends_at);
+                    if (!Number.isNaN(endsAt.getTime())) {
+                        promotionFilter.ends_at = endsAt;
+                    }
+                }
+            }
+            // Parse status
+            if (promotion.status !== undefined && typeof promotion.status === "string") {
+                promotionFilter.status = promotion.status;
+            }
+            // Parse include_open_ended
+            if (promotion.include_open_ended !== undefined) {
+                if (typeof promotion.include_open_ended === "boolean") {
+                    promotionFilter.include_open_ended = promotion.include_open_ended;
+                }
+                else if (typeof promotion.include_open_ended === "string") {
+                    promotionFilter.include_open_ended =
+                        promotion.include_open_ended === "true" || promotion.include_open_ended === "1";
+                }
+            }
+            // Only add promotion filter if at least one field is present
+            if (promotionFilter.min_discount_percentage !== undefined ||
+                promotionFilter.promotion_type !== undefined ||
+                promotionFilter.starts_at !== undefined ||
+                promotionFilter.ends_at !== undefined ||
+                promotionFilter.status !== undefined ||
+                promotionFilter.include_open_ended !== undefined) {
+                customFilterParams.promotion = promotionFilter;
+            }
+        }
+        // Merge Medusa's filterableFields with custom filter params
+        // Custom filters take precedence for overlapping keys
+        const filterParams = {
+            ...context.filterableFields,
+            ...customFilterParams,
+        };
+        // Apply filters using DynamicFilterService
+        // Pass fields from queryConfig if available, otherwise undefined (will default to ["*"])
+        // This ensures all relations (variants, options, images, collection, type) are included
+        const applyOptions = {
+            filterParams,
+            options,
+            pagination: context.queryConfig?.pagination ? {
+                offset: context.queryConfig.pagination.skip,
+                limit: context.queryConfig.pagination.take,
+            } : undefined,
+            projection: context.queryConfig?.fields && context.queryConfig.fields.length > 0 ? {
+                fields: context.queryConfig.fields,
+            } : undefined, // undefined will default to ["*"] in DynamicFilterService
+            context: context.pricingContext ? {
+                pricingContext: context.pricingContext,
+            } : undefined,
+        };
+        return await this.dynamicFilterService.applyFilters(applyOptions);
+    }
+    /**
+     * Apply a ProductFilterPlan using the dynamic filter provider system.
+     *
+     * Converts the legacy filter plan structure into provider-compatible
+     * filter parameters and applies them using DynamicFilterService.
+     *
+     * @param plan - Product filter plan from buildProductFilterPlan()
+     * @param options - Plugin options
+     * @returns Products and count matching the filters
+     */
+    async applyFilterPlan(plan, options) {
+        // Convert filter plan to provider-compatible filter parameters
+        const filterParams = {};
+        // Base filters (id, handle, tags, sales_channel_id)
+        if (Object.keys(plan.baseFilters).length > 0) {
+            filterParams.base_product = plan.baseFilters;
+        }
+        // Category filter
+        if (plan.baseFilters.categories) {
+            const categories = plan.baseFilters.categories;
+            if (categories.id && categories.id.length > 0) {
+                filterParams.category_id = categories.id;
+            }
+        }
+        // Collection filter
+        if (plan.baseFilters.collection_id) {
+            filterParams.collection_id = plan.baseFilters.collection_id;
+        }
+        // Metadata filters
+        if (Object.keys(plan.metadataFilters).length > 0) {
+            filterParams.metadata = plan.metadataFilters;
+        }
+        // Price range filter
+        if (plan.priceRange) {
+            filterParams.price_range = {
+                min: plan.priceRange.min,
+                max: plan.priceRange.max,
+                currency_code: plan.priceRange.currency_code,
+            };
+        }
+        // Promotion window filter
+        if (plan.promotionWindow) {
+            filterParams.promotion_window = {
+                start: plan.promotionWindow.range?.start,
+                end: plan.promotionWindow.range?.end,
+                activeOn: plan.promotionWindow.activeOn,
+                includeOpen: plan.promotionWindow.includeOpen,
+            };
+        }
+        // Availability filter
+        if (plan.availability) {
+            filterParams.availability = {
+                statuses: plan.availability.statuses,
+                include_preorder: plan.availability.include_preorder,
+                include_backorder: plan.availability.include_backorder,
+                include_gift_cards: plan.availability.include_gift_cards,
+                publishable_only: plan.availability.publishable_only,
+            };
+        }
+        // Rating filter
+        if (plan.rating && plan.rating.enabled) {
+            filterParams.rating = {
+                min: plan.rating.min,
+                max: plan.rating.max,
+                require_reviews: plan.rating.require_reviews,
+            };
+        }
+        // Apply filters using DynamicFilterService
+        const applyOptions = {
+            filterParams,
+            options,
+            pagination: plan.pagination,
+            projection: plan.projection,
+        };
+        return await this.dynamicFilterService.applyFilters(applyOptions);
+    }
+}
+exports.ProductFilterService = ProductFilterService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"product-filter-service.js","sourceRoot":"","sources":["../../../../src/services/product-filter-service.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/utils/query-parser.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * Query Parameter Parser Utility
+ *
+ * Normalizes query parameters from both formats:
+ * - Bracketed flat: `price_range[min]=10&price_range[max]=100`
+ * - Nested objects: `{ price_range: { min: 10, max: 100 } }`
+ *
+ * This ensures consistent handling regardless of how the HTTP server
+ * or query parser processes the query string.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeQueryParams = normalizeQueryParams;
+/**
+ * Parse a query parameter key that may be in bracketed format.
+ *
+ * Examples:
+ * - `price_range[min]` → `{ base: "price_range", key: "min" }`
+ * - `promotion[min_discount_percentage]` → `{ base: "promotion", key: "min_discount_percentage" }`
+ * - `category_id` → `{ base: "category_id", key: null }`
+ *
+ * @param key - Query parameter key (may be bracketed or flat)
+ * @returns Object with base key and nested key (if bracketed)
+ */
+function parseBracketedKey(key) {
+    const bracketMatch = key.match(/^(.+)\[([^\]]+)\]$/);
+    if (bracketMatch) {
+        return {
+            base: bracketMatch[1],
+            key: bracketMatch[2],
+        };
+    }
+    return {
+        base: key,
+        key: null,
+    };
+}
+/**
+ * Normalize query parameters to handle both bracketed and nested formats.
+ *
+ * Converts bracketed flat keys like `price_range[min]=10` into nested objects
+ * like `{ price_range: { min: 10 } }`.
+ *
+ * Also handles already-nested objects, preserving them as-is.
+ *
+ * @param query - Raw query object (may contain bracketed keys or nested objects)
+ * @returns Normalized query object with nested structure
+ *
+ * @example
+ * ```ts
+ * // Input: { "price_range[min]": "10", "price_range[max]": "100" }
+ * // Output: { price_range: { min: "10", max: "100" } }
+ *
+ * // Input: { price_range: { min: 10, max: 100 } }
+ * // Output: { price_range: { min: 10, max: 100 } } (unchanged)
+ * ```
+ */
+function normalizeQueryParams(query) {
+    const normalized = {};
+    const nestedKeys = {};
+    // First pass: collect all bracketed keys
+    for (const [key, value] of Object.entries(query)) {
+        const parsed = parseBracketedKey(key);
+        if (parsed.key !== null) {
+            // This is a bracketed key (e.g., price_range[min])
+            if (!nestedKeys[parsed.base]) {
+                nestedKeys[parsed.base] = {};
+            }
+            nestedKeys[parsed.base][parsed.key] = value;
+        }
+        else {
+            // This is a flat key (e.g., category_id)
+            // Check if it's already a nested object
+            if (value !== null &&
+                typeof value === "object" &&
+                !Array.isArray(value) &&
+                Object.getPrototypeOf(value) === Object.prototype) {
+                // Already nested, keep as-is
+                normalized[parsed.base] = value;
+            }
+            else {
+                // Flat value, add directly
+                normalized[parsed.base] = value;
+            }
+        }
+    }
+    // Second pass: merge nested keys (from bracketed format) with existing nested objects
+    for (const [baseKey, nestedValues] of Object.entries(nestedKeys)) {
+        if (baseKey in normalized && typeof normalized[baseKey] === "object" && normalized[baseKey] !== null && !Array.isArray(normalized[baseKey])) {
+            // Merge with existing nested object
+            normalized[baseKey] = {
+                ...normalized[baseKey],
+                ...nestedValues,
+            };
+        }
+        else {
+            // Create new nested object
+            normalized[baseKey] = nestedValues;
+        }
+    }
+    return normalized;
+}
+//# sourceMappingURL=data:application/json;base64,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