assai 1.1.1 → 2.1.0

package/src/factories/create_mongo_collection.mjs

@@ -1,8 +1,9 @@
 import { Collection } from 'mongodb'
 import {
+    aggregate, bulkWrite,
     count, deleteMany, deleteOne,
     deleteOneOrThrow,
-    find, findOne,
+    find, findOne, findOneAndDelete, findOneAndReplace, findOneAndUpdate,
     getClient,
     insertMany, insertOne, updateMany, updateOne
 } from '../usecases/mongo/index.mjs'
@@ -13,8 +14,7 @@ import {
  * This method will read the string DATABASE_URL to create a connection. If you have it in another
  * location, you will need to pass it at `connectionString` property inside the options parameter.
  *
- * The connection is cached by default. Use `collectionGetter` and `cachedCollectionGetter` to
- * customize this behavior.
+ * The connection is cached by default. Use `collectionGetter` to customize this behavior.
  * @template {import('../types.js').MongoDocument} T
  * @param {string} name
  * @param {IcreateCollectionOptions<T>} [options]
@@ -23,12 +23,12 @@ export function createMongoCollection(name, options = {}) {
 
     /** @type {Collection<T> | null} */
     let _collection = null
-    const { validator } = options
+    const collectionOptions = options
 
     async function getCollection() {
         const {
             connectionString, dbName, options: createOptions,
-            cachableCollectionGetter, collectionGetter,
+            collectionGetter,
         } = options
 
         // Connection getter from options
@@ -37,12 +37,6 @@ export function createMongoCollection(name, options = {}) {
         // Checking cache
         if (_collection) return _collection
 
-        // Cache function from options
-        if (cachableCollectionGetter != null) {
-            _collection = await cachableCollectionGetter()
-            return _collection
-        }
-
         // Default connection getter
         const client = await getClient({ connectionString })
         let db = client.db(dbName, createOptions)
@@ -51,31 +45,6 @@ export function createMongoCollection(name, options = {}) {
         return _collection
     }
 
-    /**
-     *
-     * @param {import('../types.js').Optional<T, 'id'>} doc
-     */
-    function validate(doc) {
-        if (validator == null) {
-            return
-        }
-        if (typeof validator == 'function') {
-            return validator(doc)
-        } else {
-            for (const [field, fieldValidator] of Object.entries(validator)) {
-                if (!fieldValidator) {
-                    continue
-                }
-                const value = fieldValidator(doc[field])
-                if (value) {
-                    // @ts-ignore
-                    doc[field] = value
-                }
-            }
-            return doc
-        }
-    }
-
     return {
         /**
          * Returns the native driver.
@@ -91,7 +60,9 @@ export function createMongoCollection(name, options = {}) {
          * @param {import('../types.js').FindOptions<T, K>} options
          * @returns {Promise<T[]>}
          */
-        find: async (query, options = {}) => await find({ query, options, getCollection }),
+        find: async (query, options = {}) => {
+            return await find({ query, options, getCollection, collectionOptions })
+        },
         /**
          * @template {import('../types.js').Projection<T> | undefined} K
          * @param {import('mongodb').Filter<T>} query
@@ -99,20 +70,17 @@ export function createMongoCollection(name, options = {}) {
          * @returns {Promise<T | null>}
          */
         findOne: async (query, options = {}) => {
-            return await findOne({ query, options, getCollection })
+            return await findOne({ query, options, collectionOptions, getCollection })
         },
         /**
          * @param {import('../types.js').Optional<T, 'id'>} doc
          * @returns {Promise<T>}
          */
         insertOne: async (doc) => {
-            const result = validate(doc)
-            if (result) {
-                doc = result
-            }
             return await insertOne({
                 doc,
                 getCollection,
+                collectionOptions,
             })
         },
         /**
@@ -120,7 +88,7 @@ export function createMongoCollection(name, options = {}) {
          * @param {import('../types.js').Optional<T, 'id'>[]} docs
          * @returns {Promise<T[]>}
          */
-        insertMany: async (docs) => await insertMany({ docs, getCollection }),
+        insertMany: async (docs) => await insertMany({ docs, collectionOptions, getCollection }),
         /**
          * @param {import('mongodb').Filter<T>} query
          * @returns {Promise<boolean>}
@@ -144,7 +112,7 @@ export function createMongoCollection(name, options = {}) {
          * @param {import('mongodb').UpdateOptions} [options]
          */
         updateOne: async (query, update, options) => await updateOne({
-            query, update, options, getCollection,
+            query, update, options, collectionOptions, getCollection,
         }),
         /**
          * @param {import('mongodb').Filter<T>} query
@@ -152,8 +120,56 @@ export function createMongoCollection(name, options = {}) {
          * @param {import('mongodb').UpdateOptions} [options]
          */
         updateMany: async (query, update, options) => await updateMany({
-            query, update, options, getCollection,
-        })
+            query, update, options, collectionOptions, getCollection,
+        }),
+        /**
+         * @param {import('mongodb').Document[]} pipeline
+         * @param {import('mongodb').AggregateOptions} [options]
+         * @returns {Promise<T[]>}
+         */
+        aggregate: async (pipeline, options) => await aggregate({
+            pipeline, options, getCollection, collectionOptions,
+        }),
+        /**
+         * @param {import('mongodb').AnyBulkWriteOperation<T>[]} operations
+         * @param {import('mongodb').BulkWriteOptions} [options]
+         */
+        bulkWrite: async (operations, options) => await bulkWrite({
+            operations, options, getCollection, collectionOptions,
+        }),
+        /**
+         * Atomically finds a document, applies the update, and returns the document.
+         * By default returns the document as it was **before** the update.
+         * Pass `{ returnDocument: 'after' }` in options to get the updated version.
+         * @param {import('mongodb').Filter<T>} query
+         * @param {import('mongodb').UpdateFilter<T>} update
+         * @param {import('mongodb').FindOneAndUpdateOptions} [options]
+         * @returns {Promise<T | null>}
+         */
+        findOneAndUpdate: async (query, update, options) => await findOneAndUpdate({
+            query, update, options, getCollection, collectionOptions,
+        }),
+        /**
+         * Atomically finds a document, deletes it, and returns the deleted document.
+         * @param {import('mongodb').Filter<T>} query
+         * @param {import('mongodb').FindOneAndDeleteOptions} [options]
+         * @returns {Promise<T | null>}
+         */
+        findOneAndDelete: async (query, options) => await findOneAndDelete({
+            query, options, getCollection, collectionOptions,
+        }),
+        /**
+         * Atomically finds a document, replaces it with `replacement`, and returns a document.
+         * By default returns the document as it was **before** the replacement.
+         * Pass `{ returnDocument: 'after' }` in options to get the new version.
+         * @param {import('mongodb').Filter<T>} query
+         * @param {import('mongodb').WithoutId<T>} replacement
+         * @param {import('mongodb').FindOneAndReplaceOptions} [options]
+         * @returns {Promise<T | null>}
+         */
+        findOneAndReplace: async (query, replacement, options) => await findOneAndReplace({
+            query, replacement, options, getCollection, collectionOptions,
+        }),
     }
 }
 
@@ -178,14 +194,6 @@ export function createMongoCollection(name, options = {}) {
  * collectionGetter: async () => await getMyCollection()
  * ```
  *
- * @property {IcollectionGetter<T>} [options.cachableCollectionGetter]
- * Same as `collectionGetter`. But the object is cached.
- *
- * Example:
- * ```js
- * cachableCollectionGetter: async () => await getMyCollection()
- * ```
- *
  * @property {string} [options.connectionString]
  * A custom connection string. If none is given, `process.env.DATABASE_URL` will be used.
  *
@@ -193,23 +201,22 @@ export function createMongoCollection(name, options = {}) {
  *
  * @property {import('mongodb').DbOptions} [options] The options used when initializing the client.
  *
- * @property {IfieldValidator<T> | IgenericValidator<T>} [validator]
+ * @property {ItimestampConfiguration} [timestamps] Configured how the package manages 'createdAt'
+ * and 'updatedAt'.
  */
 
 /**
- * @template T
- * @typedef {Partial<Record<keyof T, ((prop: any) => any)>>} IfieldValidator
- */
-
-/**
- * @template T
- * @callback IgenericValidator
- * The validator function used in insert operations.
- * This function should throw an exception if the validation fails.
- * @param {*} doc
- * @returns {T | null} The validator can return the desired document. Or null.
- *
- * If null is returned, the input parameter will be used normaly in inserts.
+ * @typedef {object} ItimestampConfiguration
+ * @property {'fromId' | 'generate' | 'none'} createdAt
+ * Changes how the 'createdAt' field is managed:
+ * - 'fromId': the field is generated when you use `find` or `findOne` and is calculated using _id.
+ * But it does not exist in the database.
+ * - 'generate': the field is generated when you use `insertOne` or `insertMany`. The value exist in
+ * the database.
+ * - 'none': no value is generated at any time.
+ * @property {'generate' | 'none'} updatedAt
+ * - 'generate': the value is generated when you use `insertOne` or `insertMany` and is updated on
+ * `updateOne` and `updateMany`.
  */
 
 /**

package/src/types.ts

@@ -27,20 +27,6 @@ type GivenProjectionReturnType<T extends MongoDocument, P extends NonNullProject
 export type ProjectionReturnType<T extends MongoDocument, P extends Projection<T>> =
     P extends NonNullProjection<T> ? GivenProjectionReturnType<T, P> : T
 
-// export type ProjectionReturnType<T extends MongoDocument, P extends Projection<T>> =
-//     P extends Partial<Record<keyof T, 0>>
-//     ? {
-//         [K in keyof T as P[K] extends 0 ? never : K]: T[K]
-//     }
-//     : (P extends Partial<Record<keyof T, 0 | 1>> ? {
-//         [K in keyof T as P[K] extends 1 ? K : (
-//             K extends 'id' ? (
-//                 P[K] extends 0 ? never : K
-//             ) :
-//             never
-//         )]: T[K]
-//     } : T)
-
-export type FindOptions<T extends MongoDocument, K extends Projection<T>> = Omit<FO<T>, 'projection'> & {
+export type FindOptions<T extends MongoDocument, K extends Projection<T>> = Omit<FO, 'projection'> & {
     projection?: K
 }

package/src/usecases/mongo/operation/aggregate.mjs

@@ -0,0 +1,26 @@
+import { Collection } from 'mongodb'
+import { renameToMongoId, stringsIntoId } from '../transformers/index.mjs'
+import { outputTransformer } from '../transformers/output_transformer.mjs'
+
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @param {object} parameter
+ * @param {() => Promise<Collection<T>>} parameter.getCollection
+ * @param {import('mongodb').Document[]} parameter.pipeline
+ * @param {import('mongodb').AggregateOptions} [parameter.options]
+ * @param {import('../../../factories/create_mongo_collection.mjs').IcreateCollectionOptions<T>} [parameter.collectionOptions]
+ * @returns {Promise<T[]>}
+ */
+export async function aggregate({ getCollection, pipeline, options, collectionOptions }) {
+    for (const stage of pipeline) {
+        if (stage.$match != null) {
+            stage.$match = renameToMongoId(stage.$match)
+        }
+    }
+    pipeline = stringsIntoId(pipeline)
+
+    const col = await getCollection()
+    const docs = await col.aggregate(pipeline, options).toArray()
+    // @ts-ignore
+    return docs.map((doc) => outputTransformer({ document: doc, collectionOptions }))
+}

package/src/usecases/mongo/operation/bulk_write.mjs

@@ -0,0 +1,54 @@
+import { Collection } from 'mongodb'
+import { renameToMongoId, stringsIntoId } from '../transformers/index.mjs'
+import { inputTransformer } from '../transformers/input_transformer.mjs'
+
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @param {object} parameter
+ * @param {() => Promise<Collection<T>>} parameter.getCollection
+ * @param {import('mongodb').AnyBulkWriteOperation<T>[]} parameter.operations
+ * @param {import('mongodb').BulkWriteOptions} [parameter.options]
+ * @param {import('../../../factories/create_mongo_collection.mjs').IcreateCollectionOptions<T>} [parameter.collectionOptions]
+ */
+export async function bulkWrite({ getCollection, operations, options, collectionOptions }) {
+    for (const op of operations) {
+        /** @type {any} */
+        const o = op
+        if (o.insertOne != null) {
+            o.insertOne.document = inputTransformer({
+                document: o.insertOne.document,
+                collectionOptions,
+            })
+        } else if (o.updateOne != null) {
+            o.updateOne.filter = renameToMongoId(o.updateOne.filter)
+            stringsIntoId(o.updateOne.filter)
+            stringsIntoId(o.updateOne.update)
+        } else if (o.updateMany != null) {
+            o.updateMany.filter = renameToMongoId(o.updateMany.filter)
+            stringsIntoId(o.updateMany.filter)
+            stringsIntoId(o.updateMany.update)
+        } else if (o.deleteOne != null) {
+            o.deleteOne.filter = renameToMongoId(o.deleteOne.filter)
+            stringsIntoId(o.deleteOne.filter)
+        } else if (o.deleteMany != null) {
+            o.deleteMany.filter = renameToMongoId(o.deleteMany.filter)
+            stringsIntoId(o.deleteMany.filter)
+        } else if (o.replaceOne != null) {
+            o.replaceOne.filter = renameToMongoId(o.replaceOne.filter)
+            stringsIntoId(o.replaceOne.filter)
+            stringsIntoId(o.replaceOne.replacement)
+        }
+    }
+
+    const col = await getCollection()
+    const result = await col.bulkWrite(operations, options)
+
+    if (result.insertedIds) {
+        for (const key of Object.keys(result.insertedIds)) {
+            // @ts-ignore
+            result.insertedIds[key] = result.insertedIds[key].toHexString()
+        }
+    }
+
+    return result
+}

package/src/usecases/mongo/operation/find.mjs

@@ -1,11 +1,10 @@
 import { Collection } from 'mongodb'
 import {
-    idsIntoString,
     renameFindOptions,
-    renameToDevId,
     renameToMongoId,
     stringsIntoId
 } from '../transformers/index.mjs'
+import { outputTransformer } from '../transformers/output_transformer.mjs'
 
 /**
  * @template {import('../../../types.js').MongoDocument} T
@@ -14,9 +13,10 @@ import {
  * @param {() => Promise<Collection<T>>} parameter.getCollection
  * @param {import('mongodb').Filter<T>} parameter.query
  * @param {import('../../../types.js').FindOptions<T, K>} [parameter.options]
+ * @param {import('../../../factories/create_mongo_collection.mjs').IcreateCollectionOptions<T>} [parameter.collectionOptions]
  * @returns {Promise<T[]>}
  */
-export async function find({ getCollection, query, options }) {
+export async function find({ getCollection, query, options, collectionOptions }) {
     query = renameToMongoId(query)
     options = renameFindOptions(options)
 
@@ -26,9 +26,10 @@ export async function find({ getCollection, query, options }) {
 
     const docs = await col.find(query, options).toArray()
     const fixedDocs = docs.map((doc) => {
-        idsIntoString(doc)
-        const transformedDoc = renameToDevId(doc)
-        return transformedDoc
+        return outputTransformer({
+            document: doc,
+            collectionOptions,
+        })
     })
     return fixedDocs
 }

package/src/usecases/mongo/operation/find_one.mjs

@@ -1,4 +1,5 @@
 import { Collection } from 'mongodb'
+import { outputTransformer } from '../transformers/output_transformer.mjs'
 import { find } from './find.mjs'
 
 /**
@@ -8,8 +9,10 @@ import { find } from './find.mjs'
  * @param {import('mongodb').Filter<T>} param.query
  * @param {import('../../../types.js').FindOptions<T, K>} [param.options]
  * @param {() => Promise<Collection<T>>} param.getCollection
+ * @param {import('../../../factories/create_mongo_collection.mjs').IcreateCollectionOptions<T>} param.collectionOptions
+ * @returns {Promise<T | null>}
  */
-export async function findOne({ query, options, getCollection }) {
+export async function findOne({ query, options, collectionOptions, getCollection }) {
     const docs = await find({
         query,
         options: {
@@ -22,5 +25,9 @@ export async function findOne({ query, options, getCollection }) {
     if (doc == null) {
         return null
     }
-    return doc
+
+    return outputTransformer({
+        document: doc,
+        collectionOptions,
+    })
 }

package/src/usecases/mongo/operation/find_one_and_delete.mjs

@@ -0,0 +1,23 @@
+import { Collection } from 'mongodb'
+import { renameToMongoId, stringsIntoId } from '../transformers/index.mjs'
+import { outputTransformer } from '../transformers/output_transformer.mjs'
+
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @param {object} param
+ * @param {import('mongodb').Filter<T>} param.query
+ * @param {import('mongodb').FindOneAndDeleteOptions} [param.options]
+ * @param {() => Promise<Collection<T>>} param.getCollection
+ * @param {import('../../../factories/create_mongo_collection.mjs').IcreateCollectionOptions<T>} [param.collectionOptions]
+ * @returns {Promise<T | null>}
+ */
+export async function findOneAndDelete({ query, options, collectionOptions, getCollection }) {
+    query = renameToMongoId(query)
+    stringsIntoId(query)
+    const col = await getCollection()
+
+    const doc = await col.findOneAndDelete(query, options ?? {})
+    if (doc == null) return null
+
+    return outputTransformer({ document: doc, collectionOptions })
+}

package/src/usecases/mongo/operation/find_one_and_replace.mjs

@@ -0,0 +1,24 @@
+import { Collection } from 'mongodb'
+import { renameToMongoId, stringsIntoId } from '../transformers/index.mjs'
+import { outputTransformer } from '../transformers/output_transformer.mjs'
+
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @param {object} param
+ * @param {import('mongodb').Filter<T>} param.query
+ * @param {import('mongodb').WithoutId<T>} param.replacement
+ * @param {import('mongodb').FindOneAndReplaceOptions} [param.options]
+ * @param {() => Promise<Collection<T>>} param.getCollection
+ * @param {import('../../../factories/create_mongo_collection.mjs').IcreateCollectionOptions<T>} [param.collectionOptions]
+ * @returns {Promise<T | null>}
+ */
+export async function findOneAndReplace({ query, replacement, options, collectionOptions, getCollection }) {
+    query = renameToMongoId(query)
+    stringsIntoId(query)
+    const col = await getCollection()
+
+    const doc = await col.findOneAndReplace(query, replacement, options ?? {})
+    if (doc == null) return null
+
+    return outputTransformer({ document: doc, collectionOptions })
+}

package/src/usecases/mongo/operation/find_one_and_update.mjs

@@ -0,0 +1,40 @@
+import { Collection } from 'mongodb'
+import { renameToMongoId, stringsIntoId } from '../transformers/index.mjs'
+import { outputTransformer } from '../transformers/output_transformer.mjs'
+
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @param {object} param
+ * @param {import('mongodb').Filter<T>} param.query
+ * @param {import('mongodb').UpdateFilter<T>} param.update
+ * @param {import('mongodb').FindOneAndUpdateOptions} [param.options]
+ * @param {() => Promise<Collection<T>>} param.getCollection
+ * @param {import('../../../factories/create_mongo_collection.mjs').IcreateCollectionOptions<T>} [param.collectionOptions]
+ * @returns {Promise<T | null>}
+ */
+export async function findOneAndUpdate({ query, update, options, collectionOptions, getCollection }) {
+    query = renameToMongoId(query)
+    stringsIntoId(query)
+    stringsIntoId(update)
+    const col = await getCollection()
+
+    const { timestamps } = collectionOptions ?? {}
+    const { updatedAt } = timestamps ?? { updatedAt: 'generate' }
+
+    const { $set } = update
+    const hasUpdatedAt = $set != null && $set.updatedAt != null
+    if (!hasUpdatedAt && updatedAt === 'generate') {
+        if ($set != null) {
+            // @ts-ignore
+            $set.updatedAt = new Date()
+        } else {
+            // @ts-ignore
+            update.$set = { updatedAt: new Date() }
+        }
+    }
+
+    const doc = await col.findOneAndUpdate(query, update, options ?? {})
+    if (doc == null) return null
+
+    return outputTransformer({ document: doc, collectionOptions })
+}

package/src/usecases/mongo/operation/index.mjs

@@ -1,9 +1,14 @@
 export * from './additional/index.mjs'
+export * from './aggregate.mjs'
+export * from './bulk_write.mjs'
 export * from './count.mjs'
 export * from './delete_many.mjs'
 export * from './delete_one.mjs'
 export * from './find.mjs'
 export * from './find_one.mjs'
+export * from './find_one_and_delete.mjs'
+export * from './find_one_and_replace.mjs'
+export * from './find_one_and_update.mjs'
 export * from './insert_many.mjs'
 export * from './insert_one.mjs'
 export * from './update_many.mjs'

package/src/usecases/mongo/operation/insert_many.mjs

@@ -1,14 +1,15 @@
 import { Collection, ObjectId } from 'mongodb'
-import { renameToMongoId, stringsIntoId } from '../transformers/index.mjs'
+import { inputTransformer } from '../transformers/input_transformer.mjs'
 
 /**
  * @template {import('../../../types.js').MongoDocument} T
  * @param {object} param
  * @param {import('../../../types.js').Optional<T, 'id'>[]} param.docs
  * @param {() => Promise<Collection<T>>} param.getCollection
+ * @param {import('../../../factories/create_mongo_collection.mjs').IcreateCollectionOptions<T>} param.collectionOptions
  * @returns {Promise<T[]>}
  */
-export async function insertMany({ docs, getCollection }) {
+export async function insertMany({ docs, collectionOptions, getCollection }) {
     if (docs.length == 0) return []
 
     // We need to clone the array to prevent the function from changing the original input object.
@@ -16,8 +17,10 @@ export async function insertMany({ docs, getCollection }) {
     docs = [...docs]
 
     for (let i = 0; i < docs.length; i++) {
-        docs[i] = renameToMongoId(docs[i])
-        stringsIntoId(docs[i])
+        docs[i] = inputTransformer({
+            document: docs[i],
+            collectionOptions: collectionOptions
+        })
     }
     const col = await getCollection()
     const result = await col.insertMany(

package/src/usecases/mongo/operation/insert_one.mjs

@@ -1,16 +1,20 @@
 import { Collection, ObjectId } from 'mongodb'
-import { renameToMongoId, stringsIntoId } from '../transformers/index.mjs'
+import { inputTransformer } from '../transformers/input_transformer.mjs'
 
 /**
  * @template {import('../../../types.js').MongoDocument} T
  * @param {object} param
  * @param {import('../../../types.js').Optional<T, 'id'>} param.doc
  * @param {() => Promise<Collection<T>>} param.getCollection
+ * @param {import('../../../factories/create_mongo_collection.mjs').IcreateCollectionOptions<T>} [param.collectionOptions]
  * @returns {Promise<T>}
  */
-export async function insertOne({ doc, getCollection }) {
-    doc = renameToMongoId(doc)
-    stringsIntoId(doc)
+export async function insertOne({ doc, collectionOptions, getCollection }) {
+    doc = inputTransformer({
+        document: doc,
+        collectionOptions
+    })
+
     const col = await getCollection()
     const result = await col.insertOne(
         // @ts-ignore
@@ -22,6 +26,8 @@ export async function insertOne({ doc, getCollection }) {
         id = id.toHexString()
     }
 
+    delete doc._id
+
     // @ts-ignore
     return { id, ...doc }
 }

package/src/usecases/mongo/operation/update_many.mjs

@@ -8,11 +8,32 @@ import { renameToMongoId, stringsIntoId } from '../transformers/index.mjs'
  * @param {import('mongodb').UpdateFilter<T>} param.update
  * @param {import('mongodb').UpdateOptions} [param.options]
  * @param {() => Promise<Collection<T>>} param.getCollection
+ * @param {import('../../../factories/create_mongo_collection.mjs').IcreateCollectionOptions<T>} [param.collectionOptions]
  */
-export async function updateMany({ query, update, options, getCollection }) {
+export async function updateMany({ query, update, options, collectionOptions, getCollection }) {
     query = renameToMongoId(query)
     stringsIntoId(query)
     stringsIntoId(update)
+
+    const { timestamps } = collectionOptions ?? {}
+    const { updatedAt } = timestamps ?? {
+        updatedAt: 'generate'
+    }
+
+    const { $set } = update
+    const hasUpdatedAt = $set != null && $set.updatedAt != null
+    if (!hasUpdatedAt && updatedAt === 'generate') {
+        if ($set != null) {
+            // @ts-ignore
+            $set.updatedAt = new Date()
+        } else {
+            // @ts-ignore
+            update.$set = {
+                updatedAt: new Date()
+            }
+        }
+    }
+
     const col = await getCollection()
     const r = await col.updateMany(query, update, options)
     return r

package/src/usecases/mongo/operation/update_one.mjs

@@ -8,12 +8,34 @@ import { renameToMongoId, stringsIntoId } from '../transformers/index.mjs'
  * @param {import('mongodb').UpdateFilter<T>} param.update
  * @param {import('mongodb').UpdateOptions} [param.options]
  * @param {() => Promise<Collection<T>>} param.getCollection
+ * @param {import('../../../factories/create_mongo_collection.mjs').IcreateCollectionOptions<T>} [param.collectionOptions]
+ * @returns {Promise<boolean>}
  */
-export async function updateOne({ query, update, options, getCollection }) {
+export async function updateOne({ query, update, options, collectionOptions, getCollection }) {
     query = renameToMongoId(query)
     stringsIntoId(query)
     stringsIntoId(update)
     const col = await getCollection()
+
+    const { timestamps } = collectionOptions ?? {}
+    const { updatedAt } = timestamps ?? {
+        updatedAt: 'generate'
+    }
+
+    const { $set } = update
+    const hasUpdatedAt = $set != null && $set.updatedAt != null
+    if (!hasUpdatedAt && updatedAt === 'generate') {
+        if ($set != null) {
+            // @ts-ignore
+            $set.updatedAt = new Date()
+        } else {
+            // @ts-ignore
+            update.$set = {
+                updatedAt: new Date()
+            }
+        }
+    }
+
     const r = await col.updateOne(query, update, options)
     return r.matchedCount > 0
 }