@bedrockio/model 0.5.4 → 0.6.0

package/dist/cjs/schema.js

@@ -12,6 +12,7 @@ var _serialization = require("./serialization");
 var _slug = require("./slug");
 var _search = require("./search");
 var _assign = require("./assign");
+var _upsert = require("./upsert");
 var _hydrate = require("./hydrate");
 var _include = require("./include");
 var _softDelete = require("./soft-delete");
@@ -57,6 +58,7 @@ function createSchema(definition, options = {}) {
   (0, _include.applyInclude)(schema);
   (0, _hydrate.applyHydrate)(schema);
   (0, _assign.applyAssign)(schema);
+  (0, _upsert.applyUpsert)(schema);
   (0, _slug.applySlug)(schema);
   return schema;
 }

package/dist/cjs/search.js

@@ -26,6 +26,7 @@ function applySearch(schema, definition) {
   validateDefinition(definition);
   validateSearchFields(schema, definition);
   applySearchCache(schema, definition);
+  applySearchSync(schema, definition);
   const {
     query: searchQuery,
     fields: searchFields
@@ -391,6 +392,32 @@ function applyCacheHook(schema, definition) {
     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.default.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;

package/dist/cjs/upsert.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyUpsert = applyUpsert;
+function applyUpsert(schema) {
+  // Note: Intentionally avoiding the findOneAndUpdate approach here
+  // as this will prevent hooks from being run on the document. This
+  // means however that we cannot always return a query here as the
+  // operations are inherently different.
+
+  schema.static('findOrCreate', async function findOrCreate(query, fields) {
+    fields ||= query;
+    let doc = await this.findOne(query);
+    if (!doc) {
+      doc = await this.create(fields);
+    }
+    return doc;
+  });
+}

package/package.json

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

package/src/schema.js

@@ -7,6 +7,7 @@ import { serializeOptions } from './serialization';
 import { applySlug } from './slug';
 import { applySearch } from './search';
 import { applyAssign } from './assign';
+import { applyUpsert } from './upsert';
 import { applyHydrate } from './hydrate';
 import { applyInclude } from './include';
 import { applySoftDelete } from './soft-delete';
@@ -61,6 +62,7 @@ export function createSchema(definition, options = {}) {
   applyInclude(schema);
   applyHydrate(schema);
   applyAssign(schema);
+  applyUpsert(schema);
   applySlug(schema);
 
   return schema;

package/src/search.js

@@ -18,6 +18,7 @@ export function applySearch(schema, definition) {
   validateDefinition(definition);
   validateSearchFields(schema, definition);
   applySearchCache(schema, definition);
+  applySearchSync(schema, definition);
 
   const { query: searchQuery, fields: searchFields } = definition.search || {};
 
@@ -415,6 +416,32 @@ function applyCacheHook(schema, 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;

package/src/upsert.js

@@ -0,0 +1,18 @@
+export function applyUpsert(schema) {
+  // Note: Intentionally avoiding the findOneAndUpdate approach here
+  // as this will prevent hooks from being run on the document. This
+  // means however that we cannot always return a query here as the
+  // operations are inherently different.
+
+  schema.static('findOrCreate', async function findOrCreate(query, fields) {
+    fields ||= query;
+
+    let doc = await this.findOne(query);
+
+    if (!doc) {
+      doc = await this.create(fields);
+    }
+
+    return doc;
+  });
+}

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":"AAsBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAyChC;AAED,iEAsBC"}

package/types/search.d.ts.map

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

package/types/upsert.d.ts

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

package/types/upsert.d.ts.map

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