@bedrockio/model 0.1.7 → 0.1.9

package/dist/cjs/include.js

@@ -16,9 +16,11 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 // @ts-ignore
 // Overloading mongoose Query prototype to
 // allow an "include" method for queries.
-_mongoose.default.Query.prototype.include = function include(paths) {
-  const filter = this.getFilter();
-  filter.include = paths;
+_mongoose.default.Query.prototype.include = function include(arg) {
+  if (arg) {
+    const filter = this.getFilter();
+    filter.include = arg;
+  }
   return this;
 };
 const DESCRIPTION = 'Field to be selected or populated.';

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,54 @@ 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) {
+function resolveSort(sort, schema) {
   if (!Array.isArray(sort)) {
     sort = [sort];
   }
+  for (let {
+    field
+  } of sort) {
+    if (!schema.path(field)) {
+      throw new Error(`Unknown sort field "${field}".`);
+    }
+  }
   return sort.map(({
     field,
     order

package/dist/cjs/validation.js

@@ -17,7 +17,6 @@ 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({
@@ -76,7 +75,8 @@ function applyValidation(schema, definition) {
       model: this,
       appendSchema,
       allowIncludes: true,
-      stripReserved: true,
+      stripDeleted: true,
+      stripTimestamps: true,
       requireWriteAccess: true,
       ...(hasUnique && {
         assertUniqueOptions: {
@@ -91,8 +91,9 @@ function applyValidation(schema, definition) {
       model: this,
       appendSchema,
       skipRequired: true,
-      stripReserved: true,
       stripUnknown: true,
+      stripDeleted: true,
+      stripTimestamps: true,
       requireWriteAccess: true,
       ...(hasUnique && {
         assertUniqueOptions: {
@@ -102,33 +103,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

package/package.json

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

package/src/include.js

@@ -8,9 +8,11 @@ import { POPULATE_MAX_DEPTH } from './const';
 // @ts-ignore
 // Overloading mongoose Query prototype to
 // allow an "include" method for queries.
-mongoose.Query.prototype.include = function include(paths) {
-  const filter = this.getFilter();
-  filter.include = paths;
+mongoose.Query.prototype.include = function include(arg) {
+  if (arg) {
+    const filter = this.getFilter();
+    filter.include = arg;
+  }
   return this;
 };
 

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,15 @@ function validateDefinition(definition) {
   }
 }
 
-function resolveSort(sort) {
+function resolveSort(sort, schema) {
   if (!Array.isArray(sort)) {
     sort = [sort];
   }
+  for (let { field } of sort) {
+    if (!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,7 +8,6 @@ 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({
@@ -78,7 +77,8 @@ export function applyValidation(schema, definition) {
         model: this,
         appendSchema,
         allowIncludes: true,
-        stripReserved: true,
+        stripDeleted: true,
+        stripTimestamps: true,
         requireWriteAccess: true,
         ...(hasUnique && {
           assertUniqueOptions: {
@@ -97,8 +97,9 @@ export function applyValidation(schema, definition) {
         model: this,
         appendSchema,
         skipRequired: true,
-        stripReserved: true,
         stripUnknown: true,
+        stripDeleted: true,
+        stripTimestamps: true,
         requireWriteAccess: true,
         ...(hasUnique && {
           assertUniqueOptions: {
@@ -112,33 +113,55 @@ 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,
+        }),
       });
     }
   );
 
+  schema.static('getIncludeValidation', function getIncludeValidation() {
+    return 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 = 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']);
+  }
+  if (stripDeleted) {
+    fields = omit(fields, ['deleted', 'deletedAt']);
   }
-  return getValidationSchema(obj, options);
+  return fields;
 }
 
 // Exported for testing

package/types/include.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../src/include.js"],"names":[],"mappings":"AAyBA,gDAoCC;AAMD,uDA4BC;AAGD,2DAIC;AApFD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKG"}
+{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../src/include.js"],"names":[],"mappings":"AA2BA,gDAoCC;AAMD,uDA4BC;AAGD,2DAIC;AApFD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKG"}

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

package/types/schema.d.ts.map

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

package/types/search.d.ts

@@ -1,5 +1,5 @@
 export function applySearch(schema: any, definition: any): void;
-export function searchValidation(definition: any, options?: {}): {
+export function searchValidation(options?: {}): {
     setup: any;
     getFields: any;
     append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): any;

package/types/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAmBA,gEAyDC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBC"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAYA,gEAyDC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBC"}

package/types/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAkEA,kDAEC;AAED,oEA6DC;AAaD,wEAkBC;AA0PD;;;EAEC;AAED;;;EAOC;AA/YD,8EAUK"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAiEA,kDAEC;AAED,oEA4EC;AAsBD,wEAkBC;AA0PD;;;EAEC;AAED;;;EAOC;AAvaD,8EAUK"}