@sprucelabs/spruce-cli 17.1.14 → 17.1.15

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

@@ -1,285 +0,0 @@
-"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

@@ -1,12 +0,0 @@
-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

@@ -1,37 +0,0 @@
-"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

@@ -1,29 +0,0 @@
-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

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

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

@@ -1,29 +0,0 @@
-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

@@ -1,3 +0,0 @@
-"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

@@ -1,24 +0,0 @@
-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

@@ -1,13 +0,0 @@
-"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

@@ -1,5 +0,0 @@
-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

@@ -1,28 +0,0 @@
-"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

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

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

@@ -1,7 +0,0 @@
-"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

@@ -1,6 +0,0 @@
-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

@@ -1,11 +0,0 @@
-"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

@@ -1,12 +0,0 @@
-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

@@ -1,109 +0,0 @@
-"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;