@bedrockio/model 0.7.6 → 0.8.0

package/src/search.js

@@ -1,9 +1,16 @@
 import yd from '@bedrockio/yada';
 import logger from '@bedrockio/logger';
 import mongoose from 'mongoose';
-import { get, pick, isEmpty, escapeRegExp, isPlainObject } from 'lodash';
+import { pick, isEmpty, escapeRegExp, isPlainObject } from 'lodash';
+
+import {
+  getField,
+  isArrayField,
+  isDateField,
+  isNumberField,
+  resolveRefPath,
+} from './utils';
 
-import { isArrayField, isDateField, isNumberField, getField } from './utils';
 import { SEARCH_DEFAULTS } from './const';
 import { OBJECT_ID_SCHEMA } from './validation';
 import { debug } from './env';
@@ -11,14 +18,11 @@ import { mergeQuery, wrapQuery } from './query';
 
 import warn from './warn';
 
-const { SchemaTypes } = mongoose;
 const { ObjectId } = mongoose.Types;
 
 export function applySearch(schema, definition) {
   validateDefinition(definition);
   validateSearchFields(schema, definition);
-  applySearchCache(schema, definition);
-  applySearchSync(schema, definition);
 
   const { query: searchQuery, fields: searchFields } = definition.search || {};
 
@@ -317,61 +321,6 @@ function parseRegexQuery(str) {
 
 // Search field caching
 
-function applySearchCache(schema, definition) {
-  if (!definition.search?.cache) {
-    return;
-  }
-
-  createCacheFields(schema, definition);
-  applyCacheHook(schema, definition);
-
-  schema.static(
-    'syncCacheFields',
-    async function syncCacheFields(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.keys(cache).map((cachedField) => {
-          return {
-            [cachedField]: null,
-          };
-        });
-        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 validateSearchFields(schema, definition) {
   const { fields } = definition.search || {};
 
@@ -386,126 +335,11 @@ function validateSearchFields(schema, definition) {
   }
 }
 
-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', path, ...rest } = def;
-
-    schema.add({
-      [cachedField]: type,
-    });
-    schema.obj[cachedField] = {
-      type,
-      ...rest,
-    };
-  }
-}
-
-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));
-  });
-}
-
-// Search field syncing
-
-function applySearchSync(schema, definition) {
-  if (!definition.search?.sync) {
-    return;
-  }
-
-  schema.post('save', async function postSave() {
-    for (let entry of definition.search.sync) {
-      const { ref, path } = entry;
-      const Model = mongoose.models[ref];
-      const docs = await Model.find({
-        [path]: this.id,
-      });
-
-      await Promise.all(
-        docs.map(async (doc) => {
-          await doc.save();
-        })
-      );
-    }
-  });
-}
-
 // Utils
 
 function isForeignField(schema, path) {
   if (!path.includes('.')) {
     return false;
   }
-  return !!getRefField(schema, path);
-}
-
-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.join('.'));
-    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;
-    });
-}
-
-// 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.');
-  }
+  return !!resolveRefPath(schema, path);
 }

package/src/slug.js

@@ -26,20 +26,22 @@ export function applySlug(schema) {
   );
 }
 
-function find(Model, str, args, query) {
+function find(Model, str, args, deleted) {
   const isObjectId = str.length === 24 && ObjectId.isValid(str);
   // There is a non-zero chance of a slug colliding with an ObjectId but
   // is exceedingly rare (run of exactly 24 [a-f0-9] chars together
   // without a hyphen) so this should be acceptable.
-  if (!query && isObjectId) {
-    return Model.findById(str, ...args);
+  const query = {};
+  if (isObjectId) {
+    query._id = str;
   } else {
-    query = { ...query };
-    if (isObjectId) {
-      query._id = str;
-    } else {
-      query.slug = str;
-    }
-    return Model.findOne(query, ...args);
+    query.slug = str;
   }
+  return Model.findOne(
+    {
+      ...deleted,
+      ...query,
+    },
+    ...args
+  );
 }

package/src/utils.js

@@ -1,5 +1,7 @@
 import mongoose from 'mongoose';
 
+const { SchemaTypes } = mongoose;
+
 // Mongoose provides an "equals" method on both documents and
 // ObjectIds, however it does not provide a static method to
 // compare two unknown values that may be either, so provide
@@ -86,6 +88,31 @@ export function getField(obj, path) {
   return field || {};
 }
 
+// Finds a reference field in a schema and splits
+// the provided path into the local and foreign
+// components of the full path.
+export function resolveRefPath(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);
+
+    let type = schema.path(base.join('.'));
+    if (type instanceof SchemaTypes.Array) {
+      type = type.caster;
+    }
+
+    if (type instanceof SchemaTypes.ObjectId) {
+      const { ref } = type.options;
+      return {
+        ref,
+        local: base.join('.'),
+        foreign: rest.join('.'),
+      };
+    }
+  }
+}
+
 // The same as getField but traverses into the final field
 // as well. In the above example this will return:
 // { type: 'Number' }, given "product.inventory"

package/src/validation.js

@@ -19,7 +19,7 @@ const DATE_TAGS = {
 export const OBJECT_ID_SCHEMA = yd
   .string()
   .mongo()
-  .message('{field} must be an id.')
+  .message('Must be an id.')
   .tag({
     'x-schema': 'ObjectId',
     'x-description':
@@ -40,7 +40,7 @@ const REFERENCE_SCHEMA = yd
         return obj.id;
       })
   )
-  .message('{field} must be an id or object containing "id" field.')
+  .message('Must be an id or object containing an "id" field.')
   .tag({
     'x-schema': 'Reference',
     'x-description': `

package/types/cache.d.ts

@@ -0,0 +1,2 @@
+export function applyCache(schema: any, definition: any): void;
+//# sourceMappingURL=cache.d.ts.map

package/types/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.js"],"names":[],"mappings":"AASA,+DAUC"}

package/types/const.d.ts

@@ -1,8 +1,8 @@
 export namespace SEARCH_DEFAULTS {
-    const limit: number;
+    let limit: number;
     namespace sort {
-        const field: string;
-        const order: string;
+        let field: string;
+        let order: string;
     }
 }
 export const POPULATE_MAX_DEPTH: 5;

package/types/const.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../src/const.js"],"names":[],"mappings":";;;;;;;AAQA,mCAAoC"}
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../src/const.js"],"names":[],"mappings":";;;;;;;AAQA,iCAAkC,CAAC,CAAC"}

package/types/include.d.ts

@@ -3,28 +3,28 @@ export function checkSelects(doc: any, ret: any): void;
 export function getParams(modelName: any, arg: any): any;
 export function getDocumentParams(doc: any, arg: any, options?: {}): 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;
+    setup(): void;
+    getFields(): any;
+    append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
+    pick(...names?: string[]): /*elided*/ any;
+    omit(...names?: string[]): /*elided*/ any;
+    format(name: any, fn: any): /*elided*/ any;
     toString(): any;
     assertions: any[];
     meta: {};
-    required(): any;
-    default(arg: any): any;
-    custom(fn: Function): any;
-    strip(strip: any): any;
-    allow(...set: any[]): any;
-    reject(...set: any[]): any;
-    nullable(): any;
-    message(message: any): any;
-    tag(tags: any): any;
-    description(description: any): any;
-    options(options: any): any;
+    required(): /*elided*/ any;
+    default(arg: any): /*elided*/ any;
+    custom(fn: Function): /*elided*/ any;
+    strip(strip: any): /*elided*/ any;
+    allow(...set: any[]): /*elided*/ any;
+    reject(...set: any[]): /*elided*/ any;
+    nullable(): /*elided*/ any;
+    message(message: any): /*elided*/ any;
+    tag(tags: any): /*elided*/ any;
+    description(description: any): /*elided*/ any;
+    options(options: any): /*elided*/ any;
     validate(value: any, options?: {}): Promise<any>;
-    clone(meta: any): any;
+    clone(meta: any): /*elided*/ any;
     toOpenApi(extra: any): any;
     getAnyType(): {
         type: string[];
@@ -39,20 +39,12 @@ export const INCLUDE_FIELD_SCHEMA: {
     };
     expandExtra(extra?: {}): {};
     inspect(): string;
-    assertEnum(set: any, allow: any): any;
-    assert(type: any, fn: any): any;
+    assertEnum(set: any, allow: any): /*elided*/ any;
+    assert(type: any, fn: any): /*elided*/ any;
     pushAssertion(assertion: any): void;
-    transform(fn: any): any;
+    transform(fn: any): /*elided*/ 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;
-    };
+    enumToOpenApi(): any;
 };
 //# 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":"AA2BA,gDAuEC;AAMD,uDA4BC;AAGD,yDAIC;AAGD,yEAUC;AApID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKG"}
+{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../src/include.js"],"names":[],"mappings":"AA2BA,gDAuEC;AAMD,uDA4BC;AAGD,yDAIC;AAaD,yEAUC;AA9ID;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA+CK,CAAC;;;;;;;;;;;;;;;;EA1CH"}

package/types/load.d.ts

@@ -11,5 +11,5 @@ export function loadModel(definition: object, name: string): any;
  * @param {string} dirPath
  */
 export function loadModelDir(dirPath: string): mongoose.Models;
-import mongoose from "mongoose";
+import mongoose from 'mongoose';
 //# sourceMappingURL=load.d.ts.map

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,OAahB;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;qBA5CoB,UAAU"}

package/types/schema.d.ts

@@ -12,7 +12,7 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     autoCreate?: boolean;
     bufferCommands?: boolean;
     bufferTimeoutMS?: number;
-    capped?: number | boolean | {
+    capped?: boolean | number | {
         size?: number;
         max?: number;
         autoIndexId?: boolean;
@@ -21,7 +21,7 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     collectionOptions?: mongoose.mongo.CreateCollectionOptions;
     timeseries?: mongoose.mongo.TimeSeriesCollectionOptions;
     expireAfterSeconds?: number;
-    expires?: string | number;
+    expires?: number | string;
     collection?: string;
     discriminatorKey?: string;
     excludeIndexes?: boolean;
@@ -34,9 +34,9 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     readConcern?: {
         level: "local" | "available" | "majority" | "snapshot" | "linearizable";
     };
-    writeConcern?: mongoose.mongo.WriteConcern;
+    writeConcern?: mongoose.WriteConcern;
     safe?: boolean | {
-        w?: string | number;
+        w?: number | string;
         wtimeout?: number;
         j?: boolean;
     };
@@ -72,5 +72,5 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     overwriteModels?: boolean;
 }, any, any>;
 export function normalizeAttributes(arg: any, path?: any[]): any;
-import mongoose from "mongoose";
+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":"AAsBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAyChC;AAED,iEAsBC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAuBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,QAAQ,CAAC,aAAa;;;;;;;YA8C3B,CAAC;WACH,CAAC;mBAAqB,CAAC;;;;;;;;;;;;;;;;;;;;;SA8G3B,CAAC;gBAEwB,CAAC;SAChB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAtHV;AAED,iEAsBC;qBA9FoB,UAAU"}

package/types/search.d.ts

@@ -1,27 +1,27 @@
 export function applySearch(schema: any, definition: any): void;
 export function searchValidation(options?: {}): {
-    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;
+    setup(): void;
+    getFields(): any;
+    append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
+    pick(...names?: string[]): /*elided*/ any;
+    omit(...names?: string[]): /*elided*/ any;
+    format(name: any, fn: any): /*elided*/ any;
     toString(): any;
     assertions: any[];
     meta: {};
-    required(): any;
-    default(arg: any): any;
-    custom(fn: Function): any;
-    strip(strip: any): any;
-    allow(...set: any[]): any;
-    reject(...set: any[]): any;
-    nullable(): any;
-    message(message: any): any;
-    tag(tags: any): any;
-    description(description: any): any;
-    options(options: any): any;
+    required(): /*elided*/ any;
+    default(arg: any): /*elided*/ any;
+    custom(fn: Function): /*elided*/ any;
+    strip(strip: any): /*elided*/ any;
+    allow(...set: any[]): /*elided*/ any;
+    reject(...set: any[]): /*elided*/ any;
+    nullable(): /*elided*/ any;
+    message(message: any): /*elided*/ any;
+    tag(tags: any): /*elided*/ any;
+    description(description: any): /*elided*/ any;
+    options(options: any): /*elided*/ any;
     validate(value: any, options?: {}): Promise<any>;
-    clone(meta: any): any;
+    clone(meta: any): /*elided*/ any;
     toOpenApi(extra: any): any;
     getAnyType(): {
         type: string[];
@@ -36,20 +36,12 @@ export function searchValidation(options?: {}): {
     };
     expandExtra(extra?: {}): {};
     inspect(): string;
-    assertEnum(set: any, allow: any): any;
-    assert(type: any, fn: any): any;
+    assertEnum(set: any, allow: any): /*elided*/ any;
+    assert(type: any, fn: any): /*elided*/ any;
     pushAssertion(assertion: any): void;
-    transform(fn: any): any;
+    transform(fn: any): /*elided*/ 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;
-    };
+    enumToOpenApi(): any;
 };
 //# sourceMappingURL=search.d.ts.map

package/types/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAgBA,gEA0DC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBC"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAsBA,gEAwDC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAA2C,CAAA;;;;;;;;;;;;;;;;EAyB1C"}

package/types/serialization.d.ts

@@ -1,6 +1,6 @@
 export namespace serializeOptions {
-    const getters: boolean;
-    const versionKey: boolean;
+    let getters: boolean;
+    let versionKey: boolean;
     function transform(doc: any, ret: any, options: any): void;
 }
 //# sourceMappingURL=serialization.d.ts.map

package/types/testing.d.ts

@@ -5,7 +5,6 @@
  * [Link](https://github.com/bedrockio/model#testing)
  * @returns mongoose.Model
  */
-export function createTestModel(...args: any[]): mongoose.Model<any, unknown, unknown, unknown, any, any>;
+export function createTestModel(...args: any[]): any;
 export function getTestModelName(): string;
-import mongoose from "mongoose";
 //# sourceMappingURL=testing.d.ts.map

package/types/testing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,0GAiBC;AAED,2CAEC"}
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,qDAiBC;AAED,2CAEC"}

package/types/utils.d.ts

@@ -1,10 +1,16 @@
 export function isEqual(a: any, b: any): boolean;
-export function isMongooseSchema(obj: any): boolean;
+export function isMongooseSchema(obj: any): obj is mongoose.Schema<any, any, any, any, any, any, any, any, any>;
 export function isReferenceField(obj: any, path: any): boolean;
 export function isDateField(obj: any, path: any): boolean;
 export function isNumberField(obj: any, path: any): boolean;
 export function isArrayField(obj: any, path: any): boolean;
 export function isSchemaTypedef(arg: any): boolean;
 export function getField(obj: any, path: any): any;
+export function resolveRefPath(schema: any, path: any): {
+    ref: any;
+    local: any;
+    foreign: any;
+};
 export function getInnerField(obj: any, path: any): any;
+import mongoose from 'mongoose';
 //# sourceMappingURL=utils.d.ts.map

package/types/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAMA,iDAcC;AAED,oDAEC;AAED,+DAEC;AAED,0DAEC;AAED,4DAEC;AAED,2DAGC;AAOD,mDAGC;AAuBD,mDAYC;AAKD,wDAEC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAQA,iDAcC;AAED,gHAEC;AAED,+DAEC;AAED,0DAEC;AAED,4DAEC;AAED,2DAGC;AAOD,mDAGC;AAuBD,mDAYC;AAKD;;;;EAoBC;AAKD,wDAEC;qBAxHoB,UAAU"}