@sprucelabs/spruce-cli 17.1.14 → 17.1.15

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

@@ -1,293 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        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 { saveOperations, } from '../types/stores.types.js';
-import errorUtil from '../utilities/error.utility.js';
-export default class AbstractStore extends AbstractMutexer {
-    constructor(db, collectionName) {
-        super();
-        this.db = db;
-        if (collectionName) {
-            this.setCollectionName(collectionName);
-        }
-    }
-    setCollectionName(name) {
-        this.collectionName = name;
-    }
-    prepareAndNormalizeRecord(record, options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const preparedRecord = this.prepareRecord
-                ? yield this.prepareRecord(record, options)
-                : record;
-            const isScrambled = this.isScrambled(preparedRecord);
-            if (isScrambled) {
-                return preparedRecord;
-            }
-            return normalizeSchemaValues(this.fullSchema, preparedRecord, Object.assign(Object.assign({}, options), { fields: options.includeFields, shouldIncludePrivateFields: options.shouldIncludePrivateFields === true, createEntityInstances: false }));
-        });
-    }
-    create(values, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                //@ts-ignore
-                values.forEach((v) => validateSchemaValues(this.createSchema, v));
-                const cleanedValues = yield Promise.all(values.map((v) => __awaiter(this, void 0, void 0, function* () { return (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) => normalizeSchemaValues(this.databaseSchema, 
-                //@ts-ignore
-                r, { shouldCreateEntityInstances: false }));
-                const records = yield this.db.create(this.collectionName, toSave);
-                return Promise.all(records.map((record) => __awaiter(this, void 0, void 0, function* () { return this.prepareAndNormalizeRecord(record, options); })));
-            }
-            catch (err) {
-                const coded = errorUtil.transformToSpruceErrors(err, new SpruceError({
-                    code: 'UNKNOWN_STORE_ERROR',
-                    storeName: this.name,
-                    action: 'create',
-                    originalError: err,
-                }));
-                throw coded[0];
-            }
-        });
-    }
-    createOne(values, options) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                //@ts-ignore
-                validateSchemaValues(this.createSchema, values);
-                const cleanedValues = this.willCreate
-                    ? yield 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 = normalizeSchemaValues(this.databaseSchema, 
-                //@ts-ignore
-                databaseRecord, { shouldCreateEntityInstances: false });
-                const record = yield this.db.createOne(this.collectionName, toSave);
-                yield ((_b = this.didCreate) === null || _b === void 0 ? void 0 : _b.call(this, record));
-                const normalized = yield this.prepareAndNormalizeRecord(record, options);
-                return normalized;
-            }
-            catch (err) {
-                const coded = errorUtil.transformToSpruceErrors(err, new SpruceError({
-                    code: 'UNKNOWN_STORE_ERROR',
-                    storeName: this.name,
-                    action: 'create',
-                    originalError: err,
-                }));
-                throw coded[0];
-            }
-        });
-    }
-    findOne(query, options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const results = yield this.find(query, { limit: 1 }, options);
-            if (results.length > 0) {
-                return results[0];
-            }
-            return null;
-        });
-    }
-    count(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const count = yield this.db.count(this.collectionName, query);
-            return count;
-        });
-    }
-    find(query, queryOptions, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const results = yield 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 = yield Promise.all(all);
-                return records;
-            }
-            return [];
-        });
-    }
-    upsertOne(query, updates, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const mutexKey = 'upsertOne';
-            yield this.lock(mutexKey);
-            try {
-                const notFoundHandler = () => __awaiter(this, void 0, void 0, function* () {
-                    const created = yield this.createOne(updates, Object.assign(Object.assign({}, options), { shouldIncludePrivateFields: true }));
-                    //@ts-ignore
-                    return created;
-                });
-                const entity = new SchemaEntity(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 = yield this.findOneAndUpdate(query, 
-                //@ts-ignore
-                cleanedUpdates, notFoundHandler, options);
-                return results;
-            }
-            finally {
-                this.unlock(mutexKey);
-            }
-        });
-    }
-    updateOne(query, updates, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const notFoundHandler = () => __awaiter(this, void 0, void 0, function* () {
-                throw new SpruceError({
-                    code: 'RECORD_NOT_FOUND',
-                    storeName: this.name,
-                    query,
-                });
-            });
-            return this.findOneAndUpdate(query, updates, notFoundHandler, options);
-        });
-    }
-    update(query, updates) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.db.update(this.collectionName, query, updates);
-        });
-    }
-    findOneAndUpdate(query, updates, notFoundHandler, options = {}) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const { ops, updates: initialUpdates } = this.pluckOperations(updates);
-            try {
-                const isScrambled = this.isScrambled(initialUpdates);
-                let current = yield this.findOne(query, Object.assign(Object.assign({}, options), { shouldIncludePrivateFields: true }));
-                if (!current) {
-                    current = yield notFoundHandler();
-                    if (current) {
-                        return current;
-                    }
-                    else {
-                        throw new Error('Make sure your notFoundHandler returns a record or throws');
-                    }
-                }
-                if (!isScrambled) {
-                    //@ts-ignore
-                    validateSchemaValues(this.updateSchema, initialUpdates);
-                }
-                const cleanedUpdates = !isScrambled && this.willUpdate
-                    ? yield this.willUpdate(initialUpdates, current)
-                    : initialUpdates;
-                const databaseRecord = Object.assign(Object.assign({}, current), cleanedUpdates);
-                const normalizedValues = isScrambled
-                    ? databaseRecord
-                    : normalizeSchemaValues(this.databaseSchema, databaseRecord, {
-                        shouldCreateEntityInstances: false,
-                        fields: Object.keys(cleanedUpdates),
-                    });
-                for (const { name, value } of ops) {
-                    normalizedValues[name] = value;
-                }
-                const results = yield this.db.updateOne(this.collectionName, query, normalizedValues);
-                yield ((_a = this.didUpdate) === null || _a === void 0 ? void 0 : _a.call(this, current, results));
-                return this.prepareAndNormalizeRecord(results, options);
-            }
-            catch (err) {
-                const coded = errorUtil.transformToSpruceErrors(err, new SpruceError({
-                    code: 'UNKNOWN_STORE_ERROR',
-                    storeName: this.name,
-                    action: 'update',
-                    originalError: err,
-                }));
-                throw coded[0];
-            }
-        });
-    }
-    pluckOperations(updates) {
-        const initialUpdates = __rest(updates, []);
-        const ops = 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 };
-    }
-    scramble(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.scrambleFields) {
-                throw new SpruceError({ code: 'SCRAMBLE_NOT_CONFIGURED' });
-            }
-            const values = yield this.generateScrambledRecord();
-            //@ts-ignore
-            return this.updateOne({ id }, values);
-        });
-    }
-    isScrambled(preparedRecord) {
-        return !!preparedRecord._isScrambled;
-    }
-    generateScrambledRecord() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.scrambleFields) {
-                throw new SpruceError({ code: 'SCRAMBLE_NOT_CONFIGURED' });
-            }
-            const scrambledFields = (_a = this.scrambleFields) === null || _a === void 0 ? void 0 : _a.reduce((values, name) => {
-                values[name] = SCRAMBLE_VALUE;
-                return values;
-            }, {});
-            const record = Object.assign(Object.assign({}, scrambledFields), { _isScrambled: true });
-            const cleanedValues = this.willScramble
-                ? yield this.willScramble(record)
-                : record;
-            return cleanedValues;
-        });
-    }
-    deleteOne(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.db.deleteOne(this.collectionName, query);
-        });
-    }
-    delete(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.db.delete(this.collectionName, query);
-        });
-    }
-}

package/node_modules/@sprucelabs/data-stores/build/esm/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/esm/tests/AbstractDatabaseTest.js

@@ -1,54 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { SchemaRegistry } from '@sprucelabs/schema';
-import AbstractSpruceTest from '@sprucelabs/test';
-import DatabaseFixture from '../fixtures/DatabaseFixture.js';
-export default class AbstractDatabaseTest extends AbstractSpruceTest {
-    static beforeEach() {
-        const _super = Object.create(null, {
-            beforeEach: { get: () => super.beforeEach }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            yield _super.beforeEach.call(this);
-            SchemaRegistry.getInstance().forgetAllSchemas();
-        });
-    }
-    static afterEach() {
-        const _super = Object.create(null, {
-            afterEach: { get: () => super.afterEach }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            yield _super.afterEach.call(this);
-            yield DatabaseFixture.destroy();
-            //@ts-ignore
-            this.db = undefined;
-            //@ts-ignore
-            this.DB_NAME = undefined;
-        });
-    }
-    static DatabaseFixture(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const d = new DatabaseFixture(Object.assign({}, options));
-            return d;
-        });
-    }
-    static connectToDatabase() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.db) {
-                const dbFixture = yield this.DatabaseFixture();
-                const db = yield dbFixture.connectToDatabase();
-                this.DB_NAME = this.shouldUseInMemoryDatabase ? '' : dbFixture.getDbName();
-                this.db = db;
-            }
-            return this.db;
-        });
-    }
-}
-AbstractDatabaseTest.shouldUseInMemoryDatabase = true;

package/node_modules/@sprucelabs/data-stores/build/esm/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/esm/types/database.types.js

@@ -1 +0,0 @@
-export {};

package/node_modules/@sprucelabs/data-stores/build/esm/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/esm/types/query.types.js

@@ -1,2 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-types */
-export {};

package/node_modules/@sprucelabs/data-stores/build/esm/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/esm/types/stores.types.js

@@ -1,10 +0,0 @@
-export const saveOperations = [
-    '$push',
-    '$inc',
-    '$min',
-    '$max',
-    '$mul',
-    '$push',
-    '$pull',
-    '$pop',
-];

package/node_modules/@sprucelabs/data-stores/build/esm/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/esm/utilities/error.utility.js

@@ -1,23 +0,0 @@
-import AbstractSpruceError from '@sprucelabs/error';
-import SpruceError from '../errors/SpruceError.js';
-const errorUtil = {
-    transformToSpruceErrors(err, fallbackErrorWhenUnableToMapToSpruceError) {
-        if (err instanceof AbstractSpruceError) {
-            return [err];
-        }
-        else if (!(err instanceof Error)) {
-            const e = AbstractSpruceError.parse(err, SpruceError);
-            return [e];
-        }
-        const fallback = err instanceof AbstractSpruceError
-            ? [err]
-            : [
-                fallbackErrorWhenUnableToMapToSpruceError !== null && fallbackErrorWhenUnableToMapToSpruceError !== void 0 ? fallbackErrorWhenUnableToMapToSpruceError : new SpruceError({
-                    code: 'UNKNOWN_ERROR',
-                    originalError: err,
-                }),
-            ];
-        return fallback;
-    },
-};
-export default errorUtil;

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

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

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

@@ -1,4 +0,0 @@
-import { ObjectId } from 'mongodb';
-export default function generateId() {
-    return new ObjectId().toString();
-}

package/node_modules/@sprucelabs/data-stores/build/esm/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/esm/utilities/generateIdDeprecated.js

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

package/node_modules/@sprucelabs/data-stores/build/esm/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/esm/utilities/mongo.utility.js

@@ -1,104 +0,0 @@
-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 { ObjectId } from 'mongodb';
-import SpruceError from '../errors/SpruceError.js';
-const mongoUtil = {
-    mapQuery(query, options = {}) {
-        const q = query || {};
-        const opts = options;
-        if (Object.prototype.hasOwnProperty.call(q, 'id') && q.id === undefined) {
-            throw new SpruceError({
-                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 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 ObjectId(id[key]);
-        }
-        else {
-            if (!id[key] || !id[key].map) {
-                throw new SpruceError({
-                    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 ObjectId(value);
-                    }
-                    catch (err) {
-                        throw new SpruceError({
-                            code: 'MONGO_ID_MAPPING_ERROR',
-                            friendlyMessage: `Could not map '${value}' to an id.`,
-                        });
-                    }
-                }
-                else {
-                    return mapNestedIdValues(value);
-                }
-            });
-        }
-    });
-    return mapped;
-}
-export default mongoUtil;

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

@@ -1,10 +0,0 @@
-import { Database } from '../types/database.types';
-export default class DatabaseFactory {
-    private static cache;
-    private constructor();
-    static Database(options: {
-        dbName: string;
-        dbConnectionString: string;
-    }): Database;
-    static reset(): void;
-}