@bedrockio/model 0.1.23 → 0.1.25

package/dist/cjs/schema.js

@@ -27,7 +27,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * @returns mongoose.Schema
  */
 function createSchema(definition, options = {}) {
-  const schema = new _mongoose.default.Schema(attributesToMongoose(normalizeAttributes({
+  const schema = new _mongoose.default.Schema(attributesToMongoose({
     ...definition.attributes,
     // Although timestamps are being set below, we still need to add
     // them to the schema so that validation can be generated for them,
@@ -39,7 +39,7 @@ function createSchema(definition, options = {}) {
       type: 'Boolean',
       default: false
     }
-  })), {
+  }), {
     timestamps: true,
     toJSON: _serialization.serializeOptions,
     toObject: _serialization.serializeOptions,
@@ -65,9 +65,8 @@ function normalizeAttributes(arg, path = []) {
       type: arg
     }, path);
   } else if (Array.isArray(arg)) {
-    const type = normalizeArrayAttributes(arg, path);
     return normalizeSchemaTypedef({
-      type
+      type: arg
     }, path);
   } else if (typeof arg === 'object') {
     assertRefs(arg, path);
@@ -105,6 +104,7 @@ function attributesToMongoose(attributes) {
   } else if (Array.isArray(attributes)) {
     return attributes.map(attributesToMongoose);
   }
+  attributes = normalizeAttributes(attributes);
   let definition = {};
   const isTypedef = (0, _utils.isSchemaTypedef)(attributes);
   for (let [key, val] of Object.entries(attributes)) {
@@ -211,20 +211,29 @@ function isExtendedSyntax(typedef) {
   } = typedef;
   return attributes && (type === 'Object' || type === 'Array');
 }
-function isScopeExtension(obj) {
-  return (0, _utils.isSchemaTypedef)(obj) && obj.type === 'Scope';
+function isScopeExtension(arg) {
+  return (0, _utils.isSchemaTypedef)(arg) && arg.type === 'Scope';
 }
-function applyScopeExtension(scope, definition) {
+function applyScopeExtension(typedef, definition) {
   const {
     type,
     attributes,
     ...options
-  } = scope;
+  } = typedef;
   for (let [key, val] of Object.entries(normalizeAttributes(attributes))) {
-    definition[key] = {
-      ...val,
-      ...options
-    };
+    if ((0, _utils.isSchemaTypedef)(val)) {
+      val = {
+        ...val,
+        ...options
+      };
+    } else {
+      val = attributesToMongoose({
+        type: 'Object',
+        attributes: val,
+        ...options
+      });
+    }
+    definition[key] = val;
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {

package/src/schema.js

@@ -28,19 +28,17 @@ import {
  */
 export function createSchema(definition, options = {}) {
   const schema = new mongoose.Schema(
-    attributesToMongoose(
-      normalizeAttributes({
-        ...definition.attributes,
-
-        // Although timestamps are being set below, we still need to add
-        // them to the schema so that validation can be generated for them,
-        // namely in getSearchValidation.
-        createdAt: 'Date',
-        updatedAt: 'Date',
-        deletedAt: 'Date',
-        deleted: { type: 'Boolean', default: false },
-      })
-    ),
+    attributesToMongoose({
+      ...definition.attributes,
+
+      // Although timestamps are being set below, we still need to add
+      // them to the schema so that validation can be generated for them,
+      // namely in getSearchValidation.
+      createdAt: 'Date',
+      updatedAt: 'Date',
+      deletedAt: 'Date',
+      deleted: { type: 'Boolean', default: false },
+    }),
     {
       timestamps: true,
       toJSON: serializeOptions,
@@ -69,8 +67,7 @@ export function normalizeAttributes(arg, path = []) {
   } else if (typeof arg === 'string') {
     return normalizeSchemaTypedef({ type: arg }, path);
   } else if (Array.isArray(arg)) {
-    const type = normalizeArrayAttributes(arg, path);
-    return normalizeSchemaTypedef({ type }, path);
+    return normalizeSchemaTypedef({ type: arg }, path);
   } else if (typeof arg === 'object') {
     assertRefs(arg, path);
 
@@ -113,6 +110,8 @@ function attributesToMongoose(attributes) {
     return attributes.map(attributesToMongoose);
   }
 
+  attributes = normalizeAttributes(attributes);
+
   let definition = {};
 
   const isTypedef = isSchemaTypedef(attributes);
@@ -223,17 +222,26 @@ function isExtendedSyntax(typedef) {
   return attributes && (type === 'Object' || type === 'Array');
 }
 
-function isScopeExtension(obj) {
-  return isSchemaTypedef(obj) && obj.type === 'Scope';
+function isScopeExtension(arg) {
+  return isSchemaTypedef(arg) && arg.type === 'Scope';
 }
 
-function applyScopeExtension(scope, definition) {
-  const { type, attributes, ...options } = scope;
+function applyScopeExtension(typedef, definition) {
+  const { type, attributes, ...options } = typedef;
   for (let [key, val] of Object.entries(normalizeAttributes(attributes))) {
-    definition[key] = {
-      ...val,
-      ...options,
-    };
+    if (isSchemaTypedef(val)) {
+      val = {
+        ...val,
+        ...options,
+      };
+    } else {
+      val = attributesToMongoose({
+        type: 'Object',
+        attributes: val,
+        ...options,
+      });
+    }
+    definition[key] = val;
   }
 }
 

package/types/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAoBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoChC;AAED,iEAuBC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAoBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkChC;AAED,iEAsBC"}