@orion-js/mongodb 3.1.1 → 3.1.10

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Orionjs Team
+Copyright (c) 2022 Orionjs Team
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/lib/connect/getMongoURLFromEnv.js

@@ -2,17 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMongoURLFromEnv = void 0;
 const connections_1 = require("./connections");
+const helpers_1 = require("@orion-js/helpers");
 const getMongoURLFromEnv = (connectionName) => {
     if (connectionName === 'main') {
-        if (!process.env.MONGO_URL) {
+        if (!(0, helpers_1.internalGetEnv)('mongo_url', 'MONGO_URL')) {
             throw new Error('MONGO_URL is required');
         }
-        return process.env.MONGO_URL;
+        return (0, helpers_1.internalGetEnv)('mongo_url', 'MONGO_URL');
     }
-    const name = `MONGO_URL_${connectionName.toUpperCase()}`;
-    const uri = connections_1.connections[connectionName]?.uri ?? process.env[name];
+    const envName = `mongo_url_${connectionName.toLowerCase()}`;
+    const processEnvName = `MONGO_URL_${connectionName.toUpperCase()}`;
+    const uri = connections_1.connections[connectionName]?.uri ?? (0, helpers_1.internalGetEnv)(envName, processEnvName);
     if (!uri) {
-        throw new Error(`To use the connection "${connectionName}" you must initialize it first calling getMongoConnection({name: "${connectionName}", uri: "MONGOURI"}) or setting the environment variable ${name}.`);
+        throw new Error(`To use the connection "${connectionName}" you must initialize it first calling getMongoConnection({name: "${connectionName}", uri: "MONGOURI"}) or setting the environment variable ${processEnvName}.`);
     }
     return uri;
 };

package/lib/createCollection/getMethods/insertMany.js

@@ -7,6 +7,7 @@ const isPlainObject_1 = __importDefault(require("lodash/isPlainObject"));
 const lodash_1 = require("lodash");
 const fromDot_1 = __importDefault(require("../../helpers/fromDot"));
 const schema_1 = require("@orion-js/schema");
+const wrapErrors_1 = require("./wrapErrors");
 exports.default = (collection) => {
     const insertMany = async (docs, options = {}) => {
         for (let index = 0; index < docs.length; index++) {
@@ -24,7 +25,9 @@ exports.default = (collection) => {
             }
             docs[index] = doc;
         }
-        const { insertedIds } = await collection.rawCollection.insertMany(docs, options.mongoOptions);
+        const { insertedIds } = await (0, wrapErrors_1.wrapErrors)(() => {
+            return collection.rawCollection.insertMany(docs, options.mongoOptions);
+        });
         const ids = (0, lodash_1.values)(insertedIds);
         return ids.map(id => id.toString());
     };

package/lib/createCollection/getMethods/insertOne.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const isPlainObject_1 = __importDefault(require("lodash/isPlainObject"));
 const fromDot_1 = __importDefault(require("../../helpers/fromDot"));
 const schema_1 = require("@orion-js/schema");
+const wrapErrors_1 = require("./wrapErrors");
 exports.default = (collection) => {
     const insertOne = async (insertDoc, options) => {
         let doc = insertDoc;
@@ -20,7 +21,9 @@ exports.default = (collection) => {
             doc = await (0, schema_1.clean)(schema, (0, fromDot_1.default)(doc));
             await (0, schema_1.validate)(schema, doc);
         }
-        await collection.rawCollection.insertOne(doc);
+        await (0, wrapErrors_1.wrapErrors)(async () => {
+            await collection.rawCollection.insertOne(doc);
+        });
         return doc._id;
     };
     return insertOne;

package/lib/createCollection/getMethods/insertOne.test.js

@@ -7,70 +7,104 @@ const insertOne_1 = __importDefault(require("./insertOne"));
 const helpers_1 = require("@orion-js/helpers");
 const __1 = __importDefault(require(".."));
 const models_1 = require("@orion-js/models");
-it('should return a function', async () => {
-    const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)() });
-    const insertOne = (0, insertOne_1.default)(Tests);
-    expect(typeof insertOne).toBe('function');
-});
-it('insertOnes a document without errors', async () => {
-    const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)() });
-    await Tests.insertOne({ hello: 'world' });
-    const count = await Tests.find({}).count();
-    expect(count).toBe(1);
-});
-it('should insertOne documents passing deep validation', async () => {
-    const wife = {
-        name: { type: String }
-    };
-    const schema = {
-        wife: { type: wife }
-    };
-    const model = (0, models_1.createModel)({ name: (0, helpers_1.generateId)(), schema });
-    const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)(), model });
-    await Tests.insertOne({ 'wife.name': 'Francisca' });
-});
-it('should clean a document before insertOneing', async () => {
-    const now = new Date();
-    const schema = {
-        name: { type: String },
-        createdAt: { type: Date, autoValue: () => now }
-    };
-    const model = (0, models_1.createModel)({ name: (0, helpers_1.generateId)(), schema });
-    const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)(), model });
-    const docId = await Tests.insertOne({ name: 1234 });
-    const result = await Tests.findOne(docId);
-    expect(result.name).toBe('1234');
-    expect(result.createdAt).toEqual(now);
-});
-it('should validate a document', async () => {
-    const schema = { name: { type: String } };
-    const model = (0, models_1.createModel)({ name: (0, helpers_1.generateId)(), schema });
-    const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)(), model });
-    expect.assertions(1);
-    try {
-        await Tests.insertOne({});
-    }
-    catch (error) {
-        expect(error.code).toBe('validationError');
-    }
-});
-it('Should be able to use custom clean for models', async () => {
-    const model = (0, models_1.createModel)({
-        name: 'File',
-        schema: {
+describe('InsertOne', () => {
+    it('should return a function', async () => {
+        const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)() });
+        const insertOne = (0, insertOne_1.default)(Tests);
+        expect(typeof insertOne).toBe('function');
+    });
+    it('insertOnes a document without errors', async () => {
+        const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)() });
+        await Tests.insertOne({ hello: 'world' });
+        const count = await Tests.find({}).count();
+        expect(count).toBe(1);
+    });
+    it('should insertOne documents passing deep validation', async () => {
+        const wife = {
             name: { type: String }
-        },
-        async clean(value) {
-            if (!value)
-                return null;
-            return {
-                ...value,
-                name: value.name.toUpperCase() + value._id
-            };
+        };
+        const schema = {
+            wife: { type: wife }
+        };
+        const model = (0, models_1.createModel)({ name: (0, helpers_1.generateId)(), schema });
+        const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)(), model });
+        await Tests.insertOne({ 'wife.name': 'Francisca' });
+    });
+    it('should clean a document before insertOneing', async () => {
+        const now = new Date();
+        const schema = {
+            name: { type: String },
+            createdAt: { type: Date, autoValue: () => now }
+        };
+        const model = (0, models_1.createModel)({ name: (0, helpers_1.generateId)(), schema });
+        const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)(), model });
+        const docId = await Tests.insertOne({ name: 1234 });
+        const result = await Tests.findOne(docId);
+        expect(result.name).toBe('1234');
+        expect(result.createdAt).toEqual(now);
+    });
+    it('should validate a document', async () => {
+        const schema = { name: { type: String } };
+        const model = (0, models_1.createModel)({ name: (0, helpers_1.generateId)(), schema });
+        const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)(), model });
+        expect.assertions(1);
+        try {
+            await Tests.insertOne({});
+        }
+        catch (error) {
+            expect(error.code).toBe('validationError');
+        }
+    });
+    it('Should be able to use custom clean for models', async () => {
+        const model = (0, models_1.createModel)({
+            name: 'File',
+            schema: {
+                name: { type: String }
+            },
+            async clean(value) {
+                if (!value)
+                    return null;
+                return {
+                    ...value,
+                    name: value.name.toUpperCase() + value._id
+                };
+            }
+        });
+        const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)(), model });
+        const docId = await Tests.insertOne({ name: 'hello' });
+        const result = await Tests.findOne(docId);
+        expect(result.name).toBe('HELLO' + docId);
+    });
+    it('should throw unique index errors', async () => {
+        const Tests = (0, __1.default)({
+            name: (0, helpers_1.generateId)(),
+            indexes: [
+                {
+                    keys: {
+                        name: 1
+                    },
+                    options: {
+                        unique: true
+                    }
+                }
+            ]
+        });
+        await Tests.createIndexesPromise;
+        await Tests.insertOne({ name: 'one' });
+        expect.assertions(3);
+        try {
+            await Tests.insertOne({ name: 'one' });
+        }
+        catch (error) {
+            expect(error.code).toBe('validationError');
+            expect(error.validationErrors).toHaveProperty('unknownKey');
+            expect(error.validationErrors.unknownKey).toBe('notUnique');
+            /**
+             * This should work on a real db, but on memory-server it doesnt give the name of the index.
+             */
+            // expect(error.code).toBe('validationError')
+            // expect(error.validationErrors).toHaveProperty('name')
+            // expect(error.validationErrors.name).toBe('notUnique')
         }
     });
-    const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)(), model });
-    const docId = await Tests.insertOne({ name: 'hello' });
-    const result = await Tests.findOne(docId);
-    expect(result.name).toBe('HELLO' + docId);
 });

package/lib/createCollection/getMethods/updateAndFind.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const wrapErrors_1 = require("./wrapErrors");
 exports.default = (collection) => {
     const updateAndFind = async function (selector, modifier, options = {}) {
-        return collection.findOneAndUpdate(selector, modifier, {
-            ...options,
-            mongoOptions: {
-                ...options.mongoOptions,
-                returnDocument: 'after'
-            }
+        return await (0, wrapErrors_1.wrapErrors)(async () => {
+            return await collection.findOneAndUpdate(selector, modifier, {
+                ...options,
+                mongoOptions: {
+                    ...options.mongoOptions,
+                    returnDocument: 'after'
+                }
+            });
         });
     };
     return updateAndFind;

package/lib/createCollection/getMethods/updateItem.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const wrapErrors_1 = require("./wrapErrors");
 exports.default = (collection) => {
     const updateItem = async function (item, modifier) {
-        const updated = await collection.updateAndFind({ _id: item._id }, modifier);
+        const updated = await (0, wrapErrors_1.wrapErrors)(async () => {
+            return await collection.updateAndFind({ _id: item._id }, modifier);
+        });
         for (const key in item) {
             delete item[key];
         }

package/lib/createCollection/getMethods/updateMany.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const getSelector_1 = __importDefault(require("./getSelector"));
 const cleanModifier_1 = __importDefault(require("./cleanModifier"));
 const validateModifier_1 = __importDefault(require("./validateModifier"));
+const wrapErrors_1 = require("./wrapErrors");
 exports.default = (collection) => {
     const updateMany = async function (selectorArg, modifierArg, options = {}) {
         let modifier = modifierArg;
@@ -19,7 +20,9 @@ exports.default = (collection) => {
             if (options.validate !== false)
                 await (0, validateModifier_1.default)(schema, modifier);
         }
-        const result = await collection.rawCollection.updateMany(selector, modifier);
+        const result = await (0, wrapErrors_1.wrapErrors)(() => {
+            return collection.rawCollection.updateMany(selector, modifier);
+        });
         return result;
     };
     return updateMany;

package/lib/createCollection/getMethods/updateOne.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const getSelector_1 = __importDefault(require("./getSelector"));
 const cleanModifier_1 = __importDefault(require("./cleanModifier"));
 const validateModifier_1 = __importDefault(require("./validateModifier"));
+const wrapErrors_1 = require("./wrapErrors");
 exports.default = (collection) => {
     const updateOne = async function (selectorArg, modifierArg, options = {}) {
         let modifier = modifierArg;
@@ -19,7 +20,9 @@ exports.default = (collection) => {
             if (options.validate !== false)
                 await (0, validateModifier_1.default)(schema, modifier);
         }
-        const result = await collection.rawCollection.updateOne(selector, modifier);
+        const result = await (0, wrapErrors_1.wrapErrors)(() => {
+            return collection.rawCollection.updateOne(selector, modifier);
+        });
         return result;
     };
     return updateOne;

package/lib/createCollection/getMethods/upsert.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const getSelector_1 = __importDefault(require("./getSelector"));
 const validateUpsert_1 = __importDefault(require("./validateModifier/validateUpsert"));
 const cleanModifier_1 = __importDefault(require("./cleanModifier"));
+const wrapErrors_1 = require("./wrapErrors");
 exports.default = (collection) => {
     const upsert = async function (selectorArg, modifierArg, options = {}) {
         let modifier = modifierArg;
@@ -20,7 +21,9 @@ exports.default = (collection) => {
             if (options.validate !== false)
                 await (0, validateUpsert_1.default)(schema, selector, modifier);
         }
-        const result = await collection.rawCollection.updateOne(selector, modifier, { upsert: true });
+        const result = await (0, wrapErrors_1.wrapErrors)(() => {
+            return collection.rawCollection.updateOne(selector, modifier, { upsert: true });
+        });
         return result;
     };
     return upsert;

package/lib/createCollection/getMethods/wrapErrors.d.ts

@@ -0,0 +1 @@
+export declare const wrapErrors: <TFunc extends Function>(operation: TFunc) => Promise<any>;

package/lib/createCollection/getMethods/wrapErrors.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapErrors = void 0;
+const schema_1 = require("@orion-js/schema");
+const wrapErrors = async (operation) => {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        if (error.code === 11000) {
+            const regex = /index: (?:.*\.)?\$?(?:([_a-z0-9]*)(?:_\d*)|([_a-z0-9]*))\s*dup key/i;
+            const match = error.message.match(regex);
+            if (!match) {
+                throw new schema_1.ValidationError({
+                    unknownKey: 'notUnique'
+                });
+            }
+            const indexNameText = match[1] || match[2];
+            const names = indexNameText.split(/_[_a-z0-9]_/);
+            const errors = {};
+            for (const name of names) {
+                errors[name] = 'notUnique';
+            }
+            throw new schema_1.ValidationError(errors);
+        }
+        throw error;
+    }
+};
+exports.wrapErrors = wrapErrors;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/mongodb",
-  "version": "3.1.1",
+  "version": "3.1.10",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
@@ -17,11 +17,11 @@
     "upgrade-interactive": "yarn upgrade-interactive"
   },
   "dependencies": {
-    "@orion-js/helpers": "^3.1.1",
-    "@orion-js/models": "^3.1.1",
-    "@orion-js/resolvers": "^3.1.1",
-    "@orion-js/schema": "^3.1.1",
-    "@orion-js/typed-model": "^3.1.1",
+    "@orion-js/helpers": "^3.1.10",
+    "@orion-js/models": "^3.1.10",
+    "@orion-js/resolvers": "^3.1.10",
+    "@orion-js/schema": "^3.1.6",
+    "@orion-js/typed-model": "^3.1.10",
     "dataloader": "2.0.0",
     "dot-object": "2.1.4",
     "mongodb": "4.1.4"
@@ -38,5 +38,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "776fc314f67ab21707912ebeadc9ed8b525cbaee"
+  "gitHead": "40fa0800303f49ad08890b2bedff2cdadb81360d"
 }