@sprucelabs/data-stores 12.0.14 → 13.0.0

package/build/esm/stores/AbstractStore.d.ts

@@ -6,7 +6,9 @@ import { PrepareOptions, PrepareResults } from '../types/stores.types';
 declare type Response<FullSchema extends Schema, CreateEntityInstances extends boolean, IncludePrivateFields extends boolean, PF extends SchemaPublicFieldNames<FullSchema>, F extends SchemaFieldNames<FullSchema>> = IsDynamicSchema<FullSchema> extends true ? DynamicSchemaAllValues<FullSchema, CreateEntityInstances> : IncludePrivateFields extends false ? Pick<SchemaPublicValues<FullSchema, CreateEntityInstances>, PF> : Pick<SchemaAllValues<FullSchema, CreateEntityInstances>, F>;
 export default abstract class AbstractStore<FullSchema extends Schema, CreateSchema extends Schema = FullSchema, UpdateSchema extends Schema = CreateSchema, DatabaseSchema extends Schema = FullSchema, DatabaseRecord = SchemaValues<DatabaseSchema> & {
     id: string;
-}, QueryRecord = SchemaPartialValues<FullSchema>, FullRecord = SchemaValues<FullSchema>, CreateRecord = SchemaValues<CreateSchema>, UpdateRecord = SchemaValues<UpdateSchema>> extends AbstractMutexer {
+}, QueryRecord = SchemaPartialValues<FullSchema>, FullRecord = SchemaValues<FullSchema>, CreateRecord = SchemaValues<CreateSchema>, UpdateRecord = SchemaValues<UpdateSchema> & {
+    $push?: Record<string, any>;
+}> extends AbstractMutexer {
     abstract readonly name: string;
     protected abstract collectionName: string;
     protected abstract createSchema: CreateSchema;
@@ -36,6 +38,7 @@ export default abstract class AbstractStore<FullSchema extends Schema, CreateSch
     updateOne<IncludePrivateFields extends boolean = false, CreateEntityInstances extends boolean = false, F extends SchemaFieldNames<FullSchema> = SchemaFieldNames<FullSchema>, PF extends SchemaPublicFieldNames<FullSchema> = SchemaPublicFieldNames<FullSchema>>(query: QueryBuilder<QueryRecord>, updates: UpdateRecord, options?: PrepareOptions<IncludePrivateFields, FullSchema, F>): Promise<Response<FullSchema, CreateEntityInstances, IncludePrivateFields, PF, F>>;
     update(query: QueryBuilder<QueryRecord>, updates: UpdateRecord): Promise<number>;
     private findOneAndUpdate;
+    private pluckOperations;
     scramble(id: string): Promise<Response<FullSchema, false, false, SchemaPublicFieldNames<FullSchema>, Extract<keyof FullSchema["fields"], string>>>;
     private isScrambled;
     private generateScrambledRecord;

package/build/esm/stores/AbstractStore.js

@@ -7,11 +7,32 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 import SchemaEntity, { normalizeSchemaValues, validateSchemaValues, } from '@sprucelabs/schema';
 import { SCRAMBLE_VALUE } from '../constants.js';
 import SpruceError from '../errors/SpruceError.js';
 import AbstractMutexer from '../mutexers/AbstractMutexer.js';
 import errorUtil from '../utilities/error.utility.js';
+const operations = [
+    '$push',
+    '$inc',
+    '$min',
+    '$max',
+    '$mul',
+    '$push',
+    '$pull',
+    '$pop',
+];
 export default class AbstractStore extends AbstractMutexer {
     constructor(db, collectionName) {
         super();
@@ -171,8 +192,9 @@ export default class AbstractStore extends AbstractMutexer {
     }
     findOneAndUpdate(query, updates, notFoundHandler, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { ops, updates: initialUpdates } = this.pluckOperations(updates);
             try {
-                const isScrambled = this.isScrambled(updates);
+                const isScrambled = this.isScrambled(initialUpdates);
                 let current = yield this.findOne(query, options);
                 if (!current) {
                     current = yield notFoundHandler();
@@ -185,19 +207,22 @@ export default class AbstractStore extends AbstractMutexer {
                 }
                 if (!isScrambled) {
                     //@ts-ignore
-                    validateSchemaValues(this.updateSchema, updates);
+                    validateSchemaValues(this.updateSchema, initialUpdates);
                 }
                 const cleanedUpdates = !isScrambled && this.willUpdate
-                    ? yield this.willUpdate(updates, current)
-                    : updates;
+                    ? yield this.willUpdate(initialUpdates, current)
+                    : initialUpdates;
                 const databaseRecord = Object.assign(Object.assign({}, current), cleanedUpdates);
-                const toSave = isScrambled
+                const normalizedValues = isScrambled
                     ? databaseRecord
                     : normalizeSchemaValues(this.databaseSchema, databaseRecord, {
                         shouldCreateEntityInstances: false,
                         fields: Object.keys(cleanedUpdates),
                     });
-                const results = yield this.db.updateOne(this.collectionName, query, toSave);
+                for (const { name, value } of ops) {
+                    normalizedValues[name] = value;
+                }
+                const results = yield this.db.updateOne(this.collectionName, query, normalizedValues);
                 return this.prepareAndNormalizeRecord(results, options);
             }
             catch (err) {
@@ -211,6 +236,25 @@ export default class AbstractStore extends AbstractMutexer {
             }
         });
     }
+    pluckOperations(updates) {
+        const initialUpdates = __rest(updates, []);
+        const ops = operations
+            .map((name) => {
+            if (name in initialUpdates) {
+                //@ts-ignore
+                const value = initialUpdates[name];
+                //@ts-ignore
+                delete initialUpdates[name];
+                return {
+                    name,
+                    value,
+                };
+            }
+            return false;
+        })
+            .filter((o) => !!o);
+        return { ops, updates: initialUpdates };
+    }
     scramble(id) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.scrambleFields) {

package/build/stores/AbstractStore.d.ts

@@ -6,7 +6,9 @@ import { PrepareOptions, PrepareResults } from '../types/stores.types';
 declare type Response<FullSchema extends Schema, CreateEntityInstances extends boolean, IncludePrivateFields extends boolean, PF extends SchemaPublicFieldNames<FullSchema>, F extends SchemaFieldNames<FullSchema>> = IsDynamicSchema<FullSchema> extends true ? DynamicSchemaAllValues<FullSchema, CreateEntityInstances> : IncludePrivateFields extends false ? Pick<SchemaPublicValues<FullSchema, CreateEntityInstances>, PF> : Pick<SchemaAllValues<FullSchema, CreateEntityInstances>, F>;
 export default abstract class AbstractStore<FullSchema extends Schema, CreateSchema extends Schema = FullSchema, UpdateSchema extends Schema = CreateSchema, DatabaseSchema extends Schema = FullSchema, DatabaseRecord = SchemaValues<DatabaseSchema> & {
     id: string;
-}, QueryRecord = SchemaPartialValues<FullSchema>, FullRecord = SchemaValues<FullSchema>, CreateRecord = SchemaValues<CreateSchema>, UpdateRecord = SchemaValues<UpdateSchema>> extends AbstractMutexer {
+}, QueryRecord = SchemaPartialValues<FullSchema>, FullRecord = SchemaValues<FullSchema>, CreateRecord = SchemaValues<CreateSchema>, UpdateRecord = SchemaValues<UpdateSchema> & {
+    $push?: Record<string, any>;
+}> extends AbstractMutexer {
     abstract readonly name: string;
     protected abstract collectionName: string;
     protected abstract createSchema: CreateSchema;
@@ -36,6 +38,7 @@ export default abstract class AbstractStore<FullSchema extends Schema, CreateSch
     updateOne<IncludePrivateFields extends boolean = false, CreateEntityInstances extends boolean = false, F extends SchemaFieldNames<FullSchema> = SchemaFieldNames<FullSchema>, PF extends SchemaPublicFieldNames<FullSchema> = SchemaPublicFieldNames<FullSchema>>(query: QueryBuilder<QueryRecord>, updates: UpdateRecord, options?: PrepareOptions<IncludePrivateFields, FullSchema, F>): Promise<Response<FullSchema, CreateEntityInstances, IncludePrivateFields, PF, F>>;
     update(query: QueryBuilder<QueryRecord>, updates: UpdateRecord): Promise<number>;
     private findOneAndUpdate;
+    private pluckOperations;
     scramble(id: string): Promise<Response<FullSchema, false, false, SchemaPublicFieldNames<FullSchema>, Extract<keyof FullSchema["fields"], string>>>;
     private isScrambled;
     private generateScrambledRecord;

package/build/stores/AbstractStore.js

@@ -22,6 +22,17 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -31,6 +42,16 @@ const constants_1 = require("../constants");
 const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
 const AbstractMutexer_1 = __importDefault(require("../mutexers/AbstractMutexer"));
 const error_utility_1 = __importDefault(require("../utilities/error.utility"));
+const operations = [
+    '$push',
+    '$inc',
+    '$min',
+    '$max',
+    '$mul',
+    '$push',
+    '$pull',
+    '$pop',
+];
 class AbstractStore extends AbstractMutexer_1.default {
     constructor(db, collectionName) {
         super();
@@ -171,8 +192,9 @@ class AbstractStore extends AbstractMutexer_1.default {
         return this.db.update(this.collectionName, query, updates);
     }
     async findOneAndUpdate(query, updates, notFoundHandler, options = {}) {
+        const { ops, updates: initialUpdates } = this.pluckOperations(updates);
         try {
-            const isScrambled = this.isScrambled(updates);
+            const isScrambled = this.isScrambled(initialUpdates);
             let current = await this.findOne(query, options);
             if (!current) {
                 current = await notFoundHandler();
@@ -185,19 +207,22 @@ class AbstractStore extends AbstractMutexer_1.default {
             }
             if (!isScrambled) {
                 //@ts-ignore
-                (0, schema_1.validateSchemaValues)(this.updateSchema, updates);
+                (0, schema_1.validateSchemaValues)(this.updateSchema, initialUpdates);
             }
             const cleanedUpdates = !isScrambled && this.willUpdate
-                ? await this.willUpdate(updates, current)
-                : updates;
+                ? await this.willUpdate(initialUpdates, current)
+                : initialUpdates;
             const databaseRecord = Object.assign(Object.assign({}, current), cleanedUpdates);
-            const toSave = isScrambled
+            const normalizedValues = isScrambled
                 ? databaseRecord
                 : (0, schema_1.normalizeSchemaValues)(this.databaseSchema, databaseRecord, {
                     shouldCreateEntityInstances: false,
                     fields: Object.keys(cleanedUpdates),
                 });
-            const results = await this.db.updateOne(this.collectionName, query, toSave);
+            for (const { name, value } of ops) {
+                normalizedValues[name] = value;
+            }
+            const results = await this.db.updateOne(this.collectionName, query, normalizedValues);
             return this.prepareAndNormalizeRecord(results, options);
         }
         catch (err) {
@@ -210,6 +235,25 @@ class AbstractStore extends AbstractMutexer_1.default {
             throw coded[0];
         }
     }
+    pluckOperations(updates) {
+        const initialUpdates = __rest(updates, []);
+        const ops = operations
+            .map((name) => {
+            if (name in initialUpdates) {
+                //@ts-ignore
+                const value = initialUpdates[name];
+                //@ts-ignore
+                delete initialUpdates[name];
+                return {
+                    name,
+                    value,
+                };
+            }
+            return false;
+        })
+            .filter((o) => !!o);
+        return { ops, updates: initialUpdates };
+    }
     async scramble(id) {
         if (!this.scrambleFields) {
             throw new SpruceError_1.default({ code: 'SCRAMBLE_NOT_CONFIGURED' });

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "12.0.14",
+  "version": "13.0.0",
   "files": [
     "build/**/*",
     "!build/__tests__",
@@ -73,10 +73,10 @@
   "dependencies": {
     "@sprucelabs/error": "^5.0.460",
     "@sprucelabs/schema": "^28.2.17",
-    "@sprucelabs/spruce-core-schemas": "^29.1.12",
+    "@sprucelabs/spruce-core-schemas": "^30.0.0",
     "@sprucelabs/spruce-skill-utils": "^26.0.43",
     "globby": "^11.0.4",
-    "just-clone": "^5.0.1",
+    "just-clone": "^5.1.0",
     "lodash": "^4.17.21",
     "mongodb": "^4.1.0",
     "nedb": "^1.8.0"