@orion-js/mongodb 3.12.0 → 3.13.1

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

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("@orion-js/helpers");
+const models_1 = require("@orion-js/models");
+const __1 = __importDefault(require(".."));
+it('updates a document if exists', async () => {
+    const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)() });
+    const docId = await Tests.insertOne({ hello: 'world' });
+    const { modifiedCount, upsertedId } = await Tests.upsert({ hello: 'world' }, { $set: { hello: 'country' } });
+    expect(modifiedCount).toBe(1);
+    expect(upsertedId).toBeNull();
+    const final = await Tests.findOne(docId);
+    expect(final.hello).toBe('country');
+});
+it('inserts a document if it does not exists', async () => {
+    const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)() });
+    const { modifiedCount, upsertedId } = await Tests.upsert({ hello: 'world' }, { $set: { hello: 'country' } });
+    expect(modifiedCount).toBe(0);
+    expect(typeof upsertedId).toBe('string');
+    const final = await Tests.findOne({});
+    expect(final.hello).toBe('country');
+});
+it('adds default value when creating docs', async () => {
+    const now = new Date();
+    let calls = 0;
+    const schema = {
+        firstName: {
+            type: String,
+            defaultValue: () => 'Nicolás'
+        },
+        lastName: {
+            type: String
+        },
+        createdAt: {
+            type: Date,
+            defaultValue: () => {
+                calls++;
+                return 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 { modifiedCount, upsertedId } = await Tests.upsert({ firstName: 'Bastian' }, { $set: { lastName: 'Ermann' } });
+    expect(modifiedCount).toBe(0);
+    expect(calls).toBe(1);
+    expect(typeof upsertedId).toBe('string');
+    const final = await Tests.findOne({});
+    expect(final).toEqual({
+        _id: upsertedId,
+        firstName: 'Nicolás',
+        lastName: 'Ermann',
+        createdAt: now
+    });
+});
+it('should upsert documents passing cleaning validation', async () => {
+    const person = {
+        name: { type: String },
+        state: { type: String, optional: true }
+    };
+    const schema = {
+        _id: { type: 'ID' },
+        name: { type: String },
+        label: { type: String },
+        wife: { type: person },
+        friends: { type: [person] }
+    };
+    const model = (0, models_1.createModel)({ name: (0, helpers_1.generateId)(), schema });
+    const Tests = (0, __1.default)({
+        name: (0, helpers_1.generateId)(),
+        model
+    });
+    const { upsertedId } = await Tests.upsert({ name: 'Nicolás', label: 1234 }, {
+        $set: { 'wife.state': 'Hungry', 'wife.name': 'Francisca' },
+        $push: { friends: { name: 'Joaquín' } }
+    });
+    await Tests.updateOne(upsertedId, { $set: { 'wife.state': 'Full' } });
+    const doc = await Tests.findOne(upsertedId);
+    expect(doc).toEqual({
+        _id: upsertedId,
+        name: 'Nicolás',
+        label: '1234',
+        wife: { state: 'Full', name: 'Francisca' },
+        friends: [{ name: 'Joaquín' }]
+    });
+});

package/lib/createCollection/getMethods/validateModifier/index.d.ts

@@ -0,0 +1 @@
+export default function validateModifier(schema: any, modifier: any): Promise<void>;

package/lib/createCollection/getMethods/validateModifier/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// inspired by https://github.com/aldeed/simple-schema-js
+const validateOperator_1 = __importDefault(require("./validateOperator"));
+async function validateModifier(schema, modifier) {
+    for (const operation of Object.keys(modifier)) {
+        const operationDoc = modifier[operation];
+        // If non-operators are mixed in, throw error
+        if (operation.slice(0, 1) !== '$') {
+            throw new Error(`Expected '${operation}' to be a modifier operator like '$set'`);
+        }
+        await (0, validateOperator_1.default)({ schema, operationDoc, operation });
+    }
+}
+exports.default = validateModifier;

package/lib/createCollection/getMethods/validateModifier/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/createCollection/getMethods/validateModifier/index.test.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+it('should pass validation when not all fields are present', async () => {
+    const wife = {
+        name: { type: String },
+        state: { type: String }
+    };
+    const schema = {
+        wife: { type: wife }
+    };
+    await (0, index_1.default)(schema, { $set: { 'wife.state': 'Full' } });
+});
+it('should throw an error when a not present field is passed', async () => {
+    const wife = {
+        name: { type: String },
+        state: { type: String }
+    };
+    const schema = {
+        wife: { type: wife }
+    };
+    expect.assertions(1);
+    try {
+        await (0, index_1.default)(schema, { $set: { 'mom.name': 'Paula' } });
+    }
+    catch (error) {
+        expect(error.code).toBe('validationError');
+    }
+});
+it('validate arrays', async () => {
+    const friend = {
+        name: { type: String }
+    };
+    const schema = {
+        friends: { type: [friend] }
+    };
+    await (0, index_1.default)(schema, { $set: { 'friends.0.name': 'Roberto' } });
+    await (0, index_1.default)(schema, { $set: { friends: [{ name: 'Roberto' }] } });
+    expect.assertions(1);
+    try {
+        await (0, index_1.default)(schema, { $set: { friends: ['Roberto'] } });
+    }
+    catch (error) {
+        expect(error.code).toBe('validationError');
+    }
+});
+it('validate $push operations', async () => {
+    const friend = {
+        name: { type: String }
+    };
+    const schema = {
+        friends: { type: [friend] }
+    };
+    await (0, index_1.default)(schema, { $push: { friends: { name: 'Roberto' } } });
+    await (0, index_1.default)(schema, {
+        $push: { friends: { $each: [{ name: 'Roberto' }, { name: 'Joaquín' }] } }
+    });
+    expect.assertions(1);
+    try {
+        await (0, index_1.default)(schema, { $set: { friends: ['Roberto'] } });
+    }
+    catch (error) {
+        expect(error.code).toBe('validationError');
+    }
+});
+it('validate $unset operations', async () => {
+    const schema = {
+        name: { type: String, optional: true }
+    };
+    await (0, index_1.default)(schema, { $unset: { name: '' } });
+});

package/lib/createCollection/getMethods/validateModifier/validateInc.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Validates $inc
+ */
+export default function ({ schema, operationDoc }: {
+    schema: any;
+    operationDoc: any;
+}): Promise<void>;

package/lib/createCollection/getMethods/validateModifier/validateInc.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@orion-js/schema");
+/**
+ * Validates $inc
+ */
+async function default_1({ schema, operationDoc }) {
+    const errors = {};
+    for (const key of Object.keys(operationDoc)) {
+        const value = operationDoc[key];
+        const error = await (0, schema_1.validateKey)(schema, key, value);
+        if (error) {
+            errors[key] = error;
+        }
+    }
+    if (Object.keys(errors).length) {
+        throw new schema_1.ValidationError(errors);
+    }
+}
+exports.default = default_1;

package/lib/createCollection/getMethods/validateModifier/validateInc.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/createCollection/getMethods/validateModifier/validateInc.test.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+it('should handle $inc correctly', async () => {
+    const schema = {
+        services: { type: 'blackbox' }
+    };
+    await (0, index_1.default)(schema, { $inc: { 'services.phoneVerification.tries': 1 } });
+});

package/lib/createCollection/getMethods/validateModifier/validateOperator.d.ts

@@ -0,0 +1,5 @@
+export default function ({ schema, operationDoc, operation }: {
+    schema: any;
+    operationDoc: any;
+    operation: any;
+}): Promise<void>;

package/lib/createCollection/getMethods/validateModifier/validateOperator.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const validatePush_1 = __importDefault(require("./validatePush"));
+const validateUnset_1 = __importDefault(require("./validateUnset"));
+const validateInc_1 = __importDefault(require("./validateInc"));
+const validateSet_1 = __importDefault(require("./validateSet"));
+const shouldCheck = function (key) {
+    if (key === '$pushAll')
+        throw new Error('$pushAll is not supported, use $push + $each');
+    return ['$pull', '$pullAll', '$pop', '$slice'].indexOf(key) === -1;
+};
+async function default_1({ schema, operationDoc, operation }) {
+    if (!shouldCheck(operation))
+        return;
+    if (operation === '$set') {
+        await (0, validateSet_1.default)({ schema, operationDoc });
+    }
+    else if (operation === '$unset') {
+        await (0, validateUnset_1.default)({ schema, operationDoc });
+    }
+    else if (operation === '$inc') {
+        await (0, validateInc_1.default)({ schema, operationDoc });
+    }
+    else if (operation === '$push' || operation === '$addToSet') {
+        await (0, validatePush_1.default)({ schema, operationDoc, operation });
+    }
+    else {
+        throw new Error(operation + ' operation is not supported yet');
+    }
+}
+exports.default = default_1;

package/lib/createCollection/getMethods/validateModifier/validatePush.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Validates $push and $addToSet
+ */
+export default function ({ schema, operationDoc, operation }: {
+    schema: any;
+    operationDoc: any;
+    operation: any;
+}): Promise<void>;

package/lib/createCollection/getMethods/validateModifier/validatePush.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@orion-js/schema");
+const fromDot_1 = __importDefault(require("../../../helpers/fromDot"));
+/**
+ * Validates $push and $addToSet
+ */
+async function default_1({ schema, operationDoc, operation }) {
+    for (const key of Object.keys(operationDoc)) {
+        const value = operationDoc[key];
+        let toValidate = null;
+        if (operation === '$push' || operation === '$addToSet') {
+            if (typeof value === 'object' && '$each' in value) {
+                toValidate = value.$each;
+            }
+            else {
+                toValidate = [value];
+            }
+        }
+        const validationObject = (0, fromDot_1.default)({ [key]: toValidate });
+        await (0, schema_1.validate)(schema, validationObject, { omitRequired: true });
+    }
+}
+exports.default = default_1;

package/lib/createCollection/getMethods/validateModifier/validatePush.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/createCollection/getMethods/validateModifier/validatePush.test.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const validateOperator_1 = __importDefault(require("./validateOperator"));
+it('validate $push operations', async () => {
+    const friend = {
+        name: { type: String }
+    };
+    const person = {
+        friends: { type: [friend] }
+    };
+    const schema = {
+        person: { type: person }
+    };
+    const operation = '$push';
+    await (0, validateOperator_1.default)({
+        schema,
+        operationDoc: { 'person.friends': { name: 'Roberto' } },
+        operation
+    });
+    expect.assertions(1);
+    try {
+        await (0, validateOperator_1.default)({
+            schema,
+            operationDoc: { friends: 'Roberto' },
+            operation
+        });
+    }
+    catch (error) {
+        expect(error.code).toBe('validationError');
+    }
+});
+it('validate $push operations with deep array', async () => {
+    const friend = {
+        name: { type: String }
+    };
+    const person = {
+        friends: { type: [friend] }
+    };
+    const schema = {
+        persons: { type: [person] }
+    };
+    const operation = '$push';
+    await (0, validateOperator_1.default)({
+        schema,
+        operationDoc: { 'persons.1.friends': { name: 'Roberto' } },
+        operation
+    });
+});
+it('validate $push with $each operations', async () => {
+    const friend = {
+        name: { type: String }
+    };
+    const schema = {
+        friends: { type: [friend] }
+    };
+    const operation = '$push';
+    await (0, validateOperator_1.default)({
+        schema,
+        operationDoc: { friends: { $each: [{ name: 'Roberto' }, { name: 'Joaquín' }] } },
+        operation
+    });
+    expect.assertions(1);
+    try {
+        await (0, validateOperator_1.default)({
+            schema,
+            operationDoc: { friends: { $each: [{ name: 'Joaquín' }, 'Roberto'] } },
+            operation
+        });
+    }
+    catch (error) {
+        expect(error.code).toBe('validationError');
+    }
+});
+it('validate $addToSet', async () => {
+    const friend = {
+        name: { type: String }
+    };
+    const schema = {
+        friends: { type: [friend] }
+    };
+    const operation = '$addToSet';
+    await (0, validateOperator_1.default)({
+        schema,
+        operationDoc: { friends: { $each: [{ name: 'Roberto' }, { name: 'Joaquín' }] } },
+        operation
+    });
+});

package/lib/createCollection/getMethods/validateModifier/validateSet.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Validates $set
+ */
+export default function ({ schema, operationDoc }: {
+    schema: any;
+    operationDoc: any;
+}): Promise<void>;

package/lib/createCollection/getMethods/validateModifier/validateSet.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@orion-js/schema");
+const mapKeys_1 = __importDefault(require("lodash/mapKeys"));
+const fromDot_1 = __importDefault(require("../../../helpers/fromDot"));
+const toDot_1 = __importDefault(require("../../../helpers/toDot"));
+/**
+ * Validates $set
+ */
+async function default_1({ schema, operationDoc }) {
+    let cleaned = (0, toDot_1.default)(operationDoc);
+    cleaned = (0, mapKeys_1.default)(cleaned, (value, key) => key.replace('$.', '0.'));
+    cleaned = (0, fromDot_1.default)(cleaned);
+    await (0, schema_1.validate)(schema, cleaned, { omitRequired: true });
+}
+exports.default = default_1;

package/lib/createCollection/getMethods/validateModifier/validateSet.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/createCollection/getMethods/validateModifier/validateSet.test.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+it('should handle $ correctly', async () => {
+    const Email = {
+        address: { type: String },
+        verified: { type: Boolean }
+    };
+    const schema = {
+        emails: { type: [Email] }
+    };
+    await (0, index_1.default)(schema, { $set: { 'emails.$.verified': true } });
+});

package/lib/createCollection/getMethods/validateModifier/validateUnset.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Validates $unset
+ */
+export default function ({ schema, operationDoc }: {
+    schema: any;
+    operationDoc: any;
+}): Promise<void>;

package/lib/createCollection/getMethods/validateModifier/validateUnset.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@orion-js/schema");
+/**
+ * Validates $unset
+ */
+async function default_1({ schema, operationDoc }) {
+    const errors = {};
+    for (const key of Object.keys(operationDoc)) {
+        const error = await (0, schema_1.validateKey)(schema, key, null);
+        if (error) {
+            errors[key] = error;
+        }
+    }
+    if (Object.keys(errors).length) {
+        throw new schema_1.ValidationError(errors);
+    }
+}
+exports.default = default_1;

package/lib/createCollection/getMethods/validateModifier/validateUnset.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/createCollection/getMethods/validateModifier/validateUnset.test.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+it('validate $unset operations', async () => {
+    const mom = {
+        name: { type: String, optional: true }
+    };
+    const schema = {
+        name: { type: String },
+        age: { type: String, optional: true },
+        mom: { type: mom }
+    };
+    await (0, index_1.default)(schema, {
+        $unset: {
+            age: ''
+        }
+    });
+    await (0, index_1.default)(schema, {
+        $unset: {
+            'mom.name': ''
+        }
+    });
+    expect.assertions(2);
+    try {
+        await (0, index_1.default)(schema, {
+            $unset: {
+                name: '',
+                age: ''
+            }
+        });
+    }
+    catch (error) {
+        expect(error.code).toBe('validationError');
+    }
+    try {
+        await (0, index_1.default)(schema, {
+            $unset: {
+                mom: ''
+            }
+        });
+    }
+    catch (error) {
+        expect(error.code).toBe('validationError');
+    }
+});
+it('should allow an $unset operation on a children of a required blackbox', async () => {
+    const schema = {
+        data: {
+            type: 'blackbox'
+        }
+    };
+    await (0, index_1.default)(schema, {
+        $unset: {
+            'data.items': ''
+        }
+    });
+    expect.assertions(1);
+    try {
+        await (0, index_1.default)(schema, {
+            $unset: {
+                data: ''
+            }
+        });
+    }
+    catch (error) {
+        expect(error.code).toBe('validationError');
+    }
+});

package/lib/createCollection/getMethods/validateModifier/validateUpsert.d.ts

@@ -0,0 +1 @@
+export default function (schema: any, selector: any, modifier: any): Promise<void>;

package/lib/createCollection/getMethods/validateModifier/validateUpsert.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+const schema_1 = require("@orion-js/schema");
+const omit_1 = __importDefault(require("lodash/omit"));
+const fromDot_1 = __importDefault(require("../../../helpers/fromDot"));
+const getPushSimulation = function ($push) {
+    if (!$push)
+        return {};
+    const simulation = {};
+    for (const key of Object.keys($push)) {
+        const value = $push[key];
+        if (typeof value === 'object' && '$each' in value) {
+            simulation[key] = value.$each;
+        }
+        else {
+            simulation[key] = [value];
+        }
+    }
+    return simulation;
+};
+const simulateNewDoc = function (selector, modifier) {
+    return (0, fromDot_1.default)({
+        ...selector,
+        ...modifier.$set,
+        ...modifier.$inc,
+        ...getPushSimulation(modifier.$push),
+        ...getPushSimulation(modifier.$addToSet),
+        ...modifier.$setOnInsert
+    });
+};
+const validateNewDoc = async function (schema, selector, modifier) {
+    const doc = simulateNewDoc(selector, modifier);
+    await (0, schema_1.validate)(schema, doc);
+};
+async function default_1(schema, selector, modifier) {
+    await validateNewDoc(schema, selector, modifier);
+    await (0, index_1.default)(schema, (0, omit_1.default)(modifier, '$setOnInsert'));
+}
+exports.default = default_1;

package/lib/createCollection/getMethods/validateModifier/validateUpsert.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/createCollection/getMethods/validateModifier/validateUpsert.test.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const validateUpsert_1 = __importDefault(require("./validateUpsert"));
+it('pass validation when everything is fine', async () => {
+    const person = {
+        name: { type: String },
+        state: { type: String, optional: true }
+    };
+    const schema = {
+        name: { type: String },
+        age: { type: Number },
+        wife: { type: person },
+        friends: { type: [person] }
+    };
+    const selector = { name: 'Nicolás' };
+    const modifier = {
+        $inc: { age: 1 },
+        $set: { 'wife.state': 'Hungry', 'wife.name': 'Francisca' },
+        $push: { friends: { name: 'Joaquín' } }
+    };
+    await (0, validateUpsert_1.default)(schema, selector, modifier);
+});
+it('get correct validation errors', async () => {
+    const person = {
+        name: { type: String },
+        state: { type: String, optional: true }
+    };
+    const schema = {
+        name: { type: String },
+        age: { type: Number },
+        wife: { type: person },
+        friends: { type: [person] }
+    };
+    const selector = { name: 'Nicolás' };
+    const modifier = {
+        $inc: { age: 'not a number' },
+        $set: { 'wife.state': 1, 'wife.name': 'Francisca' },
+        $push: { friends: 'Joaquín' }
+    };
+    expect.assertions(1);
+    try {
+        await (0, validateUpsert_1.default)(schema, selector, modifier);
+    }
+    catch (error) {
+        expect(error.code).toBe('validationError');
+    }
+});

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

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