@sprucelabs/spruce-cli 17.1.11 → 17.1.14

package/node_modules/@sprucelabs/data-stores/build/stores/AbstractStore.js

@@ -0,0 +1,285 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = __importStar(require("@sprucelabs/schema"));
+const constants_1 = require("../constants");
+const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
+const AbstractMutexer_1 = __importDefault(require("../mutexers/AbstractMutexer"));
+const stores_types_1 = require("../types/stores.types");
+const error_utility_1 = __importDefault(require("../utilities/error.utility"));
+class AbstractStore extends AbstractMutexer_1.default {
+    constructor(db, collectionName) {
+        super();
+        this.db = db;
+        if (collectionName) {
+            this.setCollectionName(collectionName);
+        }
+    }
+    setCollectionName(name) {
+        this.collectionName = name;
+    }
+    async prepareAndNormalizeRecord(record, options = {}) {
+        const preparedRecord = this.prepareRecord
+            ? await this.prepareRecord(record, options)
+            : record;
+        const isScrambled = this.isScrambled(preparedRecord);
+        if (isScrambled) {
+            return preparedRecord;
+        }
+        return (0, schema_1.normalizeSchemaValues)(this.fullSchema, preparedRecord, Object.assign(Object.assign({}, options), { fields: options.includeFields, shouldIncludePrivateFields: options.shouldIncludePrivateFields === true, createEntityInstances: false }));
+    }
+    async create(values, options) {
+        try {
+            //@ts-ignore
+            values.forEach((v) => (0, schema_1.validateSchemaValues)(this.createSchema, v));
+            const cleanedValues = await Promise.all(values.map(async (v) => (this.willCreate ? this.willCreate(v) : v)));
+            const databaseRecords = cleanedValues.map((v) => {
+                var _a;
+                return (Object.assign(Object.assign({}, v), { 
+                    //@ts-ignore
+                    id: (_a = v.id) !== null && _a !== void 0 ? _a : this.db.generateId() }));
+            });
+            const toSave = databaseRecords.map((r) => (0, schema_1.normalizeSchemaValues)(this.databaseSchema, 
+            //@ts-ignore
+            r, { shouldCreateEntityInstances: false }));
+            const records = await this.db.create(this.collectionName, toSave);
+            return Promise.all(records.map(async (record) => this.prepareAndNormalizeRecord(record, options)));
+        }
+        catch (err) {
+            const coded = error_utility_1.default.transformToSpruceErrors(err, new SpruceError_1.default({
+                code: 'UNKNOWN_STORE_ERROR',
+                storeName: this.name,
+                action: 'create',
+                originalError: err,
+            }));
+            throw coded[0];
+        }
+    }
+    async createOne(values, options) {
+        var _a, _b;
+        try {
+            //@ts-ignore
+            (0, schema_1.validateSchemaValues)(this.createSchema, values);
+            const cleanedValues = this.willCreate
+                ? await this.willCreate(values)
+                : values;
+            const databaseRecord = Object.assign(Object.assign({}, cleanedValues), { 
+                //@ts-ignore
+                id: (_a = cleanedValues.id) !== null && _a !== void 0 ? _a : this.db.generateId() });
+            const toSave = (0, schema_1.normalizeSchemaValues)(this.databaseSchema, 
+            //@ts-ignore
+            databaseRecord, { shouldCreateEntityInstances: false });
+            const record = await this.db.createOne(this.collectionName, toSave);
+            await ((_b = this.didCreate) === null || _b === void 0 ? void 0 : _b.call(this, record));
+            const normalized = await this.prepareAndNormalizeRecord(record, options);
+            return normalized;
+        }
+        catch (err) {
+            const coded = error_utility_1.default.transformToSpruceErrors(err, new SpruceError_1.default({
+                code: 'UNKNOWN_STORE_ERROR',
+                storeName: this.name,
+                action: 'create',
+                originalError: err,
+            }));
+            throw coded[0];
+        }
+    }
+    async findOne(query, options = {}) {
+        const results = await this.find(query, { limit: 1 }, options);
+        if (results.length > 0) {
+            return results[0];
+        }
+        return null;
+    }
+    async count(query) {
+        const count = await this.db.count(this.collectionName, query);
+        return count;
+    }
+    async find(query, queryOptions, options) {
+        const results = await this.db.find(this.collectionName, query, Object.assign(Object.assign({}, queryOptions), { includeFields: options === null || options === void 0 ? void 0 : options.includeFields }));
+        if (results) {
+            const all = results.map((result) => 
+            //@ts-ignore
+            this.prepareAndNormalizeRecord(result, options));
+            const records = await Promise.all(all);
+            return records;
+        }
+        return [];
+    }
+    async upsertOne(query, updates, options) {
+        const mutexKey = 'upsertOne';
+        await this.lock(mutexKey);
+        try {
+            const notFoundHandler = async () => {
+                const created = await this.createOne(updates, Object.assign(Object.assign({}, options), { shouldIncludePrivateFields: true }));
+                //@ts-ignore
+                return created;
+            };
+            const entity = new schema_1.default(this.updateSchema, updates);
+            const cleanedUpdates = entity.getValues({
+                validate: false,
+                //@ts-ignore
+                fields: Object.keys(updates),
+                createEntityInstances: false,
+            });
+            if (updates.id) {
+                //@ts-ignore
+                cleanedUpdates.id = updates.id;
+            }
+            const results = await this.findOneAndUpdate(query, 
+            //@ts-ignore
+            cleanedUpdates, notFoundHandler, options);
+            return results;
+        }
+        finally {
+            this.unlock(mutexKey);
+        }
+    }
+    async updateOne(query, updates, options) {
+        const notFoundHandler = async () => {
+            throw new SpruceError_1.default({
+                code: 'RECORD_NOT_FOUND',
+                storeName: this.name,
+                query,
+            });
+        };
+        return this.findOneAndUpdate(query, updates, notFoundHandler, options);
+    }
+    async update(query, updates) {
+        return this.db.update(this.collectionName, query, updates);
+    }
+    async findOneAndUpdate(query, updates, notFoundHandler, options = {}) {
+        var _a;
+        const { ops, updates: initialUpdates } = this.pluckOperations(updates);
+        try {
+            const isScrambled = this.isScrambled(initialUpdates);
+            let current = await this.findOne(query, Object.assign(Object.assign({}, options), { shouldIncludePrivateFields: true }));
+            if (!current) {
+                current = await notFoundHandler();
+                if (current) {
+                    return current;
+                }
+                else {
+                    throw new Error('Make sure your notFoundHandler returns a record or throws');
+                }
+            }
+            if (!isScrambled) {
+                //@ts-ignore
+                (0, schema_1.validateSchemaValues)(this.updateSchema, initialUpdates);
+            }
+            const cleanedUpdates = !isScrambled && this.willUpdate
+                ? await this.willUpdate(initialUpdates, current)
+                : initialUpdates;
+            const databaseRecord = Object.assign(Object.assign({}, current), cleanedUpdates);
+            const normalizedValues = isScrambled
+                ? databaseRecord
+                : (0, schema_1.normalizeSchemaValues)(this.databaseSchema, databaseRecord, {
+                    shouldCreateEntityInstances: false,
+                    fields: Object.keys(cleanedUpdates),
+                });
+            for (const { name, value } of ops) {
+                normalizedValues[name] = value;
+            }
+            const results = await this.db.updateOne(this.collectionName, query, normalizedValues);
+            await ((_a = this.didUpdate) === null || _a === void 0 ? void 0 : _a.call(this, current, results));
+            return this.prepareAndNormalizeRecord(results, options);
+        }
+        catch (err) {
+            const coded = error_utility_1.default.transformToSpruceErrors(err, new SpruceError_1.default({
+                code: 'UNKNOWN_STORE_ERROR',
+                storeName: this.name,
+                action: 'update',
+                originalError: err,
+            }));
+            throw coded[0];
+        }
+    }
+    pluckOperations(updates) {
+        const initialUpdates = __rest(updates, []);
+        const ops = stores_types_1.saveOperations
+            .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' });
+        }
+        const values = await this.generateScrambledRecord();
+        //@ts-ignore
+        return this.updateOne({ id }, values);
+    }
+    isScrambled(preparedRecord) {
+        return !!preparedRecord._isScrambled;
+    }
+    async generateScrambledRecord() {
+        var _a;
+        if (!this.scrambleFields) {
+            throw new SpruceError_1.default({ code: 'SCRAMBLE_NOT_CONFIGURED' });
+        }
+        const scrambledFields = (_a = this.scrambleFields) === null || _a === void 0 ? void 0 : _a.reduce((values, name) => {
+            values[name] = constants_1.SCRAMBLE_VALUE;
+            return values;
+        }, {});
+        const record = Object.assign(Object.assign({}, scrambledFields), { _isScrambled: true });
+        const cleanedValues = this.willScramble
+            ? await this.willScramble(record)
+            : record;
+        return cleanedValues;
+    }
+    async deleteOne(query) {
+        return await this.db.deleteOne(this.collectionName, query);
+    }
+    async delete(query) {
+        return await this.db.delete(this.collectionName, query);
+    }
+}
+exports.default = AbstractStore;

package/node_modules/@sprucelabs/data-stores/build/tests/AbstractDatabaseTest.d.ts

@@ -0,0 +1,12 @@
+import AbstractSpruceTest from '@sprucelabs/test';
+import DatabaseFixture, { DatabaseFixtureOptions } from '../fixtures/DatabaseFixture';
+import { Database } from '../types/database.types';
+export default class AbstractDatabaseTest extends AbstractSpruceTest {
+    protected static db: Database;
+    protected static shouldUseInMemoryDatabase: boolean;
+    protected static DB_NAME: string;
+    protected static beforeEach(): Promise<void>;
+    protected static afterEach(): Promise<void>;
+    protected static DatabaseFixture(options?: DatabaseFixtureOptions): Promise<DatabaseFixture>;
+    protected static connectToDatabase(): Promise<Database>;
+}

package/node_modules/@sprucelabs/data-stores/build/tests/AbstractDatabaseTest.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+const test_1 = __importDefault(require("@sprucelabs/test"));
+const DatabaseFixture_1 = __importDefault(require("../fixtures/DatabaseFixture"));
+class AbstractDatabaseTest extends test_1.default {
+    static async beforeEach() {
+        await super.beforeEach();
+        schema_1.SchemaRegistry.getInstance().forgetAllSchemas();
+    }
+    static async afterEach() {
+        await super.afterEach();
+        await DatabaseFixture_1.default.destroy();
+        //@ts-ignore
+        this.db = undefined;
+        //@ts-ignore
+        this.DB_NAME = undefined;
+    }
+    static async DatabaseFixture(options) {
+        const d = new DatabaseFixture_1.default(Object.assign({}, options));
+        return d;
+    }
+    static async connectToDatabase() {
+        if (!this.db) {
+            const dbFixture = await this.DatabaseFixture();
+            const db = await dbFixture.connectToDatabase();
+            this.DB_NAME = this.shouldUseInMemoryDatabase ? '' : dbFixture.getDbName();
+            this.db = db;
+        }
+        return this.db;
+    }
+}
+exports.default = AbstractDatabaseTest;
+AbstractDatabaseTest.shouldUseInMemoryDatabase = true;

package/node_modules/@sprucelabs/data-stores/build/types/database.types.d.ts

@@ -0,0 +1,29 @@
+import { QueryOptions } from './query.types';
+export declare type UniqueIndex = string[];
+export declare type Index = string[];
+export interface Database {
+    [x: string]: any;
+    syncUniqueIndexes(collectionName: string, indexes: UniqueIndex[]): Promise<void>;
+    syncIndexes(collectionName: string, indexes: Index[]): Promise<void>;
+    dropIndex(collectionName: string, fields: UniqueIndex): Promise<void>;
+    getUniqueIndexes(collectionName: string): Promise<UniqueIndex[]>;
+    getIndexes(collectionName: string): Promise<Index[] | UniqueIndex[]>;
+    isConnected(): boolean;
+    generateId(): string;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    createOne(collection: string, values: Record<string, any>): Promise<Record<string, any>>;
+    create(collection: string, values: Record<string, any>[]): Promise<Record<string, any>[]>;
+    dropCollection(name: string): Promise<void>;
+    dropDatabase(): Promise<void>;
+    findOne(collection: string, query?: Record<string, any>, options?: QueryOptions): Promise<Record<string, any> | null>;
+    find(collection: string, query?: Record<string, any>, options?: QueryOptions): Promise<Record<string, any>[]>;
+    updateOne(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<Record<string, any>>;
+    update(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<number>;
+    upsertOne(collection: string, query: Record<string, any>, updates: Record<string, any>): Promise<Record<string, any>>;
+    delete(collection: string, query: Record<string, any>): Promise<number>;
+    deleteOne(collection: string, query: Record<string, any>): Promise<number>;
+    count(collection: string, query?: Record<string, any>): Promise<number>;
+    createUniqueIndex(collection: string, fields: UniqueIndex): Promise<void>;
+    createIndex(collection: string, fields: Index): Promise<void>;
+}

package/node_modules/@sprucelabs/data-stores/build/types/database.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/@sprucelabs/data-stores/build/types/query.types.d.ts

@@ -0,0 +1,29 @@
+import { QuerySelector } from '../databases/mongo.types';
+declare type QueryPredicate<Query, K extends keyof Query> = Query[K] | QuerySelector<Query[K]> | string;
+declare type Obj = Record<string, any>;
+export declare type QueryBuilder<Query extends Obj> = {
+    [K in keyof Query]?: QueryPredicate<Query, K>;
+} & {
+    id?: string | QuerySelector<string>;
+};
+export interface QueryOptions {
+    skip?: number;
+    limit?: number;
+    sort?: {
+        field: string;
+        direction: 'asc' | 'desc';
+    }[];
+    includeFields?: string[];
+}
+export declare type FlattenAndPathKeys<O extends Obj, T extends Obj = PathKeys<O>> = Flatten<T>;
+export declare type Flatten<T extends Obj> = Pick<T, NonObjectKeysOf<T>> & UnionToIntersection<ObjectValuesOf<T>>;
+export declare type PathKeys<Query extends Obj, prefix extends string = ''> = {
+    [K in Extract<keyof Query, string> as `${prefix}${K}`]: Query[K] extends Obj ? PathKeys<Query[K], `${K}.`> : Query[K];
+};
+declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+declare type ValuesOf<T> = T[keyof T];
+declare type ObjectValuesOf<T> = Exclude<Extract<ValuesOf<T>, object>, Array<any>>;
+declare type NonObjectKeysOf<T> = {
+    [K in keyof T]: T[K] extends Array<any> ? K : T[K] extends Obj ? never : K;
+}[keyof T];
+export {};

package/node_modules/@sprucelabs/data-stores/build/types/query.types.js

@@ -0,0 +1,3 @@
+"use strict";
+/* eslint-disable @typescript-eslint/ban-types */
+Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/@sprucelabs/data-stores/build/types/stores.types.d.ts

@@ -0,0 +1,24 @@
+import { Schema, SchemaFieldNames, SchemaPublicValues, SchemaValues } from '@sprucelabs/schema';
+import StoreFactory from '../factories/StoreFactory';
+import { Database } from './database.types';
+export declare const saveOperations: readonly ["$push", "$inc", "$min", "$max", "$mul", "$push", "$pull", "$pop"];
+export declare type SaveOperation = typeof saveOperations[number];
+export declare type SaveOperations = Partial<Record<SaveOperation, Record<string, any>>>;
+export interface UniversalStoreOptions {
+    db: Database;
+    storeFactory: StoreFactory;
+}
+export interface Store {
+    initialize?(): Promise<void>;
+}
+export interface StoreMap {
+}
+export interface StoreOptionsMap {
+}
+export interface PrepareOptions<IncludePrivateFields extends boolean, S extends Schema, FieldNames extends SchemaFieldNames<S> = SchemaFieldNames<S>> {
+    shouldIncludePrivateFields?: IncludePrivateFields;
+    includeFields?: FieldNames[];
+}
+export declare type PrepareResults<S extends Schema, IncludePrivateFields extends boolean> = IncludePrivateFields extends true ? SchemaPublicValues<S> : SchemaValues<S>;
+export declare type StoreName = keyof StoreMap;
+export declare type StoreOptions<Name extends StoreName> = Name extends keyof StoreOptionsMap ? StoreOptionsMap[Name] : Record<string, never>;

package/node_modules/@sprucelabs/data-stores/build/types/stores.types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveOperations = void 0;
+exports.saveOperations = [
+    '$push',
+    '$inc',
+    '$min',
+    '$max',
+    '$mul',
+    '$push',
+    '$pull',
+    '$pop',
+];

package/node_modules/@sprucelabs/data-stores/build/utilities/error.utility.d.ts

@@ -0,0 +1,5 @@
+import SpruceError from '../errors/SpruceError';
+declare const errorUtil: {
+    transformToSpruceErrors(err: SpruceError | Error | Record<string, any>, fallbackErrorWhenUnableToMapToSpruceError?: SpruceError): SpruceError[];
+};
+export default errorUtil;

package/node_modules/@sprucelabs/data-stores/build/utilities/error.utility.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("@sprucelabs/error"));
+const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
+const errorUtil = {
+    transformToSpruceErrors(err, fallbackErrorWhenUnableToMapToSpruceError) {
+        if (err instanceof error_1.default) {
+            return [err];
+        }
+        else if (!(err instanceof Error)) {
+            const e = error_1.default.parse(err, SpruceError_1.default);
+            return [e];
+        }
+        const fallback = err instanceof error_1.default
+            ? [err]
+            : [
+                fallbackErrorWhenUnableToMapToSpruceError !== null && fallbackErrorWhenUnableToMapToSpruceError !== void 0 ? fallbackErrorWhenUnableToMapToSpruceError : new SpruceError_1.default({
+                    code: 'UNKNOWN_ERROR',
+                    originalError: err,
+                }),
+            ];
+        return fallback;
+    },
+};
+exports.default = errorUtil;

package/node_modules/@sprucelabs/data-stores/build/utilities/generateId.d.ts

@@ -0,0 +1 @@
+export default function generateId(): string;

package/node_modules/@sprucelabs/data-stores/build/utilities/generateId.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongodb_1 = require("mongodb");
+function generateId() {
+    return new mongodb_1.ObjectId().toString();
+}
+exports.default = generateId;

package/node_modules/@sprucelabs/data-stores/build/utilities/generateIdDeprecated.d.ts

@@ -0,0 +1,6 @@
+import generateId from './generateId';
+/**
+ * @deprecated change generateId to use @sprucelabs/spruce-test-utils generateId
+ */
+declare const generateIdDeprecated: typeof generateId;
+export default generateIdDeprecated;

package/node_modules/@sprucelabs/data-stores/build/utilities/generateIdDeprecated.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generateId_1 = __importDefault(require("./generateId"));
+/**
+ * @deprecated change generateId to use @sprucelabs/spruce-test-utils generateId
+ */
+const generateIdDeprecated = generateId_1.default;
+exports.default = generateIdDeprecated;

package/node_modules/@sprucelabs/data-stores/build/utilities/mongo.utility.d.ts

@@ -0,0 +1,12 @@
+import { FindOneOptions } from '../databases/mongo.types';
+import { QueryOptions } from '../types/query.types';
+declare const mongoUtil: {
+    mapQuery(query: Record<string, any>, options?: {
+        shouldTransformToObjectId?: boolean;
+    }): {
+        [x: string]: any;
+    };
+    prepareUpdates(updates: Record<string, any>): Record<string, any>;
+    queryOptionsToMongoFindOptions(options?: QueryOptions): FindOneOptions<any>;
+};
+export default mongoUtil;

package/node_modules/@sprucelabs/data-stores/build/utilities/mongo.utility.js

@@ -0,0 +1,109 @@
+"use strict";
+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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongodb_1 = require("mongodb");
+const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
+const mongoUtil = {
+    mapQuery(query, options = {}) {
+        const q = query || {};
+        const opts = options;
+        if (Object.prototype.hasOwnProperty.call(q, 'id') && q.id === undefined) {
+            throw new SpruceError_1.default({
+                code: 'MONGO_ID_MAPPING_ERROR',
+                friendlyMessage: '`id` cannot be undefined',
+            });
+        }
+        const { id, $or, $and } = q, rest = __rest(q, ["id", "$or", "$and"]);
+        let normalizedValues = rest;
+        if (Array.isArray($and)) {
+            normalizedValues.$and = $and.map((a) => this.mapQuery(a, options));
+        }
+        if (Array.isArray($or)) {
+            normalizedValues.$or = $or.map((o) => this.mapQuery(o, options));
+        }
+        else if (typeof id === 'string') {
+            normalizedValues._id =
+                opts.shouldTransformToObjectId === false ? id : new mongodb_1.ObjectId(id);
+        }
+        else if (id) {
+            normalizedValues._id = mapNestedIdValues(id, options);
+        }
+        return normalizedValues;
+    },
+    prepareUpdates(updates) {
+        let hasDollarSigns = !!Object.keys(updates).find((key) => key[0] === '$');
+        const values = hasDollarSigns ? updates : { $set: updates };
+        return values;
+    },
+    queryOptionsToMongoFindOptions(options) {
+        const _a = options || {}, { sort, includeFields: fields = [] } = _a, rest = __rest(_a, ["sort", "includeFields"]);
+        const mappedOptions = Object.assign({}, rest);
+        if (fields.length > 0) {
+            mappedOptions.projection = {
+                _id: 0,
+            };
+            for (const field of fields) {
+                mappedOptions.projection[field === 'id' ? '_id' : field] = 1;
+            }
+        }
+        if (sort) {
+            let mongoSort = {};
+            sort.forEach((sort) => (mongoSort[sort.field === 'id' ? '_id' : sort.field] =
+                sort.direction === 'asc' ? 1 : -1));
+            mappedOptions.sort = mongoSort;
+        }
+        return mappedOptions;
+    },
+};
+function mapNestedIdValues(id, options = {}) {
+    const mapped = {};
+    Object.keys(id).forEach((key) => {
+        if (['$gt', '$lt', '$gte', '$lte', '$ne'].indexOf(key) > -1) {
+            mapped[key] =
+                options.shouldTransformToObjectId === false
+                    ? id[key]
+                    : new mongodb_1.ObjectId(id[key]);
+        }
+        else {
+            if (!id[key] || !id[key].map) {
+                throw new SpruceError_1.default({
+                    code: 'MONGO_ID_MAPPING_ERROR',
+                    friendlyMessage: `Invalid query, id: { ${key} } must be an array.`,
+                });
+            }
+            mapped[key] = id[key].map((value) => {
+                if (typeof value === 'string') {
+                    try {
+                        return options.shouldTransformToObjectId === false
+                            ? value
+                            : new mongodb_1.ObjectId(value);
+                    }
+                    catch (err) {
+                        throw new SpruceError_1.default({
+                            code: 'MONGO_ID_MAPPING_ERROR',
+                            friendlyMessage: `Could not map '${value}' to an id.`,
+                        });
+                    }
+                }
+                else {
+                    return mapNestedIdValues(value);
+                }
+            });
+        }
+    });
+    return mapped;
+}
+exports.default = mongoUtil;