assai 2.0.0 → 2.1.0

package/src/__test/manage_mock_database.mjs

@@ -1,25 +1,25 @@
-import { MongoMemoryServer } from 'mongodb-memory-server'
-import { after, before } from 'node:test'
-import { closeClient } from '../usecases/mongo/mongo_client.mjs'
-
-/**
- * Starts a memory version of the mongodb server on a random free port.
- *
- * This method will also automatically close the connection with the database.
- */
-export function manageMockDatabase() {
-    /** @type {null | MongoMemoryServer} */
-    let server = null
-
-    before(async () => {
-        server = await MongoMemoryServer.create()
-        const uri = server.getUri('test')
-        process.env.DATABASE_URL = uri
-    })
-
-    after(async () => {
-        await closeClient()
-        await server?.stop()
-        process.exit()
-    })
+import { MongoMemoryServer } from 'mongodb-memory-server'
+import { after, before } from 'node:test'
+import { closeClient } from '../usecases/mongo/mongo_client.mjs'
+
+/**
+ * Starts a memory version of the mongodb server on a random free port.
+ *
+ * This method will also automatically close the connection with the database.
+ */
+export function manageMockDatabase() {
+    /** @type {null | MongoMemoryServer} */
+    let server = null
+
+    before(async () => {
+        server = await MongoMemoryServer.create()
+        const uri = server.getUri('test')
+        process.env.DATABASE_URL = uri
+    })
+
+    after(async () => {
+        await closeClient()
+        await server?.stop()
+        process.exit()
+    })
 }

package/src/__test/manage_mock_registry.mjs

@@ -1,55 +1,55 @@
-import { fakerPT_BR } from '@faker-js/faker'
-import { ObjectId } from 'mongodb'
-import { after, before } from 'node:test'
-import { generateNewId } from '../usecases/mongo/generate_new_id.mjs'
-import { closeClient } from '../usecases/mongo/mongo_client.mjs'
-import { deleteOne } from '../usecases/mongo/operation/delete_one.mjs'
-import { insertOne } from '../usecases/mongo/operation/insert_one.mjs'
-import { mockGetCollection } from './mock_get_collection.mjs'
-
-/**
- *
- * @param {import('./mock_get_collection.mjs').ItestCollection} param
- * @param {object} options
- * @param {boolean} [options.deleteAtEnd]
- */
-export function manageMockRegistry({ tag, ...rest } = {}, {
-    deleteAtEnd = true
-} = {}) {
-
-    const id = generateNewId()
-    const name = rest.name ?? fakerPT_BR.person.fullName()
-
-    before(async () => {
-        /** @type {import('./mock_get_collection.mjs').ItestCollection} */
-        const doc = {
-            id,
-            createdAt: new Date(),
-            tag,
-            name: name,
-            ...rest,
-        }
-        await insertOne({
-            // @ts-ignore
-            getCollection: mockGetCollection,
-            doc: doc,
-        })
-    })
-
-    after(async () => {
-        if (deleteAtEnd) {
-            await deleteOne({
-                query: {
-                    _id: ObjectId.createFromHexString(id)
-                },
-                // @ts-ignore
-                getCollection: mockGetCollection,
-            })
-        }
-        await closeClient()
-    })
-
-    return {
-        id, name
-    }
+import { fakerPT_BR } from '@faker-js/faker'
+import { ObjectId } from 'mongodb'
+import { after, before } from 'node:test'
+import { generateNewId } from '../usecases/mongo/generate_new_id.mjs'
+import { closeClient } from '../usecases/mongo/mongo_client.mjs'
+import { deleteOne } from '../usecases/mongo/operation/delete_one.mjs'
+import { insertOne } from '../usecases/mongo/operation/insert_one.mjs'
+import { mockGetCollection } from './mock_get_collection.mjs'
+
+/**
+ *
+ * @param {import('./mock_get_collection.mjs').ItestCollection} param
+ * @param {object} options
+ * @param {boolean} [options.deleteAtEnd]
+ */
+export function manageMockRegistry({ tag, ...rest } = {}, {
+    deleteAtEnd = true
+} = {}) {
+
+    const id = generateNewId()
+    const name = rest.name ?? fakerPT_BR.person.fullName()
+
+    before(async () => {
+        /** @type {import('./mock_get_collection.mjs').ItestCollection} */
+        const doc = {
+            id,
+            createdAt: new Date(),
+            tag,
+            name: name,
+            ...rest,
+        }
+        await insertOne({
+            // @ts-ignore
+            getCollection: mockGetCollection,
+            doc: doc,
+        })
+    })
+
+    after(async () => {
+        if (deleteAtEnd) {
+            await deleteOne({
+                query: {
+                    _id: ObjectId.createFromHexString(id)
+                },
+                // @ts-ignore
+                getCollection: mockGetCollection,
+            })
+        }
+        await closeClient()
+    })
+
+    return {
+        id, name
+    }
 }

package/src/__test/mock_get_collection.mjs

@@ -1,21 +1,21 @@
-import { Collection, ObjectId } from 'mongodb'
-import { getClient } from '../usecases/mongo/mongo_client.mjs'
-
-export async function mockGetCollection(collectionName = 'test') {
-    const client = await getClient()
-    const db = client.db()
-    /** @type {Collection<ItestCollection>} */
-    const collection = db.collection(collectionName)
-    return collection
-}
-
-/**
- * @typedef {object} ItestCollection
- * @property {ObjectId} [_id]
- * @property {string} [id]
- * @property {string} [name]
- * @property {string | ObjectId} [tag]
- * @property {Date} [createdAt]
- * @property {object[]} [posts]
- * @property {object} [address]
+import { Collection, ObjectId } from 'mongodb'
+import { getClient } from '../usecases/mongo/mongo_client.mjs'
+
+export async function mockGetCollection(collectionName = 'test') {
+    const client = await getClient()
+    const db = client.db()
+    /** @type {Collection<ItestCollection>} */
+    const collection = db.collection(collectionName)
+    return collection
+}
+
+/**
+ * @typedef {object} ItestCollection
+ * @property {ObjectId} [_id]
+ * @property {string} [id]
+ * @property {string} [name]
+ * @property {string | ObjectId} [tag]
+ * @property {Date} [createdAt]
+ * @property {object[]} [posts]
+ * @property {object} [address]
  */

package/src/data/errors/operation_fail.mjs

@@ -1,10 +1,10 @@
-export class OperationFail extends Error {
-
-    /**
-     *
-     * @param {string} msg
-     */
-    constructor(msg) {
-        super(msg)
-    }
+export class OperationFail extends Error {
+
+    /**
+     *
+     * @param {string} msg
+     */
+    constructor(msg) {
+        super(msg)
+    }
 }

package/src/data/errors/unsupported_error.mjs

@@ -1,10 +1,10 @@
-export class NotImplemented extends Error {
-
-    /**
-     *
-     * @param {string} msg
-     */
-    constructor(msg) {
-        super(msg)
-    }
+export class NotImplemented extends Error {
+
+    /**
+     *
+     * @param {string} msg
+     */
+    constructor(msg) {
+        super(msg)
+    }
 }

package/src/data/interfaces/mongo_operator.mjs

@@ -1,3 +1,3 @@
-/**
- * @typedef {'$eq' | '$lt' | '$lte'} ImongoOperator
+/**
+ * @typedef {'$eq' | '$lt' | '$lte'} ImongoOperator
  */

package/src/data/interfaces/native_collection.mjs

@@ -1,28 +1,28 @@
-/**
- * @template {import('mongodb').Document} T
- * @typedef {object} InativeCollection
- * @property {InativeInsertOne<T>} insertOne
- * @property {InativeDeleteOne<T>} deleteOne
- * @property {InativeUpdateOne<T>} updateOne
- */
-
-/**
- * @template {import('mongodb').Document} T
- * @callback InativeInsertOne
- * @param {import('../../types.js').Optional<T, '_id'>} data
- * @returns {Promise<any>}
- */
-
-/**
- * @template {import('mongodb').Document} T
- * @callback InativeDeleteOne
- * @param {import('mongodb').Filter<T>} filter
- * @returns {Promise<any>}
- */
-
-/**
- * @template {import('mongodb').Document} T
- * @callback InativeUpdateOne
- * @param {import('mongodb').Filter<T>} filter
- * @param {import('mongodb').UpdateFilter<T>} update
+/**
+ * @template {import('mongodb').Document} T
+ * @typedef {object} InativeCollection
+ * @property {InativeInsertOne<T>} insertOne
+ * @property {InativeDeleteOne<T>} deleteOne
+ * @property {InativeUpdateOne<T>} updateOne
+ */
+
+/**
+ * @template {import('mongodb').Document} T
+ * @callback InativeInsertOne
+ * @param {import('../../types.js').Optional<T, '_id'>} data
+ * @returns {Promise<any>}
+ */
+
+/**
+ * @template {import('mongodb').Document} T
+ * @callback InativeDeleteOne
+ * @param {import('mongodb').Filter<T>} filter
+ * @returns {Promise<any>}
+ */
+
+/**
+ * @template {import('mongodb').Document} T
+ * @callback InativeUpdateOne
+ * @param {import('mongodb').Filter<T>} filter
+ * @param {import('mongodb').UpdateFilter<T>} update
  */

package/src/factories/create_mock_collection.mjs

@@ -1,174 +1,174 @@
-import { ObjectId } from 'mongodb'
-import { NotImplemented } from '../data/errors/unsupported_error.mjs'
-
-/** @type {Record<string, any[]>} */
-const memory = {}
-
-/**
- * @template {import('mongodb').Document} T
- * @param {string} [name]
- * @returns {import('../data/interfaces/native_collection.mjs').InativeCollection<T>}
- */
-export function createMockCollection(name = 'mock') {
-
-    function getItems() {
-        let items = memory[name]
-        if (items == null) {
-            items = []
-            memory[name] = items
-        }
-        return items
-    }
-
-    /**
-     *
-     * @param {import('mongodb').Filter<T>} filter
-     */
-    function getFilteredItems(filter) {
-        const keys = Object.keys(filter)
-        const dollarFilters = keys.filter(x => x.startsWith('$'))
-        if (dollarFilters.length > 0) {
-            throw new NotImplemented('root dollar sign filters not supported')
-        }
-
-        /** @type {((item: T) => boolean)[]} */
-        const fieldFilter = []
-        for (const field of keys) {
-            const value = filter[field]
-            /**
-             * @returns {import('../data/interfaces/mongo_operator.mjs').ImongoOperator[]}
-             */
-            function getOperators() {
-                if (value == null) return ['$eq']
-                if (typeof value != 'object') return ['$eq']
-                if (Array.isArray(value)) return ['$eq']
-                if (value instanceof RegExp) {
-                    throw new NotImplemented('Search using a regular expression is not supported')
-                }
-
-                // Getting operators used in query
-                const fieldInnerKeys = Object.keys(value)
-                const operators = fieldInnerKeys.filter(x => x.startsWith('$'))
-                const hasOperator = operators.length > 0
-
-                // Lack of operator presumes equal operator
-                if (!hasOperator) return ['$eq']
-
-                const areAllKeysOperators = fieldInnerKeys.every(x => x.startsWith('$'))
-                if (!areAllKeysOperators) {
-                    // Means the object contained operators (such as "$eq" or "$lt"),
-                    // But not all keys are operators, which is not valid.
-                    throw new Error(`The value on field ${field} does not look right...`)
-                }
-
-                // Reading operators from object
-                /** @type {import('../data/interfaces/mongo_operator.mjs').ImongoOperator[]} */
-                const usedOperators = []
-                for (const operator of operators) {
-                    switch (operator) {
-                        case '$eq':
-                            usedOperators.push('$eq')
-                        default:
-                            throw new NotImplemented(`Operator ${operator} not implemented`)
-                    }
-                }
-                return usedOperators
-            }
-
-            const operators = getOperators()
-            for (const operator of operators) {
-                switch (operator) {
-                    case '$eq':
-                        fieldFilter.push((doc) => {
-                            const savedValue = doc[field]
-                            return savedValue == value
-                        })
-                    default:
-                        throw new NotImplemented(`Operator ${operator} is not supported`)
-                }
-            }
-        }
-
-        const allCollectionItems = getItems()
-        return allCollectionItems.filter(savedDoc => {
-            return fieldFilter.every(comparator => {
-                return comparator(savedDoc)
-            })
-        })
-    }
-
-    /**
-     * $set
-     * @param {*} doc
-     * @param {*} update The update object. Should not contain operator
-     */
-    function performSetUpdate(doc, update) {
-        for (const [field, newValue] of Object.entries(update)) {
-            doc[field] = newValue
-        }
-    }
-
-    return {
-        async insertOne(doc) {
-            const items = getItems()
-            if (doc._id == null) {
-                // @ts-ignore
-                doc._id = new ObjectId()
-            }
-            items.push(doc)
-        },
-        async deleteOne(filter) {
-            const documentsToDelete = getFilteredItems(filter)
-            const allCollectionItems = getItems()
-
-            // Deleting the documents, one document at a time
-            while (documentsToDelete.length > 0) {
-                const docToDelete = documentsToDelete[0]
-                const index = allCollectionItems.indexOf(docToDelete)
-                if (index < 0) {
-                    throw new Error('Document extracted from memory was not found in memory')
-                }
-                allCollectionItems.splice(index, 1)
-            }
-        },
-        async updateOne(filter, update) {
-            // Getting document to update
-            const documentsToUpdate = getFilteredItems(filter)
-            if (documentsToUpdate.length == 0) {
-                return
-            }
-            const docToUpdate = documentsToUpdate[0]
-
-            const updateKeys = Object.keys(update)
-            const operators = updateKeys.filter(x => x.startsWith('$'))
-
-            // Checking for empty updates
-            if (updateKeys.length == 0) {
-                return
-            }
-
-            // Is a simple $set operation
-            if (operators.length == 0) {
-                performSetUpdate(docToUpdate, update)
-                return
-            }
-
-            // Validating update object
-            if (updateKeys.length != operators.length) {
-                throw new Error('This update does not look right...')
-            }
-
-            // Processing complex update
-            for (const operator of operators) {
-                const value = update[operator]
-                switch (operator) {
-                    case '$set':
-                        performSetUpdate(docToUpdate, value)
-                        break
-                    default:
-                        throw new Error(`Operator ${operator} not supported`)
-                }
-            }
-        }
-    }
+import { ObjectId } from 'mongodb'
+import { NotImplemented } from '../data/errors/unsupported_error.mjs'
+
+/** @type {Record<string, any[]>} */
+const memory = {}
+
+/**
+ * @template {import('mongodb').Document} T
+ * @param {string} [name]
+ * @returns {import('../data/interfaces/native_collection.mjs').InativeCollection<T>}
+ */
+export function createMockCollection(name = 'mock') {
+
+    function getItems() {
+        let items = memory[name]
+        if (items == null) {
+            items = []
+            memory[name] = items
+        }
+        return items
+    }
+
+    /**
+     *
+     * @param {import('mongodb').Filter<T>} filter
+     */
+    function getFilteredItems(filter) {
+        const keys = Object.keys(filter)
+        const dollarFilters = keys.filter(x => x.startsWith('$'))
+        if (dollarFilters.length > 0) {
+            throw new NotImplemented('root dollar sign filters not supported')
+        }
+
+        /** @type {((item: T) => boolean)[]} */
+        const fieldFilter = []
+        for (const field of keys) {
+            const value = filter[field]
+            /**
+             * @returns {import('../data/interfaces/mongo_operator.mjs').ImongoOperator[]}
+             */
+            function getOperators() {
+                if (value == null) return ['$eq']
+                if (typeof value != 'object') return ['$eq']
+                if (Array.isArray(value)) return ['$eq']
+                if (value instanceof RegExp) {
+                    throw new NotImplemented('Search using a regular expression is not supported')
+                }
+
+                // Getting operators used in query
+                const fieldInnerKeys = Object.keys(value)
+                const operators = fieldInnerKeys.filter(x => x.startsWith('$'))
+                const hasOperator = operators.length > 0
+
+                // Lack of operator presumes equal operator
+                if (!hasOperator) return ['$eq']
+
+                const areAllKeysOperators = fieldInnerKeys.every(x => x.startsWith('$'))
+                if (!areAllKeysOperators) {
+                    // Means the object contained operators (such as "$eq" or "$lt"),
+                    // But not all keys are operators, which is not valid.
+                    throw new Error(`The value on field ${field} does not look right...`)
+                }
+
+                // Reading operators from object
+                /** @type {import('../data/interfaces/mongo_operator.mjs').ImongoOperator[]} */
+                const usedOperators = []
+                for (const operator of operators) {
+                    switch (operator) {
+                        case '$eq':
+                            usedOperators.push('$eq')
+                        default:
+                            throw new NotImplemented(`Operator ${operator} not implemented`)
+                    }
+                }
+                return usedOperators
+            }
+
+            const operators = getOperators()
+            for (const operator of operators) {
+                switch (operator) {
+                    case '$eq':
+                        fieldFilter.push((doc) => {
+                            const savedValue = doc[field]
+                            return savedValue == value
+                        })
+                    default:
+                        throw new NotImplemented(`Operator ${operator} is not supported`)
+                }
+            }
+        }
+
+        const allCollectionItems = getItems()
+        return allCollectionItems.filter(savedDoc => {
+            return fieldFilter.every(comparator => {
+                return comparator(savedDoc)
+            })
+        })
+    }
+
+    /**
+     * $set
+     * @param {*} doc
+     * @param {*} update The update object. Should not contain operator
+     */
+    function performSetUpdate(doc, update) {
+        for (const [field, newValue] of Object.entries(update)) {
+            doc[field] = newValue
+        }
+    }
+
+    return {
+        async insertOne(doc) {
+            const items = getItems()
+            if (doc._id == null) {
+                // @ts-ignore
+                doc._id = new ObjectId()
+            }
+            items.push(doc)
+        },
+        async deleteOne(filter) {
+            const documentsToDelete = getFilteredItems(filter)
+            const allCollectionItems = getItems()
+
+            // Deleting the documents, one document at a time
+            while (documentsToDelete.length > 0) {
+                const docToDelete = documentsToDelete[0]
+                const index = allCollectionItems.indexOf(docToDelete)
+                if (index < 0) {
+                    throw new Error('Document extracted from memory was not found in memory')
+                }
+                allCollectionItems.splice(index, 1)
+            }
+        },
+        async updateOne(filter, update) {
+            // Getting document to update
+            const documentsToUpdate = getFilteredItems(filter)
+            if (documentsToUpdate.length == 0) {
+                return
+            }
+            const docToUpdate = documentsToUpdate[0]
+
+            const updateKeys = Object.keys(update)
+            const operators = updateKeys.filter(x => x.startsWith('$'))
+
+            // Checking for empty updates
+            if (updateKeys.length == 0) {
+                return
+            }
+
+            // Is a simple $set operation
+            if (operators.length == 0) {
+                performSetUpdate(docToUpdate, update)
+                return
+            }
+
+            // Validating update object
+            if (updateKeys.length != operators.length) {
+                throw new Error('This update does not look right...')
+            }
+
+            // Processing complex update
+            for (const operator of operators) {
+                const value = update[operator]
+                switch (operator) {
+                    case '$set':
+                        performSetUpdate(docToUpdate, value)
+                        break
+                    default:
+                        throw new Error(`Operator ${operator} not supported`)
+                }
+            }
+        }
+    }
 }