assai 2.0.0 → 2.1.1

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)
+            o.updateOne.filter = stringsIntoId(o.updateOne.filter)
+            o.updateOne.update = stringsIntoId(o.updateOne.update)
+        } else if (o.updateMany != null) {
+            o.updateMany.filter = renameToMongoId(o.updateMany.filter)
+            o.updateMany.filter = stringsIntoId(o.updateMany.filter)
+            o.updateMany.update = stringsIntoId(o.updateMany.update)
+        } else if (o.deleteOne != null) {
+            o.deleteOne.filter = renameToMongoId(o.deleteOne.filter)
+            o.deleteOne.filter = stringsIntoId(o.deleteOne.filter)
+        } else if (o.deleteMany != null) {
+            o.deleteMany.filter = renameToMongoId(o.deleteMany.filter)
+            o.deleteMany.filter = stringsIntoId(o.deleteMany.filter)
+        } else if (o.replaceOne != null) {
+            o.replaceOne.filter = renameToMongoId(o.replaceOne.filter)
+            o.replaceOne.filter = stringsIntoId(o.replaceOne.filter)
+            o.replaceOne.replacement = 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/count.mjs

@@ -1,17 +1,17 @@
-import { Collection } from 'mongodb'
-import { renameToMongoId, stringsIntoId } from '../transformers/index.mjs'
-
-/**
- * @template {import('../../../types.js').MongoDocument} T
- * @param {object} params
- * @param {() => Promise<Collection<T>>} params.getCollection
- * @param {import('mongodb').Filter<T>} [params.query]
- */
-export async function count({ getCollection, query }) {
-    query = renameToMongoId(query)
-    stringsIntoId(query)
-
-    const col = await getCollection()
-    const count = await col.countDocuments(query)
-    return count
+import { Collection } from 'mongodb'
+import { renameToMongoId, stringsIntoId } from '../transformers/index.mjs'
+
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @param {object} params
+ * @param {() => Promise<Collection<T>>} params.getCollection
+ * @param {import('mongodb').Filter<T>} [params.query]
+ */
+export async function count({ getCollection, query }) {
+    query = renameToMongoId(query)
+    query = stringsIntoId(query)
+
+    const col = await getCollection()
+    const count = await col.countDocuments(query)
+    return count
 }

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

@@ -1,16 +1,16 @@
-import { Collection } from 'mongodb'
-import { renameToMongoId, stringsIntoId } from '../transformers/index.mjs'
-
-/**
- * @template {import('../../../types.js').MongoDocument} T
- * @param {object} parameter
- * @param {import('mongodb').Filter<T>} parameter.query
- * @param {() => Promise<Collection<T>>} parameter.getCollection
- */
-export async function deleteMany({ query, getCollection }) {
-    query = renameToMongoId(query)
-    stringsIntoId(query)
-    const col = await getCollection()
-    const r = await col.deleteMany(query)
-    return r.deletedCount
+import { Collection } from 'mongodb'
+import { renameToMongoId, stringsIntoId } from '../transformers/index.mjs'
+
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @param {object} parameter
+ * @param {import('mongodb').Filter<T>} parameter.query
+ * @param {() => Promise<Collection<T>>} parameter.getCollection
+ */
+export async function deleteMany({ query, getCollection }) {
+    query = renameToMongoId(query)
+    query = stringsIntoId(query)
+    const col = await getCollection()
+    const r = await col.deleteMany(query)
+    return r.deletedCount
 }

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

@@ -1,17 +1,17 @@
-import { Collection } from 'mongodb'
-import { renameToMongoId, stringsIntoId } from '../transformers/index.mjs'
-
-/**
- * @template {import('../../../types.js').MongoDocument} T
- * @param {object} parameter
- * @param {import('mongodb').Filter<T>} parameter.query
- * @param {() => Promise<Collection<T>>} parameter.getCollection
- * @returns {Promise<boolean>}
- */
-export async function deleteOne({ query, getCollection }) {
-    query = renameToMongoId(query)
-    stringsIntoId(query)
-    const col = await getCollection()
-    const r = await col.deleteOne(query)
-    return r.deletedCount > 0
+import { Collection } from 'mongodb'
+import { renameToMongoId, stringsIntoId } from '../transformers/index.mjs'
+
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @param {object} parameter
+ * @param {import('mongodb').Filter<T>} parameter.query
+ * @param {() => Promise<Collection<T>>} parameter.getCollection
+ * @returns {Promise<boolean>}
+ */
+export async function deleteOne({ query, getCollection }) {
+    query = renameToMongoId(query)
+    query = stringsIntoId(query)
+    const col = await getCollection()
+    const r = await col.deleteOne(query)
+    return r.deletedCount > 0
 }

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

@@ -1,35 +1,35 @@
-import { Collection } from 'mongodb'
-import {
-    renameFindOptions,
-    renameToMongoId,
-    stringsIntoId
-} from '../transformers/index.mjs'
-import { outputTransformer } from '../transformers/output_transformer.mjs'
-
-/**
- * @template {import('../../../types.js').MongoDocument} T
- * @template {import('../../../types.js').Projection<T>} K
- * @param {object} parameter
- * @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, collectionOptions }) {
-    query = renameToMongoId(query)
-    options = renameFindOptions(options)
-
-    stringsIntoId(query)
-
-    const col = await getCollection()
-
-    const docs = await col.find(query, options).toArray()
-    const fixedDocs = docs.map((doc) => {
-        return outputTransformer({
-            document: doc,
-            collectionOptions,
-        })
-    })
-    return fixedDocs
+import { Collection } from 'mongodb'
+import {
+    renameFindOptions,
+    renameToMongoId,
+    stringsIntoId
+} from '../transformers/index.mjs'
+import { outputTransformer } from '../transformers/output_transformer.mjs'
+
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @template {import('../../../types.js').Projection<T>} K
+ * @param {object} parameter
+ * @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, collectionOptions }) {
+    query = renameToMongoId(query)
+    options = renameFindOptions(options)
+
+    query = stringsIntoId(query)
+
+    const col = await getCollection()
+
+    const docs = await col.find(query, options).toArray()
+    const fixedDocs = docs.map((doc) => {
+        return outputTransformer({
+            document: doc,
+            collectionOptions,
+        })
+    })
+    return fixedDocs
 }

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

@@ -1,33 +1,33 @@
-import { Collection } from 'mongodb'
-import { outputTransformer } from '../transformers/output_transformer.mjs'
-import { find } from './find.mjs'
-
-/**
- * @template {import('../../../types.js').MongoDocument} T
- * @template {import('../../../types.js').Projection<T> | undefined} K
- * @param {object} param
- * @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, collectionOptions, getCollection }) {
-    const docs = await find({
-        query,
-        options: {
-            limit: 1,
-            ...options,
-        },
-        getCollection,
-    })
-    const doc = docs[0]
-    if (doc == null) {
-        return null
-    }
-
-    return outputTransformer({
-        document: doc,
-        collectionOptions,
-    })
+import { Collection } from 'mongodb'
+import { outputTransformer } from '../transformers/output_transformer.mjs'
+import { find } from './find.mjs'
+
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @template {import('../../../types.js').Projection<T> | undefined} K
+ * @param {object} param
+ * @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, collectionOptions, getCollection }) {
+    const docs = await find({
+        query,
+        options: {
+            limit: 1,
+            ...options,
+        },
+        getCollection,
+    })
+    const doc = docs[0]
+    if (doc == null) {
+        return null
+    }
+
+    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)
+    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)
+    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)
+    query = stringsIntoId(query)
+    update = 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,10 +1,15 @@
-export * from './additional/index.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 './insert_many.mjs'
-export * from './insert_one.mjs'
-export * from './update_many.mjs'
-export * from './update_one.mjs'
+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'
+export * from './update_one.mjs'

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

@@ -1,40 +1,40 @@
-import { Collection, ObjectId } from 'mongodb'
-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, collectionOptions, getCollection }) {
-    if (docs.length == 0) return []
-
-    // We need to clone the array to prevent the function from changing the original input object.
-    // This is necessary since we change the objects inside the array to rename the "id" to "_id".
-    docs = [...docs]
-
-    for (let i = 0; i < docs.length; i++) {
-        docs[i] = inputTransformer({
-            document: docs[i],
-            collectionOptions: collectionOptions
-        })
-    }
-    const col = await getCollection()
-    const result = await col.insertMany(
-        // @ts-ignore
-        docs
-    )
-    let { insertedIds } = result
-    const indexes = Object.keys(insertedIds)
-    for (const index of indexes) {
-        const id = insertedIds[index]
-        if (id instanceof ObjectId) {
-            docs[index].id = id.toHexString()
-        }
-    }
-    // @ts-ignore
-    return docs
+import { Collection, ObjectId } from 'mongodb'
+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, collectionOptions, getCollection }) {
+    if (docs.length == 0) return []
+
+    // We need to clone the array to prevent the function from changing the original input object.
+    // This is necessary since we change the objects inside the array to rename the "id" to "_id".
+    docs = [...docs]
+
+    for (let i = 0; i < docs.length; i++) {
+        docs[i] = inputTransformer({
+            document: docs[i],
+            collectionOptions: collectionOptions
+        })
+    }
+    const col = await getCollection()
+    const result = await col.insertMany(
+        // @ts-ignore
+        docs
+    )
+    let { insertedIds } = result
+    const indexes = Object.keys(insertedIds)
+    for (const index of indexes) {
+        const id = insertedIds[index]
+        if (id instanceof ObjectId) {
+            docs[index].id = id.toHexString()
+        }
+    }
+    // @ts-ignore
+    return docs
 }

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

@@ -1,33 +1,33 @@
-import { Collection, ObjectId } from 'mongodb'
-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, collectionOptions, getCollection }) {
-    doc = inputTransformer({
-        document: doc,
-        collectionOptions
-    })
-
-    const col = await getCollection()
-    const result = await col.insertOne(
-        // @ts-ignore
-        doc
-    )
-    let id = result.insertedId
-    if (id instanceof ObjectId) {
-        // @ts-ignore
-        id = id.toHexString()
-    }
-
-    delete doc._id
-
-    // @ts-ignore
-    return { id, ...doc }
+import { Collection, ObjectId } from 'mongodb'
+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, collectionOptions, getCollection }) {
+    doc = inputTransformer({
+        document: doc,
+        collectionOptions
+    })
+
+    const col = await getCollection()
+    const result = await col.insertOne(
+        // @ts-ignore
+        doc
+    )
+    let id = result.insertedId
+    if (id instanceof ObjectId) {
+        // @ts-ignore
+        id = id.toHexString()
+    }
+
+    delete doc._id
+
+    // @ts-ignore
+    return { id, ...doc }
 }

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

@@ -1,40 +1,40 @@
-import { Collection } from 'mongodb'
-import { renameToMongoId, stringsIntoId } from '../transformers/index.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').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, 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
+import { Collection } from 'mongodb'
+import { renameToMongoId, stringsIntoId } from '../transformers/index.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').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, collectionOptions, getCollection }) {
+    query = renameToMongoId(query)
+    query = stringsIntoId(query)
+    update = 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
 }