@bedrockio/model 0.2.17 → 0.2.19

package/src/search.js

@@ -1,7 +1,15 @@
 import yd from '@bedrockio/yada';
 import logger from '@bedrockio/logger';
 import mongoose from 'mongoose';
-import { pick, isEmpty, escapeRegExp, isPlainObject } from 'lodash';
+import {
+  get,
+  pick,
+  isEmpty,
+  camelCase,
+  upperFirst,
+  escapeRegExp,
+  isPlainObject,
+} from 'lodash';
 
 import { isDateField, isNumberField, getField } from './utils';
 import { SEARCH_DEFAULTS } from './const';
@@ -11,19 +19,21 @@ import { wrapQuery } from './query';
 
 import warn from './warn';
 
+const { SchemaTypes } = mongoose;
 const { ObjectId } = mongoose.Types;
 
 export function applySearch(schema, definition) {
   validateDefinition(definition);
+  applySearchCache(schema, definition);
 
   schema.static('search', function search(body = {}) {
     const options = {
       ...SEARCH_DEFAULTS,
-      ...definition.search,
+      ...definition.search?.query,
       ...body,
     };
 
-    const { ids, keyword, skip = 0, limit, sort, fields, ...rest } = options;
+    const { ids, keyword, skip = 0, limit, sort, ...rest } = options;
 
     const query = {};
 
@@ -32,7 +42,10 @@ export function applySearch(schema, definition) {
     }
 
     if (keyword) {
-      Object.assign(query, buildKeywordQuery(schema, keyword, fields));
+      Object.assign(
+        query,
+        buildKeywordQuery(schema, keyword, definition.search?.fields)
+      );
     }
 
     Object.assign(query, normalizeQuery(rest, schema.obj));
@@ -172,7 +185,7 @@ function buildKeywordQuery(schema, keyword, fields) {
   } else if (hasTextIndex(schema)) {
     queries = [getTextQuery(keyword)];
   } else {
-    queries = [];
+    throw new Error('No keyword fields defined.');
   }
 
   if (ObjectId.isValid(keyword)) {
@@ -300,3 +313,217 @@ function parseRegexQuery(str) {
     $options,
   };
 }
+
+// Search field caching
+
+function applySearchCache(schema, definition) {
+  normalizeCacheFields(schema, definition);
+
+  if (!definition.search?.cache) {
+    return;
+  }
+
+  createCacheFields(schema, definition);
+  applyCacheHook(schema, definition);
+
+  schema.static(
+    'syncSearchFields',
+    async function syncSearchFields(options = {}) {
+      assertIncludeModule(this);
+
+      const { force } = options;
+      const { cache = {} } = definition.search || {};
+
+      const paths = getCachePaths(definition);
+
+      const cachedFields = Object.keys(cache);
+
+      if (!cachedFields.length) {
+        throw new Error('No search fields to sync.');
+      }
+
+      const query = {};
+
+      if (!force) {
+        const $or = Object.entries(cache).map((entry) => {
+          const [cachedField, def] = entry;
+          const { base } = def;
+          return {
+            [base]: {
+              $exists: true,
+            },
+            [cachedField]: {
+              $exists: false,
+            },
+          };
+        });
+        query.$or = $or;
+      }
+
+      const docs = await this.find(query).include(paths);
+
+      const ops = docs.map((doc) => {
+        return {
+          updateOne: {
+            filter: {
+              _id: doc._id,
+            },
+            update: {
+              $set: getUpdates(doc, paths, definition),
+            },
+          },
+        };
+      });
+
+      return await this.bulkWrite(ops);
+    }
+  );
+}
+
+function normalizeCacheFields(schema, definition) {
+  const { fields, cache = {} } = definition.search || {};
+  if (!fields) {
+    return;
+  }
+
+  const normalized = [];
+
+  for (let path of fields) {
+    if (isForeignField(schema, path)) {
+      const cacheName = generateCacheFieldName(path);
+      const type = resolveSchemaType(schema, path);
+      const base = getRefBase(schema, path);
+      cache[cacheName] = {
+        type,
+        base,
+        path: path,
+      };
+      normalized.push(cacheName);
+    } else {
+      normalized.push(path);
+    }
+  }
+
+  definition.search.cache = cache;
+  definition.search.fields = normalized;
+}
+
+function createCacheFields(schema, definition) {
+  for (let [cachedField, def] of Object.entries(definition.search.cache)) {
+    // Fall back to string type for virtuals or not defined.
+    const { type = 'String' } = def;
+    schema.add({
+      [cachedField]: type,
+    });
+    schema.obj[cachedField] = {
+      type,
+      readAccess: 'none',
+    };
+  }
+}
+
+function applyCacheHook(schema, definition) {
+  schema.pre('save', async function () {
+    assertIncludeModule(this.constructor);
+    assertAssignModule(this.constructor);
+
+    const doc = this;
+    const paths = getCachePaths(definition, (cachedField, def) => {
+      if (def.lazy) {
+        return !get(doc, cachedField);
+      } else {
+        return true;
+      }
+    });
+
+    await this.include(paths);
+    this.assign(getUpdates(this, paths, definition));
+  });
+}
+
+function resolveSchemaType(schema, path) {
+  if (!path.includes('.')) {
+    return get(schema.obj, path)?.type;
+  }
+  const field = getRefField(schema, path);
+  if (field) {
+    const { type, rest } = field;
+    const Model = mongoose.models[type.options.ref];
+    return resolveSchemaType(Model.schema, rest.join('.'));
+  }
+}
+
+function isForeignField(schema, path) {
+  if (!path.includes('.')) {
+    return false;
+  }
+  return !!getRefField(schema, path);
+}
+
+function getRefBase(schema, path) {
+  const field = getRefField(schema, path);
+  if (field) {
+    return field.base.join('.');
+  }
+}
+
+function getRefField(schema, path) {
+  const split = path.split('.');
+  for (let i = 1; i < split.length; i++) {
+    const base = split.slice(0, i);
+    const rest = split.slice(i);
+    const type = schema.path(base);
+    if (type instanceof SchemaTypes.ObjectId) {
+      return {
+        type,
+        base,
+        rest,
+      };
+    }
+  }
+}
+
+function getUpdates(doc, paths, definition) {
+  const updates = {};
+
+  const entries = Object.entries(definition.search.cache).filter((entry) => {
+    return paths.includes(entry[1].path);
+  });
+  for (let [cachedField, def] of entries) {
+    // doc.get will not return virtuals (even with specified options),
+    // so use lodash to ensure they are included here.
+    // https://mongoosejs.com/docs/api/document.html#Document.prototype.get()
+    updates[cachedField] = get(doc, def.path);
+  }
+  return updates;
+}
+
+function getCachePaths(definition, filter) {
+  filter ||= () => true;
+  const { cache } = definition.search || {};
+  return Object.entries(cache)
+    .filter((entry) => {
+      return filter(...entry);
+    })
+    .map((entry) => {
+      return entry[1].path;
+    });
+}
+
+function generateCacheFieldName(field) {
+  return `cached${upperFirst(camelCase(field))}`;
+}
+
+// Assertions
+
+function assertIncludeModule(Model) {
+  if (!Model.schema.methods.include) {
+    throw new Error('Include module is required for cached search fields.');
+  }
+}
+
+function assertAssignModule(Model) {
+  if (!Model.schema.methods.assign) {
+    throw new Error('Assign module is required for cached search fields.');
+  }
+}

package/types/delete-hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delete-hooks.d.ts","sourceRoot":"","sources":["../src/delete-hooks.js"],"names":[],"mappings":"AAQA,qEAkDC"}
+{"version":3,"file":"delete-hooks.d.ts","sourceRoot":"","sources":["../src/delete-hooks.js"],"names":[],"mappings":"AAQA,qEA8CC"}

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/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":"AAoBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAuChC;AAED,iEAsBC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAoBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAuChC;AAED,iEAsBC"}

package/types/search.d.ts.map

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