@cocreate/mongodb 1.7.1 → 1.8.0

package/.github/workflows/automated.yml

@@ -58,8 +58,7 @@ jobs:
         run: echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" > ~/.npmrc
       - name: Install dependencies
         run: yarn install
-      - name: Build
-        run: yarn build
+
       - name: Set Environment Variables
         run: |
           echo "organization_id=${{ secrets.COCREATE_ORGANIZATION_ID }}" >> $GITHUB_ENV

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+# [1.8.0](https://github.com/CoCreate-app/CoCreate-mongodb/compare/v1.7.2...v1.8.0) (2023-09-07)
+
+
+### Features
+
+* support $push, $delete, $pop, $pull methods on arrays. ([06bf984](https://github.com/CoCreate-app/CoCreate-mongodb/commit/06bf9844863885d2cf9c6cc9591500becb105f51))
+* Use cursor when filtering through documents, increasing performance and enabeling ability to process very large data sets ([376c63f](https://github.com/CoCreate-app/CoCreate-mongodb/commit/376c63fa461221f71811032528d04c4b8235241e))
+
+## [1.7.2](https://github.com/CoCreate-app/CoCreate-mongodb/compare/v1.7.1...v1.7.2) (2023-08-21)
+
+
+### Bug Fixes
+
+* removed webpack.config and build step as no webpack.config exist ([2f15aff](https://github.com/CoCreate-app/CoCreate-mongodb/commit/2f15aff759bc500691359f708fcb24264d312470))
+
 ## [1.7.1](https://github.com/CoCreate-app/CoCreate-mongodb/compare/v1.7.0...v1.7.1) (2023-08-21)
 
 

package/CoCreate.config.js

@@ -1,25 +1,23 @@
-module.exports = {
-    "organization_id": "",
-    "key": "",
-    "host": "",
-
-    "sources": [{
-        "array": "files",
-        "object": {
-            "_id": "60145dc49f64ba1680b86693",
-            "name": "index.html",
-            "path": "/docs/mongodb/index.html",
-            "src": "{{./docs/index.html}}",
-            "host": [
-                "cocreate.app",
-                "general.cocreate.app"
-            ],
-            "directory": "/docs/mongodb",
-            "content-type": "text/html",
-            "public": "true",
-            "website_id": "5ffbceb7f11d2d00103c4535"
-        }
-    }
-    ]
-}
-
+module.exports = {
+    "organization_id": "",
+    "key": "",
+    "host": "",
+    "sources": [
+        {
+            "array": "files",
+            "object": {
+                "_id": "60145dc49f64ba1680b86693",
+                "name": "index.html",
+                "path": "/docs/mongodb/index.html",
+                "src": "{{./docs/index.html}}",
+                "host": [
+                    "*"
+                ],
+                "directory": "/docs/mongodb",
+                "content-type": "text/html",
+                "public": "true",
+                "website_id": "5ffbceb7f11d2d00103c4535"
+            }
+        }
+    ]
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/mongodb",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "description": "A simple mongodb component in vanilla javascript. Easily configured using HTML5 data-attributes and/or JavaScript API.",
   "keywords": [
     "mongodb",

package/src/index.js

@@ -131,7 +131,7 @@ function array(action, data) {
 
                 if (action == 'readCollection') {
 
-                    let { query, sort } = getFilters(data);
+                    let { query, sort } = await getFilters(data);
 
                     db.listCollections().toArray(function (error, result) {
                         if (error)
@@ -277,15 +277,9 @@ function object(action, data) {
             if (data.request)
                 data[type] = data.request
 
-
             if (!data['timeStamp'])
                 data['timeStamp'] = new Date().toISOString()
 
-
-            let isFilter
-            if (data.filter && data.filter.query)
-                isFilter = true
-
             let databases = data.database;
             if (!Array.isArray(databases))
                 databases = [databases]
@@ -301,60 +295,22 @@ function object(action, data) {
                     const db = client.db(database);
                     const arrayObj = db.collection(array);
 
-                    let { query, sort } = getFilters(data);
-                    if (data['organization_id']) {
-                        query['organization_id'] = { $eq: data['organization_id'] }
-                    }
-
-                    let _ids = []
-                    let update_ids = []
-                    let updateData = {}
+                    if (data[type] && !Array.isArray(data[type]))
+                        data[type] = [data[type]]
 
-                    if (data[type]) {
-                        if (!Array.isArray(data[type]))
-                            data[type] = [data[type]]
+                    if (action == 'createObject') {
                         for (let i = 0; i < data[type].length; i++) {
                             data[type][i] = replaceArray(data[type][i])
+                            data[type][i] = dotNotationToObject(data[type][i])
                             data[type][i]['organization_id'] = data['organization_id'];
 
-
-                            if (action == 'createObject') {
-                                data[type][i] = dotNotationToObject(data[type][i])
-
-                                if (!data[type][i]._id)
-                                    data[type][i]._id = ObjectId()
-                                else
-                                    data[type][i]._id = ObjectId(data[type][i]._id)
-                                data[type][i]['created'] = { on: data.timeStamp, by: data.user_id || data.clientId }
-                            }
-                            if (action == 'readObject' && data[type][i]._id) {
-                                _ids.push(ObjectId(data[type][i]._id))
-                            }
-                            if (action == 'updateObject') {
-                                if (data[type][i]._id)
-                                    update_ids.push({ _id: data[type][i]._id, updateDoc: data[type][i], updateType: '_id' })
-
-                                if (!data[type][i]._id)
-                                    updateData = createUpdate({ object: [data[type][i]] }, type)
-
-                                data[type][i]['modified'] = { on: data.timeStamp, by: data.user_id || data.clientId }
-
-                            }
-                            if (action == 'deleteObject') {
-                                if (data[type][i]._id) {
-                                    _ids.push(ObjectId(data[type][i]._id))
-                                    documents.push({ _id: data[type][i]._id, storage: data.storageName, database, array })
-                                }
-                            }
+                            if (!data[type][i]._id)
+                                data[type][i]._id = ObjectId()
+                            else
+                                data[type][i]._id = ObjectId(data[type][i]._id)
+                            data[type][i]['created'] = { on: data.timeStamp, by: data.user_id || data.clientId }
                         }
-                        if (_ids.length == 1)
-                            query['_id'] = ObjectId(_ids[0])
-                        else if (_ids.length > 0)
-                            query['_id'] = { $in: _ids }
-                    }
-
 
-                    if (action == 'createObject') {
                         arrayObj.insertMany(data[type], function (error, result) {
                             if (error)
                                 errorHandler(data, error, database, array)
@@ -371,58 +327,63 @@ function object(action, data) {
                                 resolve(data)
                             }
                         });
-                    }
+                    } else {
+                        let isFilter
+                        if (data.filter && data.filter.query)
+                            isFilter = true
+
+                        let { query, sort, index, limit } = await getFilters(data, arrayObj);
+
+                        if (action == 'readObject') {
+                            if (data[type]) {
+                                let _ids = []
+                                for (let i = 0; i < data[type].length; i++) {
+                                    data[type][i] = replaceArray(data[type][i])
+                                    if (data[type][i]._id) {
+                                        _ids.push(ObjectId(data[type][i]._id))
+                                    }
+                                }
 
-                    if (action == 'readObject') {
-                        let index = 0, limit = 0
-                        if (data.filter) {
-                            const count = await arrayObj.estimatedDocumentCount()
-                            data.filter.count = count
-
-                            if (data.filter.index)
-                                index = data.filter.index
-                            if (data.filter.limit)
-                                limit = data.filter.limit
-                            if (limit)
-                                limit = index + limit;
-                        }
+                                if (_ids.length == 1)
+                                    query['_id'] = _ids[0]
+                                else if (_ids.length > 0)
+                                    query['_id'] = { $in: _ids }
 
-                        arrayObj.find(query).skip(index).limit(limit).sort(sort).toArray(function (error, result) {
-                            if (error)
-                                errorHandler(data, error, database, array)
+                            }
+
+                            try {
+                                const cursor = arrayObj.find(query).sort(sort).skip(index).limit(limit);
+                                while (await cursor.hasNext()) {
+                                    const document = await cursor.next();
 
-                            if (result) {
-                                // TODO: forEach at cursor
-                                for (let doc of result) {
-                                    let isMatch = true
-                                    if (data.filter && data.filter['search'])
-                                        isMatch = searchData(doc, data.filter['search'])
-                                    if (isMatch) {
-                                        doc.storage = 'mongodb'
-                                        doc.database = database
-                                        doc.array = array
-                                        doc._id = doc._id.toString()
-
-                                        if (data.returnObject == false) {
-                                            let tempDoc = {};
-                                            let docs = new Map(data[type].map((obj) => [obj._id, obj]));
-                                            let doc1 = docs.get(doc._id)
-                                            if (doc1) {
-                                                tempDoc._id = tempDoc
-                                                for (let key of Object.keys(doc1)) {
-                                                    tempDoc[key] = doc[key]
-                                                }
-                                                doc = tempDoc
+                                    if (data.filter && data.filter.search) {
+                                        let isMatch = searchData(document, data.filter.search)
+                                        if (!isMatch)
+                                            continue;
+                                    }
+
+                                    document.storage = 'mongodb'
+                                    document.database = database
+                                    document.array = array
+                                    document._id = document._id.toString()
+
+                                    if (data.returnObject == false) {
+                                        let tempDoc = {};
+                                        let docs = new Map(data[type].map((obj) => [obj._id, obj]));
+                                        let doc1 = docs.get(document._id)
+                                        if (doc1) {
+                                            tempDoc._id = tempDoc
+                                            for (let key of Object.keys(doc1)) {
+                                                tempDoc[key] = document[key]
                                             }
+                                            document = tempDoc
                                         }
-
-                                        documents.push(doc)
                                     }
-                                }
 
-                                // if (index && limit) {
-                                //     documents = documents.slice(index, limit)
-                                // }
+                                    documents.push(document)
+                                }
+                            } catch (error) {
+                                errorHandler(data, error, database, array)
                             }
 
                             arraysLength -= 1
@@ -433,121 +394,111 @@ function object(action, data) {
                                 data = createData(data, documents, type)
                                 resolve(data)
                             }
-                        });
-                    }
+                        } else if (action == 'updateObject') {
 
-                    if (action == 'updateObject' || action == 'deleteObject') {
-                        const queryDocs = () => {
-                            return new Promise(async (resolve, reject) => {
+                            if (!data[type].length) {
+                                arraysLength -= 1
 
-                                arrayObj.find(query).sort(sort).toArray(function (error, result) {
-                                    if (error)
-                                        errorHandler(data, error, database, array)
+                                if (!arraysLength)
+                                    databasesLength -= 1
 
-                                    if (data.filter && data.filter.search) {
-                                        let searchResult = []
+                                if (!databasesLength && !arraysLength) {
+                                    data = createData(data, documents, type)
+                                    resolve(data)
+                                }
+                            }
 
-                                        for (let doc of result) {
-                                            let isMatch = searchData(doc, data.filter.search)
-                                            if (isMatch)
-                                                searchResult.push(doc)
+                            let docsLength = data[type].length
+                            for (let i = 0; i < data[type].length; i++) {
+                                if (data[type][i]._id)
+                                    query['_id'] = ObjectId(data[type][i]._id)
+
+                                data[type][i] = replaceArray(data[type][i])
+                                let { update, projection } = createUpdate(data, type, i)
+
+                                if (query['_id']) {
+                                    arrayObj.updateOne(query, update, {
+                                        upsert: data.upsert,
+                                        projection
+                                    }).then((result) => {
+                                        documents.push({ _id: query['_id'].toString(), storage: data.storageName, database, array, ...update['$set'] })
+                                    }).catch((error) => {
+                                        errorHandler(data, error, database, array)
+                                        console.log(action, 'error', error);
+                                    }).finally(() => {
+                                        docsLength -= 1
+                                        if (!docsLength)
+                                            arraysLength -= 1
+
+                                        if (!arraysLength)
+                                            databasesLength -= 1
+
+                                        if (!databasesLength && !arraysLength) {
+                                            data = createData(data, documents, type)
+                                            resolve(data)
+                                        }
+                                    })
+                                } else if (update && isFilter) {
+                                    const cursor = arrayObj.find(query).sort(sort).skip(index).limit(limit);
+                                    while (await cursor.hasNext()) {
+                                        const document = await cursor.next();
+
+                                        if (data.filter && data.filter.search) {
+                                            let isMatch = searchData(document, data.filter.search)
+                                            if (!isMatch)
+                                                continue;
                                         }
-                                        result = searchResult
-                                    }
-                                    resolve(result)
-                                })
-                            }, (err) => {
-                                console.log(err);
-                            });
-                        }
-
-                        let Result, $update, update, projection;
-
-                        if (isFilter && data.returnObject != false)
-                            if (action == 'deleteObject' || action == 'updateObject' && updateData.update)
-                                Result = await queryDocs()
-
-                        if (Result) {
-                            for (let doc of Result) {
-                                if (action == 'deleteObject')
-                                    documents.push({ _id: doc._id, storage: data.storageName, database, array })
-                                else
-                                    doc['modified'] = { on: data.timeStamp, by: data.user_id || data.clientId }
-
-                                _ids.push(doc._id)
-                            }
-                            update_ids.push({ updateType: 'filter' })
-                        }
 
-                        if (action == 'updateObject') {
-                            let docsLength = update_ids.length
-                            for (let { updateDoc, updateType } of update_ids) {
-
-                                if (updateType == '_id') {
-                                    let update_id = updateDoc._id
-                                    query['_id'] = ObjectId(update_id)
-                                    $update = createUpdate({ object: [updateDoc] }, type)
-                                    update = $update.update
-                                    projection = $update.projection
-                                    documents.push({ _id: update_id, storage: data.storageName, database, array, ...update['$set'] })
+                                        arrayObj.updateOne({ _id: document._id }, update, {
+                                            upsert: data.upsert,
+                                            projection
+                                        }).then((result) => {
+                                            if (data.returnObject != false)
+                                                documents.push({ _id: document._id, storage: data.storageName, database, array, ...update['$set'] })
+                                        }).catch((error) => {
+                                            errorHandler(data, error, database, array)
+                                            console.log(action, 'error', error);
+                                        })
+                                    }
                                 }
+                            }
+                        } else if (action == 'deleteObject') {
+                            if (isFilter && data.returnObject != false) {
+                                const cursor = arrayObj.find(query).sort(sort).skip(index).limit(limit);
+                                while (await cursor.hasNext()) {
+                                    const document = await cursor.next();
 
-                                if (updateType == 'filter') {
-                                    query['_id'] = { $in: _ids }
-                                    $update = updateData
-                                    update = $update.update
-                                    projection = $update.projection
-                                    for (let _id of _ids)
-                                        documents.push({ _id, storage: data.storageName, database, array, ...update['$set'] })
+                                    if (data.filter && data.filter.search) {
+                                        let isMatch = searchData(document, data.filter.search)
+                                        if (!isMatch)
+                                            continue;
+                                    }
 
+                                    arrayObj.deleteOne({
+                                        _id: document._id
+                                    }).then((result) => {
+                                        documents.push({ _id: document._id, storage: data.storageName, database, array })
+                                    }).catch((error) => {
+                                        errorHandler(data, error, database, array)
+                                        console.log(action, 'error', error);
+                                    });
                                 }
 
-                                update['$set']['organization_id'] = data.organization_id
-
-                                arrayObj.updateMany(query, update, {
-                                    upsert: data.upsert,
-                                    projection
-                                }).then((result) => {
-
-                                }).catch((error) => {
-                                    errorHandler(data, error, database, array)
-                                    console.log(action, 'error', error);
-                                }).finally((error) => {
-                                    docsLength -= 1
-                                    if (!docsLength)
-                                        arraysLength -= 1
-
-                                    if (!arraysLength)
-                                        databasesLength -= 1
-
-                                    if (!databasesLength && !arraysLength) {
-                                        data = createData(data, documents, type)
-                                        resolve(data)
-                                    }
-                                })
                             }
 
-                            if (!update_ids.length) {
-                                docsLength -= 1
-                                if (!docsLength)
-                                    arraysLength -= 1
-
-                                if (!arraysLength)
-                                    databasesLength -= 1
-
-                                if (!databasesLength && !arraysLength) {
-                                    data = createData(data, documents, type)
-                                    resolve(data)
+                            let _ids = [];
+                            for (let i = 0; i < data[type].length; i++) {
+                                if (data[type][i]._id) {
+                                    _ids.push(ObjectId(data[type][i]._id))
+                                    documents.push({ _id: data[type][i]._id, storage: data.storageName, database, array })
                                 }
                             }
 
-                        }
-
-                        if (action == 'deleteObject') {
                             if (_ids.length == 1)
-                                query['_id'] = ObjectId(_ids[0])
-                            else if (_ids.length > 0)
+                                query['_id'] = _ids[0]
+                            else if (_ids.length)
                                 query['_id'] = { $in: _ids }
+
                             arrayObj.deleteMany(query, function (error, result) {
                                 arraysLength -= 1
                                 if (!arraysLength)
@@ -560,7 +511,6 @@ function object(action, data) {
 
                             })
                         }
-
                     }
 
                 }
@@ -577,29 +527,81 @@ function object(action, data) {
 
 }
 
-function createUpdate(data, type) {
+function createUpdate(data, type, index) {
     let update = {}, projection = {};
-    if (data[type][0]) {
-        update['$set'] = data[type][0]
-        // update['$set']['organization_id'] = data['organization_id'];
+    if (data[type][index]) {
+        update['$set'] = data[type][index]
+        update['$set']['modified'] = { on: data.timeStamp, by: data.user_id || data.clientId }
+        update['$set']['organization_id'] = data.organization_id
+
         if (update['$set']['_id'])
             delete update['$set']['_id']
+
         Object.keys(update['$set']).forEach(key => {
+            if (key.includes('$rename') || key.includes('$update')) {
 
-            if (key.includes('[u]')) {
-                update['$addToSet'] = { [key.replace('[u]', '')]: update['$set'][key] }
+            } else if (key.includes('$delete')) {
+
+            } else if (key.includes('$inc')) {
+                update['$inc'] = update['$set'][key]
                 delete update['$set'][key]
-            } else if (key.includes('[]')) {
-                if (!Array.isArray(update['$set'][key]))
-                    update['$set'][key] = [update['$set'][key]]
+            } else if (key.endsWith(']')) {
+                // Use a regular expression to extract the key and index (including a potentially undefined or keyword index)
+                const regex = /^(.*(?:\[\d+\].*?)?)\[(.*?)\](?:\[\])?$/;
+                const match = inputString.match(regex);
+                const index = parseInt(match[2], 10);
+
+                if (index && index !== -1 && index !== 1 && update['$set'][key] === '$delete') {
+                    match[1] = replaceArray({ [update['$set'][key]]: update['$set'][key] });
+                    match[1] = Object.keys(match[1])[0]
+
+                    if (!update['$unset'])
+                        update['$unset'] = {}
+
+                    update.$unset[match[1]] = 1;
+
+                    if (!update['$pull'])
+                        update['$pull'] = {}
+
+                    update.$pull[match[1]] = null;
+                } else {
+                    match[1] = replaceArray({ [match[1]]: update['$set'][key] });
+                    match[1] = Object.keys(match[1])[0]
+
+                    if (update['$set'][key] === '$pop' || update['$set'][key] === '$delete') {
+                        if (!update['$pop'])
+                            update['$pop'] = {}
+
+                        update.$pop[match[1]] = index || 1
+                    } else if (match[2] === '$addToSet') {
+                        if (!update['$addToSet'])
+                            update['$addToSet'] = {}
+
+                        update.$addToSet[match[1]] = update['$set'][key]
+                    } else if (match[2] === '$pull') {
+                        if (!update['$pull'])
+                            update['$pull'] = {}
+
+                        update.$pull[match[1]] = update['$set'][key]
+                    } else {
+                        if (!Array.isArray(update['$set'][key]))
+                            update['$set'][key] = [update['$set'][key]]
+
+                        let insert = { $each: update['$set'][key] }
+                        if (index)
+                            insert.$postion = match[2]
+
+                        if (!update['$push'])
+                            update['$push'] = {}
+
+                        update.$push[match[1]] = insert
 
-                update['$push'] = {
-                    [key.replace('[]', '')]: { $each: update['$set'][key] }
+                    }
                 }
+
                 delete update['$set'][key]
+
             }
-            // { $push: { "skills": { $each: ["Sports", "Acting"] } } })
-            // { $addToSet: { "skills": "GST" } }) // adds "GST"to all arrays if not exist
             projection[key] = 1
         })
     }
@@ -645,42 +647,51 @@ function createData(data, array, type) {
     return data
 }
 
-function getFilters(data) {
-    let query = {}, sort = {}
-    let filter = {
-        query: [],
-        sort: [],
-        search: {
-            value: [],
-            type: "or"
-        },
-        index: 0,
-        ...data.filter
-    };
-
-    query = createQuery(filter.query);
-
-
-    if (filter.sort) {
-        for (let i = 0; i < filter.sort.length; i++) {
-            let direction = filter.sort[i].direction
-            if (direction == 'desc' || direction == -1)
-                direction = -1;
-            else
-                direction = 1;
+async function getFilters(data, arrayObj) {
+    let query =
+        {}, sort = {}, index = 0, limit = 0, count
+    if (data.filter) {
+
+        if (data.filter.query)
+            query = createQuery(data.filter.query);
+
+
+        if (data.filter.sort) {
+            for (let i = 0; i < data.filter.sort.length; i++) {
+                let direction = data.filter.sort[i].direction
+                if (direction == 'desc' || direction == -1)
+                    direction = -1;
+                else
+                    direction = 1;
 
-            sort[filter.sort[i].key] = filter.sort[i].direction
+                sort[data.filter.sort[i].key] = direction
+            }
+        }
+
+        if (arrayObj) {
+            count = await arrayObj.estimatedDocumentCount()
+            data.filter.count = count
         }
+
+        if (data.filter.index)
+            index = data.filter.index
+        if (data.filter.limit)
+            limit = data.filter.limit
+        if (limit)
+            limit = index + limit;
     }
-    return { query, sort }
+
+    if (data['organization_id'])
+        query['organization_id'] = { $eq: data['organization_id'] }
+
+    return { query, sort, index, limit, count }
 }
 
-// TODO: create impved mongodb query to cover many cases
-function createQuery(filters) {
+// TODO: improve mongodb query to cover many cases
+function createQuery(queries) {
     let query = new Object();
 
-
-    for (let item of filters) {
+    for (let item of queries) {
 
         if (!item.key)
             continue

package/webpack.config.js

@@ -1,90 +0,0 @@
-const path = require("path")
-const TerserPlugin = require("terser-webpack-plugin")
-const MiniCssExtractPlugin = require("mini-css-extract-plugin")
-const { CleanWebpackPlugin } = require("clean-webpack-plugin")
-
-module.exports = (env, argv) => {
-    let isProduction = false
-    if (argv.mode === 'production')
-        isProduction = true
-
-    const config = {
-        entry: {
-            "CoCreate-mongodb": "./src/index.js",
-        },
-        output: {
-            path: path.resolve(__dirname, "dist"),
-            filename: isProduction ? "[name].min.js" : "[name].js",
-            libraryTarget: "umd",
-            libraryExport: "default",
-            library: ["CoCreate", "mongodb"],
-            globalObject: "this",
-        },
-
-        plugins: [
-            new CleanWebpackPlugin(),
-            new MiniCssExtractPlugin({
-                filename: "[name].css",
-            }),
-        ],
-        // Default mode for Webpack is production.
-        // Depending on mode Webpack will apply different things
-        // on final bundle. For now we don't need production's JavaScript
-        // minifying and other thing so let's set mode to development
-        mode: isProduction ? "production" : "development",
-        module: {
-            rules: [
-                {
-                    test: /.js$/,
-                    exclude: /(node_modules)/,
-                    use: {
-                        loader: "babel-loader",
-                        options: {
-                            plugins: ["@babel/plugin-transform-modules-commonjs"],
-                        },
-                    },
-                },
-                {
-                    test: /.css$/i,
-                    use: [
-                        { loader: "style-loader", options: { injectType: "linkTag" } },
-                        "file-loader",
-                    ],
-                },
-            ],
-        },
-
-        // add source map
-        ...(isProduction ? {} : { devtool: "eval-source-map" }),
-
-        optimization: {
-            minimize: true,
-            minimizer: [
-                new TerserPlugin({
-                    extractComments: true,
-                    // cache: true,
-                    parallel: true,
-                    // sourceMap: true, // Must be set to true if using source-maps in production
-                    terserOptions: {
-                        // https://github.com/webpack-contrib/terser-webpack-plugin#terseroptions
-                        // extractComments: 'all',
-                        compress: {
-                            drop_console: true,
-                        },
-                    },
-                }),
-            ],
-            splitChunks: {
-                chunks: "all",
-                minSize: 200,
-                // maxSize: 99999,
-                //minChunks: 1,
-
-                cacheGroups: {
-                    defaultVendors: false,
-                },
-            },
-        },
-    }
-    return config
-}