@warlock.js/cascade 4.0.171 → 4.1.1

package/esm/expressions/aggregate-expressions.d.mts

@@ -0,0 +1,224 @@
+//#region ../../@warlock.js/cascade/src/expressions/aggregate-expressions.d.ts
+/**
+ * Database-agnostic aggregation expressions.
+ *
+ * `count` / `sum` / `avg` / `min` / `max` are **cross-driver** — the same
+ * call compiles to the native shape on every supported database (MongoDB
+ * `{ $sum: "$field" }`, SQL `SUM(field)`, ...).
+ *
+ * `distinct` / `floor` / `first` / `last` are **MongoDB-only**. They have no
+ * single-scalar `GROUP BY` equivalent in SQL, so on Postgres they throw a
+ * fail-fast error at the `.groupBy()` call (naming the `selectRaw` /
+ * `havingRaw` escape hatch) rather than emit a silently-different query.
+ *
+ * @example
+ * ```typescript
+ * import { $agg } from '@warlock.js/cascade';
+ *
+ * // Works for both MongoDB and SQL
+ * Lesson.query()
+ *   .groupBy("type", {
+ *     count: $agg.count(),
+ *     total: $agg.sum("duration"),
+ *     avg: $agg.avg("rating")
+ *   })
+ *   .get();
+ * ```
+ */
+/**
+ * Abstract aggregate expression format.
+ *
+ * This format is database-agnostic and will be translated by each driver
+ * to their native syntax.
+ */
+type AggregateExpression = {
+  /** The aggregate function type */__agg: AggregateFunction; /** The field to aggregate (null for count) */
+  __field: string | null;
+};
+/**
+ * Supported aggregate functions.
+ */
+type AggregateFunction = "count" | "sum" | "avg" | "min" | "max" | "first" | "last" | "distinct" | "floor";
+/**
+ * Checks if a value is an abstract aggregate expression.
+ */
+declare function isAggregateExpression(value: unknown): value is AggregateExpression;
+/**
+ * Database-agnostic aggregation expression helpers.
+ *
+ * These helpers create abstract expressions that each driver translates
+ * to their native format.
+ */
+declare const $agg: {
+  /**
+   * Count documents in each group.
+   *
+   * @returns Abstract count expression
+   *
+   * @example
+   * ```typescript
+   * query.groupBy("type", {
+   *   count: $agg.count()
+   * });
+   * ```
+   *
+   * Translates to:
+   * - MongoDB: `{ $sum: 1 }`
+   * - SQL: `COUNT(*)`
+   */
+  count(): AggregateExpression;
+  /**
+   * Sum a numeric field across documents in each group.
+   *
+   * @param field - The field name to sum
+   * @returns Abstract sum expression
+   *
+   * @example
+   * ```typescript
+   * query.groupBy("type", {
+   *   totalDuration: $agg.sum("duration")
+   * });
+   * ```
+   *
+   * Translates to:
+   * - MongoDB: `{ $sum: "$duration" }`
+   * - SQL: `SUM(duration)`
+   */
+  sum(field: string): AggregateExpression;
+  /**
+   * Calculate the average value of a field across documents in each group.
+   *
+   * @param field - The field name to average
+   * @returns Abstract average expression
+   *
+   * @example
+   * ```typescript
+   * query.groupBy("type", {
+   *   avgRating: $agg.avg("rating")
+   * });
+   * ```
+   *
+   * Translates to:
+   * - MongoDB: `{ $avg: "$rating" }`
+   * - SQL: `AVG(rating)`
+   */
+  avg(field: string): AggregateExpression;
+  /**
+   * Get the minimum value of a field across documents in each group.
+   *
+   * @param field - The field name
+   * @returns Abstract min expression
+   *
+   * @example
+   * ```typescript
+   * query.groupBy("type", {
+   *   minPrice: $agg.min("price")
+   * });
+   * ```
+   *
+   * Translates to:
+   * - MongoDB: `{ $min: "$price" }`
+   * - SQL: `MIN(price)`
+   */
+  min(field: string): AggregateExpression;
+  /**
+   * Get the maximum value of a field across documents in each group.
+   *
+   * @param field - The field name
+   * @returns Abstract max expression
+   *
+   * @example
+   * ```typescript
+   * query.groupBy("type", {
+   *   maxPrice: $agg.max("price")
+   * });
+   * ```
+   *
+   * Translates to:
+   * - MongoDB: `{ $max: "$price" }`
+   * - SQL: `MAX(price)`
+   */
+  max(field: string): AggregateExpression;
+  /**
+   * Get the distinct values of a field across documents in each group.
+   *
+   * @param field - The field name
+   * @returns Abstract distinct expression
+   *
+   * @example
+   * ```typescript
+   * query.groupBy("type", {
+   *   distinctColors: $agg.distinct("color")
+   * });
+   * ```
+   *
+   * **MongoDB-only.** MongoDB: `{ $distinct: "$color" }` (returns the array
+   * of distinct values). On Postgres this throws — SQL `DISTINCT` is a set
+   * quantifier, not a scalar aggregate, so there is no equivalent single
+   * value to put in a `GROUP BY` projection. Use `selectRaw` if you need a
+   * Postgres-specific shape (e.g. `array_agg(DISTINCT color)`).
+   */
+  distinct(field: string): AggregateExpression;
+  /**
+   * Get the floor value of a field across documents in each group.
+   *
+   * @param field - The field name
+   * @returns Abstract floor expression
+   *
+   * @example
+   * ```typescript
+   * query.groupBy("type", {
+   *   floorPrice: $agg.floor("price")
+   * });
+   * ```
+   *
+   * **MongoDB-only.** MongoDB: `{ $floor: "$price" }`. On Postgres this
+   * throws — `FLOOR` is a scalar function, not an aggregate, so it is
+   * meaningless inside a bare `$group` / `GROUP BY`. Use `selectRaw` with
+   * `FLOOR(...)` over the aggregated value if you need it on Postgres.
+   */
+  floor(field: string): AggregateExpression;
+  /**
+   * Get the first value of a field in each group (order-dependent).
+   *
+   * @param field - The field name
+   * @returns Abstract first expression
+   *
+   * @example
+   * ```typescript
+   * query.groupBy("type", {
+   *   firstName: $agg.first("name")
+   * });
+   * ```
+   *
+   * **MongoDB-only.** MongoDB: `{ $first: "$name" }` (group-order
+   * dependent). On Postgres this throws — the SQL equivalent is
+   * `FIRST_VALUE(name) OVER (ORDER BY ...)`, a window function needing an
+   * ordering context the `$agg` API doesn't carry. Use `selectRaw` with an
+   * explicit window function if you need it on Postgres.
+   */
+  first(field: string): AggregateExpression;
+  /**
+   * Get the last value of a field in each group (order-dependent).
+   *
+   * @param field - The field name
+   * @returns Abstract last expression
+   *
+   * @example
+   * ```typescript
+   * query.groupBy("type", {
+   *   lastName: $agg.last("name")
+   * });
+   * ```
+   *
+   * **MongoDB-only.** MongoDB: `{ $last: "$name" }` (group-order
+   * dependent). On Postgres this throws — the SQL equivalent is
+   * `LAST_VALUE(name) OVER (ORDER BY ...)`, a window function needing an
+   * ordering context the `$agg` API doesn't carry. Use `selectRaw` with an
+   * explicit window function if you need it on Postgres.
+   */
+  last(field: string): AggregateExpression;
+};
+//#endregion
+export { $agg, AggregateExpression, AggregateFunction, isAggregateExpression };
+//# sourceMappingURL=aggregate-expressions.d.mts.map

package/esm/expressions/aggregate-expressions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-expressions.d.mts","names":[],"sources":["../../../../../../@warlock.js/cascade/src/expressions/aggregate-expressions.ts"],"mappings":";;AAiCA;;;;;;;;AAIS;AAMT;;;;AAA6B;AAc7B;;;;;;;;AAAmF;AAenF;;;;;;;;KAvCY,mBAAA;EAyLY,kCAvLtB,KAAA,EAAO,iBAAiB,EAqOH;EAnOrB,OAAA;AAAA;;;;KAMU,iBAAA;;;;iBAcI,qBAAA,CAAsB,KAAA,YAAiB,KAAA,IAAS,mBAAmB;;;;;;;cAetE,IAAA;;;;;;;;;;;;;AAgM6B;;;;WA/K/B,mBAAA;;;;;;;;;;;;;;;;;;sBAqBW,mBAAA;;;;;;;;;;;;;;;;;;sBAqBA,mBAAA;;;;;;;;;;;;;;;;;;sBAqBA,mBAAA;;;;;;;;;;;;;;;;;;sBAqBA,mBAAA;;;;;;;;;;;;;;;;;;;;2BAuBK,mBAAA;;;;;;;;;;;;;;;;;;;wBAsBH,mBAAA;;;;;;;;;;;;;;;;;;;;wBAuBA,mBAAA;;;;;;;;;;;;;;;;;;;;uBAuBD,mBAAA;AAAA"}

package/esm/expressions/aggregate-expressions.mjs

@@ -0,0 +1,232 @@
+//#region ../../@warlock.js/cascade/src/expressions/aggregate-expressions.ts
+/**
+* Checks if a value is an abstract aggregate expression.
+*/
+function isAggregateExpression(value) {
+	return typeof value === "object" && value !== null && "__field" in value && typeof value.__agg === "string";
+}
+/**
+* Database-agnostic aggregation expression helpers.
+*
+* These helpers create abstract expressions that each driver translates
+* to their native format.
+*/
+const $agg = {
+	/**
+	* Count documents in each group.
+	*
+	* @returns Abstract count expression
+	*
+	* @example
+	* ```typescript
+	* query.groupBy("type", {
+	*   count: $agg.count()
+	* });
+	* ```
+	*
+	* Translates to:
+	* - MongoDB: `{ $sum: 1 }`
+	* - SQL: `COUNT(*)`
+	*/
+	count() {
+		return {
+			__agg: "count",
+			__field: null
+		};
+	},
+	/**
+	* Sum a numeric field across documents in each group.
+	*
+	* @param field - The field name to sum
+	* @returns Abstract sum expression
+	*
+	* @example
+	* ```typescript
+	* query.groupBy("type", {
+	*   totalDuration: $agg.sum("duration")
+	* });
+	* ```
+	*
+	* Translates to:
+	* - MongoDB: `{ $sum: "$duration" }`
+	* - SQL: `SUM(duration)`
+	*/
+	sum(field) {
+		return {
+			__agg: "sum",
+			__field: field
+		};
+	},
+	/**
+	* Calculate the average value of a field across documents in each group.
+	*
+	* @param field - The field name to average
+	* @returns Abstract average expression
+	*
+	* @example
+	* ```typescript
+	* query.groupBy("type", {
+	*   avgRating: $agg.avg("rating")
+	* });
+	* ```
+	*
+	* Translates to:
+	* - MongoDB: `{ $avg: "$rating" }`
+	* - SQL: `AVG(rating)`
+	*/
+	avg(field) {
+		return {
+			__agg: "avg",
+			__field: field
+		};
+	},
+	/**
+	* Get the minimum value of a field across documents in each group.
+	*
+	* @param field - The field name
+	* @returns Abstract min expression
+	*
+	* @example
+	* ```typescript
+	* query.groupBy("type", {
+	*   minPrice: $agg.min("price")
+	* });
+	* ```
+	*
+	* Translates to:
+	* - MongoDB: `{ $min: "$price" }`
+	* - SQL: `MIN(price)`
+	*/
+	min(field) {
+		return {
+			__agg: "min",
+			__field: field
+		};
+	},
+	/**
+	* Get the maximum value of a field across documents in each group.
+	*
+	* @param field - The field name
+	* @returns Abstract max expression
+	*
+	* @example
+	* ```typescript
+	* query.groupBy("type", {
+	*   maxPrice: $agg.max("price")
+	* });
+	* ```
+	*
+	* Translates to:
+	* - MongoDB: `{ $max: "$price" }`
+	* - SQL: `MAX(price)`
+	*/
+	max(field) {
+		return {
+			__agg: "max",
+			__field: field
+		};
+	},
+	/**
+	* Get the distinct values of a field across documents in each group.
+	*
+	* @param field - The field name
+	* @returns Abstract distinct expression
+	*
+	* @example
+	* ```typescript
+	* query.groupBy("type", {
+	*   distinctColors: $agg.distinct("color")
+	* });
+	* ```
+	*
+	* **MongoDB-only.** MongoDB: `{ $distinct: "$color" }` (returns the array
+	* of distinct values). On Postgres this throws — SQL `DISTINCT` is a set
+	* quantifier, not a scalar aggregate, so there is no equivalent single
+	* value to put in a `GROUP BY` projection. Use `selectRaw` if you need a
+	* Postgres-specific shape (e.g. `array_agg(DISTINCT color)`).
+	*/
+	distinct(field) {
+		return {
+			__agg: "distinct",
+			__field: field
+		};
+	},
+	/**
+	* Get the floor value of a field across documents in each group.
+	*
+	* @param field - The field name
+	* @returns Abstract floor expression
+	*
+	* @example
+	* ```typescript
+	* query.groupBy("type", {
+	*   floorPrice: $agg.floor("price")
+	* });
+	* ```
+	*
+	* **MongoDB-only.** MongoDB: `{ $floor: "$price" }`. On Postgres this
+	* throws — `FLOOR` is a scalar function, not an aggregate, so it is
+	* meaningless inside a bare `$group` / `GROUP BY`. Use `selectRaw` with
+	* `FLOOR(...)` over the aggregated value if you need it on Postgres.
+	*/
+	floor(field) {
+		return {
+			__agg: "floor",
+			__field: field
+		};
+	},
+	/**
+	* Get the first value of a field in each group (order-dependent).
+	*
+	* @param field - The field name
+	* @returns Abstract first expression
+	*
+	* @example
+	* ```typescript
+	* query.groupBy("type", {
+	*   firstName: $agg.first("name")
+	* });
+	* ```
+	*
+	* **MongoDB-only.** MongoDB: `{ $first: "$name" }` (group-order
+	* dependent). On Postgres this throws — the SQL equivalent is
+	* `FIRST_VALUE(name) OVER (ORDER BY ...)`, a window function needing an
+	* ordering context the `$agg` API doesn't carry. Use `selectRaw` with an
+	* explicit window function if you need it on Postgres.
+	*/
+	first(field) {
+		return {
+			__agg: "first",
+			__field: field
+		};
+	},
+	/**
+	* Get the last value of a field in each group (order-dependent).
+	*
+	* @param field - The field name
+	* @returns Abstract last expression
+	*
+	* @example
+	* ```typescript
+	* query.groupBy("type", {
+	*   lastName: $agg.last("name")
+	* });
+	* ```
+	*
+	* **MongoDB-only.** MongoDB: `{ $last: "$name" }` (group-order
+	* dependent). On Postgres this throws — the SQL equivalent is
+	* `LAST_VALUE(name) OVER (ORDER BY ...)`, a window function needing an
+	* ordering context the `$agg` API doesn't carry. Use `selectRaw` with an
+	* explicit window function if you need it on Postgres.
+	*/
+	last(field) {
+		return {
+			__agg: "last",
+			__field: field
+		};
+	}
+};
+
+//#endregion
+export { $agg, isAggregateExpression };
+//# sourceMappingURL=aggregate-expressions.mjs.map

package/esm/expressions/aggregate-expressions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-expressions.mjs","names":[],"sources":["../../../../../../@warlock.js/cascade/src/expressions/aggregate-expressions.ts"],"sourcesContent":["/**\n * Database-agnostic aggregation expressions.\n *\n * `count` / `sum` / `avg` / `min` / `max` are **cross-driver** — the same\n * call compiles to the native shape on every supported database (MongoDB\n * `{ $sum: \"$field\" }`, SQL `SUM(field)`, ...).\n *\n * `distinct` / `floor` / `first` / `last` are **MongoDB-only**. They have no\n * single-scalar `GROUP BY` equivalent in SQL, so on Postgres they throw a\n * fail-fast error at the `.groupBy()` call (naming the `selectRaw` /\n * `havingRaw` escape hatch) rather than emit a silently-different query.\n *\n * @example\n * ```typescript\n * import { $agg } from '@warlock.js/cascade';\n *\n * // Works for both MongoDB and SQL\n * Lesson.query()\n *   .groupBy(\"type\", {\n *     count: $agg.count(),\n *     total: $agg.sum(\"duration\"),\n *     avg: $agg.avg(\"rating\")\n *   })\n *   .get();\n * ```\n */\n\n/**\n * Abstract aggregate expression format.\n *\n * This format is database-agnostic and will be translated by each driver\n * to their native syntax.\n */\nexport type AggregateExpression = {\n  /** The aggregate function type */\n  __agg: AggregateFunction;\n  /** The field to aggregate (null for count) */\n  __field: string | null;\n};\n\n/**\n * Supported aggregate functions.\n */\nexport type AggregateFunction =\n  | \"count\"\n  | \"sum\"\n  | \"avg\"\n  | \"min\"\n  | \"max\"\n  | \"first\"\n  | \"last\"\n  | \"distinct\"\n  | \"floor\";\n\n/**\n * Checks if a value is an abstract aggregate expression.\n */\nexport function isAggregateExpression(value: unknown): value is AggregateExpression {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"__field\" in value &&\n    typeof (value as AggregateExpression).__agg === \"string\"\n  );\n}\n\n/**\n * Database-agnostic aggregation expression helpers.\n *\n * These helpers create abstract expressions that each driver translates\n * to their native format.\n */\nexport const $agg = {\n  /**\n   * Count documents in each group.\n   *\n   * @returns Abstract count expression\n   *\n   * @example\n   * ```typescript\n   * query.groupBy(\"type\", {\n   *   count: $agg.count()\n   * });\n   * ```\n   *\n   * Translates to:\n   * - MongoDB: `{ $sum: 1 }`\n   * - SQL: `COUNT(*)`\n   */\n  count(): AggregateExpression {\n    return { __agg: \"count\", __field: null };\n  },\n\n  /**\n   * Sum a numeric field across documents in each group.\n   *\n   * @param field - The field name to sum\n   * @returns Abstract sum expression\n   *\n   * @example\n   * ```typescript\n   * query.groupBy(\"type\", {\n   *   totalDuration: $agg.sum(\"duration\")\n   * });\n   * ```\n   *\n   * Translates to:\n   * - MongoDB: `{ $sum: \"$duration\" }`\n   * - SQL: `SUM(duration)`\n   */\n  sum(field: string): AggregateExpression {\n    return { __agg: \"sum\", __field: field };\n  },\n\n  /**\n   * Calculate the average value of a field across documents in each group.\n   *\n   * @param field - The field name to average\n   * @returns Abstract average expression\n   *\n   * @example\n   * ```typescript\n   * query.groupBy(\"type\", {\n   *   avgRating: $agg.avg(\"rating\")\n   * });\n   * ```\n   *\n   * Translates to:\n   * - MongoDB: `{ $avg: \"$rating\" }`\n   * - SQL: `AVG(rating)`\n   */\n  avg(field: string): AggregateExpression {\n    return { __agg: \"avg\", __field: field };\n  },\n\n  /**\n   * Get the minimum value of a field across documents in each group.\n   *\n   * @param field - The field name\n   * @returns Abstract min expression\n   *\n   * @example\n   * ```typescript\n   * query.groupBy(\"type\", {\n   *   minPrice: $agg.min(\"price\")\n   * });\n   * ```\n   *\n   * Translates to:\n   * - MongoDB: `{ $min: \"$price\" }`\n   * - SQL: `MIN(price)`\n   */\n  min(field: string): AggregateExpression {\n    return { __agg: \"min\", __field: field };\n  },\n\n  /**\n   * Get the maximum value of a field across documents in each group.\n   *\n   * @param field - The field name\n   * @returns Abstract max expression\n   *\n   * @example\n   * ```typescript\n   * query.groupBy(\"type\", {\n   *   maxPrice: $agg.max(\"price\")\n   * });\n   * ```\n   *\n   * Translates to:\n   * - MongoDB: `{ $max: \"$price\" }`\n   * - SQL: `MAX(price)`\n   */\n  max(field: string): AggregateExpression {\n    return { __agg: \"max\", __field: field };\n  },\n\n  /**\n   * Get the distinct values of a field across documents in each group.\n   *\n   * @param field - The field name\n   * @returns Abstract distinct expression\n   *\n   * @example\n   * ```typescript\n   * query.groupBy(\"type\", {\n   *   distinctColors: $agg.distinct(\"color\")\n   * });\n   * ```\n   *\n   * **MongoDB-only.** MongoDB: `{ $distinct: \"$color\" }` (returns the array\n   * of distinct values). On Postgres this throws — SQL `DISTINCT` is a set\n   * quantifier, not a scalar aggregate, so there is no equivalent single\n   * value to put in a `GROUP BY` projection. Use `selectRaw` if you need a\n   * Postgres-specific shape (e.g. `array_agg(DISTINCT color)`).\n   */\n  distinct(field: string): AggregateExpression {\n    return { __agg: \"distinct\", __field: field };\n  },\n\n  /**\n   * Get the floor value of a field across documents in each group.\n   *\n   * @param field - The field name\n   * @returns Abstract floor expression\n   *\n   * @example\n   * ```typescript\n   * query.groupBy(\"type\", {\n   *   floorPrice: $agg.floor(\"price\")\n   * });\n   * ```\n   *\n   * **MongoDB-only.** MongoDB: `{ $floor: \"$price\" }`. On Postgres this\n   * throws — `FLOOR` is a scalar function, not an aggregate, so it is\n   * meaningless inside a bare `$group` / `GROUP BY`. Use `selectRaw` with\n   * `FLOOR(...)` over the aggregated value if you need it on Postgres.\n   */\n  floor(field: string): AggregateExpression {\n    return { __agg: \"floor\", __field: field };\n  },\n\n  /**\n   * Get the first value of a field in each group (order-dependent).\n   *\n   * @param field - The field name\n   * @returns Abstract first expression\n   *\n   * @example\n   * ```typescript\n   * query.groupBy(\"type\", {\n   *   firstName: $agg.first(\"name\")\n   * });\n   * ```\n   *\n   * **MongoDB-only.** MongoDB: `{ $first: \"$name\" }` (group-order\n   * dependent). On Postgres this throws — the SQL equivalent is\n   * `FIRST_VALUE(name) OVER (ORDER BY ...)`, a window function needing an\n   * ordering context the `$agg` API doesn't carry. Use `selectRaw` with an\n   * explicit window function if you need it on Postgres.\n   */\n  first(field: string): AggregateExpression {\n    return { __agg: \"first\", __field: field };\n  },\n\n  /**\n   * Get the last value of a field in each group (order-dependent).\n   *\n   * @param field - The field name\n   * @returns Abstract last expression\n   *\n   * @example\n   * ```typescript\n   * query.groupBy(\"type\", {\n   *   lastName: $agg.last(\"name\")\n   * });\n   * ```\n   *\n   * **MongoDB-only.** MongoDB: `{ $last: \"$name\" }` (group-order\n   * dependent). On Postgres this throws — the SQL equivalent is\n   * `LAST_VALUE(name) OVER (ORDER BY ...)`, a window function needing an\n   * ordering context the `$agg` API doesn't carry. Use `selectRaw` with an\n   * explicit window function if you need it on Postgres.\n   */\n  last(field: string): AggregateExpression {\n    return { __agg: \"last\", __field: field };\n  },\n};\n"],"mappings":";;;;AAyDA,SAAgB,sBAAsB,OAA8C;CAClF,OACE,OAAO,UAAU,YACjB,UAAU,QACV,aAAa,SACb,OAAQ,MAA8B,UAAU;AAEpD;;;;;;;AAQA,MAAa,OAAO;;;;;;;;;;;;;;;;;CAiBlB,QAA6B;EAC3B,OAAO;GAAE,OAAO;GAAS,SAAS;EAAK;CACzC;;;;;;;;;;;;;;;;;;CAmBA,IAAI,OAAoC;EACtC,OAAO;GAAE,OAAO;GAAO,SAAS;EAAM;CACxC;;;;;;;;;;;;;;;;;;CAmBA,IAAI,OAAoC;EACtC,OAAO;GAAE,OAAO;GAAO,SAAS;EAAM;CACxC;;;;;;;;;;;;;;;;;;CAmBA,IAAI,OAAoC;EACtC,OAAO;GAAE,OAAO;GAAO,SAAS;EAAM;CACxC;;;;;;;;;;;;;;;;;;CAmBA,IAAI,OAAoC;EACtC,OAAO;GAAE,OAAO;GAAO,SAAS;EAAM;CACxC;;;;;;;;;;;;;;;;;;;;CAqBA,SAAS,OAAoC;EAC3C,OAAO;GAAE,OAAO;GAAY,SAAS;EAAM;CAC7C;;;;;;;;;;;;;;;;;;;CAoBA,MAAM,OAAoC;EACxC,OAAO;GAAE,OAAO;GAAS,SAAS;EAAM;CAC1C;;;;;;;;;;;;;;;;;;;;CAqBA,MAAM,OAAoC;EACxC,OAAO;GAAE,OAAO;GAAS,SAAS;EAAM;CAC1C;;;;;;;;;;;;;;;;;;;;CAqBA,KAAK,OAAoC;EACvC,OAAO;GAAE,OAAO;GAAQ,SAAS;EAAM;CACzC;AACF"}

package/esm/index.d.mts

@@ -0,0 +1,67 @@
+import { DeleteStrategy, MigrationDefaults, ModelDefaults, NamingConvention, RelationDefaults, StrictMode, UuidStrategy } from "./types.mjs";
+import { TableIndexInformation } from "./contracts/driver-blueprint.contract.mjs";
+import { ColumnDefinition, ColumnType, ForeignKeyDefinition, FullTextIndexOptions, GeoIndexOptions, IndexDefinition, MigrationDriverContract, MigrationDriverFactory, VectorIndexOptions } from "./contracts/migration-driver.contract.mjs";
+import { ColumnBuilder } from "./migration/column-builder.mjs";
+import { DetachedColumnBuilder, arrayBigInt, arrayBoolean, arrayDate, arrayDecimal, arrayFloat, arrayInt, arrayJson, arrayText, arrayTimestamp, arrayUuid, bigInt, bigInteger, binary, blobCol, boolCol, char, date, dateTime, decimal, double, enumCol, float, geometry, int, integer, ipAddress, json, lineString, longText, macAddress, mediumText, objectCol, point, polygon, setCol, smallInt, smallInteger, string, text, time, timestamp, tinyInt, tinyInteger, ulid, uuid, vector, year } from "./migration/column-helpers.mjs";
+import { DatabaseDirtyTracker } from "./database-dirty-tracker.mjs";
+import { ChildModel, GlobalScopeDefinition, GlobalScopeOptions, LocalScopeCallback, ModelSchema, ScopeTiming } from "./model/model.types.mjs";
+import { ModelEventListener, ModelEventName, ModelEvents, OnDeletedEventContext, globalModelEvents } from "./events/model-events.mjs";
+import { BelongsToManyOptions, BelongsToOptions, HasManyOptions, HasOneOptions, LoadedRelationResult, LoadedRelationsMap, PivotData, PivotIds, RelationConstraintCallback, RelationConstraints, RelationDefinition, RelationDefinitions, RelationType } from "./relations/types.mjs";
+import { PivotOperations, createPivotOperations } from "./relations/pivot-operations.mjs";
+import { ModelSnapshot, RelationHydrator, SerializedRelation } from "./relations/relation-hydrator.mjs";
+import { EmbedKey, ModelSyncConfig, ModelSyncContract, ModelSyncOperationContract, SyncConfig, SyncContext, SyncEventPayload, SyncInstruction, SyncInstructionOptions, SyncResult } from "./sync/types.mjs";
+import { Model } from "./model/model.mjs";
+import { ConnectionOptions, DatabaseDriver, ModelDefaultConfig, connectToDatabase, getDatabaseDriver, transaction } from "./utils/connect-to-database.mjs";
+import { ForeignKeyBuilder } from "./migration/foreign-key-builder.mjs";
+import { AlterSchema, ColumnMap, IndexEntry, Migration, MigrationAlterOptions, MigrationConstructor, MigrationContract, MigrationCreateOptions, OperationType, PendingOperation, UniqueEntry, migrate } from "./migration/migration.mjs";
+import { ChunkCallback, CursorPaginationOptions, CursorPaginationResult, DriverQuery, GroupByInput, HavingInput, JoinOptions, OrderDirection, PaginationOptions, PaginationResult, QueryBuilderContract, RawExpression, WhereCallback, WhereObject, WhereOperator } from "./contracts/query-builder.contract.mjs";
+import { SyncAdapterContract } from "./contracts/sync-adapter.contract.mjs";
+import { CreateDatabaseOptions, DriverContract, DriverEvent, DriverEventListener, DriverTransactionContract, DropDatabaseOptions, InsertResult, TransactionContext, UpdateOperations, UpdateResult } from "./contracts/database-driver.contract.mjs";
+import { GenerateIdOptions, IdGeneratorContract } from "./contracts/database-id-generator.contract.mjs";
+import { RemoverContract, RemoverOptions, RemoverResult } from "./contracts/database-remover.contract.mjs";
+import { RestorerContract, RestorerOptions, RestorerResult } from "./contracts/database-restorer.contract.mjs";
+import { BuildUpdateOperationsResult, WriterContract, WriterOptions, WriterResult } from "./contracts/database-writer.contract.mjs";
+import { DataSource, DataSourceOptions } from "./data-source/data-source.mjs";
+import { databaseDataSourceContext } from "./context/database-data-source-context.mjs";
+import { databaseTransactionContext } from "./context/database-transaction-context.mjs";
+import { DataSourceRegistryEvent, DataSourceRegistryListener, dataSourceRegistry } from "./data-source/data-source-registry.mjs";
+import { MissingDataSourceError } from "./errors/missing-data-source.error.mjs";
+import { TransactionRollbackError } from "./errors/transaction-rollback.error.mjs";
+import { ModelRef, RegisterModel, RegisterModelOptions, cleanupModelsRegistery, getAllModelsFromRegistry, getModelFromRegistry, registerModelInRegistry, removeModelFromRegistery, resolveModelClass, resolveModelName, tryResolveModelClass, verifyRegisteredRelations } from "./model/register-model.mjs";
+import { BelongsTo, BelongsToMany, HasMany, HasOne, RELATION_METADATA_KEY } from "./model/relation-decorators.mjs";
+import { DatabaseRemover } from "./remover/database-remover.mjs";
+import { DatabaseRestorer } from "./restorer/database-restorer.mjs";
+import { DatabaseWriterValidationError } from "./validation/database-writer-validation-error.mjs";
+import { BaseQueryRuleOptions, BaseUniqueRuleOptions, ExistsRuleOptions, UniqueRuleOptions } from "./validation/types.mjs";
+import { DatabaseWriter } from "./writer/database-writer.mjs";
+import { RelationLoader } from "./relations/relation-loader.mjs";
+import { $agg, AggregateExpression, AggregateFunction, isAggregateExpression } from "./expressions/aggregate-expressions.mjs";
+import { MongoDriverOptions, Operation, PipelineStage } from "./drivers/mongodb/types.mjs";
+import { MongoDbDriver, isMongoDBDriverLoaded } from "./drivers/mongodb/mongodb-driver.mjs";
+import { MongoIdGenerator } from "./drivers/mongodb/mongodb-id-generator.mjs";
+import { MongoQueryBuilder } from "./drivers/mongodb/mongodb-query-builder.mjs";
+import { MongoSyncAdapter } from "./drivers/mongodb/mongodb-sync-adapter.mjs";
+import { modelSync } from "./sync/model-sync.mjs";
+import { ModelSyncOperation } from "./sync/model-sync-operation.mjs";
+import { DEFAULT_MAX_SYNC_DEPTH, SyncContextManager } from "./sync/sync-context.mjs";
+import { SyncManager } from "./sync/sync-manager.mjs";
+import { ModelTransformCallback, useModelTransformer } from "./utils/database-writer.utils.mjs";
+import { DefineModelOptions, ModelType, defineModel } from "./utils/define-model.mjs";
+import { onceConnected, onceDisconnected } from "./utils/once-connected.mjs";
+import { MigrationRecord, MigrationResult, MigrationRunnerOptions, MigrationStatus, PendingMigration, RollbackOptions, RunMigrationsOptions } from "./migration/types.mjs";
+import { MigrationRunner, migrationRunner } from "./migration/migration-runner.mjs";
+import { CreateDatabaseResult, DropAllTablesResult, createDatabase, dropAllTables } from "./operations/database.mjs";
+import { ExportMigrationsSQLOptions, RollbackMigrationsOptions, exportMigrationsSQL, freshMigrate, listExecutedMigrations, rollbackMigrations, runMigrations } from "./operations/migrations.mjs";
+import { MongoMigrationDriver } from "./drivers/mongodb/mongodb-migration-driver.mjs";
+import { SqlDialectContract } from "./drivers/sql/sql-dialect.contract.mjs";
+import { SqlAggregateFunction, SqlDeleteOperation, SqlGroupClause, SqlHavingClause, SqlInsertOperation, SqlJoinClause, SqlJoinType, SqlOrderClause, SqlQueryConfig, SqlQueryResult, SqlSelectClause, SqlUpdateOperation, SqlWhereOperation, SqlWhereType } from "./drivers/sql/sql-types.mjs";
+import { PostgresDialect } from "./drivers/postgres/postgres-dialect.mjs";
+import { PostgresConnectionConfig, PostgresCopyOptions, PostgresIsolationLevel, PostgresNotification, PostgresOperation, PostgresPoolConfig, PostgresQueryResult, PostgresTransactionOptions, PostgresWhereClause } from "./drivers/postgres/types.mjs";
+import { PostgresDriver } from "./drivers/postgres/postgres-driver.mjs";
+import { PostgresBlueprint } from "./drivers/postgres/postgres-blueprint.mjs";
+import { PostgresMigrationDriver } from "./drivers/postgres/postgres-migration-driver.mjs";
+import { PostgresQueryBuilder } from "./drivers/postgres/postgres-query-builder.mjs";
+import { PostgresOperationType, PostgresParserOperation, PostgresParserOptions, PostgresQueryParser } from "./drivers/postgres/postgres-query-parser.mjs";
+import { PostgresSyncAdapter } from "./drivers/postgres/postgres-sync-adapter.mjs";
+import { MongoClientOptions, TransactionOptions } from "mongodb";
+export { $agg, AggregateExpression, AggregateFunction, AlterSchema, type BaseQueryRuleOptions, type BaseUniqueRuleOptions, BelongsTo, BelongsToMany, type BelongsToManyOptions, type BelongsToOptions, BuildUpdateOperationsResult, type ChildModel, ChunkCallback, ColumnBuilder, ColumnDefinition, ColumnMap, ColumnType, ConnectionOptions, CreateDatabaseOptions, CreateDatabaseResult, CursorPaginationOptions, CursorPaginationResult, DEFAULT_MAX_SYNC_DEPTH, DataSource, DataSourceOptions, DataSourceRegistryEvent, DataSourceRegistryListener, DatabaseDirtyTracker, DatabaseDriver, DatabaseRemover, DatabaseRestorer, DatabaseWriter, DatabaseWriterValidationError, DefineModelOptions, DeleteStrategy, DetachedColumnBuilder, DriverContract, DriverEvent, DriverEventListener, DriverQuery, DriverTransactionContract, DropAllTablesResult, DropDatabaseOptions, type EmbedKey, type ExistsRuleOptions, ExportMigrationsSQLOptions, ForeignKeyBuilder, ForeignKeyDefinition, FullTextIndexOptions, GenerateIdOptions, GeoIndexOptions, type GlobalScopeDefinition, type GlobalScopeOptions, GroupByInput, HasMany, type HasManyOptions, HasOne, type HasOneOptions, HavingInput, IdGeneratorContract, IndexDefinition, IndexEntry, InsertResult, JoinOptions, type LoadedRelationResult, type LoadedRelationsMap, type LocalScopeCallback, Migration, MigrationAlterOptions, MigrationConstructor, MigrationContract, MigrationCreateOptions, MigrationDefaults, MigrationDriverContract, MigrationDriverFactory, type MigrationRecord, type MigrationResult, MigrationRunner, type MigrationRunnerOptions, type MigrationStatus, MissingDataSourceError, Model, ModelDefaultConfig, ModelDefaults, ModelEventListener, ModelEventName, ModelEvents, ModelRef, type ModelSchema, type ModelSnapshot, type ModelSyncConfig, type ModelSyncContract, ModelSyncOperation, type ModelSyncOperationContract, ModelTransformCallback, ModelType, type MongoClientOptions, MongoDbDriver, MongoDriverOptions, MongoIdGenerator, MongoMigrationDriver, MongoQueryBuilder, MongoSyncAdapter, NamingConvention, OnDeletedEventContext, Operation, OperationType, OrderDirection, PaginationOptions, PaginationResult, type PendingMigration, PendingOperation, PipelineStage, type PivotData, type PivotIds, PivotOperations, PostgresBlueprint, PostgresConnectionConfig, PostgresCopyOptions, PostgresDialect, PostgresDriver, PostgresIsolationLevel, PostgresMigrationDriver, PostgresNotification, PostgresOperation, PostgresOperationType, PostgresParserOperation, PostgresParserOptions, PostgresPoolConfig, PostgresQueryBuilder, PostgresQueryParser, PostgresQueryResult, PostgresSyncAdapter, PostgresTransactionOptions, PostgresWhereClause, QueryBuilderContract, RELATION_METADATA_KEY, RawExpression, RegisterModel, RegisterModelOptions, type RelationConstraintCallback, type RelationConstraints, RelationDefaults, type RelationDefinition, type RelationDefinitions, RelationHydrator, RelationLoader, type RelationType, RemoverContract, RemoverOptions, RemoverResult, RestorerContract, RestorerOptions, RestorerResult, RollbackMigrationsOptions, type RollbackOptions, type RunMigrationsOptions, type ScopeTiming, type SerializedRelation, SqlAggregateFunction, SqlDeleteOperation, SqlDialectContract, SqlGroupClause, SqlHavingClause, SqlInsertOperation, SqlJoinClause, SqlJoinType, SqlOrderClause, SqlQueryConfig, SqlQueryResult, SqlSelectClause, SqlUpdateOperation, SqlWhereOperation, SqlWhereType, StrictMode, SyncAdapterContract, type SyncConfig, type SyncContext, SyncContextManager, type SyncEventPayload, SyncInstruction, type SyncInstructionOptions, SyncManager, type SyncResult, type TableIndexInformation, TransactionContext, type TransactionOptions, TransactionRollbackError, UniqueEntry, type UniqueRuleOptions, UpdateOperations, UpdateResult, UuidStrategy, VectorIndexOptions, WhereCallback, WhereObject, WhereOperator, WriterContract, WriterOptions, WriterResult, arrayBigInt, arrayBoolean, arrayDate, arrayDecimal, arrayFloat, arrayInt, arrayJson, arrayText, arrayTimestamp, arrayUuid, bigInt, bigInteger, binary, blobCol, boolCol as bool, boolCol, char, cleanupModelsRegistery, connectToDatabase, createDatabase, createPivotOperations, dataSourceRegistry, databaseDataSourceContext, databaseTransactionContext, date, dateTime, decimal, defineModel, double, dropAllTables, enumCol, exportMigrationsSQL, float, freshMigrate, geometry, getAllModelsFromRegistry, getDatabaseDriver, getModelFromRegistry, globalModelEvents, int, integer, ipAddress, isAggregateExpression, isMongoDBDriverLoaded, json, lineString, listExecutedMigrations, longText, macAddress, mediumText, migrate, migrationRunner, modelSync, objectCol, onceConnected, onceDisconnected, point, polygon, registerModelInRegistry, removeModelFromRegistery, resolveModelClass, resolveModelName, rollbackMigrations, runMigrations, setCol, smallInt, smallInteger, string, text, time, timestamp, tinyInt, tinyInteger, transaction, tryResolveModelClass, ulid, useModelTransformer, uuid, vector, verifyRegisteredRelations, year };

package/esm/index.mjs

@@ -0,0 +1,53 @@
+import { databaseDataSourceContext } from "./context/database-data-source-context.mjs";
+import { databaseTransactionContext } from "./context/database-transaction-context.mjs";
+import { DataSource } from "./data-source/data-source.mjs";
+import { MissingDataSourceError } from "./errors/missing-data-source.error.mjs";
+import { dataSourceRegistry } from "./data-source/data-source-registry.mjs";
+import { TransactionRollbackError } from "./errors/transaction-rollback.error.mjs";
+import { DatabaseDirtyTracker } from "./database-dirty-tracker.mjs";
+import { ModelEvents, globalModelEvents } from "./events/model-events.mjs";
+import { BelongsTo, BelongsToMany, HasMany, HasOne, RELATION_METADATA_KEY } from "./model/relation-decorators.mjs";
+import { RegisterModel, cleanupModelsRegistery, getAllModelsFromRegistry, getModelFromRegistry, registerModelInRegistry, removeModelFromRegistery, resolveModelClass, resolveModelName, tryResolveModelClass, verifyRegisteredRelations } from "./model/register-model.mjs";
+import { RelationLoader } from "./relations/relation-loader.mjs";
+import { DEFAULT_MAX_SYNC_DEPTH, SyncContextManager } from "./sync/sync-context.mjs";
+import { SyncManager } from "./sync/sync-manager.mjs";
+import { ModelSyncOperation } from "./sync/model-sync-operation.mjs";
+import { modelSync } from "./sync/model-sync.mjs";
+import { DatabaseRemover } from "./remover/database-remover.mjs";
+import { RelationHydrator } from "./relations/relation-hydrator.mjs";
+import { DatabaseWriterValidationError } from "./validation/database-writer-validation-error.mjs";
+import "./validation/index.mjs";
+import { DatabaseWriter } from "./writer/database-writer.mjs";
+import { PivotOperations, createPivotOperations } from "./relations/pivot-operations.mjs";
+import { DatabaseRestorer } from "./restorer/database-restorer.mjs";
+import { Model } from "./model/model.mjs";
+import "./relations/index.mjs";
+import { $agg, isAggregateExpression } from "./expressions/aggregate-expressions.mjs";
+import { MongoIdGenerator } from "./drivers/mongodb/mongodb-id-generator.mjs";
+import { MongoMigrationDriver } from "./drivers/mongodb/mongodb-migration-driver.mjs";
+import { MongoQueryBuilder } from "./drivers/mongodb/mongodb-query-builder.mjs";
+import { MongoSyncAdapter } from "./drivers/mongodb/mongodb-sync-adapter.mjs";
+import { MongoDbDriver, isMongoDBDriverLoaded } from "./drivers/mongodb/mongodb-driver.mjs";
+import { PostgresBlueprint } from "./drivers/postgres/postgres-blueprint.mjs";
+import { PostgresDialect } from "./drivers/postgres/postgres-dialect.mjs";
+import { PostgresMigrationDriver } from "./drivers/postgres/postgres-migration-driver.mjs";
+import { PostgresQueryParser } from "./drivers/postgres/postgres-query-parser.mjs";
+import { PostgresQueryBuilder } from "./drivers/postgres/postgres-query-builder.mjs";
+import { PostgresSyncAdapter } from "./drivers/postgres/postgres-sync-adapter.mjs";
+import { PostgresDriver } from "./drivers/postgres/postgres-driver.mjs";
+import "./drivers/postgres/index.mjs";
+import { connectToDatabase, getDatabaseDriver, transaction } from "./utils/connect-to-database.mjs";
+import { useModelTransformer } from "./utils/database-writer.utils.mjs";
+import { defineModel } from "./utils/define-model.mjs";
+import { onceConnected, onceDisconnected } from "./utils/once-connected.mjs";
+import { ColumnBuilder } from "./migration/column-builder.mjs";
+import { ForeignKeyBuilder } from "./migration/foreign-key-builder.mjs";
+import { DetachedColumnBuilder, arrayBigInt, arrayBoolean, arrayDate, arrayDecimal, arrayFloat, arrayInt, arrayJson, arrayText, arrayTimestamp, arrayUuid, bigInt, bigInteger, binary, blobCol, boolCol, char, date, dateTime, decimal, double, enumCol, float, geometry, int, integer, ipAddress, json, lineString, longText, macAddress, mediumText, objectCol, point, polygon, setCol, smallInt, smallInteger, string, text, time, timestamp, tinyInt, tinyInteger, ulid, uuid, vector, year } from "./migration/column-helpers.mjs";
+import { Migration, migrate } from "./migration/migration.mjs";
+import { MigrationRunner, migrationRunner } from "./migration/migration-runner.mjs";
+import "./migration/index.mjs";
+import { createDatabase, dropAllTables } from "./operations/database.mjs";
+import { exportMigrationsSQL, freshMigrate, listExecutedMigrations, rollbackMigrations, runMigrations } from "./operations/migrations.mjs";
+import "./operations/index.mjs";
+
+export { $agg, BelongsTo, BelongsToMany, ColumnBuilder, DEFAULT_MAX_SYNC_DEPTH, DataSource, DatabaseDirtyTracker, DatabaseRemover, DatabaseRestorer, DatabaseWriter, DatabaseWriterValidationError, DetachedColumnBuilder, ForeignKeyBuilder, HasMany, HasOne, Migration, MigrationRunner, MissingDataSourceError, Model, ModelEvents, ModelSyncOperation, MongoDbDriver, MongoIdGenerator, MongoMigrationDriver, MongoQueryBuilder, MongoSyncAdapter, PivotOperations, PostgresBlueprint, PostgresDialect, PostgresDriver, PostgresMigrationDriver, PostgresQueryBuilder, PostgresQueryParser, PostgresSyncAdapter, RELATION_METADATA_KEY, RegisterModel, RelationHydrator, RelationLoader, SyncContextManager, SyncManager, TransactionRollbackError, arrayBigInt, arrayBoolean, arrayDate, arrayDecimal, arrayFloat, arrayInt, arrayJson, arrayText, arrayTimestamp, arrayUuid, bigInt, bigInteger, binary, blobCol, boolCol as bool, boolCol, char, cleanupModelsRegistery, connectToDatabase, createDatabase, createPivotOperations, dataSourceRegistry, databaseDataSourceContext, databaseTransactionContext, date, dateTime, decimal, defineModel, double, dropAllTables, enumCol, exportMigrationsSQL, float, freshMigrate, geometry, getAllModelsFromRegistry, getDatabaseDriver, getModelFromRegistry, globalModelEvents, int, integer, ipAddress, isAggregateExpression, isMongoDBDriverLoaded, json, lineString, listExecutedMigrations, longText, macAddress, mediumText, migrate, migrationRunner, modelSync, objectCol, onceConnected, onceDisconnected, point, polygon, registerModelInRegistry, removeModelFromRegistery, resolveModelClass, resolveModelName, rollbackMigrations, runMigrations, setCol, smallInt, smallInteger, string, text, time, timestamp, tinyInt, tinyInteger, transaction, tryResolveModelClass, ulid, useModelTransformer, uuid, vector, verifyRegisteredRelations, year };