@orion-js/mongodb 3.2.14 → 3.2.18

package/lib/createCollection/getMethods/findOneAndUpdate.js

@@ -13,7 +13,7 @@ exports.default = (collection) => {
         if (!modifier) {
             throw new Error('Modifier is required when making an update');
         }
-        if (collection.model) {
+        if (collection.schema) {
             const schema = collection.getSchema();
             modifier = options.clean !== false ? await (0, cleanModifier_1.default)(schema, modifier) : modifier;
             if (options.validate !== false)

package/lib/createCollection/getMethods/insertMany.js

@@ -18,7 +18,7 @@ exports.default = (collection) => {
             if (!doc._id) {
                 doc._id = collection.generateId();
             }
-            if (collection.model) {
+            if (collection.schema) {
                 const schema = collection.getSchema();
                 doc = await (0, schema_1.clean)(schema, (0, fromDot_1.default)(doc));
                 await (0, schema_1.validate)(schema, doc);

package/lib/createCollection/getMethods/insertOne.js

@@ -16,7 +16,7 @@ exports.default = (collection) => {
         if (!doc._id) {
             doc._id = collection.generateId();
         }
-        if (collection.model) {
+        if (collection.schema) {
             const schema = collection.getSchema();
             doc = await (0, schema_1.clean)(schema, (0, fromDot_1.default)(doc));
             await (0, schema_1.validate)(schema, doc);

package/lib/createCollection/getMethods/updateMany.js

@@ -14,7 +14,7 @@ exports.default = (collection) => {
         if (!modifier) {
             throw new Error('Modifier is required when making an update');
         }
-        if (collection.model) {
+        if (collection.schema) {
             const schema = collection.getSchema();
             modifier = options.clean !== false ? await (0, cleanModifier_1.default)(schema, modifier) : modifier;
             if (options.validate !== false)

package/lib/createCollection/getMethods/updateOne.js

@@ -14,7 +14,7 @@ exports.default = (collection) => {
         if (!modifier) {
             throw new Error('Modifier is required when making an update');
         }
-        if (collection.model) {
+        if (collection.schema) {
             const schema = collection.getSchema();
             modifier = options.clean !== false ? await (0, cleanModifier_1.default)(schema, modifier) : modifier;
             if (options.validate !== false)

package/lib/createCollection/getMethods/upsert.js

@@ -12,7 +12,7 @@ exports.default = (collection) => {
         let modifier = modifierArg;
         let selector = (0, getSelector_1.default)(arguments);
         modifier.$setOnInsert = { ...modifier.$setOnInsert, _id: collection.generateId() };
-        if (collection.model) {
+        if (collection.schema) {
             const schema = collection.getSchema();
             if (options.clean !== false) {
                 selector = (await (0, cleanModifier_1.default)(schema, { $set: selector })).$set;

package/lib/createCollection/getSchemaAndModel.d.ts

@@ -0,0 +1,10 @@
+import { Model } from '@orion-js/models';
+import { Schema } from '@orion-js/schema';
+import { CreateCollectionOptions } from '../types';
+export declare function getModel(options: CreateCollectionOptions): Model;
+export declare function prepareShema(schema: Schema): Schema;
+export declare function getSchema(options: CreateCollectionOptions, optionsModel?: Model): Schema;
+export declare function getSchemaAndModel(options: CreateCollectionOptions): {
+    schema: Schema;
+    model: Model;
+};

package/lib/createCollection/getSchemaAndModel.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaAndModel = exports.getSchema = exports.prepareShema = exports.getModel = void 0;
+const lodash_1 = require("lodash");
+function getModel(options) {
+    if (!options.model)
+        return;
+    return options.model && options.model.getModel ? options.model.getModel() : options.model;
+}
+exports.getModel = getModel;
+function prepareShema(schema) {
+    if (!schema._id) {
+        schema._id = {
+            type: String
+        };
+    }
+    return schema;
+}
+exports.prepareShema = prepareShema;
+function getSchema(options, optionsModel) {
+    if (optionsModel) {
+        const schema = optionsModel ? (0, lodash_1.cloneDeep)(optionsModel.getCleanSchema()) : {};
+        return prepareShema(schema);
+    }
+    // schema is a typed model
+    if (options.schema && options.schema.getModel) {
+        const model = options.schema.getModel();
+        const schema = model ? (0, lodash_1.cloneDeep)(model.getCleanSchema()) : {};
+        return prepareShema(schema);
+    }
+    if (options.schema && (0, lodash_1.isPlainObject)(options.schema)) {
+        return prepareShema(options.schema);
+    }
+}
+exports.getSchema = getSchema;
+function getSchemaAndModel(options) {
+    const model = getModel(options);
+    const schema = getSchema(options, model);
+    return { schema, model };
+}
+exports.getSchemaAndModel = getSchemaAndModel;

package/lib/createCollection/index.js

@@ -9,8 +9,8 @@ const getMethods_1 = require("./getMethods");
 const dataLoader_1 = require("./getMethods/dataLoader");
 const generateId_1 = __importDefault(require("./generateId"));
 const createIndexes_1 = require("./createIndexes");
-const lodash_1 = require("lodash");
 const __1 = require("..");
+const getSchemaAndModel_1 = require("./getSchemaAndModel");
 exports.createIndexesPromises = [];
 const createCollection = (options) => {
     const connectionName = options.connectionName || 'main';
@@ -20,10 +20,11 @@ const createCollection = (options) => {
     }
     const db = orionConnection.db;
     const rawCollection = db.collection(options.name);
-    const model = options.model && options.model.getModel ? options.model.getModel() : options.model;
+    const { schema, model } = (0, getSchemaAndModel_1.getSchemaAndModel)(options);
     const collection = {
         name: options.name,
         connectionName,
+        schema,
         model,
         indexes: options.indexes || [],
         db,
@@ -31,15 +32,7 @@ const createCollection = (options) => {
         connectionPromise: orionConnection.connectionPromise,
         rawCollection,
         generateId: (0, generateId_1.default)(options),
-        getSchema: () => {
-            const schema = (0, lodash_1.cloneDeep)(model.getCleanSchema());
-            if (!schema._id) {
-                schema._id = {
-                    type: 'ID'
-                };
-            }
-            return schema;
-        }
+        getSchema: () => schema
     };
     // helpers
     collection.initItem = (0, initItem_1.default)(collection);

package/lib/createCollection/typedModel.test.js

@@ -99,4 +99,53 @@ describe('Collections with typed model', () => {
         const person = await Persons.findOne('1');
         expect(person.firstName).toBe('John');
     });
+    it('Should validate but not initialize documents when passed typed schema', async () => {
+        const resolve = async (person, { title }, viewer) => {
+            return `${title} ${person.firstName} ${person.lastName}`;
+        };
+        const titleResolver = (0, resolvers_1.modelResolver)({
+            returns: String,
+            resolve
+        });
+        let Person = class Person {
+        };
+        __decorate([
+            (0, typed_model_1.Prop)(),
+            __metadata("design:type", String)
+        ], Person.prototype, "firstName", void 0);
+        __decorate([
+            (0, typed_model_1.Prop)({ max: 3 }),
+            __metadata("design:type", String)
+        ], Person.prototype, "lastName", void 0);
+        __decorate([
+            (0, typed_model_1.ResolverProp)(titleResolver),
+            __metadata("design:type", Object)
+        ], Person.prototype, "title", void 0);
+        Person = __decorate([
+            (0, typed_model_1.TypedSchema)()
+        ], Person);
+        const Persons = (0, _1.default)({
+            name: (0, helpers_1.generateId)(),
+            schema: Person
+        });
+        expect.assertions(3);
+        try {
+            await Persons.insertOne({
+                _id: '1',
+                firstName: 'John',
+                lastName: 'ppoo'
+            });
+        }
+        catch (error) {
+            expect(error.message).toBe('Validation Error: {lastName: stringTooLong}');
+        }
+        await Persons.insertOne({
+            _id: '1',
+            firstName: 'John',
+            lastName: 'Doe'
+        });
+        const person = await Persons.findOne('1');
+        expect(person.firstName).toBe('John');
+        expect(person.title).toBeUndefined();
+    });
 });

package/lib/types/index.d.ts

@@ -87,10 +87,31 @@ export declare type UpdateOne<ModelClass> = (selector: ModelToMongoSelector<Mode
 export declare type UpdateMany<ModelClass> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: UpdateOptions) => Promise<MongoDB.UpdateResult | MongoDB.Document>;
 export declare type Upsert<ModelClass> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: UpdateOptions) => Promise<MongoDB.UpdateResult>;
 export interface CreateCollectionOptions {
+    /**
+     * The name of the collection on the Mongo Database
+     */
     name: string;
+    /**
+     * The name of the connection to use. The Mongo URL of this connection will be search on env variables.
+     * If not found, the connection url will be `env.mongo_url`
+     * If defined, the connection url will be `env.mongo_url_${name}`
+     */
     connectionName?: string;
+    /**
+     * The schema used for cleaning and validation of the documents
+     */
+    schema?: any;
+    /**
+     * @deprecated Use schema instead. If you use model, all items will be initialized with the model to add resolvers (which are also deprecated)
+     */
     model?: any;
+    /**
+     * The indexes to use
+     */
     indexes?: Array<CollectionIndex>;
+    /**
+     * Select between random id generation o mongo (time based) id generation
+     */
     idGeneration?: 'mongo' | 'random';
 }
 export declare type EstimatedDocumentCount<ModelClass> = (options?: MongoDB.EstimatedDocumentCountOptions) => Promise<number>;
@@ -99,6 +120,10 @@ export declare type CreateCollection = <ModelClass = any>(options: CreateCollect
 export interface Collection<ModelClass = any> {
     name: string;
     connectionName?: string;
+    schema?: Schema;
+    /**
+     * @deprecated Use schema instead. If you use model, all items will be initialized with the model to add resolvers (which are also deprecated)
+     */
     model?: Model;
     indexes: Array<CollectionIndex>;
     generateId: () => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/mongodb",
-  "version": "3.2.14",
+  "version": "3.2.18",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
@@ -19,11 +19,11 @@
   "dependencies": {
     "@orion-js/env": "^3.2.0",
     "@orion-js/helpers": "^3.2.0",
-    "@orion-js/models": "^3.2.0",
-    "@orion-js/resolvers": "^3.2.0",
-    "@orion-js/schema": "^3.2.0",
+    "@orion-js/models": "^3.2.18",
+    "@orion-js/resolvers": "^3.2.18",
+    "@orion-js/schema": "^3.2.18",
     "@orion-js/services": "^3.2.10",
-    "@orion-js/typed-model": "^3.2.10",
+    "@orion-js/typed-model": "^3.2.18",
     "dataloader": "2.1.0",
     "dot-object": "2.1.4",
     "mongodb": "4.5.0"
@@ -40,5 +40,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "87d4cca0154b4beb6e6fa97f298b1440e0c3c231"
+  "gitHead": "95db28fdf82bca1f23a07ea3a0d8f1218b7c1373"
 }