@warlock.js/cascade 4.4.0 → 4.6.0

package/esm/drivers/mongodb/mongodb-id-generator.d.mts

@@ -5,40 +5,38 @@ import { MongoDbDriver } from "./mongodb-driver.mjs";
 /**
  * MongoDB-specific ID generator for auto-incrementing integer IDs.
  *
- * Maintains a separate collection that tracks the last generated ID for each table.
- * Generates auto-incrementing IDs similar to SQL's AUTO_INCREMENT feature.
+ * Maintains a separate collection that tracks the last generated ID for each
+ * table, mimicking SQL's `AUTO_INCREMENT` / `SERIAL`.
  *
  * **Collection Structure:**
  * ```json
- * {
- *   "collection": "users",
- *   "id": 12345
- * }
+ * { "collection": "users", "id": 12345 }
  * ```
  *
- * **Features:**
- * - Atomic ID generation using findOneAndUpdate with aggregation pipeline
- * - Automatic transaction support (driver handles session context)
- * - Configurable initial ID and increment values
- * - Thread-safe and concurrent-safe
+ * **Atomicity & concurrency:**
+ * - Each id (or block of ids) is reserved with a SINGLE atomic
+ *   `findOneAndUpdate` on one document; MongoDB serializes concurrent writes to
+ *   the same document, so concurrent callers receive distinct, non-overlapping
+ *   ids/blocks.
+ * - A unique index on `{ collection: 1 }` is ensured lazily (once per instance)
+ *   so two concurrent first-time upserts for a brand-new table can't create
+ *   duplicate counter documents; the loser of that race gets an E11000 and is
+ *   retried (by then the document exists, so it takes the increment branch).
+ *
+ * **Transactions — IMPORTANT:** the counter write is its OWN standalone,
+ * immediately-durable operation. It does NOT join an ambient
+ * `transaction()` session (it calls `findOneAndUpdate` directly without a
+ * session). This is intentional and matches SQL `SERIAL` semantics: if the
+ * surrounding transaction rolls back, the inserted records are undone but the
+ * consumed id(s) are NOT — they remain a gap in the sequence. Do not rely on
+ * id reservation being rolled back with a transaction.
  *
  * @example
  * ```typescript
- * const mongoDriver = new MongoDbDriver(config);
  * const idGenerator = new MongoIdGenerator(mongoDriver);
  *
- * const dataSource = new DataSource({
- *   name: "primary",
- *   driver: mongoDriver,
- *   idGenerator,
- * });
- *
- * // Generate IDs with custom configuration
- * const id = await idGenerator.generateNextId({
- *   table: "users",
- *   initialId: 1000,
- *   incrementIdBy: 1
- * });
+ * const id = await idGenerator.generateNextId({ table: "users" });        // one id
+ * const ids = await idGenerator.generateNextIds({ table: "users", count: 100 }); // a block
  * ```
  */
 declare class MongoIdGenerator implements IdGeneratorContract {
@@ -50,66 +48,118 @@ declare class MongoIdGenerator implements IdGeneratorContract {
    * Named "MasterMind" for backward compatibility with legacy Cascade.
    */
   readonly counterCollection: string;
+  /**
+   * Memoized "ensure unique index" promise — the index is created at most once
+   * per generator instance, before the first reservation completes.
+   */
+  private indexEnsured?;
   /**
    * Create a new MongoDB ID generator instance.
    *
    * @param driver - The MongoDB driver instance
    * @param counterCollection - Name of the collection storing ID counters (default: "MasterMind")
-   *
-   * @example
-   * ```typescript
-   * const idGenerator = new MongoIdGenerator(mongoDriver, "id_counters");
-   * ```
    */
   constructor(driver: MongoDbDriver, counterCollection?: string);
   /**
    * Generate the next ID for a table.
    *
-   * Uses atomic findOneAndUpdate with aggregation pipeline to ensure uniqueness
-   * even in concurrent scenarios. Automatically participates in active transactions.
+   * Reserves a single id via one atomic `findOneAndUpdate` (see the class doc
+   * for the atomicity / transaction contract). Equivalent to a block of size 1.
    *
    * @param options - Configuration for ID generation
    * @returns The generated ID
    *
    * @example
    * ```typescript
-   * // Simple usage
-   * const id = await idGenerator.generateNextId({ table: "users" });
-   *
-   * // With custom initial ID
-   * const id = await idGenerator.generateNextId({
-   *   table: "products",
-   *   initialId: 1000,
-   *   incrementIdBy: 1
-   * });
+   * const id = await idGenerator.generateNextId({ table: "users", initialId: 1000 });
    * ```
    */
   generateNextId(options: GenerateIdOptions): Promise<number>;
   /**
-   * Get the last generated ID for a table.
+   * Reserve a contiguous block of `count` ids in a single atomic operation.
    *
-   * @param table - The table/collection name
-   * @returns The last generated ID, or 0 if none exists
+   * Advances the counter by `count * incrementIdBy` in one `findOneAndUpdate`
+   * (so the stored last id becomes the block's last id) and returns the block
+   * in ascending order. See the class doc for the non-transactional contract.
+   *
+   * @param options - `GenerateIdOptions` plus the block `count`
+   * @returns The reserved ids in ascending order (length `count`)
    *
    * @example
    * ```typescript
-   * const lastId = await idGenerator.getLastId("users");
-   * console.log(`Last user ID: ${lastId}`);
+   * const ids = await idGenerator.generateNextIds({ table: "users", count: 100 });
+   * // ids[0] is the first id, ids[99] the last; getLastId("users") === ids[99]
    * ```
    */
+  generateNextIds(options: GenerateIdOptions & {
+    count: number;
+  }): Promise<number[]>;
+  /**
+   * Atomically advance the counter for `table` by a whole block and return the
+   * block's LAST id.
+   *
+   * One `findOneAndUpdate` with an aggregation pipeline:
+   * - **Cold start** (counter field missing or null): seed `initialId + (count - 1) * incrementIdBy`
+   *   so the FIRST id of the block equals `initialId` (the `count - 1` here vs
+   *   `count` in the steady-state branch is deliberate — the counter stores the
+   *   last-issued id and the very first id must be exactly `initialId`).
+   * - **Steady state**: add `count * incrementIdBy` to the stored counter.
+   *
+   * Retries on a duplicate-key error from the cold-start upsert race (see
+   * {@link isDuplicateKeyError}).
+   *
+   * @param table - The table/collection the block is for
+   * @param initialId - The first id ever issued for this table
+   * @param incrementIdBy - The fixed stride between ids
+   * @param count - Block size (`>= 1`)
+   * @returns The last id of the reserved block
+   */
+  private reserveBlock;
+  /**
+   * Run `operation`, retrying on a duplicate-key (E11000) error up to
+   * {@link MAX_RESERVE_ATTEMPTS} times. Only the cold-start upsert race throws
+   * E11000 (once the unique index exists); on retry the counter document
+   * already exists, so the increment branch runs and succeeds. Any other error
+   * is rethrown immediately.
+   *
+   * @param operation - The reservation to run
+   * @returns The operation's result
+   */
+  private withDuplicateKeyRetry;
+  /**
+   * Ensure the unique index on `{ collection: 1 }` exists (once per instance).
+   *
+   * Best-effort: a pre-existing duplicate counter document (created before this
+   * index existed) makes index creation fail with E11000. We swallow that
+   * rather than block app boot — without the index the generator degrades to
+   * its prior (un-indexed) behavior, and the retry path becomes a no-op since
+   * E11000 can no longer be raised by the upsert.
+   */
+  private ensureIndexes;
+  /**
+   * Create the unique index on the counter collection's `collection` field.
+   * Failures are swallowed (see {@link ensureIndexes}).
+   */
+  private createCounterIndex;
+  /**
+   * Get the last generated ID for a table.
+   *
+   * @param table - The table/collection name
+   * @returns The last generated ID, or 0 if none exists
+   */
   getLastId(table: string): Promise<number>;
   /**
    * Set the last ID for a table.
    *
-   * Creates or updates the counter document for the specified table.
-   * Useful for seeding or resetting ID sequences.
+   * Creates or updates the counter document for the specified table. Useful for
+   * seeding or resetting ID sequences.
    *
    * @param table - The table/collection name
    * @param id - The ID to set as the last generated ID
    *
    * @example
    * ```typescript
-   * // Reset user IDs to start from 1000
+   * // Reset user IDs to start from 1000 (next generated id is 1001)
    * await idGenerator.setLastId("users", 1000);
    * ```
    */

package/esm/drivers/mongodb/mongodb-id-generator.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"mongodb-id-generator.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/cascade/src/drivers/mongodb/mongodb-id-generator.ts"],"mappings":";;;;;;;AA0CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsH4D;;;;;;cAtH/C,gBAAA,YAA4B,mBAAA;EAAA,iBAqBpB,MAAA;;;;;;;WAdH,iBAAA;;;;;;;;;;;;cAcG,MAAA,EAAQ,aAAA,EACzB,iBAAA;;;;;;;;;;;;;;;;;;;;;;;EA6BW,cAAA,CAAe,OAAA,EAAS,iBAAA,GAAoB,OAAA;;;;;;;;;;;;;EA8C5C,SAAA,CAAU,KAAA,WAAgB,OAAA;;;;;;;;;;;;;;;;EAqB1B,SAAA,CAAU,KAAA,UAAe,EAAA,WAAa,OAAA;AAAA"}
+{"version":3,"file":"mongodb-id-generator.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/cascade/src/drivers/mongodb/mongodb-id-generator.ts"],"mappings":";;;;;;;AA4DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,gBAAA,YAA4B,mBAAA;EAAA,iBAsBpB,MAAA;EA4MoB;;;;;;EAAA,SA3NvB,iBAAA;;;;;UAMR,YAAA;;;;;;;cASW,MAAA,EAAQ,aAAA,EACzB,iBAAA;;;;;;;;;;;;;;;EAqBW,cAAA,CAAe,OAAA,EAAS,iBAAA,GAAoB,OAAA;;;;;;;;;;;;;;;;;EAwB5C,eAAA,CACX,OAAA,EAAS,iBAAA;IAAsB,KAAA;EAAA,IAC9B,OAAA;;;;;;;;;;;;;;;;;;;;;UAmCW,YAAA;;;;;;;;;;;UA8DA,qBAAA;;;;;;;;;;UA6BA,aAAA;;;;;UAYA,kBAAA;;;;;;;EAkBD,SAAA,CAAU,KAAA,WAAgB,OAAA;;;;;;;;;;;;;;;;EAqB1B,SAAA,CAAU,KAAA,UAAe,EAAA,WAAa,OAAA;AAAA"}

package/esm/drivers/mongodb/mongodb-id-generator.mjs

@@ -1,41 +1,52 @@
 //#region ../@warlock.js/cascade/src/drivers/mongodb/mongodb-id-generator.ts
+/** Number of times a reservation retries after a duplicate-key (E11000) error. */
+const MAX_RESERVE_ATTEMPTS = 3;
+/** MongoDB duplicate-key error code. */
+const DUPLICATE_KEY_ERROR_CODE = 11e3;
+/**
+* Is `error` a MongoDB duplicate-key (E11000) error?
+*
+* Raised when two concurrent first-time upserts race to create the same
+* counter document once the unique index on `{ collection: 1 }` exists.
+*/
+function isDuplicateKeyError(error) {
+	return typeof error === "object" && error !== null && error.code === DUPLICATE_KEY_ERROR_CODE;
+}
 /**
 * MongoDB-specific ID generator for auto-incrementing integer IDs.
 *
-* Maintains a separate collection that tracks the last generated ID for each table.
-* Generates auto-incrementing IDs similar to SQL's AUTO_INCREMENT feature.
+* Maintains a separate collection that tracks the last generated ID for each
+* table, mimicking SQL's `AUTO_INCREMENT` / `SERIAL`.
 *
 * **Collection Structure:**
 * ```json
-* {
-*   "collection": "users",
-*   "id": 12345
-* }
+* { "collection": "users", "id": 12345 }
 * ```
 *
-* **Features:**
-* - Atomic ID generation using findOneAndUpdate with aggregation pipeline
-* - Automatic transaction support (driver handles session context)
-* - Configurable initial ID and increment values
-* - Thread-safe and concurrent-safe
+* **Atomicity & concurrency:**
+* - Each id (or block of ids) is reserved with a SINGLE atomic
+*   `findOneAndUpdate` on one document; MongoDB serializes concurrent writes to
+*   the same document, so concurrent callers receive distinct, non-overlapping
+*   ids/blocks.
+* - A unique index on `{ collection: 1 }` is ensured lazily (once per instance)
+*   so two concurrent first-time upserts for a brand-new table can't create
+*   duplicate counter documents; the loser of that race gets an E11000 and is
+*   retried (by then the document exists, so it takes the increment branch).
+*
+* **Transactions — IMPORTANT:** the counter write is its OWN standalone,
+* immediately-durable operation. It does NOT join an ambient
+* `transaction()` session (it calls `findOneAndUpdate` directly without a
+* session). This is intentional and matches SQL `SERIAL` semantics: if the
+* surrounding transaction rolls back, the inserted records are undone but the
+* consumed id(s) are NOT — they remain a gap in the sequence. Do not rely on
+* id reservation being rolled back with a transaction.
 *
 * @example
 * ```typescript
-* const mongoDriver = new MongoDbDriver(config);
 * const idGenerator = new MongoIdGenerator(mongoDriver);
 *
-* const dataSource = new DataSource({
-*   name: "primary",
-*   driver: mongoDriver,
-*   idGenerator,
-* });
-*
-* // Generate IDs with custom configuration
-* const id = await idGenerator.generateNextId({
-*   table: "users",
-*   initialId: 1000,
-*   incrementIdBy: 1
-* });
+* const id = await idGenerator.generateNextId({ table: "users" });        // one id
+* const ids = await idGenerator.generateNextIds({ table: "users", count: 100 }); // a block
 * ```
 */
 var MongoIdGenerator = class {
@@ -48,15 +59,15 @@ var MongoIdGenerator = class {
 	*/
 	counterCollection = "MasterMind";
 	/**
+	* Memoized "ensure unique index" promise — the index is created at most once
+	* per generator instance, before the first reservation completes.
+	*/
+	indexEnsured;
+	/**
 	* Create a new MongoDB ID generator instance.
 	*
 	* @param driver - The MongoDB driver instance
 	* @param counterCollection - Name of the collection storing ID counters (default: "MasterMind")
-	*
-	* @example
-	* ```typescript
-	* const idGenerator = new MongoIdGenerator(mongoDriver, "id_counters");
-	* ```
 	*/
 	constructor(driver, counterCollection) {
 		this.driver = driver;
@@ -65,66 +76,149 @@ var MongoIdGenerator = class {
 	/**
 	* Generate the next ID for a table.
 	*
-	* Uses atomic findOneAndUpdate with aggregation pipeline to ensure uniqueness
-	* even in concurrent scenarios. Automatically participates in active transactions.
+	* Reserves a single id via one atomic `findOneAndUpdate` (see the class doc
+	* for the atomicity / transaction contract). Equivalent to a block of size 1.
 	*
 	* @param options - Configuration for ID generation
 	* @returns The generated ID
 	*
 	* @example
 	* ```typescript
-	* // Simple usage
-	* const id = await idGenerator.generateNextId({ table: "users" });
-	*
-	* // With custom initial ID
-	* const id = await idGenerator.generateNextId({
-	*   table: "products",
-	*   initialId: 1000,
-	*   incrementIdBy: 1
-	* });
+	* const id = await idGenerator.generateNextId({ table: "users", initialId: 1000 });
 	* ```
 	*/
 	async generateNextId(options) {
 		const { table, initialId = 1, incrementIdBy = 1 } = options;
-		return (await this.driver.getDatabase().collection(this.counterCollection).findOneAndUpdate({ collection: table }, [{ $set: {
-			id: { $cond: {
-				if: { $or: [{ $eq: ["$id", null] }, { $not: "$id" }] },
-				then: initialId,
-				else: { $add: ["$id", incrementIdBy] }
-			} },
-			collection: table
-		} }], {
-			upsert: true,
-			returnDocument: "after"
-		}))?.id ?? initialId;
+		await this.ensureIndexes();
+		return await this.reserveBlock(table, initialId, incrementIdBy, 1);
 	}
 	/**
-	* Get the last generated ID for a table.
+	* Reserve a contiguous block of `count` ids in a single atomic operation.
 	*
-	* @param table - The table/collection name
-	* @returns The last generated ID, or 0 if none exists
+	* Advances the counter by `count * incrementIdBy` in one `findOneAndUpdate`
+	* (so the stored last id becomes the block's last id) and returns the block
+	* in ascending order. See the class doc for the non-transactional contract.
+	*
+	* @param options - `GenerateIdOptions` plus the block `count`
+	* @returns The reserved ids in ascending order (length `count`)
 	*
 	* @example
 	* ```typescript
-	* const lastId = await idGenerator.getLastId("users");
-	* console.log(`Last user ID: ${lastId}`);
+	* const ids = await idGenerator.generateNextIds({ table: "users", count: 100 });
+	* // ids[0] is the first id, ids[99] the last; getLastId("users") === ids[99]
 	* ```
 	*/
+	async generateNextIds(options) {
+		const { table, initialId = 1, incrementIdBy = 1, count } = options;
+		if (count <= 0) return [];
+		await this.ensureIndexes();
+		const firstId = await this.reserveBlock(table, initialId, incrementIdBy, count) - (count - 1) * incrementIdBy;
+		return Array.from({ length: count }, (_, index) => firstId + index * incrementIdBy);
+	}
+	/**
+	* Atomically advance the counter for `table` by a whole block and return the
+	* block's LAST id.
+	*
+	* One `findOneAndUpdate` with an aggregation pipeline:
+	* - **Cold start** (counter field missing or null): seed `initialId + (count - 1) * incrementIdBy`
+	*   so the FIRST id of the block equals `initialId` (the `count - 1` here vs
+	*   `count` in the steady-state branch is deliberate — the counter stores the
+	*   last-issued id and the very first id must be exactly `initialId`).
+	* - **Steady state**: add `count * incrementIdBy` to the stored counter.
+	*
+	* Retries on a duplicate-key error from the cold-start upsert race (see
+	* {@link isDuplicateKeyError}).
+	*
+	* @param table - The table/collection the block is for
+	* @param initialId - The first id ever issued for this table
+	* @param incrementIdBy - The fixed stride between ids
+	* @param count - Block size (`>= 1`)
+	* @returns The last id of the reserved block
+	*/
+	async reserveBlock(table, initialId, incrementIdBy, count) {
+		const run = async () => {
+			const lastId = (await this.driver.getDatabase().collection(this.counterCollection).findOneAndUpdate({ collection: table }, [{ $set: {
+				id: { $cond: {
+					if: { $or: [{ $eq: [{ $type: "$id" }, "missing"] }, { $eq: ["$id", null] }] },
+					then: initialId + (count - 1) * incrementIdBy,
+					else: { $add: ["$id", count * incrementIdBy] }
+				} },
+				collection: table
+			} }], {
+				upsert: true,
+				returnDocument: "after"
+			}))?.id;
+			if (typeof lastId !== "number") throw new Error(`Failed to reserve an id block for "${table}": counter returned no id.`);
+			return lastId;
+		};
+		return await this.withDuplicateKeyRetry(run);
+	}
+	/**
+	* Run `operation`, retrying on a duplicate-key (E11000) error up to
+	* {@link MAX_RESERVE_ATTEMPTS} times. Only the cold-start upsert race throws
+	* E11000 (once the unique index exists); on retry the counter document
+	* already exists, so the increment branch runs and succeeds. Any other error
+	* is rethrown immediately.
+	*
+	* @param operation - The reservation to run
+	* @returns The operation's result
+	*/
+	async withDuplicateKeyRetry(operation) {
+		let lastError;
+		for (let attempt = 1; attempt <= MAX_RESERVE_ATTEMPTS; attempt++) try {
+			return await operation();
+		} catch (error) {
+			if (!isDuplicateKeyError(error)) throw error;
+			lastError = error;
+		}
+		throw lastError;
+	}
+	/**
+	* Ensure the unique index on `{ collection: 1 }` exists (once per instance).
+	*
+	* Best-effort: a pre-existing duplicate counter document (created before this
+	* index existed) makes index creation fail with E11000. We swallow that
+	* rather than block app boot — without the index the generator degrades to
+	* its prior (un-indexed) behavior, and the retry path becomes a no-op since
+	* E11000 can no longer be raised by the upsert.
+	*/
+	async ensureIndexes() {
+		if (!this.indexEnsured) this.indexEnsured = this.createCounterIndex();
+		return await this.indexEnsured;
+	}
+	/**
+	* Create the unique index on the counter collection's `collection` field.
+	* Failures are swallowed (see {@link ensureIndexes}).
+	*/
+	async createCounterIndex() {
+		try {
+			await this.driver.getDatabase().collection(this.counterCollection).createIndex({ collection: 1 }, {
+				unique: true,
+				name: "collection_unique"
+			});
+		} catch {}
+	}
+	/**
+	* Get the last generated ID for a table.
+	*
+	* @param table - The table/collection name
+	* @returns The last generated ID, or 0 if none exists
+	*/
 	async getLastId(table) {
 		return (await this.driver.queryBuilder(this.counterCollection).where("collection", table).first())?.id ?? 0;
 	}
 	/**
 	* Set the last ID for a table.
 	*
-	* Creates or updates the counter document for the specified table.
-	* Useful for seeding or resetting ID sequences.
+	* Creates or updates the counter document for the specified table. Useful for
+	* seeding or resetting ID sequences.
 	*
 	* @param table - The table/collection name
 	* @param id - The ID to set as the last generated ID
 	*
 	* @example
 	* ```typescript
-	* // Reset user IDs to start from 1000
+	* // Reset user IDs to start from 1000 (next generated id is 1001)
 	* await idGenerator.setLastId("users", 1000);
 	* ```
 	*/

package/esm/drivers/mongodb/mongodb-id-generator.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"mongodb-id-generator.mjs","names":[],"sources":["../../../../../../../../@warlock.js/cascade/src/drivers/mongodb/mongodb-id-generator.ts"],"sourcesContent":["import type { GenerateIdOptions, IdGeneratorContract } from \"../../contracts\";\nimport type { MongoDbDriver } from \"./mongodb-driver\";\n\n/**\n * MongoDB-specific ID generator for auto-incrementing integer IDs.\n *\n * Maintains a separate collection that tracks the last generated ID for each table.\n * Generates auto-incrementing IDs similar to SQL's AUTO_INCREMENT feature.\n *\n * **Collection Structure:**\n * ```json\n * {\n *   \"collection\": \"users\",\n *   \"id\": 12345\n * }\n * ```\n *\n * **Features:**\n * - Atomic ID generation using findOneAndUpdate with aggregation pipeline\n * - Automatic transaction support (driver handles session context)\n * - Configurable initial ID and increment values\n * - Thread-safe and concurrent-safe\n *\n * @example\n * ```typescript\n * const mongoDriver = new MongoDbDriver(config);\n * const idGenerator = new MongoIdGenerator(mongoDriver);\n *\n * const dataSource = new DataSource({\n *   name: \"primary\",\n *   driver: mongoDriver,\n *   idGenerator,\n * });\n *\n * // Generate IDs with custom configuration\n * const id = await idGenerator.generateNextId({\n *   table: \"users\",\n *   initialId: 1000,\n *   incrementIdBy: 1\n * });\n * ```\n */\nexport class MongoIdGenerator implements IdGeneratorContract {\n  /**\n   * The collection name that stores ID counters.\n   * Each document tracks the last ID for a specific table.\n   *\n   * Named \"MasterMind\" for backward compatibility with legacy Cascade.\n   */\n  public readonly counterCollection: string = \"MasterMind\";\n\n  /**\n   * Create a new MongoDB ID generator instance.\n   *\n   * @param driver - The MongoDB driver instance\n   * @param counterCollection - Name of the collection storing ID counters (default: \"MasterMind\")\n   *\n   * @example\n   * ```typescript\n   * const idGenerator = new MongoIdGenerator(mongoDriver, \"id_counters\");\n   * ```\n   */\n  public constructor(\n    private readonly driver: MongoDbDriver,\n    counterCollection?: string,\n  ) {\n    if (counterCollection) {\n      this.counterCollection = counterCollection;\n    }\n  }\n\n  /**\n   * Generate the next ID for a table.\n   *\n   * Uses atomic findOneAndUpdate with aggregation pipeline to ensure uniqueness\n   * even in concurrent scenarios. Automatically participates in active transactions.\n   *\n   * @param options - Configuration for ID generation\n   * @returns The generated ID\n   *\n   * @example\n   * ```typescript\n   * // Simple usage\n   * const id = await idGenerator.generateNextId({ table: \"users\" });\n   *\n   * // With custom initial ID\n   * const id = await idGenerator.generateNextId({\n   *   table: \"products\",\n   *   initialId: 1000,\n   *   incrementIdBy: 1\n   * });\n   * ```\n   */\n  public async generateNextId(options: GenerateIdOptions): Promise<number> {\n    const { table, initialId = 1, incrementIdBy = 1 } = options;\n\n    // Get the MongoDB database instance\n    const database = this.driver.getDatabase();\n    const collection = database.collection(this.counterCollection);\n\n    // Use atomic findOneAndUpdate with aggregation pipeline\n    // The driver's withSession method will automatically attach the session if in a transaction\n    const result = await collection.findOneAndUpdate(\n      { collection: table },\n      [\n        {\n          $set: {\n            id: {\n              $cond: {\n                if: { $or: [{ $eq: [\"$id\", null] }, { $not: \"$id\" }] },\n                then: initialId,\n                else: { $add: [\"$id\", incrementIdBy] },\n              },\n            },\n            collection: table,\n          },\n        },\n      ],\n      {\n        upsert: true,\n        returnDocument: \"after\",\n      },\n    );\n\n    return result?.id ?? initialId;\n  }\n\n  /**\n   * Get the last generated ID for a table.\n   *\n   * @param table - The table/collection name\n   * @returns The last generated ID, or 0 if none exists\n   *\n   * @example\n   * ```typescript\n   * const lastId = await idGenerator.getLastId(\"users\");\n   * console.log(`Last user ID: ${lastId}`);\n   * ```\n   */\n  public async getLastId(table: string): Promise<number> {\n    const query = this.driver.queryBuilder(this.counterCollection);\n    const doc = (await query.where(\"collection\", table).first()) as Record<string, unknown> | null;\n    return (doc?.id as number) ?? 0;\n  }\n\n  /**\n   * Set the last ID for a table.\n   *\n   * Creates or updates the counter document for the specified table.\n   * Useful for seeding or resetting ID sequences.\n   *\n   * @param table - The table/collection name\n   * @param id - The ID to set as the last generated ID\n   *\n   * @example\n   * ```typescript\n   * // Reset user IDs to start from 1000\n   * await idGenerator.setLastId(\"users\", 1000);\n   * ```\n   */\n  public async setLastId(table: string, id: number): Promise<void> {\n    await this.driver.update(\n      this.counterCollection,\n      { collection: table },\n      { $set: { id, collection: table } },\n      { upsert: true },\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,IAAa,mBAAb,MAA6D;CAqBxC;;;;;;;CAdnB,AAAgB,oBAA4B;;;;;;;;;;;;CAa5C,AAAO,YACL,AAAiB,QACjB,mBACA;EAFiB;EAGjB,IAAI,mBACF,KAAK,oBAAoB;CAE7B;;;;;;;;;;;;;;;;;;;;;;;CAwBA,MAAa,eAAe,SAA6C;EACvE,MAAM,EAAE,OAAO,YAAY,GAAG,gBAAgB,MAAM;EA8BpD,QAAO,MA3BU,KAAK,OAAO,YACH,CAAC,CAAC,WAAW,KAAK,iBAId,CAAC,CAAC,iBAC9B,EAAE,YAAY,MAAM,GACpB,CACE,EACE,MAAM;GACJ,IAAI,EACF,OAAO;IACL,IAAI,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,OAAO,IAAI,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC,EAAE;IACrD,MAAM;IACN,MAAM,EAAE,MAAM,CAAC,OAAO,aAAa,EAAE;GACvC,EACF;GACA,YAAY;EACd,EACF,CACF,GACA;GACE,QAAQ;GACR,gBAAgB;EAClB,CACF,EAEa,EAAE,MAAM;CACvB;;;;;;;;;;;;;CAcA,MAAa,UAAU,OAAgC;EAGrD,QAAQ,MAFM,KAAK,OAAO,aAAa,KAAK,iBACrB,CAAC,CAAC,MAAM,cAAc,KAAK,CAAC,CAAC,MAAM,EAC/C,EAAE,MAAiB;CAChC;;;;;;;;;;;;;;;;CAiBA,MAAa,UAAU,OAAe,IAA2B;EAC/D,MAAM,KAAK,OAAO,OAChB,KAAK,mBACL,EAAE,YAAY,MAAM,GACpB,EAAE,MAAM;GAAE;GAAI,YAAY;EAAM,EAAE,GAClC,EAAE,QAAQ,KAAK,CACjB;CACF;AACF"}
+{"version":3,"file":"mongodb-id-generator.mjs","names":[],"sources":["../../../../../../../../@warlock.js/cascade/src/drivers/mongodb/mongodb-id-generator.ts"],"sourcesContent":["import type { GenerateIdOptions, IdGeneratorContract } from \"../../contracts\";\nimport type { MongoDbDriver } from \"./mongodb-driver\";\n\n/** Number of times a reservation retries after a duplicate-key (E11000) error. */\nconst MAX_RESERVE_ATTEMPTS = 3;\n\n/** MongoDB duplicate-key error code. */\nconst DUPLICATE_KEY_ERROR_CODE = 11000;\n\n/**\n * Is `error` a MongoDB duplicate-key (E11000) error?\n *\n * Raised when two concurrent first-time upserts race to create the same\n * counter document once the unique index on `{ collection: 1 }` exists.\n */\nfunction isDuplicateKeyError(error: unknown): boolean {\n  return (\n    typeof error === \"object\" &&\n    error !== null &&\n    (error as { code?: number }).code === DUPLICATE_KEY_ERROR_CODE\n  );\n}\n\n/**\n * MongoDB-specific ID generator for auto-incrementing integer IDs.\n *\n * Maintains a separate collection that tracks the last generated ID for each\n * table, mimicking SQL's `AUTO_INCREMENT` / `SERIAL`.\n *\n * **Collection Structure:**\n * ```json\n * { \"collection\": \"users\", \"id\": 12345 }\n * ```\n *\n * **Atomicity & concurrency:**\n * - Each id (or block of ids) is reserved with a SINGLE atomic\n *   `findOneAndUpdate` on one document; MongoDB serializes concurrent writes to\n *   the same document, so concurrent callers receive distinct, non-overlapping\n *   ids/blocks.\n * - A unique index on `{ collection: 1 }` is ensured lazily (once per instance)\n *   so two concurrent first-time upserts for a brand-new table can't create\n *   duplicate counter documents; the loser of that race gets an E11000 and is\n *   retried (by then the document exists, so it takes the increment branch).\n *\n * **Transactions — IMPORTANT:** the counter write is its OWN standalone,\n * immediately-durable operation. It does NOT join an ambient\n * `transaction()` session (it calls `findOneAndUpdate` directly without a\n * session). This is intentional and matches SQL `SERIAL` semantics: if the\n * surrounding transaction rolls back, the inserted records are undone but the\n * consumed id(s) are NOT — they remain a gap in the sequence. Do not rely on\n * id reservation being rolled back with a transaction.\n *\n * @example\n * ```typescript\n * const idGenerator = new MongoIdGenerator(mongoDriver);\n *\n * const id = await idGenerator.generateNextId({ table: \"users\" });        // one id\n * const ids = await idGenerator.generateNextIds({ table: \"users\", count: 100 }); // a block\n * ```\n */\nexport class MongoIdGenerator implements IdGeneratorContract {\n  /**\n   * The collection name that stores ID counters.\n   * Each document tracks the last ID for a specific table.\n   *\n   * Named \"MasterMind\" for backward compatibility with legacy Cascade.\n   */\n  public readonly counterCollection: string = \"MasterMind\";\n\n  /**\n   * Memoized \"ensure unique index\" promise — the index is created at most once\n   * per generator instance, before the first reservation completes.\n   */\n  private indexEnsured?: Promise<void>;\n\n  /**\n   * Create a new MongoDB ID generator instance.\n   *\n   * @param driver - The MongoDB driver instance\n   * @param counterCollection - Name of the collection storing ID counters (default: \"MasterMind\")\n   */\n  public constructor(\n    private readonly driver: MongoDbDriver,\n    counterCollection?: string,\n  ) {\n    if (counterCollection) {\n      this.counterCollection = counterCollection;\n    }\n  }\n\n  /**\n   * Generate the next ID for a table.\n   *\n   * Reserves a single id via one atomic `findOneAndUpdate` (see the class doc\n   * for the atomicity / transaction contract). Equivalent to a block of size 1.\n   *\n   * @param options - Configuration for ID generation\n   * @returns The generated ID\n   *\n   * @example\n   * ```typescript\n   * const id = await idGenerator.generateNextId({ table: \"users\", initialId: 1000 });\n   * ```\n   */\n  public async generateNextId(options: GenerateIdOptions): Promise<number> {\n    const { table, initialId = 1, incrementIdBy = 1 } = options;\n\n    await this.ensureIndexes();\n\n    return await this.reserveBlock(table, initialId, incrementIdBy, 1);\n  }\n\n  /**\n   * Reserve a contiguous block of `count` ids in a single atomic operation.\n   *\n   * Advances the counter by `count * incrementIdBy` in one `findOneAndUpdate`\n   * (so the stored last id becomes the block's last id) and returns the block\n   * in ascending order. See the class doc for the non-transactional contract.\n   *\n   * @param options - `GenerateIdOptions` plus the block `count`\n   * @returns The reserved ids in ascending order (length `count`)\n   *\n   * @example\n   * ```typescript\n   * const ids = await idGenerator.generateNextIds({ table: \"users\", count: 100 });\n   * // ids[0] is the first id, ids[99] the last; getLastId(\"users\") === ids[99]\n   * ```\n   */\n  public async generateNextIds(\n    options: GenerateIdOptions & { count: number },\n  ): Promise<number[]> {\n    const { table, initialId = 1, incrementIdBy = 1, count } = options;\n\n    if (count <= 0) {\n      return [];\n    }\n\n    await this.ensureIndexes();\n\n    const lastId = await this.reserveBlock(table, initialId, incrementIdBy, count);\n    const firstId = lastId - (count - 1) * incrementIdBy;\n\n    return Array.from({ length: count }, (_, index) => firstId + index * incrementIdBy);\n  }\n\n  /**\n   * Atomically advance the counter for `table` by a whole block and return the\n   * block's LAST id.\n   *\n   * One `findOneAndUpdate` with an aggregation pipeline:\n   * - **Cold start** (counter field missing or null): seed `initialId + (count - 1) * incrementIdBy`\n   *   so the FIRST id of the block equals `initialId` (the `count - 1` here vs\n   *   `count` in the steady-state branch is deliberate — the counter stores the\n   *   last-issued id and the very first id must be exactly `initialId`).\n   * - **Steady state**: add `count * incrementIdBy` to the stored counter.\n   *\n   * Retries on a duplicate-key error from the cold-start upsert race (see\n   * {@link isDuplicateKeyError}).\n   *\n   * @param table - The table/collection the block is for\n   * @param initialId - The first id ever issued for this table\n   * @param incrementIdBy - The fixed stride between ids\n   * @param count - Block size (`>= 1`)\n   * @returns The last id of the reserved block\n   */\n  private async reserveBlock(\n    table: string,\n    initialId: number,\n    incrementIdBy: number,\n    count: number,\n  ): Promise<number> {\n    const run = async (): Promise<number> => {\n      const database = this.driver.getDatabase();\n      const collection = database.collection(this.counterCollection);\n\n      const result = await collection.findOneAndUpdate(\n        { collection: table },\n        [\n          {\n            $set: {\n              id: {\n                $cond: {\n                  // Cold start = the counter field is absent or null. Tested by\n                  // existence ($type), NOT truthiness — a legitimately stored\n                  // last-id of 0 (initialId: 0) must take the increment branch,\n                  // not be mistaken for an unset counter and re-issued.\n                  if: {\n                    $or: [{ $eq: [{ $type: \"$id\" }, \"missing\"] }, { $eq: [\"$id\", null] }],\n                  },\n                  then: initialId + (count - 1) * incrementIdBy,\n                  else: { $add: [\"$id\", count * incrementIdBy] },\n                },\n              },\n              collection: table,\n            },\n          },\n        ],\n        {\n          upsert: true,\n          returnDocument: \"after\",\n        },\n      );\n\n      const lastId = result?.id;\n\n      if (typeof lastId !== \"number\") {\n        throw new Error(\n          `Failed to reserve an id block for \"${table}\": counter returned no id.`,\n        );\n      }\n\n      return lastId;\n    };\n\n    return await this.withDuplicateKeyRetry(run);\n  }\n\n  /**\n   * Run `operation`, retrying on a duplicate-key (E11000) error up to\n   * {@link MAX_RESERVE_ATTEMPTS} times. Only the cold-start upsert race throws\n   * E11000 (once the unique index exists); on retry the counter document\n   * already exists, so the increment branch runs and succeeds. Any other error\n   * is rethrown immediately.\n   *\n   * @param operation - The reservation to run\n   * @returns The operation's result\n   */\n  private async withDuplicateKeyRetry<TResult>(\n    operation: () => Promise<TResult>,\n  ): Promise<TResult> {\n    let lastError: unknown;\n\n    for (let attempt = 1; attempt <= MAX_RESERVE_ATTEMPTS; attempt++) {\n      try {\n        return await operation();\n      } catch (error) {\n        if (!isDuplicateKeyError(error)) {\n          throw error;\n        }\n\n        lastError = error;\n      }\n    }\n\n    throw lastError;\n  }\n\n  /**\n   * Ensure the unique index on `{ collection: 1 }` exists (once per instance).\n   *\n   * Best-effort: a pre-existing duplicate counter document (created before this\n   * index existed) makes index creation fail with E11000. We swallow that\n   * rather than block app boot — without the index the generator degrades to\n   * its prior (un-indexed) behavior, and the retry path becomes a no-op since\n   * E11000 can no longer be raised by the upsert.\n   */\n  private async ensureIndexes(): Promise<void> {\n    if (!this.indexEnsured) {\n      this.indexEnsured = this.createCounterIndex();\n    }\n\n    return await this.indexEnsured;\n  }\n\n  /**\n   * Create the unique index on the counter collection's `collection` field.\n   * Failures are swallowed (see {@link ensureIndexes}).\n   */\n  private async createCounterIndex(): Promise<void> {\n    try {\n      const database = this.driver.getDatabase();\n      await database.collection(this.counterCollection).createIndex(\n        { collection: 1 },\n        { unique: true, name: \"collection_unique\" },\n      );\n    } catch {\n      // Best-effort — see ensureIndexes(). Degrade gracefully without the index.\n    }\n  }\n\n  /**\n   * Get the last generated ID for a table.\n   *\n   * @param table - The table/collection name\n   * @returns The last generated ID, or 0 if none exists\n   */\n  public async getLastId(table: string): Promise<number> {\n    const query = this.driver.queryBuilder(this.counterCollection);\n    const doc = (await query.where(\"collection\", table).first()) as Record<string, unknown> | null;\n    return (doc?.id as number) ?? 0;\n  }\n\n  /**\n   * Set the last ID for a table.\n   *\n   * Creates or updates the counter document for the specified table. Useful for\n   * seeding or resetting ID sequences.\n   *\n   * @param table - The table/collection name\n   * @param id - The ID to set as the last generated ID\n   *\n   * @example\n   * ```typescript\n   * // Reset user IDs to start from 1000 (next generated id is 1001)\n   * await idGenerator.setLastId(\"users\", 1000);\n   * ```\n   */\n  public async setLastId(table: string, id: number): Promise<void> {\n    await this.driver.update(\n      this.counterCollection,\n      { collection: table },\n      { $set: { id, collection: table } },\n      { upsert: true },\n    );\n  }\n}\n"],"mappings":"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"}

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

@@ -675,6 +675,31 @@ declare class MongoQueryBuilder<T = unknown> extends QueryBuilder<T> implements
    */
   groupBy(fields: GroupByInput): this;
   groupBy(fields: GroupByInput, aggregates: Record<string, RawExpression>): this;
+  /**
+   * Portable date-bucketed grouping.
+   *
+   * Groups documents by `column` truncated to the given bucket
+   * (`day` / `week` / `month` / `year`) via MongoDB's `$dateTrunc`, and runs
+   * the optional aggregates over each bucket. The bucket is exposed under the
+   * column's own name in the output (the `_id` is renamed in a follow-up
+   * `$project`, the same convention as `groupBy`).
+   *
+   * @param column - The date field to bucket
+   * @param unit - The bucket granularity
+   * @param aggregates - Optional aggregate operations keyed by output alias
+   *
+   * @example
+   * ```typescript
+   * import { $agg, $expr } from "@warlock.js/cascade";
+   *
+   * query.groupByDate("created_at", "month", {
+   *   revenue: $agg.sum($expr.mul("price", "quantity")),
+   * });
+   * // $group: { _id: { $dateTrunc: { date: "$created_at", unit: "month" } },
+   * //           revenue: { $sum: { $multiply: ["$price", "$quantity"] } } }
+   * ```
+   */
+  groupByDate(column: string, unit: "day" | "week" | "month" | "year", aggregates?: Record<string, RawExpression>): this;
   /**
    * Groups documents using a raw MongoDB expression.
    * @param expression - The raw grouping expression

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

@@ -1 +1 @@
-{"version":3,"file":"mongodb-query-builder.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/cascade/src/drivers/mongodb/mongodb-query-builder.ts"],"mappings":"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"}
+{"version":3,"file":"mongodb-query-builder.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/cascade/src/drivers/mongodb/mongodb-query-builder.ts"],"mappings":"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"}