@bedrockio/model 0.1.17 → 0.1.19

package/dist/cjs/assign.js

@@ -28,7 +28,7 @@ function unsetReferenceFields(fields, schema = {}) {
     if (!value && (0, _utils.isReferenceField)(schema, key)) {
       fields[key] = undefined;
     } else if (value && typeof value === 'object') {
-      unsetReferenceFields(value, (0, _utils.resolveField)(schema, key));
+      unsetReferenceFields(value, (0, _utils.getField)(schema, key));
     }
   }
 }

package/dist/cjs/include.js

@@ -218,7 +218,7 @@ function setNodePath(node, options) {
     let halt = false;
     for (let [key, type] of resolvePaths(schema, str)) {
       if (type === 'real') {
-        const field = (0, _utils.resolveInnerField)(schema.obj, key);
+        const field = (0, _utils.getInnerField)(schema.obj, key);
         // Only exclude the field if the match is exact, ie:
         // -name - Exclude "name"
         // -user.name - Implies population of "user" but exclude "user.name",
@@ -256,8 +256,8 @@ function resolvePaths(schema, str) {
     source = source.replaceAll('\\*', '[^.]+');
     source = `^${source}$`;
     const reg = RegExp(source);
-    paths = Object.keys(schema.paths || {}).filter(path => {
-      return !path.startsWith('_') && reg.test(path);
+    paths = getSchemaPaths(schema).filter(path => {
+      return reg.test(path);
     });
   } else {
     paths = [str];
@@ -265,4 +265,17 @@ function resolvePaths(schema, str) {
   return paths.map(path => {
     return [path, schema.pathType(path)];
   });
+}
+function getSchemaPaths(schema) {
+  return Object.entries(schema.paths || {}).flatMap(([key, schema]) => {
+    if (key.startsWith('_')) {
+      return [];
+    } else if (schema.schema) {
+      return getSchemaPaths(schema.schema).map(path => {
+        return [key, path].join('.');
+      });
+    } else {
+      return [key];
+    }
+  });
 }

package/dist/cjs/search.js

@@ -227,7 +227,7 @@ function normalizeQuery(query, schema, root = {}, rootPath = []) {
         root[path.join('.')] = mapOperatorQuery(value);
       }
     } else if (isNestedQuery(key, value)) {
-      normalizeQuery(value, (0, _utils.resolveField)(schema, key), root, path);
+      normalizeQuery(value, (0, _utils.getField)(schema, key), root, path);
     } else if (isRegexQuery(key, value)) {
       root[path.join('.')] = parseRegexQuery(value);
     } else if (isArrayQuery(key, value)) {

package/dist/cjs/serialization.js

@@ -28,7 +28,7 @@ function transformField(obj, field, options) {
       if (!isAllowedField(key, field, options)) {
         delete obj[key];
       } else {
-        transformField(val, (0, _utils.resolveField)(field, key), options);
+        transformField(val, (0, _utils.getInnerField)(field, key), options);
       }
     }
   }
@@ -44,7 +44,7 @@ function isAllowedField(key, field, options) {
   } else {
     const {
       readAccess
-    } = (0, _utils.resolveField)(field, key);
+    } = (0, _utils.getField)(field, key);
     try {
       return (0, _access.hasReadAccess)(readAccess, options);
     } catch {

package/dist/cjs/utils.js

@@ -3,13 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.getField = getField;
+exports.getInnerField = getInnerField;
 exports.isDateField = isDateField;
 exports.isMongooseSchema = isMongooseSchema;
 exports.isNumberField = isNumberField;
 exports.isReferenceField = isReferenceField;
 exports.isSchemaTypedef = isSchemaTypedef;
-exports.resolveField = resolveField;
-exports.resolveInnerField = resolveInnerField;
 var _mongoose = _interopRequireDefault(require("mongoose"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function isMongooseSchema(obj) {
@@ -27,47 +27,63 @@ function isNumberField(obj, path) {
 function isType(obj, path, test) {
   const {
     type
-  } = resolveInnerField(obj, path);
+  } = getInnerField(obj, path);
   return type === test || type === _mongoose.default.Schema.Types[test];
 }
 function isSchemaTypedef(arg) {
   // Has a type defined and is not a literal type field.
-  return arg?.type && !arg.type?.type;
+  return !!arg?.type && !arg.type?.type;
 }
 
-// Note: Resolved field may be an object or a function
-// from mongoose.Schema.Types that is resolved from the
-// shorthand: field: 'String'.
-function resolveField(obj, path) {
-  let typedef = obj;
-  for (let key of path.split('.')) {
-    typedef = resolveFieldForKey(typedef, key);
+// Gets the schema "field". For a structure like below:
+// {
+//   products: {
+//     type: [
+//       {
+//         inventory: {
+//           type: [
+//             {
+//               type: 'Number',
+//             },
+//           ],
+//           writeAccess: 'none',
+//         },
+//       },
+//     ],
+//   },
+// }
+//
+// Given a path "products.inventory" it will return the inner
+// "inventory" field. It must traverse into arrays and other mongoose
+// schemas along the way except for the final field.
+function getField(obj, path) {
+  let field = obj;
+  if (typeof path === 'string') {
+    path = path.split('.');
   }
-  return typedef;
+  path.forEach((key, i) => {
+    field = field[key];
+    if (i < path.length - 1) {
+      field = resolveInnerField(field);
+    }
+  });
+  return field || {};
 }
 
-// The same as resolveField but gets the element
-// typedef in the case of arrays.
-function resolveInnerField(obj, path) {
-  let typedef = resolveField(obj, path);
-  if (Array.isArray(typedef.type)) {
-    typedef = typedef.type[0];
-  }
-  return typedef;
+// The same as getField but traverses into the final field
+// as well. In the above example this will return:
+// { type: 'Number' }, given "product.inventory"
+function getInnerField(obj, path) {
+  return resolveInnerField(getField(obj, path));
 }
-function resolveFieldForKey(obj, key) {
-  let typedef;
-  if (isSchemaTypedef(obj)) {
-    const {
-      type
-    } = obj;
-    if (Array.isArray(type)) {
-      typedef = type[0][key];
-    } else {
-      typedef = type[key];
-    }
-  } else {
-    typedef = obj[key];
+function resolveInnerField(field) {
+  if (Array.isArray(field?.type)) {
+    field = field.type[0];
+  }
+  if (field?.type instanceof _mongoose.default.Schema) {
+    field = field.type.obj;
+  } else if (field instanceof _mongoose.default.Schema) {
+    field = field.obj;
   }
-  return typedef || {};
+  return field;
 }

package/package.json

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

package/src/assign.js

@@ -1,6 +1,6 @@
 import { isPlainObject } from 'lodash';
 
-import { isReferenceField, resolveField } from './utils';
+import { isReferenceField, getField } from './utils';
 
 export function applyAssign(schema) {
   schema.method('assign', function assign(fields) {
@@ -24,7 +24,7 @@ function unsetReferenceFields(fields, schema = {}) {
     if (!value && isReferenceField(schema, key)) {
       fields[key] = undefined;
     } else if (value && typeof value === 'object') {
-      unsetReferenceFields(value, resolveField(schema, key));
+      unsetReferenceFields(value, getField(schema, key));
     }
   }
 }

package/src/include.js

@@ -2,7 +2,7 @@ import mongoose from 'mongoose';
 import { escapeRegExp } from 'lodash';
 import yd from '@bedrockio/yada';
 
-import { resolveInnerField, isSchemaTypedef } from './utils';
+import { getInnerField, isSchemaTypedef } from './utils';
 import { POPULATE_MAX_DEPTH } from './const';
 
 // @ts-ignore
@@ -202,7 +202,7 @@ function setNodePath(node, options) {
 
     for (let [key, type] of resolvePaths(schema, str)) {
       if (type === 'real') {
-        const field = resolveInnerField(schema.obj, key);
+        const field = getInnerField(schema.obj, key);
         // Only exclude the field if the match is exact, ie:
         // -name - Exclude "name"
         // -user.name - Implies population of "user" but exclude "user.name",
@@ -242,8 +242,8 @@ function resolvePaths(schema, str) {
     source = source.replaceAll('\\*', '[^.]+');
     source = `^${source}$`;
     const reg = RegExp(source);
-    paths = Object.keys(schema.paths || {}).filter((path) => {
-      return !path.startsWith('_') && reg.test(path);
+    paths = getSchemaPaths(schema).filter((path) => {
+      return reg.test(path);
     });
   } else {
     paths = [str];
@@ -252,3 +252,17 @@ function resolvePaths(schema, str) {
     return [path, schema.pathType(path)];
   });
 }
+
+function getSchemaPaths(schema) {
+  return Object.entries(schema.paths || {}).flatMap(([key, schema]) => {
+    if (key.startsWith('_')) {
+      return [];
+    } else if (schema.schema) {
+      return getSchemaPaths(schema.schema).map((path) => {
+        return [key, path].join('.');
+      });
+    } else {
+      return [key];
+    }
+  });
+}

package/src/search.js

@@ -3,7 +3,7 @@ import logger from '@bedrockio/logger';
 import mongoose from 'mongoose';
 import { pick, isEmpty, isPlainObject } from 'lodash';
 
-import { isDateField, isNumberField, resolveField } from './utils';
+import { isDateField, isNumberField, getField } from './utils';
 import { SEARCH_DEFAULTS } from './const';
 import { OBJECT_ID_SCHEMA } from './validation';
 import { debug } from './env';
@@ -239,7 +239,7 @@ function normalizeQuery(query, schema, root = {}, rootPath = []) {
         root[path.join('.')] = mapOperatorQuery(value);
       }
     } else if (isNestedQuery(key, value)) {
-      normalizeQuery(value, resolveField(schema, key), root, path);
+      normalizeQuery(value, getField(schema, key), root, path);
     } else if (isRegexQuery(key, value)) {
       root[path.join('.')] = parseRegexQuery(value);
     } else if (isArrayQuery(key, value)) {

package/src/serialization.js

@@ -2,7 +2,7 @@ import { isPlainObject } from 'lodash';
 
 import { checkSelects } from './include';
 import { hasReadAccess } from './access';
-import { resolveField } from './utils';
+import { getField, getInnerField } from './utils';
 
 export const serializeOptions = {
   getters: true,
@@ -24,7 +24,7 @@ function transformField(obj, field, options) {
       if (!isAllowedField(key, field, options)) {
         delete obj[key];
       } else {
-        transformField(val, resolveField(field, key), options);
+        transformField(val, getInnerField(field, key), options);
       }
     }
   }
@@ -39,7 +39,7 @@ function isAllowedField(key, field, options) {
     // to false and should not be exposed.
     return false;
   } else {
-    const { readAccess } = resolveField(field, key);
+    const { readAccess } = getField(field, key);
     try {
       return hasReadAccess(readAccess, options);
     } catch {

package/src/utils.js

@@ -17,47 +17,65 @@ export function isNumberField(obj, path) {
 }
 
 function isType(obj, path, test) {
-  const { type } = resolveInnerField(obj, path);
+  const { type } = getInnerField(obj, path);
   return type === test || type === mongoose.Schema.Types[test];
 }
 
 export function isSchemaTypedef(arg) {
   // Has a type defined and is not a literal type field.
-  return arg?.type && !arg.type?.type;
+  return !!arg?.type && !arg.type?.type;
 }
 
-// Note: Resolved field may be an object or a function
-// from mongoose.Schema.Types that is resolved from the
-// shorthand: field: 'String'.
-export function resolveField(obj, path) {
-  let typedef = obj;
-  for (let key of path.split('.')) {
-    typedef = resolveFieldForKey(typedef, key);
+// Gets the schema "field". For a structure like below:
+// {
+//   products: {
+//     type: [
+//       {
+//         inventory: {
+//           type: [
+//             {
+//               type: 'Number',
+//             },
+//           ],
+//           writeAccess: 'none',
+//         },
+//       },
+//     ],
+//   },
+// }
+//
+// Given a path "products.inventory" it will return the inner
+// "inventory" field. It must traverse into arrays and other mongoose
+// schemas along the way except for the final field.
+export function getField(obj, path) {
+  let field = obj;
+  if (typeof path === 'string') {
+    path = path.split('.');
   }
-  return typedef;
+  path.forEach((key, i) => {
+    field = field[key];
+    if (i < path.length - 1) {
+      field = resolveInnerField(field);
+    }
+  });
+  return field || {};
 }
 
-// The same as resolveField but gets the element
-// typedef in the case of arrays.
-export function resolveInnerField(obj, path) {
-  let typedef = resolveField(obj, path);
-  if (Array.isArray(typedef.type)) {
-    typedef = typedef.type[0];
-  }
-  return typedef;
+// The same as getField but traverses into the final field
+// as well. In the above example this will return:
+// { type: 'Number' }, given "product.inventory"
+export function getInnerField(obj, path) {
+  return resolveInnerField(getField(obj, path));
 }
 
-function resolveFieldForKey(obj, key) {
-  let typedef;
-  if (isSchemaTypedef(obj)) {
-    const { type } = obj;
-    if (Array.isArray(type)) {
-      typedef = type[0][key];
-    } else {
-      typedef = type[key];
-    }
-  } else {
-    typedef = obj[key];
+function resolveInnerField(field) {
+  if (Array.isArray(field?.type)) {
+    field = field.type[0];
+  }
+  if (field?.type instanceof mongoose.Schema) {
+    field = field.type.obj;
+  } else if (field instanceof mongoose.Schema) {
+    field = field.obj;
   }
-  return typedef || {};
+  return field;
 }

package/types/utils.d.ts

@@ -3,6 +3,6 @@ export function isReferenceField(obj: any, path: any): boolean;
 export function isDateField(obj: any, path: any): boolean;
 export function isNumberField(obj: any, path: any): boolean;
 export function isSchemaTypedef(arg: any): boolean;
-export function resolveField(obj: any, path: any): any;
-export function resolveInnerField(obj: any, path: any): any;
+export function getField(obj: any, path: any): any;
+export function getInnerField(obj: any, path: any): any;
 //# sourceMappingURL=utils.d.ts.map

package/types/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAEA,oDAEC;AAED,+DAEC;AAED,0DAEC;AAED,4DAEC;AAOD,mDAGC;AAKD,uDAMC;AAID,4DAMC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAEA,oDAEC;AAED,+DAEC;AAED,0DAEC;AAED,4DAEC;AAOD,mDAGC;AAuBD,mDAYC;AAKD,wDAEC"}