@bedrockio/model 0.4.0 → 0.4.2

package/dist/cjs/query.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.mergeQuery = mergeQuery;
 exports.wrapQuery = wrapQuery;
 // Wrapper that allows a mongoose query object to be returned
 // to access chained methods while still resolving with a
@@ -18,4 +19,20 @@ function wrapQuery(query, fn) {
     }
   };
   return query;
+}
+function mergeQuery(target, source) {
+  const result = Object.assign({}, target, source);
+  if (target.$or && source.$or) {
+    const {
+      $or
+    } = target;
+    result.$or = source.$or.map(conditions => {
+      return {
+        $and: [conditions, {
+          $or
+        }]
+      };
+    });
+  }
+  return result;
 }

package/dist/cjs/search.js

@@ -25,10 +25,14 @@ const {
 function applySearch(schema, definition) {
   validateDefinition(definition);
   applySearchCache(schema, definition);
+  const {
+    query: searchQuery,
+    fields: searchFields
+  } = definition.search || {};
   schema.static('search', function search(body = {}) {
     const options = {
       ..._const.SEARCH_DEFAULTS,
-      ...definition.search?.query,
+      ...searchQuery,
       ...body
     };
     const {
@@ -39,16 +43,19 @@ function applySearch(schema, definition) {
       sort,
       ...rest
     } = options;
-    const query = {};
+    let query = normalizeQuery(rest, schema.obj);
     if (ids?.length) {
-      query._id = {
-        $in: ids
+      query = {
+        ...query,
+        _id: {
+          $in: ids
+        }
       };
     }
     if (keyword) {
-      Object.assign(query, buildKeywordQuery(schema, keyword, definition.search?.fields));
+      const keywordQuery = buildKeywordQuery(schema, keyword, searchFields);
+      query = (0, _query.mergeQuery)(query, keywordQuery);
     }
-    Object.assign(query, normalizeQuery(rest, schema.obj));
     if (_env.debug) {
       _logger.default.info(`Search query for ${this.modelName}:\n`, JSON.stringify(query, null, 2));
     }

package/dist/cjs/validation.js

@@ -83,6 +83,7 @@ function applyValidation(schema, definition) {
       model: this,
       appendSchema,
       allowInclude,
+      allowEmpty: true,
       stripDeleted: true,
       stripTimestamps: true,
       allowDefaultTags: true,
@@ -286,6 +287,10 @@ function getSchemaForTypedef(typedef, options = {}) {
     // Unsetting only allowed for primitive types.
     if (allowUnset(typedef, options)) {
       schema = _yada.default.allow(null, '', schema);
+    } else if (allowEmpty(typedef, options)) {
+      schema = schema.options({
+        allowEmpty: true
+      });
     }
   }
   if (isRequired(typedef, options)) {
@@ -400,6 +405,9 @@ function isRequired(typedef, options) {
 function allowUnset(typedef, options) {
   return options.allowUnset && !typedef.required;
 }
+function allowEmpty(typedef, options) {
+  return options.allowEmpty && typedef.type === 'String';
+}
 function isExcludedField(field, options) {
   if ((0, _utils.isSchemaTypedef)(field)) {
     if (options.requireWriteAccess) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {
@@ -30,7 +30,7 @@
     "lodash": "^4.17.21"
   },
   "peerDependencies": {
-    "@bedrockio/yada": "^1.0.40",
+    "@bedrockio/yada": "^1.1.2",
     "mongoose": "^7.6.13"
   },
   "devDependencies": {
@@ -38,7 +38,7 @@
     "@babel/core": "^7.20.12",
     "@babel/preset-env": "^7.20.2",
     "@bedrockio/prettier-config": "^1.0.2",
-    "@bedrockio/yada": "^1.0.40",
+    "@bedrockio/yada": "^1.1.2",
     "@shelf/jest-mongodb": "^4.3.2",
     "eslint": "^8.33.0",
     "eslint-plugin-bedrock": "^1.0.26",

package/src/query.js

@@ -13,3 +13,16 @@ export function wrapQuery(query, fn) {
   };
   return query;
 }
+
+export function mergeQuery(target, source) {
+  const result = Object.assign({}, target, source);
+  if (target.$or && source.$or) {
+    const { $or } = target;
+    result.$or = source.$or.map((conditions) => {
+      return {
+        $and: [conditions, { $or }],
+      };
+    });
+  }
+  return result;
+}

package/src/search.js

@@ -15,7 +15,7 @@ import { isDateField, isNumberField, getField } from './utils';
 import { SEARCH_DEFAULTS } from './const';
 import { OBJECT_ID_SCHEMA } from './validation';
 import { debug } from './env';
-import { wrapQuery } from './query';
+import { mergeQuery, wrapQuery } from './query';
 
 import warn from './warn';
 
@@ -26,30 +26,31 @@ export function applySearch(schema, definition) {
   validateDefinition(definition);
   applySearchCache(schema, definition);
 
+  const { query: searchQuery, fields: searchFields } = definition.search || {};
+
   schema.static('search', function search(body = {}) {
     const options = {
       ...SEARCH_DEFAULTS,
-      ...definition.search?.query,
+      ...searchQuery,
       ...body,
     };
 
     const { ids, keyword, skip = 0, limit, sort, ...rest } = options;
 
-    const query = {};
+    let query = normalizeQuery(rest, schema.obj);
 
     if (ids?.length) {
-      query._id = { $in: ids };
+      query = {
+        ...query,
+        _id: { $in: ids },
+      };
     }
 
     if (keyword) {
-      Object.assign(
-        query,
-        buildKeywordQuery(schema, keyword, definition.search?.fields)
-      );
+      const keywordQuery = buildKeywordQuery(schema, keyword, searchFields);
+      query = mergeQuery(query, keywordQuery);
     }
 
-    Object.assign(query, normalizeQuery(rest, schema.obj));
-
     if (debug) {
       logger.info(
         `Search query for ${this.modelName}:\n`,

package/src/validation.js

@@ -95,6 +95,7 @@ export function applyValidation(schema, definition) {
         model: this,
         appendSchema,
         allowInclude,
+        allowEmpty: true,
         stripDeleted: true,
         stripTimestamps: true,
         allowDefaultTags: true,
@@ -301,6 +302,10 @@ function getSchemaForTypedef(typedef, options = {}) {
     // Unsetting only allowed for primitive types.
     if (allowUnset(typedef, options)) {
       schema = yd.allow(null, '', schema);
+    } else if (allowEmpty(typedef, options)) {
+      schema = schema.options({
+        allowEmpty: true,
+      });
     }
   }
 
@@ -459,6 +464,10 @@ function allowUnset(typedef, options) {
   return options.allowUnset && !typedef.required;
 }
 
+function allowEmpty(typedef, options) {
+  return options.allowEmpty && typedef.type === 'String';
+}
+
 function isExcludedField(field, options) {
   if (isSchemaTypedef(field)) {
     if (options.requireWriteAccess) {

package/types/include.d.ts

@@ -14,7 +14,7 @@ export const INCLUDE_FIELD_SCHEMA: {
     meta: {};
     required(): any;
     default(arg: any): any;
-    custom(...args: import("@bedrockio/yada/types/Schema").CustomSignature): any;
+    custom(fn: Function): any;
     strip(strip: any): any;
     allow(...set: any[]): any;
     reject(...set: any[]): any;

package/types/query.d.ts

@@ -1,2 +1,3 @@
 export function wrapQuery(query: any, fn: any): any;
+export function mergeQuery(target: any, source: any): any;
 //# sourceMappingURL=query.d.ts.map

package/types/query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.js"],"names":[],"mappings":"AAIA,oDAUC"}
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.js"],"names":[],"mappings":"AAIA,oDAUC;AAED,0DAWC"}

package/types/search.d.ts

@@ -11,7 +11,7 @@ export function searchValidation(options?: {}): {
     meta: {};
     required(): any;
     default(arg: any): any;
-    custom(...args: import("@bedrockio/yada/types/Schema").CustomSignature): any;
+    custom(fn: Function): any;
     strip(strip: any): any;
     allow(...set: any[]): any;
     reject(...set: any[]): any;

package/types/search.d.ts.map

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

package/types/validation.d.ts

@@ -73,7 +73,7 @@ export const OBJECT_ID_SCHEMA: {
     assertions: any[];
     meta: {};
     default(arg: any): any;
-    custom(...args: import("@bedrockio/yada/types/Schema").CustomSignature): any;
+    custom(fn: Function): any;
     strip(strip: any): any;
     allow(...set: any[]): any;
     reject(...set: any[]): any;

package/types/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAkFA,kDAEC;AAED,oEA8FC;AAsBD,wEA2BC;AAmSD;;;EAEC;AAED;;;EAOC;AAjgBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQK"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAkFA,kDAEC;AAED,oEA+FC;AAsBD,wEA2BC;AA2SD;;;EAEC;AAED;;;EAOC;AA1gBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQK"}