@bedrockio/model 0.4.0 → 0.4.1

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/package.json

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

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/types/load.d.ts

@@ -4,73 +4,7 @@
  * @param {string} name
  * @returns mongoose.Model
  */
-export function loadModel(definition: object, name: string): mongoose.Model<any, any, any, any, any, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, any, any, any, {
-    [x: string]: any;
-}, {
-    autoIndex?: boolean;
-    autoCreate?: boolean;
-    bufferCommands?: boolean;
-    bufferTimeoutMS?: number;
-    capped?: number | boolean | {
-        size?: number;
-        max?: number;
-        autoIndexId?: boolean;
-    };
-    collation?: mongoose.mongo.CollationOptions;
-    collectionOptions?: mongoose.mongo.CreateCollectionOptions;
-    timeseries?: mongoose.mongo.TimeSeriesCollectionOptions;
-    expireAfterSeconds?: number;
-    expires?: string | number;
-    collection?: string;
-    discriminatorKey?: string;
-    excludeIndexes?: boolean;
-    id?: boolean;
-    _id?: boolean;
-    minimize?: boolean;
-    optimisticConcurrency?: boolean;
-    pluginTags?: string[];
-    read?: string;
-    writeConcern?: mongoose.mongo.WriteConcern;
-    safe?: boolean | {
-        w?: string | number;
-        wtimeout?: number;
-        j?: boolean;
-    };
-    shardKey?: Record<string, unknown>;
-    strict?: boolean | "throw";
-    strictQuery?: boolean | "throw";
-    toJSON: {
-        getters: boolean;
-        versionKey: boolean;
-        transform: (doc: any, ret: any, options: any) => void;
-    } | mongoose.ToObjectOptions<any>;
-    toObject: {
-        getters: boolean;
-        versionKey: boolean;
-        transform: (doc: any, ret: any, options: any) => void;
-    } | mongoose.ToObjectOptions<any>;
-    typeKey?: string;
-    validateBeforeSave?: boolean;
-    validateModifiedOnly?: boolean;
-    versionKey?: string | boolean;
-    selectPopulatedPaths?: boolean;
-    skipVersioning?: {
-        [key: string]: boolean;
-    };
-    storeSubdocValidationError?: boolean;
-    timestamps: boolean | mongoose.SchemaTimestampsConfig;
-    suppressReservedKeysWarning?: boolean;
-    statics?: {
-        [x: string]: any;
-    };
-    methods?: any;
-    query?: any;
-    castNonArrays?: boolean;
-    virtuals?: mongoose.SchemaOptionsVirtualsPropertyType<any, any, any>;
-    overwriteModels?: boolean;
-}, any, any>> & {
-    [x: string]: any;
-};
+export function loadModel(definition: object, name: string): any;
 /**
  * Loads all model definitions in the given directory.
  * Returns the full loaded model set.

package/types/load.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../src/load.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,sCAJW,MAAM,QACN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAahB;AAED;;;;GAIG;AACH,sCAFW,MAAM,mBAkBhB"}
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../src/load.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,sCAJW,MAAM,QACN,MAAM,OAahB;AAED;;;;GAIG;AACH,sCAFW,MAAM,mBAkBhB"}

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/schema.d.ts

@@ -6,9 +6,7 @@
  * @param {mongoose.SchemaOptions} options
  * @returns mongoose.Schema
  */
-export function createSchema(definition: object, options?: mongoose.SchemaOptions): mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, any, any, any, {
-    [x: string]: any;
-}, {
+export function createSchema(definition: object, options?: mongoose.SchemaOptions): mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, any, any, any, any, {
     autoIndex?: boolean;
     autoCreate?: boolean;
     bufferCommands?: boolean;
@@ -62,10 +60,8 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     storeSubdocValidationError?: boolean;
     timestamps: boolean | mongoose.SchemaTimestampsConfig;
     suppressReservedKeysWarning?: boolean;
-    statics?: {
-        [x: string]: any;
-    };
-    methods?: any;
+    statics?: mongoose.AddThisParameter<any, mongoose.Model<any, {}, {}, {}, any, any>>;
+    methods?: mongoose.AddThisParameter<any, any> & mongoose.AnyObject;
     query?: any;
     castNonArrays?: boolean;
     virtuals?: mongoose.SchemaOptionsVirtualsPropertyType<any, any, any>;

package/types/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAqBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAwChC;AAED,iEAsBC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAqBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAwChC;AAED,iEAsBC"}

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

@@ -11,7 +11,6 @@ export function getTupleValidator(types: any): {
 };
 export const OBJECT_ID_SCHEMA: {
     required(): any;
-    allowEmpty(): any;
     length(length: number): any;
     min(length: number): any;
     max(length: number): 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,oEA8FC;AAsBD,wEA2BC;AAmSD;;;EAEC;AAED;;;EAOC;AAjgBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQK"}