@warlock.js/cascade 5.30.0 → 5.32.0

package/esm/drivers/mongodb/mongodb-query-operations.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"mongodb-query-operations.d.mts","names":[],"sources":["../../../../../../../../../packages/cascade/src/drivers/mongodb/mongodb-query-operations.ts"],"mappings":";;;;;AAqCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,oBAAA;EAAA,QAiBgB,UAAA;EAqG0C;;;;;;;;;;;;;;;;cArG1C,UAAA,EAAY,SAAA;EAEhC,aAAA,CAAc,UAAA,EAAY,SAAA;EA+Nd;;;;;;;;;;;;;;;;;;;;;;;EApMZ,iBAAA,CAAkB,IAAA,UAAc,IAAA,EAAM,MAAA,mBAAyB,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;EAkC/D,mBAAA,CACL,IAAA,UACA,IAAA,EAAM,MAAA,mBACN,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCK,gBAAA,CAAiB,IAAA,UAAc,IAAA,EAAM,MAAA,mBAAyB,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;EAkC9D,iBAAA,CACL,IAAA,UACA,IAAA,EAAM,MAAA,mBACN,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyCK,kBAAA,CAAmB,IAAA,UAAc,IAAA,EAAM,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0CvC,YAAA,CACL,KAAA,EAAO,aAAA,EACP,IAAA,UACA,IAAA,EAAM,MAAA,mBACN,SAAA;AAAA"}
+{"version":3,"file":"mongodb-query-operations.d.mts","names":[],"sources":["../../../../../../../../../packages/cascade/src/drivers/mongodb/mongodb-query-operations.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqCa;UAiBgB;;;;;;;;;;;;;;;;;EAA3B,YAA2B,YAAY;EAEhC,cAAc,YAAY;;;;;;;;;;;;;;;;;;;;;;;;EA2B1B,kBAAkB,cAAc,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;EAkC/D,oBAAoB,cAAc,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCjE,iBAAiB,cAAc,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;EAkC9D,kBAAkB,cAAc,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwC/D,mBAAmB,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0CvC,aACL,OAAO,eACP,cACA,MAAM,yBACN"}

package/esm/drivers/mongodb/mongodb-query-operations.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"mongodb-query-operations.mjs","names":[],"sources":["../../../../../../../../../packages/cascade/src/drivers/mongodb/mongodb-query-operations.ts"],"sourcesContent":["import type { Operation, PipelineStage } from \"./types\";\n\n/**\n * Helper class for constructing MongoDB aggregation pipeline operations.\n *\n * This class encapsulates the logic for creating operation objects that will be\n * converted to MongoDB aggregation stages by the query parser. It provides a\n * clean abstraction over the low-level operation structure, making the query\n * builder code more maintainable and testable.\n *\n * Each operation consists of:\n * - **stage**: The MongoDB aggregation stage name (e.g., \"$match\", \"$project\")\n * - **type**: An internal identifier for the operation type\n * - **data**: The data associated with the operation\n * - **mergeable**: Whether this operation can be merged with adjacent similar operations\n *\n * @internal This class is for internal use within the MongoDB driver\n *\n * @example\n * ```typescript\n * const operations: Operation[] = [];\n * const helper = new MongoQueryOperations(operations);\n *\n * // Add a match operation\n * helper.addMatchOperation(\"whereIn\", { field: \"status\", values: [\"active\", \"pending\"] });\n *\n * // Add a project operation\n * helper.addProjectOperation(\"select\", { fields: [\"name\", \"email\"] });\n *\n * // Operations array is now populated\n * console.log(operations);\n * // [\n * //   { stage: \"$match\", mergeable: true, type: \"whereIn\", data: {...} },\n * //   { stage: \"$project\", mergeable: true, type: \"select\", data: {...} }\n * // ]\n * ```\n */\nexport class MongoQueryOperations {\n  /**\n   * Creates a new operations helper.\n   *\n   * The helper maintains a reference to the operations array and populates it\n   * as methods are called. This allows the query builder to maintain a single\n   * ordered list of operations that will be converted to a MongoDB aggregation\n   * pipeline.\n   *\n   * @param operations - Reference to the operations array to populate\n   *\n   * @example\n   * ```typescript\n   * const operations: Operation[] = [];\n   * const helper = new MongoQueryOperations(operations);\n   * ```\n   */\n  public constructor(private operations: Operation[]) {}\n\n  public setOperations(operations: Operation[]): void {\n    this.operations = operations;\n  }\n\n  /**\n   * Adds a $match stage operation to the pipeline.\n   *\n   * Match operations filter documents in the aggregation pipeline, similar to\n   * the WHERE clause in SQL. Multiple match operations can be merged together\n   * by the parser for optimization.\n   *\n   * @param type - The operation type identifier (e.g., \"where\", \"whereIn\", \"whereLike\")\n   * @param data - The operation data data containing filter criteria\n   * @param mergeable - Whether this operation can be merged with adjacent match operations (default: true)\n   *\n   * @example\n   * ```typescript\n   * // Simple where operation\n   * helper.addMatchOperation(\"where\", { field: \"age\", operator: \">\", value: 18 });\n   *\n   * // WhereIn operation\n   * helper.addMatchOperation(\"whereIn\", { field: \"status\", values: [\"active\", \"pending\"] });\n   *\n   * // Non-mergeable match (e.g., after a group stage)\n   * helper.addMatchOperation(\"having\", { field: \"count\", operator: \">\", value: 5 }, false);\n   * ```\n   */\n  public addMatchOperation(type: string, data: Record<string, unknown>, mergeable = true): void {\n    this.operations.push({\n      stage: \"$match\",\n      mergeable,\n      type,\n      data,\n    });\n  }\n\n  /**\n   * Adds a $project stage operation to the pipeline.\n   *\n   * Project operations control which fields are included or excluded in the\n   * output documents, similar to the SELECT clause in SQL. They can also be\n   * used to compute new fields or reshape documents.\n   *\n   * @param type - The operation type identifier (e.g., \"select\", \"deselect\", \"selectRaw\")\n   * @param data - The operation data data containing projection specifications\n   * @param mergeable - Whether this operation can be merged with adjacent project operations (default: true)\n   *\n   * @example\n   * ```typescript\n   * // Select specific fields\n   * helper.addProjectOperation(\"select\", { fields: [\"name\", \"email\", \"age\"] });\n   *\n   * // Deselect fields\n   * helper.addProjectOperation(\"deselect\", { fields: [\"password\", \"secret\"] });\n   *\n   * // Computed field\n   * helper.addProjectOperation(\"selectRaw\", {\n   *   expression: { fullName: { $concat: [\"$firstName\", \" \", \"$lastName\"] } }\n   * });\n   * ```\n   */\n  public addProjectOperation(\n    type: string,\n    data: Record<string, unknown>,\n    mergeable = true,\n  ): void {\n    this.operations.push({\n      stage: \"$project\",\n      mergeable,\n      type,\n      data,\n    });\n  }\n\n  /**\n   * Adds a $sort stage operation to the pipeline.\n   *\n   * Sort operations order the documents in the pipeline, similar to the ORDER BY\n   * clause in SQL. Multiple sort operations can be merged to create compound\n   * sorting.\n   *\n   * @param type - The operation type identifier (e.g., \"orderBy\", \"orderByRandom\")\n   * @param data - The operation data data containing sort specifications\n   * @param mergeable - Whether this operation can be merged with adjacent sort operations (default: true)\n   *\n   * @example\n   * ```typescript\n   * // Order by a single field\n   * helper.addSortOperation(\"orderBy\", { field: \"createdAt\", direction: \"desc\" });\n   *\n   * // Random ordering (not mergeable)\n   * helper.addSortOperation(\"orderByRandom\", {limit: 1000}, false);\n   *\n   * // Order by raw expression\n   * helper.addSortOperation(\"orderByRaw\", {\n   *   expression: { score: -1, name: 1 }\n   * });\n   * ```\n   */\n  public addSortOperation(type: string, data: Record<string, unknown>, mergeable = true): void {\n    this.operations.push({\n      stage: \"$sort\",\n      mergeable,\n      type,\n      data,\n    });\n  }\n\n  /**\n   * Adds a $group stage operation to the pipeline.\n   *\n   * Group operations aggregate documents by specified fields and compute\n   * aggregate values, similar to the GROUP BY clause in SQL. Group operations\n   * are typically not mergeable as they represent distinct aggregation boundaries.\n   *\n   * @param type - The operation type identifier (e.g., \"groupBy\", \"distinct\")\n   * @param data - The operation data data containing grouping specifications\n   * @param mergeable - Whether this operation can be merged with adjacent group operations (default: false)\n   *\n   * @example\n   * ```typescript\n   * // Group by a single field\n   * helper.addGroupOperation(\"groupBy\", { fields: \"category\" });\n   *\n   * // Group by multiple fields\n   * helper.addGroupOperation(\"groupBy\", {\n   *   fields: { category: \"$category\", status: \"$status\" }\n   * });\n   *\n   * // Distinct operation (special case of grouping)\n   * helper.addGroupOperation(\"distinct\", { fields: [\"email\"] });\n   * ```\n   */\n  public addGroupOperation(\n    type: string,\n    data: Record<string, unknown>,\n    mergeable = false,\n  ): void {\n    this.operations.push({\n      stage: \"$group\",\n      mergeable,\n      type,\n      data,\n    });\n  }\n\n  /**\n   * Adds a $lookup stage operation to the pipeline.\n   *\n   * Lookup operations perform left outer joins with other collections, similar\n   * to JOIN in SQL. Lookup operations are never mergeable as each represents a\n   * distinct join operation.\n   *\n   * @param type - The operation type identifier (typically \"join\")\n   * @param data - The operation data data containing join specifications\n   *\n   * @example\n   * ```typescript\n   * // Simple lookup\n   * helper.addLookupOperation(\"join\", {\n   *   table: \"orders\",\n   *   localField: \"id\",\n   *   foreignField: \"userId\",\n   *   alias: \"userOrders\"\n   * });\n   *\n   * // Lookup with pipeline\n   * helper.addLookupOperation(\"join\", {\n   *   table: \"products\",\n   *   pipeline: [\n   *     { $match: { inStock: true } },\n   *     { $sort: { price: 1 } }\n   *   ],\n   *   alias: \"availableProducts\"\n   * });\n   * ```\n   */\n  public addLookupOperation(type: string, data: Record<string, unknown>): void {\n    this.operations.push({\n      stage: \"$lookup\",\n      mergeable: false,\n      type,\n      data,\n    });\n  }\n\n  /**\n   * Adds a generic stage operation to the pipeline.\n   *\n   * This method provides flexibility to add any MongoDB aggregation stage,\n   * including less common stages like $facet, $bucket, $setWindowFields, etc.\n   * Use this for operations that don't fit into the standard categories.\n   *\n   * @param stage - The MongoDB aggregation stage name (e.g., \"$limit\", \"$skip\", \"$unwind\")\n   * @param type - The operation type identifier\n   * @param data - The operation data data\n   * @param mergeable - Whether this operation can be merged with adjacent operations (default: false)\n   *\n   * @example\n   * ```typescript\n   * // Add a limit operation\n   * helper.addOperation(\"$limit\", \"limit\", { value: 10 });\n   *\n   * // Add a skip operation\n   * helper.addOperation(\"$skip\", \"skip\", { value: 20 });\n   *\n   * // Add an unwind operation\n   * helper.addOperation(\"$unwind\", \"unwind\", { path: \"$tags\" });\n   *\n   * // Add a window function\n   * helper.addOperation(\"$setWindowFields\", \"selectWindow\", {\n   *   spec: {\n   *     partitionBy: \"$category\",\n   *     sortBy: { price: 1 },\n   *     output: { rank: { $rank: {} } }\n   *   }\n   * });\n   * ```\n   */\n  public addOperation(\n    stage: PipelineStage,\n    type: string,\n    data: Record<string, unknown>,\n    mergeable = false,\n  ): void {\n    this.operations.push({\n      stage,\n      mergeable,\n      type,\n      data,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,IAAa,uBAAb,MAAkC;CAiBL;;;;;;;;;;;;;;;;;CAA3B,AAAO,YAAY,AAAQ,YAAyB;EAAzB;CAA0B;CAErD,AAAO,cAAc,YAA+B;EAClD,KAAK,aAAa;CACpB;;;;;;;;;;;;;;;;;;;;;;;;CAyBA,AAAO,kBAAkB,MAAc,MAA+B,YAAY,MAAY;EAC5F,KAAK,WAAW,KAAK;GACnB,OAAO;GACP;GACA;GACA;EACF,CAAC;CACH;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BA,AAAO,oBACL,MACA,MACA,YAAY,MACN;EACN,KAAK,WAAW,KAAK;GACnB,OAAO;GACP;GACA;GACA;EACF,CAAC;CACH;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BA,AAAO,iBAAiB,MAAc,MAA+B,YAAY,MAAY;EAC3F,KAAK,WAAW,KAAK;GACnB,OAAO;GACP;GACA;GACA;EACF,CAAC;CACH;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BA,AAAO,kBACL,MACA,MACA,YAAY,OACN;EACN,KAAK,WAAW,KAAK;GACnB,OAAO;GACP;GACA;GACA;EACF,CAAC;CACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCA,AAAO,mBAAmB,MAAc,MAAqC;EAC3E,KAAK,WAAW,KAAK;GACnB,OAAO;GACP,WAAW;GACX;GACA;EACF,CAAC;CACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCA,AAAO,aACL,OACA,MACA,MACA,YAAY,OACN;EACN,KAAK,WAAW,KAAK;GACnB;GACA;GACA;GACA;EACF,CAAC;CACH;AACF"}
+{"version":3,"file":"mongodb-query-operations.mjs","names":[],"sources":["../../../../../../../../../packages/cascade/src/drivers/mongodb/mongodb-query-operations.ts"],"sourcesContent":["import type { Operation, PipelineStage } from \"./types\";\n\n/**\n * Helper class for constructing MongoDB aggregation pipeline operations.\n *\n * This class encapsulates the logic for creating operation objects that will be\n * converted to MongoDB aggregation stages by the query parser. It provides a\n * clean abstraction over the low-level operation structure, making the query\n * builder code more maintainable and testable.\n *\n * Each operation consists of:\n * - **stage**: The MongoDB aggregation stage name (e.g., \"$match\", \"$project\")\n * - **type**: An internal identifier for the operation type\n * - **data**: The data associated with the operation\n * - **mergeable**: Whether this operation can be merged with adjacent similar operations\n *\n * @internal This class is for internal use within the MongoDB driver\n *\n * @example\n * ```typescript\n * const operations: Operation[] = [];\n * const helper = new MongoQueryOperations(operations);\n *\n * // Add a match operation\n * helper.addMatchOperation(\"whereIn\", { field: \"status\", values: [\"active\", \"pending\"] });\n *\n * // Add a project operation\n * helper.addProjectOperation(\"select\", { fields: [\"name\", \"email\"] });\n *\n * // Operations array is now populated\n * console.log(operations);\n * // [\n * //   { stage: \"$match\", mergeable: true, type: \"whereIn\", data: {...} },\n * //   { stage: \"$project\", mergeable: true, type: \"select\", data: {...} }\n * // ]\n * ```\n */\nexport class MongoQueryOperations {\n  /**\n   * Creates a new operations helper.\n   *\n   * The helper maintains a reference to the operations array and populates it\n   * as methods are called. This allows the query builder to maintain a single\n   * ordered list of operations that will be converted to a MongoDB aggregation\n   * pipeline.\n   *\n   * @param operations - Reference to the operations array to populate\n   *\n   * @example\n   * ```typescript\n   * const operations: Operation[] = [];\n   * const helper = new MongoQueryOperations(operations);\n   * ```\n   */\n  public constructor(private operations: Operation[]) {}\n\n  public setOperations(operations: Operation[]): void {\n    this.operations = operations;\n  }\n\n  /**\n   * Adds a $match stage operation to the pipeline.\n   *\n   * Match operations filter documents in the aggregation pipeline, similar to\n   * the WHERE clause in SQL. Multiple match operations can be merged together\n   * by the parser for optimization.\n   *\n   * @param type - The operation type identifier (e.g., \"where\", \"whereIn\", \"whereLike\")\n   * @param data - The operation data data containing filter criteria\n   * @param mergeable - Whether this operation can be merged with adjacent match operations (default: true)\n   *\n   * @example\n   * ```typescript\n   * // Simple where operation\n   * helper.addMatchOperation(\"where\", { field: \"age\", operator: \">\", value: 18 });\n   *\n   * // WhereIn operation\n   * helper.addMatchOperation(\"whereIn\", { field: \"status\", values: [\"active\", \"pending\"] });\n   *\n   * // Non-mergeable match (e.g., after a group stage)\n   * helper.addMatchOperation(\"having\", { field: \"count\", operator: \">\", value: 5 }, false);\n   * ```\n   */\n  public addMatchOperation(type: string, data: Record<string, unknown>, mergeable = true): void {\n    this.operations.push({\n      stage: \"$match\",\n      mergeable,\n      type,\n      data,\n    });\n  }\n\n  /**\n   * Adds a $project stage operation to the pipeline.\n   *\n   * Project operations control which fields are included or excluded in the\n   * output documents, similar to the SELECT clause in SQL. They can also be\n   * used to compute new fields or reshape documents.\n   *\n   * @param type - The operation type identifier (e.g., \"select\", \"deselect\", \"selectRaw\")\n   * @param data - The operation data data containing projection specifications\n   * @param mergeable - Whether this operation can be merged with adjacent project operations (default: true)\n   *\n   * @example\n   * ```typescript\n   * // Select specific fields\n   * helper.addProjectOperation(\"select\", { fields: [\"name\", \"email\", \"age\"] });\n   *\n   * // Deselect fields\n   * helper.addProjectOperation(\"deselect\", { fields: [\"password\", \"secret\"] });\n   *\n   * // Computed field\n   * helper.addProjectOperation(\"selectRaw\", {\n   *   expression: { fullName: { $concat: [\"$firstName\", \" \", \"$lastName\"] } }\n   * });\n   * ```\n   */\n  public addProjectOperation(type: string, data: Record<string, unknown>, mergeable = true): void {\n    this.operations.push({\n      stage: \"$project\",\n      mergeable,\n      type,\n      data,\n    });\n  }\n\n  /**\n   * Adds a $sort stage operation to the pipeline.\n   *\n   * Sort operations order the documents in the pipeline, similar to the ORDER BY\n   * clause in SQL. Multiple sort operations can be merged to create compound\n   * sorting.\n   *\n   * @param type - The operation type identifier (e.g., \"orderBy\", \"orderByRandom\")\n   * @param data - The operation data data containing sort specifications\n   * @param mergeable - Whether this operation can be merged with adjacent sort operations (default: true)\n   *\n   * @example\n   * ```typescript\n   * // Order by a single field\n   * helper.addSortOperation(\"orderBy\", { field: \"createdAt\", direction: \"desc\" });\n   *\n   * // Random ordering (not mergeable)\n   * helper.addSortOperation(\"orderByRandom\", {limit: 1000}, false);\n   *\n   * // Order by raw expression\n   * helper.addSortOperation(\"orderByRaw\", {\n   *   expression: { score: -1, name: 1 }\n   * });\n   * ```\n   */\n  public addSortOperation(type: string, data: Record<string, unknown>, mergeable = true): void {\n    this.operations.push({\n      stage: \"$sort\",\n      mergeable,\n      type,\n      data,\n    });\n  }\n\n  /**\n   * Adds a $group stage operation to the pipeline.\n   *\n   * Group operations aggregate documents by specified fields and compute\n   * aggregate values, similar to the GROUP BY clause in SQL. Group operations\n   * are typically not mergeable as they represent distinct aggregation boundaries.\n   *\n   * @param type - The operation type identifier (e.g., \"groupBy\", \"distinct\")\n   * @param data - The operation data data containing grouping specifications\n   * @param mergeable - Whether this operation can be merged with adjacent group operations (default: false)\n   *\n   * @example\n   * ```typescript\n   * // Group by a single field\n   * helper.addGroupOperation(\"groupBy\", { fields: \"category\" });\n   *\n   * // Group by multiple fields\n   * helper.addGroupOperation(\"groupBy\", {\n   *   fields: { category: \"$category\", status: \"$status\" }\n   * });\n   *\n   * // Distinct operation (special case of grouping)\n   * helper.addGroupOperation(\"distinct\", { fields: [\"email\"] });\n   * ```\n   */\n  public addGroupOperation(type: string, data: Record<string, unknown>, mergeable = false): void {\n    this.operations.push({\n      stage: \"$group\",\n      mergeable,\n      type,\n      data,\n    });\n  }\n\n  /**\n   * Adds a $lookup stage operation to the pipeline.\n   *\n   * Lookup operations perform left outer joins with other collections, similar\n   * to JOIN in SQL. Lookup operations are never mergeable as each represents a\n   * distinct join operation.\n   *\n   * @param type - The operation type identifier (typically \"join\")\n   * @param data - The operation data data containing join specifications\n   *\n   * @example\n   * ```typescript\n   * // Simple lookup\n   * helper.addLookupOperation(\"join\", {\n   *   table: \"orders\",\n   *   localField: \"id\",\n   *   foreignField: \"userId\",\n   *   alias: \"userOrders\"\n   * });\n   *\n   * // Lookup with pipeline\n   * helper.addLookupOperation(\"join\", {\n   *   table: \"products\",\n   *   pipeline: [\n   *     { $match: { inStock: true } },\n   *     { $sort: { price: 1 } }\n   *   ],\n   *   alias: \"availableProducts\"\n   * });\n   * ```\n   */\n  public addLookupOperation(type: string, data: Record<string, unknown>): void {\n    this.operations.push({\n      stage: \"$lookup\",\n      mergeable: false,\n      type,\n      data,\n    });\n  }\n\n  /**\n   * Adds a generic stage operation to the pipeline.\n   *\n   * This method provides flexibility to add any MongoDB aggregation stage,\n   * including less common stages like $facet, $bucket, $setWindowFields, etc.\n   * Use this for operations that don't fit into the standard categories.\n   *\n   * @param stage - The MongoDB aggregation stage name (e.g., \"$limit\", \"$skip\", \"$unwind\")\n   * @param type - The operation type identifier\n   * @param data - The operation data data\n   * @param mergeable - Whether this operation can be merged with adjacent operations (default: false)\n   *\n   * @example\n   * ```typescript\n   * // Add a limit operation\n   * helper.addOperation(\"$limit\", \"limit\", { value: 10 });\n   *\n   * // Add a skip operation\n   * helper.addOperation(\"$skip\", \"skip\", { value: 20 });\n   *\n   * // Add an unwind operation\n   * helper.addOperation(\"$unwind\", \"unwind\", { path: \"$tags\" });\n   *\n   * // Add a window function\n   * helper.addOperation(\"$setWindowFields\", \"selectWindow\", {\n   *   spec: {\n   *     partitionBy: \"$category\",\n   *     sortBy: { price: 1 },\n   *     output: { rank: { $rank: {} } }\n   *   }\n   * });\n   * ```\n   */\n  public addOperation(\n    stage: PipelineStage,\n    type: string,\n    data: Record<string, unknown>,\n    mergeable = false,\n  ): void {\n    this.operations.push({\n      stage,\n      mergeable,\n      type,\n      data,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,IAAa,uBAAb,MAAkC;CAiBL;;;;;;;;;;;;;;;;;CAA3B,AAAO,YAAY,AAAQ,YAAyB;EAAzB;CAA0B;CAErD,AAAO,cAAc,YAA+B;EAClD,KAAK,aAAa;CACpB;;;;;;;;;;;;;;;;;;;;;;;;CAyBA,AAAO,kBAAkB,MAAc,MAA+B,YAAY,MAAY;EAC5F,KAAK,WAAW,KAAK;GACnB,OAAO;GACP;GACA;GACA;EACF,CAAC;CACH;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BA,AAAO,oBAAoB,MAAc,MAA+B,YAAY,MAAY;EAC9F,KAAK,WAAW,KAAK;GACnB,OAAO;GACP;GACA;GACA;EACF,CAAC;CACH;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BA,AAAO,iBAAiB,MAAc,MAA+B,YAAY,MAAY;EAC3F,KAAK,WAAW,KAAK;GACnB,OAAO;GACP;GACA;GACA;EACF,CAAC;CACH;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BA,AAAO,kBAAkB,MAAc,MAA+B,YAAY,OAAa;EAC7F,KAAK,WAAW,KAAK;GACnB,OAAO;GACP;GACA;GACA;EACF,CAAC;CACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCA,AAAO,mBAAmB,MAAc,MAAqC;EAC3E,KAAK,WAAW,KAAK;GACnB,OAAO;GACP,WAAW;GACX;GACA;EACF,CAAC;CACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCA,AAAO,aACL,OACA,MACA,MACA,YAAY,OACN;EACN,KAAK,WAAW,KAAK;GACnB;GACA;GACA;GACA;EACF,CAAC;CACH;AACF"}

package/esm/drivers/mongodb/mongodb-query-parser.d.mts

@@ -1,14 +1,16 @@
 import { Operation } from "./types.mjs";
 import { MongoQueryBuilder } from "./mongodb-query-builder.mjs";
 import { Collection } from "mongodb";
-
 //#region ../../packages/cascade/src/drivers/mongodb/mongodb-query-parser.d.ts
 /**
  * Options for configuring the MongoDB query parser.
  */
-type MongoQueryParserOptions = {
-  /** The MongoDB collection being queried */collection: Collection; /** The ordered list of operations to parse */
-  operations: Operation[]; /** Factory method for creating sub-builders (used for callbacks) */
+export type MongoQueryParserOptions = {
+  /** The MongoDB collection being queried */
+  collection: Collection;
+  /** The ordered list of operations to parse */
+  operations: Operation[];
+  /** Factory method for creating sub-builders (used for callbacks) */
   createSubBuilder: () => MongoQueryBuilder;
 };
 /**
@@ -19,7 +21,7 @@ type MongoQueryParserOptions = {
  * intelligent grouping of mergeable operations (like multiple where clauses)
  * into single pipeline stages for optimal performance.
  */
-declare class MongoQueryParser {
+export declare class MongoQueryParser {
   /**
    * The MongoDB collection being queried.
    */
@@ -365,5 +367,4 @@ declare class MongoQueryParser {
   private buildLookupStage;
 }
 //#endregion
-export { MongoQueryParser };
 //# sourceMappingURL=mongodb-query-parser.d.mts.map

package/esm/drivers/mongodb/mongodb-query-parser.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"mongodb-query-parser.d.mts","names":[],"sources":["../../../../../../../../../packages/cascade/src/drivers/mongodb/mongodb-query-parser.ts"],"mappings":";;;;;;;AAyDA;KAAY,uBAAA;6CAEV,UAAA,EAAY,UAAA,EAEA;EAAZ,UAAA,EAAY,SAAA,IAE6B;EAAzC,gBAAA,QAAwB,iBAAA;AAAA;AAuB1B;;;;;;;;AAAA,cAAa,gBAAA;;;;mBAIM,UAAA;EAkJT;;;EAAA,iBA7IS,UAAA;EAwTT;;;EAAA,iBAnTS,gBAAA;EA6cT;;;;EAAA,iBAvcS,eAAA;EA20BT;;;;;;EAAA,iBAn0BS,oBAAA;EAyqCT;;;;;cAlqCW,OAAA,EAAS,uBAAuB;EAktC3C;;;;;;;;;;;;;;;;;;;;EAxrCD,KAAA;EA07CC;;;;EAAA,QAj2CA,iBAAA;EAi6CA;;;;;;;;;;EAAA,QAl3CA,iBAAA;EAo2DA;;AAAgB;;;;;;;;;;;EAAhB,QAj0DA,yBAAA;;;;;;;;;;;;;;;;;;UAuDA,WAAA;;;;UAkCA,oBAAA;;;;;;UAkCA,yBAAA;;;;;;;;;;UAyBA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;EA4DD,cAAA;;;;;;;;UAmCC,eAAA;;;;;;;;UAoDA,UAAA;;;;;;;;;;;UAyEA,eAAA;EAAA,QAqKA,iBAAA;;;;;;;;;UAkBA,sBAAA;;;;;;;UAgFA,mBAAA;;;;;;;;;;;;;UAyNA,oBAAA;;;;;;;;;UAgBA,sBAAA;EAAA,QAkDA,kBAAA;;;;;;;UAcA,gBAAA;EAAA,QAYA,oBAAA;;;;;;;;UA2BA,4BAAA;EAAA,QAsBA,aAAA;EAAA,QAYA,qBAAA;EAAA,QASA,4BAAA;EAAA,QAWA,UAAA;EAAA,QAIA,0BAAA;EAAA,QAOA,wBAAA;EAAA,QAKA,uBAAA;EAAA,QAKA,kBAAA;EAAA,QAgBA,sBAAA;EAAA,QAiBA,0BAAA;EAAA,QAQA,+BAAA;EAAA,QAMA,6BAAA;EAAA,QAMA,wBAAA;EAAA,QASA,sBAAA;EAAA,QAQA,yBAAA;EAAA,QASA,kBAAA;EAAA,QAWA,UAAA;EAAA,QAMA,QAAA;EAAA,QAMA,aAAA;EAAA,QAIA,qBAAA;;;;;;UAeA,qBAAA;EAAA,QAmCA,kBAAA;EAAA,QAeA,2BAAA;EAAA,QA0BA,uBAAA;EAAA,QAoBA,wBAAA;EAAA,QAwBA,qBAAA;EAAA,QAMA,wBAAA;EAAA,QAMA,mBAAA;EAAA,QAeA,mBAAA;;;;;UAkBA,0BAAA;EAAA,QAaA,cAAA;EAAA,QAYA,qBAAA;EAAA,QAMA,uBAAA;;;;;;;UAsBA,iBAAA;;;;;;;UAgHA,cAAA;;;;;;;UA0BA,eAAA;EAAA,QA6DA,iBAAA;;;;;;;;UAgBA,+BAAA;;;;;;;;;;UAoCA,qBAAA;;;;;;;UA0BA,sBAAA;;;;;;;UA4BA,4BAAA;;;;;;;;;;;;;UAuFA,uBAAA;EAAA,QAoCA,YAAA;;;;;;;UAgDA,gBAAA;AAAA"}
+{"version":3,"file":"mongodb-query-parser.d.mts","names":[],"sources":["../../../../../../../../../packages/cascade/src/drivers/mongodb/mongodb-query-parser.ts"],"mappings":";;;;;;;YAyDY;;EAEV,YAAY;;EAEZ,YAAY;;EAEZ,wBAAwB;;;;;;;;;;qBAuBb;;;;mBAIM;;;;mBAKA;;;;mBAKA;;;;;mBAMA;;;;;;;mBAQA;;;;;;EAOjB,YAAmB,SAAS;;;;;;;;;;;;;;;;;;;;;EA0BrB;;;;;UAyFC;;;;;;;;;;;UA+CA;;;;;;;;;;;;;;UAmCA;;;;;;;;;;;;;;;;;;UAuDA;;;;UAkCA;;;;;;UAkCA;;;;;;;;;;UAyBA;;;;;;;;;;;;;;;;;;;;;;;;EA4DD;;;;;;;;UAmCC;;;;;;;;UAoDA;;;;;;;;;;;UAyEA;UAqKA;;;;;;;;;UAkBA;;;;;;;UAkFA;;;;;;;;;;;;;UAyNA;;;;;;;;;UAgBA;UAoDA;;;;;;;UAcA;UAYA;;;;;;;;UA2BA;UAsBA;UAYA;UASA;UAWA;UAIA;UAOA;UAKA;UAKA;UAgBA;UAiBA;UAQA;UAMA;UAMA;UASA;UAQA;UASA;UAWA;UAMA;UAMA;UAIA;;;;;;UAeA;UAmCA;UAeA;UA0BA;UAoBA;UAwBA;UAMA;UAMA;UAgBA;;;;;UAkBA;UAaA;UAYA;UAMA;;;;;;;UAsBA;;;;;;;UAgHA;;;;;;;UA4BA;UA6DA;;;;;;;;UAgBA;;;;;;;;;;UAoCA;;;;;;;UA0BA;;;;;;;UA4BA;;;;;;;;;;;;;UAuFA;UAoCA;;;;;;;UAgDA"}

package/esm/drivers/mongodb/mongodb-query-parser.mjs

@@ -1066,10 +1066,7 @@ var MongoQueryParser = class {
 			case "selectConcat":
 				projection[op.data.alias] = this.buildConcatExpression(op.data.fields);
 				break;
-			case "selectCoalesce":
-				projection[op.data.alias] = this.buildCoalesceExpression(op.data.fields);
-				break;
-			default: break;
+			case "selectCoalesce": projection[op.data.alias] = this.buildCoalesceExpression(op.data.fields);
 		}
 		for (const callback of driverCallbacks) callback(projection);
 		return Object.keys(projection).length > 0 ? { $project: projection } : null;
@@ -1127,7 +1124,6 @@ var MongoQueryParser = class {
 				if (stage) return stage;
 				break;
 			}
-			default: break;
 		}
 		return null;
 	}
@@ -1305,5 +1301,5 @@ var MongoQueryParser = class {
 };
 
 //#endregion
-export { MongoQueryParser };
+export { MongoQueryParser, resolveMongoLikePattern };
 //# sourceMappingURL=mongodb-query-parser.mjs.map