@bedrockio/model 0.1.6 → 0.1.8

package/dist/cjs/include.js

@@ -3,22 +3,31 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.INCLUDE_FIELD_SCHEMA = void 0;
 exports.applyInclude = applyInclude;
 exports.checkSelects = checkSelects;
 exports.getIncludes = getIncludes;
 var _mongoose = _interopRequireDefault(require("mongoose"));
 var _lodash = require("lodash");
+var _yada = _interopRequireDefault(require("@bedrockio/yada"));
 var _utils = require("./utils");
 var _const = require("./const");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // @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.';
+const INCLUDE_FIELD_SCHEMA = _yada.default.object({
+  include: _yada.default.allow(_yada.default.string().description(DESCRIPTION), _yada.default.array(_yada.default.string().description(DESCRIPTION)))
+});
+exports.INCLUDE_FIELD_SCHEMA = INCLUDE_FIELD_SCHEMA;
 function applyInclude(schema) {
   schema.virtual('include').set(function (include) {
     this.$locals.include = include;
@@ -138,6 +147,9 @@ function nodeToPopulates(node) {
 function pathsToNode(paths, modelName) {
   const node = {};
   for (let str of paths) {
+    if (typeof str !== 'string') {
+      throw new Error('Provided include path was not as string.');
+    }
     let exclude = false;
     if (str.startsWith('-')) {
       exclude = true;

package/dist/cjs/search.js

@@ -87,7 +87,6 @@ function searchValidation(definition, options = {}) {
   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.'),
-    include: _yada.default.string().description('Fields to be selected or populated.'),
     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),
     limit: _yada.default.number().positive().default(limit).description('Limits the number of results.'),
@@ -227,8 +226,10 @@ function isNestedQuery(key, value) {
     return !isMongoOperator(key);
   });
 }
+
+// Exclude "include" here as a special case.
 function isArrayQuery(key, value) {
-  return !isMongoOperator(key) && Array.isArray(value);
+  return !isMongoOperator(key) && !isInclude(key) && Array.isArray(value);
 }
 function isRangeQuery(schema, key, value) {
   // Range queries only allowed on Date and Number fields.
@@ -247,6 +248,9 @@ function mapOperatorQuery(obj) {
 function isMongoOperator(str) {
   return str.startsWith('$');
 }
+function isInclude(str) {
+  return str === 'include';
+}
 
 // Regex queries
 

package/dist/cjs/validation.js

@@ -18,6 +18,7 @@ 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({
   'x-schema': 'DateTime',
@@ -74,6 +75,7 @@ function applyValidation(schema, definition) {
     return getSchemaFromMongoose(schema, {
       model: this,
       appendSchema,
+      allowIncludes: true,
       stripReserved: true,
       requireWriteAccess: true,
       ...(hasUnique && {
@@ -104,6 +106,7 @@ function applyValidation(schema, definition) {
     return getSchemaFromMongoose(schema, {
       allowSearch: true,
       skipRequired: true,
+      allowIncludes: true,
       expandDotSyntax: true,
       unwindArrayFields: true,
       requireReadAccess: true,
@@ -111,6 +114,9 @@ function applyValidation(schema, definition) {
       model: this
     });
   });
+  schema.static('getIncludeValidation', function getIncludeValidation() {
+    return _include.INCLUDE_FIELD_SCHEMA;
+  });
   schema.static('getBaseSchema', function getBaseSchema() {
     return getSchemaFromMongoose(schema);
   });
@@ -132,7 +138,8 @@ function getSchemaFromMongoose(schema, options = {}) {
 function getValidationSchema(attributes, options = {}) {
   const {
     appendSchema,
-    assertUniqueOptions
+    assertUniqueOptions,
+    allowIncludes
   } = options;
   let schema = getObjectSchema(attributes, options);
   if (assertUniqueOptions) {
@@ -148,6 +155,9 @@ function getValidationSchema(attributes, options = {}) {
   if (appendSchema) {
     schema = schema.append(appendSchema);
   }
+  if (allowIncludes) {
+    schema = schema.append(_include.INCLUDE_FIELD_SCHEMA);
+  }
   return schema;
 }
 function getObjectSchema(arg, options) {

package/package.json

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

package/src/include.js

@@ -1,5 +1,6 @@
 import mongoose from 'mongoose';
 import { escapeRegExp } from 'lodash';
+import yd from '@bedrockio/yada';
 
 import { resolveInnerField } from './utils';
 import { POPULATE_MAX_DEPTH } from './const';
@@ -7,12 +8,23 @@ 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;
 };
 
+const DESCRIPTION = 'Field to be selected or populated.';
+
+export const INCLUDE_FIELD_SCHEMA = yd.object({
+  include: yd.allow(
+    yd.string().description(DESCRIPTION),
+    yd.array(yd.string().description(DESCRIPTION))
+  ),
+});
+
 export function applyInclude(schema) {
   schema.virtual('include').set(function (include) {
     this.$locals.include = include;
@@ -126,6 +138,9 @@ function nodeToPopulates(node) {
 function pathsToNode(paths, modelName) {
   const node = {};
   for (let str of paths) {
+    if (typeof str !== 'string') {
+      throw new Error('Provided include path was not as string.');
+    }
     let exclude = false;
     if (str.startsWith('-')) {
       exclude = true;

package/src/search.js

@@ -90,7 +90,6 @@ export function searchValidation(definition, options = {}) {
     keyword: yd
       .string()
       .description('A keyword to perform a text search against.'),
-    include: yd.string().description('Fields to be selected or populated.'),
     skip: yd.number().default(0).description('Number of records to skip.'),
     sort: yd.allow(SORT_SCHEMA, yd.array(SORT_SCHEMA)).default(sort),
     limit: yd
@@ -230,8 +229,9 @@ function isNestedQuery(key, value) {
   });
 }
 
+// Exclude "include" here as a special case.
 function isArrayQuery(key, value) {
-  return !isMongoOperator(key) && Array.isArray(value);
+  return !isMongoOperator(key) && !isInclude(key) && Array.isArray(value);
 }
 
 function isRangeQuery(schema, key, value) {
@@ -254,6 +254,10 @@ function isMongoOperator(str) {
   return str.startsWith('$');
 }
 
+function isInclude(str) {
+  return str === 'include';
+}
+
 // Regex queries
 
 const REGEX_QUERY = /^\/(.+)\/(\w*)$/;

package/src/validation.js

@@ -9,6 +9,7 @@ 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({
   'x-schema': 'DateTime',
@@ -76,6 +77,7 @@ export function applyValidation(schema, definition) {
       return getSchemaFromMongoose(schema, {
         model: this,
         appendSchema,
+        allowIncludes: true,
         stripReserved: true,
         requireWriteAccess: true,
         ...(hasUnique && {
@@ -114,6 +116,7 @@ export function applyValidation(schema, definition) {
       return getSchemaFromMongoose(schema, {
         allowSearch: true,
         skipRequired: true,
+        allowIncludes: true,
         expandDotSyntax: true,
         unwindArrayFields: true,
         requireReadAccess: true,
@@ -123,6 +126,10 @@ export function applyValidation(schema, definition) {
     }
   );
 
+  schema.static('getIncludeValidation', function getIncludeValidation() {
+    return INCLUDE_FIELD_SCHEMA;
+  });
+
   schema.static('getBaseSchema', function getBaseSchema() {
     return getSchemaFromMongoose(schema);
   });
@@ -140,7 +147,7 @@ function getSchemaFromMongoose(schema, options = {}) {
 
 // Exported for testing
 export function getValidationSchema(attributes, options = {}) {
-  const { appendSchema, assertUniqueOptions } = options;
+  const { appendSchema, assertUniqueOptions, allowIncludes } = options;
   let schema = getObjectSchema(attributes, options);
   if (assertUniqueOptions) {
     schema = schema.custom(async (obj, { root }) => {
@@ -153,6 +160,9 @@ export function getValidationSchema(attributes, options = {}) {
   if (appendSchema) {
     schema = schema.append(appendSchema);
   }
+  if (allowIncludes) {
+    schema = schema.append(INCLUDE_FIELD_SCHEMA);
+  }
   return schema;
 }
 

package/types/include.d.ts

@@ -1,4 +1,44 @@
 export function applyInclude(schema: any): void;
 export function checkSelects(doc: any, ret: any): void;
 export function getIncludes(modelName: any, arg: any): any;
+export const INCLUDE_FIELD_SCHEMA: {
+    setup: any;
+    getFields: any;
+    append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): any;
+    pick(...names?: string[]): any;
+    omit(...names?: string[]): any;
+    format(name: any, fn: any): import("@bedrockio/yada/types/TypeSchema").default;
+    toString(): any;
+    assertions: any[];
+    meta: {};
+    required(): any;
+    default(value: any): any;
+    custom(...args: import("@bedrockio/yada/types/Schema").CustomSignature): any;
+    strip(strip: any): any;
+    allow(...set: any[]): any;
+    reject(...set: any[]): any;
+    message(message: any): any;
+    tag(tags: any): any;
+    description(description: any): any;
+    options(options: any): any;
+    validate(value: any, options?: {}): Promise<any>;
+    clone(meta: any): any;
+    toOpenApi(extra: any): any;
+    expandExtra(extra?: {}): {};
+    assertEnum(set: any, allow: any): any;
+    assert(type: any, fn: any): any;
+    pushAssertion(assertion: any): void;
+    transform(fn: any): any;
+    getSortIndex(type: any): number;
+    runAssertion(assertion: any, value: any, options?: {}): Promise<any>;
+    enumToOpenApi(): {
+        type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        enum: any;
+        oneOf?: undefined;
+    } | {
+        oneOf: any[];
+        type?: undefined;
+        enum?: undefined;
+    };
+};
 //# sourceMappingURL=include.d.ts.map

package/types/include.d.ts.map

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

package/types/search.d.ts

@@ -2,7 +2,7 @@ export function applySearch(schema: any, definition: any): void;
 export function searchValidation(definition: any, options?: {}): {
     setup: any;
     getFields: any;
-    append(arg: import("@bedrockio/yada/types/Schema").default | import("@bedrockio/yada/types/object").SchemaMap): any;
+    append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): any;
     pick(...names?: string[]): any;
     omit(...names?: string[]): any;
     format(name: any, fn: any): import("@bedrockio/yada/types/TypeSchema").default;

package/types/search.d.ts.map

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

package/types/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAiEA,kDAEC;AAED,oEA2DC;AAaD,wEAeC;AA0PD;;;EAEC;AAED;;;EAOC;AA1YD,8EAUK"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAkEA,kDAEC;AAED,oEAiEC;AAaD,wEAkBC;AA0PD;;;EAEC;AAED;;;EAOC;AAnZD,8EAUK"}