@bedrockio/model 0.1.8 → 0.1.10

package/dist/cjs/schema.js

@@ -3,7 +3,6 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.RESERVED_FIELDS = void 0;
 exports.createSchema = createSchema;
 exports.normalizeAttributes = normalizeAttributes;
 var _mongoose = _interopRequireDefault(require("mongoose"));
@@ -19,8 +18,6 @@ var _softDelete = require("./soft-delete");
 var _disallowed = require("./disallowed");
 var _validation = require("./validation");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const RESERVED_FIELDS = ['createdAt', 'updatedAt', 'deletedAt', 'deleted'];
-
 /**
  * Creates a new Mongoose schema with Bedrock extensions
  * applied. For more about syntax and functionality see
@@ -29,7 +26,6 @@ const RESERVED_FIELDS = ['createdAt', 'updatedAt', 'deletedAt', 'deleted'];
  * @param {mongoose.SchemaOptions} options
  * @returns mongoose.Schema
  */
-exports.RESERVED_FIELDS = RESERVED_FIELDS;
 function createSchema(definition, options = {}) {
   const schema = new _mongoose.default.Schema(attributesToMongoose(normalizeAttributes({
     ...definition.attributes,

package/dist/cjs/search.js

@@ -16,10 +16,6 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 const {
   ObjectId
 } = _mongoose.default.Types;
-const SORT_SCHEMA = _yada.default.object({
-  field: _yada.default.string().required(),
-  order: _yada.default.string().allow('desc', 'asc').required()
-}).description('An object describing the sort order of results.');
 function applySearch(schema, definition) {
   validateDefinition(definition);
   schema.static('search', function search(body = {}) {
@@ -47,7 +43,7 @@ function applySearch(schema, definition) {
       Object.assign(query, buildKeywordQuery(keyword, fields));
     }
     Object.assign(query, normalizeQuery(rest, schema.obj));
-    const mQuery = this.find(query).sort(resolveSort(sort)).skip(skip).limit(limit);
+    const mQuery = this.find(query).sort(resolveSort(sort, schema)).skip(skip).limit(limit);
 
     // The following construct is awkward but it allows the mongoose query
     // object to be returned while still ultimately resolving with metadata
@@ -73,36 +69,56 @@ function applySearch(schema, definition) {
     return mQuery;
   });
 }
-function searchValidation(definition, options = {}) {
-  options = {
+function searchValidation(options = {}) {
+  const {
+    defaults,
+    definition,
+    appendSchema
+  } = options;
+  const searchOptions = {
     ..._const.SEARCH_DEFAULTS,
     ...(0, _lodash.pick)(definition.search, 'limit', 'sort'),
-    ...options
+    ...defaults
   };
   const {
     limit,
-    sort,
-    ...rest
-  } = options;
+    sort
+  } = searchOptions;
   return _yada.default.object({
     ids: _yada.default.array(_validation.OBJECT_ID_SCHEMA),
     keyword: _yada.default.string().description('A keyword to perform a text search against.'),
     skip: _yada.default.number().default(0).description('Number of records to skip.'),
-    sort: _yada.default.allow(SORT_SCHEMA, _yada.default.array(SORT_SCHEMA)).default(sort),
+    sort: getSortSchema(sort),
     limit: _yada.default.number().positive().default(limit).description('Limits the number of results.'),
-    ...rest
+    ...appendSchema
   });
 }
+function getSortSchema(sort) {
+  const schema = _yada.default.object({
+    field: _yada.default.string().required(),
+    order: _yada.default.string().allow('desc', 'asc').required()
+  }).description('An object describing the sort order of results.');
+  return _yada.default.allow(schema, _yada.default.array(schema)).default(sort);
+}
 function validateDefinition(definition) {
   if (Array.isArray(definition.search)) {
     (0, _warn.default)(['"search" field on model definition must not be an array.', 'Use "search.fields" to define fields for keyword queries.'].join('\n'));
     throw new Error('Invalid model definition.');
   }
 }
-function resolveSort(sort) {
-  if (!Array.isArray(sort)) {
+function resolveSort(sort, schema) {
+  if (!sort) {
+    sort = [];
+  } else if (!Array.isArray(sort)) {
     sort = [sort];
   }
+  for (let {
+    field
+  } of sort) {
+    if (!field || !schema.path(field)) {
+      throw new Error(`Unknown sort field "${field}".`);
+    }
+  }
   return sort.map(({
     field,
     order

package/dist/cjs/validation.js

@@ -17,34 +17,35 @@ var _search = require("./search");
 var _errors = require("./errors");
 var _softDelete = require("./soft-delete");
 var _utils = require("./utils");
-var _schema = require("./schema");
 var _include = require("./include");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const DATE_SCHEMA = _yada.default.date().iso().tag({
+const DATE_TAGS = {
   'x-schema': 'DateTime',
   'x-description': 'A `string` in [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html) format.'
+};
+const OBJECT_ID_SCHEMA = _yada.default.string().mongo().tag({
+  'x-schema': 'ObjectId',
+  'x-description': 'A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).'
 });
-const OBJECT_ID_DESCRIPTION = `
+exports.OBJECT_ID_SCHEMA = OBJECT_ID_SCHEMA;
+const REFERENCE_SCHEMA = _yada.default.allow(OBJECT_ID_SCHEMA, _yada.default.object({
+  id: OBJECT_ID_SCHEMA.required()
+}).custom(obj => {
+  return obj.id;
+})).tag({
+  'x-schema': 'Reference',
+  'x-description': `
 A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).
 An object with an \`id\` field may also be passed, which will be converted into a string.
-`;
-const OBJECT_ID_SCHEMA = _yada.default.custom(async val => {
-  const id = String(val.id || val);
-  await namedSchemas.objectId.validate(id);
-  return id;
-}).tag({
-  type: 'ObjectId',
-  'x-schema': 'ObjectId',
-  'x-description': OBJECT_ID_DESCRIPTION.trim()
+    `.trim()
 });
-exports.OBJECT_ID_SCHEMA = OBJECT_ID_SCHEMA;
 const namedSchemas = {
   // Email is special as we are assuming that in
   // all cases lowercase should be allowed but coerced.
   email: _yada.default.string().lowercase().email(),
   // Force "objectId" to have parity with refs.
   // "mongo" is notably excluded here for this reason.
-  objectId: _yada.default.string().mongo(),
+  objectId: OBJECT_ID_SCHEMA,
   ascii: _yada.default.string().ascii(),
   base64: _yada.default.string().base64(),
   btc: _yada.default.string().btc(),
@@ -76,7 +77,9 @@ function applyValidation(schema, definition) {
       model: this,
       appendSchema,
       allowIncludes: true,
-      stripReserved: true,
+      stripDeleted: true,
+      stripTimestamps: true,
+      allowExpandedRefs: true,
       requireWriteAccess: true,
       ...(hasUnique && {
         assertUniqueOptions: {
@@ -91,8 +94,10 @@ function applyValidation(schema, definition) {
       model: this,
       appendSchema,
       skipRequired: true,
-      stripReserved: true,
       stripUnknown: true,
+      stripDeleted: true,
+      stripTimestamps: true,
+      allowExpandedRefs: true,
       requireWriteAccess: true,
       ...(hasUnique && {
         assertUniqueOptions: {
@@ -102,36 +107,57 @@ function applyValidation(schema, definition) {
       })
     });
   });
-  schema.static('getSearchValidation', function getSearchValidation(searchOptions) {
+  schema.static('getSearchValidation', function getSearchValidation(options = {}) {
+    const {
+      defaults,
+      includeDeleted,
+      ...appendSchema
+    } = options;
     return getSchemaFromMongoose(schema, {
+      model: this,
       allowSearch: true,
       skipRequired: true,
       allowIncludes: true,
       expandDotSyntax: true,
       unwindArrayFields: true,
       requireReadAccess: true,
-      appendSchema: (0, _search.searchValidation)(definition, searchOptions),
-      model: this
+      stripDeleted: !includeDeleted,
+      appendSchema: (0, _search.searchValidation)({
+        defaults,
+        definition,
+        appendSchema
+      })
     });
   });
   schema.static('getIncludeValidation', function getIncludeValidation() {
     return _include.INCLUDE_FIELD_SCHEMA;
   });
   schema.static('getBaseSchema', function getBaseSchema() {
-    return getSchemaFromMongoose(schema);
+    return getSchemaFromMongoose(schema, {
+      stripDeleted: true
+    });
   });
 }
 
 // Yada schemas
 
 function getSchemaFromMongoose(schema, options = {}) {
-  let {
-    obj
-  } = schema;
-  if (options.stripReserved) {
-    obj = (0, _lodash.omit)(obj, _schema.RESERVED_FIELDS);
+  const fields = getMongooseFields(schema, options);
+  return getValidationSchema(fields, options);
+}
+function getMongooseFields(schema, options) {
+  const {
+    stripTimestamps,
+    stripDeleted
+  } = options;
+  let fields = schema.obj;
+  if (stripTimestamps) {
+    fields = (0, _lodash.omit)(fields, ['createdAt', 'updatedAt']);
+  }
+  if (stripDeleted) {
+    fields = (0, _lodash.omit)(fields, ['deleted', 'deletedAt']);
   }
-  return getValidationSchema(obj, options);
+  return fields;
 }
 
 // Exported for testing
@@ -191,7 +217,7 @@ function getObjectSchema(arg, options) {
     }
     return schema;
   } else {
-    return getSchemaForType(arg);
+    return getSchemaForType(arg, options);
   }
 }
 function getArraySchema(arr, options) {
@@ -225,7 +251,7 @@ function getSchemaForTypedef(typedef, options = {}) {
   } else if (typeof type === 'object') {
     schema = getObjectSchema(type, options);
   } else {
-    schema = getSchemaForType(type);
+    schema = getSchemaForType(type, options);
   }
   if (isRequired(typedef, options)) {
     schema = schema.required();
@@ -258,7 +284,7 @@ function getSchemaForTypedef(typedef, options = {}) {
   }
   return schema;
 }
-function getSchemaForType(type) {
+function getSchemaForType(type, options) {
   switch (type) {
     case 'String':
       return _yada.default.string();
@@ -267,14 +293,18 @@ function getSchemaForType(type) {
     case 'Boolean':
       return _yada.default.boolean();
     case 'Date':
-      return DATE_SCHEMA;
+      return _yada.default.date().iso().tag(DATE_TAGS);
     case 'Mixed':
     case 'Object':
       return _yada.default.object();
     case 'Array':
       return _yada.default.array();
     case 'ObjectId':
-      return OBJECT_ID_SCHEMA;
+      if (options.allowExpandedRefs) {
+        return REFERENCE_SCHEMA;
+      } else {
+        return OBJECT_ID_SCHEMA;
+      }
     default:
       throw new TypeError(`Unknown schema type ${type}`);
   }
@@ -293,19 +323,19 @@ function getSearchSchema(schema, type) {
   } else if (type === 'Date') {
     return _yada.default.allow(schema, _yada.default.array(schema), _yada.default.object({
       lt: _yada.default.date().iso().tag({
-        'x-ref': 'DateTime',
+        ...DATE_TAGS,
         description: 'Select dates occurring before.'
       }),
       gt: _yada.default.date().iso().tag({
-        'x-ref': 'DateTime',
+        ...DATE_TAGS,
         description: 'Select dates occurring after.'
       }),
       lte: _yada.default.date().iso().tag({
-        'x-ref': 'DateTime',
+        ...DATE_TAGS,
         description: 'Select dates occurring on or before.'
       }),
       gte: _yada.default.date().iso().tag({
-        'x-ref': 'DateTime',
+        ...DATE_TAGS,
         description: 'Select dates occurring on or after.'
       })
     }).tag({

package/package.json

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

package/src/schema.js

@@ -18,13 +18,6 @@ import {
   getTupleValidator,
 } from './validation';
 
-export const RESERVED_FIELDS = [
-  'createdAt',
-  'updatedAt',
-  'deletedAt',
-  'deleted',
-];
-
 /**
  * Creates a new Mongoose schema with Bedrock extensions
  * applied. For more about syntax and functionality see

package/src/search.js

@@ -10,13 +10,6 @@ import warn from './warn';
 
 const { ObjectId } = mongoose.Types;
 
-const SORT_SCHEMA = yd
-  .object({
-    field: yd.string().required(),
-    order: yd.string().allow('desc', 'asc').required(),
-  })
-  .description('An object describing the sort order of results.');
-
 export function applySearch(schema, definition) {
   validateDefinition(definition);
 
@@ -42,7 +35,7 @@ export function applySearch(schema, definition) {
     Object.assign(query, normalizeQuery(rest, schema.obj));
 
     const mQuery = this.find(query)
-      .sort(resolveSort(sort))
+      .sort(resolveSort(sort, schema))
       .skip(skip)
       .limit(limit);
 
@@ -76,14 +69,16 @@ export function applySearch(schema, definition) {
   });
 }
 
-export function searchValidation(definition, options = {}) {
-  options = {
+export function searchValidation(options = {}) {
+  const { defaults, definition, appendSchema } = options;
+
+  const searchOptions = {
     ...SEARCH_DEFAULTS,
     ...pick(definition.search, 'limit', 'sort'),
-    ...options,
+    ...defaults,
   };
 
-  const { limit, sort, ...rest } = options;
+  const { limit, sort } = searchOptions;
 
   return yd.object({
     ids: yd.array(OBJECT_ID_SCHEMA),
@@ -91,16 +86,26 @@ export function searchValidation(definition, options = {}) {
       .string()
       .description('A keyword to perform a text search against.'),
     skip: yd.number().default(0).description('Number of records to skip.'),
-    sort: yd.allow(SORT_SCHEMA, yd.array(SORT_SCHEMA)).default(sort),
+    sort: getSortSchema(sort),
     limit: yd
       .number()
       .positive()
       .default(limit)
       .description('Limits the number of results.'),
-    ...rest,
+    ...appendSchema,
   });
 }
 
+function getSortSchema(sort) {
+  const schema = yd
+    .object({
+      field: yd.string().required(),
+      order: yd.string().allow('desc', 'asc').required(),
+    })
+    .description('An object describing the sort order of results.');
+  return yd.allow(schema, yd.array(schema)).default(sort);
+}
+
 function validateDefinition(definition) {
   if (Array.isArray(definition.search)) {
     warn(
@@ -113,10 +118,17 @@ function validateDefinition(definition) {
   }
 }
 
-function resolveSort(sort) {
-  if (!Array.isArray(sort)) {
+function resolveSort(sort, schema) {
+  if (!sort) {
+    sort = [];
+  } else if (!Array.isArray(sort)) {
     sort = [sort];
   }
+  for (let { field } of sort) {
+    if (!field || !schema.path(field)) {
+      throw new Error(`Unknown sort field "${field}".`);
+    }
+  }
   return sort.map(({ field, order }) => {
     return [field, order === 'desc' ? -1 : 1];
   });

package/src/validation.js

@@ -8,30 +8,37 @@ import { searchValidation } from './search';
 import { PermissionsError, ImplementationError } from './errors';
 import { hasUniqueConstraints, assertUnique } from './soft-delete';
 import { isMongooseSchema, isSchemaTypedef } from './utils';
-import { RESERVED_FIELDS } from './schema';
 import { INCLUDE_FIELD_SCHEMA } from './include';
 
-const DATE_SCHEMA = yd.date().iso().tag({
+const DATE_TAGS = {
   'x-schema': 'DateTime',
   'x-description':
     'A `string` in [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html) format.',
+};
+
+export const OBJECT_ID_SCHEMA = yd.string().mongo().tag({
+  'x-schema': 'ObjectId',
+  'x-description':
+    'A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).',
 });
 
-const OBJECT_ID_DESCRIPTION = `
+const REFERENCE_SCHEMA = yd
+  .allow(
+    OBJECT_ID_SCHEMA,
+    yd
+      .object({
+        id: OBJECT_ID_SCHEMA.required(),
+      })
+      .custom((obj) => {
+        return obj.id;
+      })
+  )
+  .tag({
+    'x-schema': 'Reference',
+    'x-description': `
 A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).
 An object with an \`id\` field may also be passed, which will be converted into a string.
-`;
-
-export const OBJECT_ID_SCHEMA = yd
-  .custom(async (val) => {
-    const id = String(val.id || val);
-    await namedSchemas.objectId.validate(id);
-    return id;
-  })
-  .tag({
-    type: 'ObjectId',
-    'x-schema': 'ObjectId',
-    'x-description': OBJECT_ID_DESCRIPTION.trim(),
+    `.trim(),
   });
 
 const namedSchemas = {
@@ -40,7 +47,7 @@ const namedSchemas = {
   email: yd.string().lowercase().email(),
   // Force "objectId" to have parity with refs.
   // "mongo" is notably excluded here for this reason.
-  objectId: yd.string().mongo(),
+  objectId: OBJECT_ID_SCHEMA,
 
   ascii: yd.string().ascii(),
   base64: yd.string().base64(),
@@ -78,7 +85,9 @@ export function applyValidation(schema, definition) {
         model: this,
         appendSchema,
         allowIncludes: true,
-        stripReserved: true,
+        stripDeleted: true,
+        stripTimestamps: true,
+        allowExpandedRefs: true,
         requireWriteAccess: true,
         ...(hasUnique && {
           assertUniqueOptions: {
@@ -97,8 +106,10 @@ export function applyValidation(schema, definition) {
         model: this,
         appendSchema,
         skipRequired: true,
-        stripReserved: true,
         stripUnknown: true,
+        stripDeleted: true,
+        stripTimestamps: true,
+        allowExpandedRefs: true,
         requireWriteAccess: true,
         ...(hasUnique && {
           assertUniqueOptions: {
@@ -112,16 +123,23 @@ export function applyValidation(schema, definition) {
 
   schema.static(
     'getSearchValidation',
-    function getSearchValidation(searchOptions) {
+    function getSearchValidation(options = {}) {
+      const { defaults, includeDeleted, ...appendSchema } = options;
+
       return getSchemaFromMongoose(schema, {
+        model: this,
         allowSearch: true,
         skipRequired: true,
         allowIncludes: true,
         expandDotSyntax: true,
         unwindArrayFields: true,
         requireReadAccess: true,
-        appendSchema: searchValidation(definition, searchOptions),
-        model: this,
+        stripDeleted: !includeDeleted,
+        appendSchema: searchValidation({
+          defaults,
+          definition,
+          appendSchema,
+        }),
       });
     }
   );
@@ -131,18 +149,29 @@ export function applyValidation(schema, definition) {
   });
 
   schema.static('getBaseSchema', function getBaseSchema() {
-    return getSchemaFromMongoose(schema);
+    return getSchemaFromMongoose(schema, {
+      stripDeleted: true,
+    });
   });
 }
 
 // Yada schemas
 
 function getSchemaFromMongoose(schema, options = {}) {
-  let { obj } = schema;
-  if (options.stripReserved) {
-    obj = omit(obj, RESERVED_FIELDS);
+  const fields = getMongooseFields(schema, options);
+  return getValidationSchema(fields, options);
+}
+
+function getMongooseFields(schema, options) {
+  const { stripTimestamps, stripDeleted } = options;
+  let fields = schema.obj;
+  if (stripTimestamps) {
+    fields = omit(fields, ['createdAt', 'updatedAt']);
   }
-  return getValidationSchema(obj, options);
+  if (stripDeleted) {
+    fields = omit(fields, ['deleted', 'deletedAt']);
+  }
+  return fields;
 }
 
 // Exported for testing
@@ -197,7 +226,7 @@ function getObjectSchema(arg, options) {
 
     return schema;
   } else {
-    return getSchemaForType(arg);
+    return getSchemaForType(arg, options);
   }
 }
 
@@ -233,7 +262,7 @@ function getSchemaForTypedef(typedef, options = {}) {
   } else if (typeof type === 'object') {
     schema = getObjectSchema(type, options);
   } else {
-    schema = getSchemaForType(type);
+    schema = getSchemaForType(type, options);
   }
 
   if (isRequired(typedef, options)) {
@@ -269,7 +298,7 @@ function getSchemaForTypedef(typedef, options = {}) {
   return schema;
 }
 
-function getSchemaForType(type) {
+function getSchemaForType(type, options) {
   switch (type) {
     case 'String':
       return yd.string();
@@ -278,14 +307,18 @@ function getSchemaForType(type) {
     case 'Boolean':
       return yd.boolean();
     case 'Date':
-      return DATE_SCHEMA;
+      return yd.date().iso().tag(DATE_TAGS);
     case 'Mixed':
     case 'Object':
       return yd.object();
     case 'Array':
       return yd.array();
     case 'ObjectId':
-      return OBJECT_ID_SCHEMA;
+      if (options.allowExpandedRefs) {
+        return REFERENCE_SCHEMA;
+      } else {
+        return OBJECT_ID_SCHEMA;
+      }
     default:
       throw new TypeError(`Unknown schema type ${type}`);
   }
@@ -322,22 +355,34 @@ function getSearchSchema(schema, type) {
         yd.array(schema),
         yd
           .object({
-            lt: yd.date().iso().tag({
-              'x-ref': 'DateTime',
-              description: 'Select dates occurring before.',
-            }),
-            gt: yd.date().iso().tag({
-              'x-ref': 'DateTime',
-              description: 'Select dates occurring after.',
-            }),
-            lte: yd.date().iso().tag({
-              'x-ref': 'DateTime',
-              description: 'Select dates occurring on or before.',
-            }),
-            gte: yd.date().iso().tag({
-              'x-ref': 'DateTime',
-              description: 'Select dates occurring on or after.',
-            }),
+            lt: yd
+              .date()
+              .iso()
+              .tag({
+                ...DATE_TAGS,
+                description: 'Select dates occurring before.',
+              }),
+            gt: yd
+              .date()
+              .iso()
+              .tag({
+                ...DATE_TAGS,
+                description: 'Select dates occurring after.',
+              }),
+            lte: yd
+              .date()
+              .iso()
+              .tag({
+                ...DATE_TAGS,
+                description: 'Select dates occurring on or before.',
+              }),
+            gte: yd
+              .date()
+              .iso()
+              .tag({
+                ...DATE_TAGS,
+                description: 'Select dates occurring on or after.',
+              }),
           })
           .tag({
             'x-schema': 'DateRange',

package/types/schema.d.ts

@@ -66,6 +66,5 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     overwriteModels?: boolean;
 }, any>;
 export function normalizeAttributes(arg: any, path?: any[]): any;
-export const RESERVED_FIELDS: string[];
 import mongoose from "mongoose";
 //# sourceMappingURL=schema.d.ts.map