@sprucelabs/spruce-cli 17.1.14 → 17.1.15

package/node_modules/@sprucelabs/data-stores/build/esm/errors/unknownStoreError.builder.js

@@ -1,19 +0,0 @@
-import { buildErrorSchema } from '@sprucelabs/schema';
-export default buildErrorSchema({
-    id: 'unknownStoreError',
-    name: 'Unknown store error',
-    description: '',
-    fields: {
-        action: {
-            type: 'text',
-            label: 'Action',
-            isRequired: true,
-            hint: 'e.g. createPerson, updateLocation, etc',
-        },
-        storeName: {
-            type: 'text',
-            label: 'Store name',
-            isRequired: true,
-        },
-    },
-});

package/node_modules/@sprucelabs/data-stores/build/esm/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;
-}

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

@@ -1,32 +0,0 @@
-import { SchemaError } from '@sprucelabs/schema';
-import MongoDatabase from '../databases/MongoDatabase.js';
-import NeDbDatabase from '../databases/NeDbDatabase.js';
-export default class DatabaseFactory {
-    constructor() { }
-    static Database(options) {
-        const { dbName, dbConnectionString } = options;
-        let database;
-        if (!dbConnectionString) {
-            throw new SchemaError({
-                code: 'MISSING_PARAMETERS',
-                parameters: ['dbConnectionString'],
-                friendlyMessage: "DatabaseFactory can't connect to the database! Setting env.DB_CONNECTION_STRING may help!",
-            });
-        }
-        const cacheKey = options.dbName + options.dbConnectionString;
-        if (!this.cache[cacheKey]) {
-            if (dbConnectionString.startsWith('memory')) {
-                database = new NeDbDatabase();
-            }
-            else {
-                database = new MongoDatabase(dbConnectionString, { dbName });
-            }
-            this.cache[cacheKey] = database;
-        }
-        return this.cache[cacheKey];
-    }
-    static reset() {
-        this.cache = {};
-    }
-}
-DatabaseFactory.cache = {};

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

@@ -1,25 +0,0 @@
-import { Database } from '../types/database.types';
-import { Store, StoreMap, StoreName, StoreOptions } from '../types/stores.types';
-interface StoreContructor {
-    Store(o: any): Promise<Store> | Store;
-}
-export default class StoreFactory {
-    private storeMap;
-    private db;
-    private static initializations;
-    private stores;
-    private constructor();
-    static Factory(db: Database): StoreFactory;
-    /**
-     * @deprecated stores.Store(..) -> stores.getStore(...)
-     * This change has big speed improvements. This factory method
-     * will never be removed, but hopefully won't be needed often.
-     */
-    Store<Name extends StoreName, Options extends StoreOptions<Name>>(name: Name, options?: Options): Promise<StoreMap[Name]>;
-    getStoreNames(): StoreName[];
-    setStoreClass(name: string, TestStore: StoreContructor): void;
-    setStore(name: StoreName, store: Store): void;
-    getStore<Name extends StoreName>(name: Name): Promise<StoreMap[Name]>;
-    static reset(): void;
-}
-export {};

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

@@ -1,72 +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 { namesUtil } from '@sprucelabs/spruce-skill-utils';
-import SpruceError from '../errors/SpruceError.js';
-export default class StoreFactory {
-    constructor(db) {
-        this.storeMap = {};
-        this.stores = {};
-        this.db = db;
-    }
-    static Factory(db) {
-        return new this(db);
-    }
-    /**
-     * @deprecated stores.Store(..) -> stores.getStore(...)
-     * This change has big speed improvements. This factory method
-     * will never be removed, but hopefully won't be needed often.
-     */
-    Store(name, options) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const Store = this.storeMap[name];
-            if (Store) {
-                if (!Store.Store) {
-                    throw new SpruceError({
-                        code: 'INVALID_STORE',
-                        friendlyMessage: `You have to have ${namesUtil.toPascal(name)}.Store(options: UniversalStoreOptions) factory method on your store that returns \`new this(...)\`.`,
-                    });
-                }
-                const instance = yield Store.Store(Object.assign({ db: this.db, storeFactory: this }, options));
-                if (!StoreFactory.initializations[name]) {
-                    StoreFactory.initializations[name] = true;
-                    yield ((_a = instance.initialize) === null || _a === void 0 ? void 0 : _a.call(instance));
-                }
-                return instance;
-            }
-            throw new SpruceError({
-                code: 'INVALID_STORE_NAME',
-                suppliedName: name,
-                validNames: this.getStoreNames(),
-            });
-        });
-    }
-    getStoreNames() {
-        return Object.keys(this.storeMap);
-    }
-    setStoreClass(name, TestStore) {
-        this.storeMap[name] = TestStore;
-    }
-    setStore(name, store) {
-        this.stores[name] = store;
-    }
-    getStore(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.stores[name]) {
-                this.stores[name] = yield this.Store(name);
-            }
-            return this.stores[name];
-        });
-    }
-    static reset() {
-        this.initializations = {};
-    }
-}
-StoreFactory.initializations = {};

package/node_modules/@sprucelabs/data-stores/build/esm/fixtures/DatabaseFixture.d.ts

@@ -1,22 +0,0 @@
-import { Database } from '../types/database.types';
-export interface DatabaseFixtureOptions {
-    dbConnectionString?: string;
-    dbName?: string;
-}
-export default class DatabaseFixture {
-    private static dbCount;
-    private dbName?;
-    private static activeDatabases;
-    private dbConnectionString?;
-    private static defaultOptions?;
-    constructor(options?: DatabaseFixtureOptions);
-    connectToDatabase(): Promise<Database>;
-    private static connect;
-    static setDefaultConnectOptions(options: DatabaseFixtureOptions): void;
-    static generateDbName(): string;
-    getDbName(): string;
-    static destroy(): Promise<void>;
-    static beforeAll(): void;
-    static beforeEach(): Promise<void>;
-    static afterEach(): Promise<void>;
-}

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

@@ -1,99 +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 { SchemaError } from '@sprucelabs/schema';
-import { MONGO_TEST_URI } from '../databases/MongoDatabase.js';
-import DatabaseFactory from '../factories/DatabaseFactory.js';
-const MEMORY = 'memory://';
-export default class DatabaseFixture {
-    constructor(options) {
-        const { dbConnectionString = MEMORY, dbName } = Object.assign(Object.assign({}, DatabaseFixture.defaultOptions), options);
-        const missing = [];
-        if (!dbConnectionString) {
-            missing.push('dbConnectionString');
-        }
-        if (!dbName && dbConnectionString !== MEMORY) {
-            missing.push('dbName');
-        }
-        if (missing.length > 0) {
-            throw new SchemaError({
-                code: 'MISSING_PARAMETERS',
-                parameters: missing,
-            });
-        }
-        this.dbName = dbName;
-        this.dbConnectionString = dbConnectionString;
-    }
-    connectToDatabase() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const options = {};
-            if (this.dbConnectionString && this.dbName) {
-                options.dbConnectionString = this.dbConnectionString;
-                options.dbName = this.dbName;
-            }
-            else if (this.dbConnectionString) {
-                options.dbConnectionString = this.dbConnectionString;
-            }
-            else {
-                options.dbName = this.dbName = DatabaseFixture.generateDbName();
-                options.dbConnectionString = MONGO_TEST_URI;
-            }
-            const database = yield DatabaseFixture.connect(options);
-            return database;
-        });
-    }
-    static connect(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const database = DatabaseFactory.Database(options);
-            yield database.connect();
-            DatabaseFixture.activeDatabases.push(database);
-            return database;
-        });
-    }
-    static setDefaultConnectOptions(options) {
-        this.defaultOptions = options;
-    }
-    static generateDbName() {
-        return `mercury_${new Date().getTime()}-${this.dbCount++}`;
-    }
-    getDbName() {
-        if (!this.dbName) {
-            throw new Error('You need to connect to the database using `shouldUseInMemoryDatabase=false` before accessing dbName.');
-        }
-        return this.dbName;
-    }
-    static destroy() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.defaultOptions && this.activeDatabases.length === 0) {
-                yield DatabaseFixture.connect(this.defaultOptions);
-            }
-            for (const db of this.activeDatabases) {
-                if (db.isConnected()) {
-                    yield db.dropDatabase();
-                    yield db.close();
-                }
-            }
-            this.activeDatabases = [];
-            DatabaseFactory.reset();
-        });
-    }
-    static beforeAll() { }
-    static beforeEach() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.destroy();
-        });
-    }
-    static afterEach() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.destroy();
-        });
-    }
-}
-DatabaseFixture.dbCount = 0;
-DatabaseFixture.activeDatabases = [];

package/node_modules/@sprucelabs/data-stores/build/esm/fixtures/StoreFixture.d.ts

@@ -1,5 +0,0 @@
-export default class StoreFixture {
-    private activeDir;
-    constructor(activeDir: string);
-    Factory(): Promise<import("..").StoreFactory>;
-}

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

@@ -1,25 +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 StoreLoader from '../loaders/StoreLoader.js';
-import DatabaseFixture from './DatabaseFixture.js';
-export default class StoreFixture {
-    constructor(activeDir) {
-        this.activeDir = activeDir;
-    }
-    Factory() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const dbFixture = new DatabaseFixture();
-            const db = yield dbFixture.connectToDatabase();
-            const loader = yield StoreLoader.Loader(this.activeDir, db);
-            const factory = yield loader.loadStores();
-            return factory;
-        });
-    }
-}

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

@@ -1,21 +0,0 @@
-export { default as AbstractDatabaseTest } from './tests/AbstractDatabaseTest';
-export { default as DatabaseFixture } from './fixtures/DatabaseFixture';
-export * from './fixtures/DatabaseFixture';
-export { default as AbstractStore } from './stores/AbstractStore';
-export { default as StoreFactory } from './factories/StoreFactory';
-export { default as DatabaseFactory } from './factories/DatabaseFactory';
-export { default as StoreLoader } from './loaders/StoreLoader';
-export { default as MongoDatabase } from './databases/MongoDatabase';
-export * from './databases/MongoDatabase';
-export { default as NeDbDatabase } from './databases/NeDbDatabase';
-export { default as mongoUtil } from './utilities/mongo.utility';
-export * from './databases/NeDbDatabase';
-export * from './types/database.types';
-export * from './types/query.types';
-export * from './types/stores.types';
-export * from './constants';
-export { default as generateId } from './utilities/generateIdDeprecated';
-export { default as CursorPager } from './cursors/CursorPager';
-export * from './cursors/CursorPager';
-export { default as CursorPagerFaker } from './cursors/CursorPagerFaker';
-export * from './cursors/CursorPager';

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

@@ -1,21 +0,0 @@
-export { default as AbstractDatabaseTest } from './tests/AbstractDatabaseTest.js';
-export { default as DatabaseFixture } from './fixtures/DatabaseFixture.js';
-export * from './fixtures/DatabaseFixture.js';
-export { default as AbstractStore } from './stores/AbstractStore.js';
-export { default as StoreFactory } from './factories/StoreFactory.js';
-export { default as DatabaseFactory } from './factories/DatabaseFactory.js';
-export { default as StoreLoader } from './loaders/StoreLoader.js';
-export { default as MongoDatabase } from './databases/MongoDatabase.js';
-export * from './databases/MongoDatabase.js';
-export { default as NeDbDatabase } from './databases/NeDbDatabase.js';
-export { default as mongoUtil } from './utilities/mongo.utility.js';
-export * from './databases/NeDbDatabase.js';
-export * from './types/database.types.js';
-export * from './types/query.types.js';
-export * from './types/stores.types.js';
-export * from './constants.js';
-export { default as generateId } from './utilities/generateIdDeprecated.js';
-export { default as CursorPager } from './cursors/CursorPager.js';
-export * from './cursors/CursorPager.js';
-export { default as CursorPagerFaker } from './cursors/CursorPagerFaker.js';
-export * from './cursors/CursorPager.js';

package/node_modules/@sprucelabs/data-stores/build/esm/loaders/StoreLoader.d.ts

@@ -1,25 +0,0 @@
-import AbstractSpruceError from '@sprucelabs/error';
-import { FailedToLoadStoreErrorOptions } from "./../.spruce/errors/options.types";
-import StoreFactory from '../factories/StoreFactory';
-import { Database } from '../types/database.types';
-declare type StoreLoadError = AbstractSpruceError<FailedToLoadStoreErrorOptions>;
-export default class StoreLoader {
-    private activeDir;
-    private db;
-    private static instance;
-    private static defaultStoreDir;
-    private static defaultDb;
-    private constructor();
-    static setStoreDir(dir: string): void;
-    static setDatabase(db: Database): void;
-    static Loader(activeDir: string, db: Database): Promise<StoreLoader>;
-    static getInstance(cwd?: string, database?: Database): Promise<StoreLoader>;
-    loadStores(): Promise<StoreFactory>;
-    loadStoresAndErrors(): Promise<{
-        factory: StoreFactory;
-        errors: StoreLoadError[];
-    }>;
-    private loadStoreClassesWithErrors;
-    static clearInstance(): void;
-}
-export {};

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

@@ -1,120 +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 pathUtil from 'path';
-import { SchemaError } from '@sprucelabs/schema';
-import { diskUtil, HASH_SPRUCE_DIR_NAME, namesUtil, } from '@sprucelabs/spruce-skill-utils';
-import globby from 'globby';
-import SpruceError from '../errors/SpruceError.js';
-import StoreFactory from '../factories/StoreFactory.js';
-export default class StoreLoader {
-    constructor(activeDir, db) {
-        this.activeDir = activeDir;
-        this.db = db;
-    }
-    static setStoreDir(dir) {
-        this.defaultStoreDir = dir;
-    }
-    static setDatabase(db) {
-        this.defaultDb = db;
-    }
-    static Loader(activeDir, db) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new this(activeDir, db);
-        });
-    }
-    static getInstance(cwd, database) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const dir = cwd !== null && cwd !== void 0 ? cwd : this.defaultStoreDir;
-            const db = database !== null && database !== void 0 ? database : this.defaultDb;
-            const missing = [];
-            if (!dir) {
-                missing.push('cwd');
-            }
-            if (!db) {
-                missing.push('database');
-            }
-            if (missing.length > 0) {
-                throw new SchemaError({
-                    code: 'MISSING_PARAMETERS',
-                    parameters: missing,
-                });
-            }
-            const normalizedDir = dir.replace(/\/$/, '');
-            if (!this.instance[normalizedDir]) {
-                this.instance[normalizedDir] = this.Loader(normalizedDir, db);
-            }
-            return this.instance[normalizedDir];
-        });
-    }
-    loadStores() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { factory, errors } = yield this.loadStoresAndErrors();
-            if (errors.length > 0) {
-                throw new SpruceError({ code: 'FAILED_TO_LOAD_STORES', errors });
-            }
-            return factory;
-        });
-    }
-    loadStoresAndErrors() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { stores, errors } = yield this.loadStoreClassesWithErrors();
-            const factory = StoreFactory.Factory(this.db);
-            for (const store of stores) {
-                factory.setStoreClass(namesUtil.toCamel(store.namePascal), store.Class);
-            }
-            return { factory, errors };
-        });
-    }
-    loadStoreClassesWithErrors() {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            const combinedFile = diskUtil.resolveFile(this.activeDir, HASH_SPRUCE_DIR_NAME, 'stores', 'stores');
-            if (!combinedFile) {
-                return { stores: [], errors: [] };
-            }
-            const errors = [];
-            const Stores = [];
-            try {
-                const map = require(combinedFile).default;
-                Object.keys(map).forEach((k) => {
-                    Stores.push({
-                        Class: map[k],
-                        namePascal: k,
-                    });
-                });
-            }
-            catch (_c) {
-                const pattern = diskUtil.resolvePath(this.activeDir, '**', '*.store.[j|t]s');
-                const matches = yield globby(pattern);
-                for (const match of matches) {
-                    const namePascal = (_b = (_a = match.split(pathUtil.sep).pop()) === null || _a === void 0 ? void 0 : _a.split('.store').shift()) !== null && _b !== void 0 ? _b : 'MISSING';
-                    try {
-                        const Class = require(match).default;
-                        Stores.push({ namePascal, Class });
-                    }
-                    catch (err) {
-                        const spruceError = new SpruceError({
-                            code: 'FAILED_TO_LOAD_STORE',
-                            originalError: err,
-                            name: namePascal,
-                        });
-                        //@ts-ignore
-                        errors.push(spruceError);
-                    }
-                }
-            }
-            return { stores: Stores, errors };
-        });
-    }
-    static clearInstance() {
-        this.instance = {};
-    }
-}
-StoreLoader.instance = {};

package/node_modules/@sprucelabs/data-stores/build/esm/mutexers/AbstractMutexer.d.ts

@@ -1,6 +0,0 @@
-export default abstract class AbstractMutexer {
-    private mutexesByKey;
-    lock(key: string): Promise<void>;
-    unlock(key: string): void;
-    isLocked(key: string): Promise<boolean>;
-}

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

@@ -1,56 +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());
-    });
-};
-export default class AbstractMutexer {
-    constructor() {
-        this.mutexesByKey = {};
-    }
-    lock(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.mutexesByKey[key]) {
-                this.mutexesByKey[key] = {
-                    promises: [],
-                    resolvers: [],
-                    count: 0,
-                };
-            }
-            this.mutexesByKey[key].count++;
-            if (this.mutexesByKey[key].count === 1) {
-                this.mutexesByKey[key].promises.push(new Promise((resolve) => resolve(undefined)));
-                this.mutexesByKey[key].resolvers.push(() => { });
-            }
-            else {
-                const resolver = (resolve) => {
-                    this.mutexesByKey[key].resolvers.push(resolve);
-                };
-                const promise = new Promise(resolver);
-                this.mutexesByKey[key].promises.push(promise);
-            }
-            return this.mutexesByKey[key].promises[this.mutexesByKey[key].count - 1];
-        });
-    }
-    unlock(key) {
-        if (this.mutexesByKey[key]) {
-            this.mutexesByKey[key].promises.shift();
-            this.mutexesByKey[key].resolvers.shift();
-            this.mutexesByKey[key].count--;
-            if (this.mutexesByKey[key].count === 0) {
-                delete this.mutexesByKey[key];
-            }
-            else {
-                this.mutexesByKey[key].resolvers[0]();
-            }
-        }
-    }
-    isLocked(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return !!this.mutexesByKey[key];
-        });
-    }
-}

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

@@ -1,48 +0,0 @@
-import { DynamicSchemaAllValues, Schema, IsDynamicSchema, SchemaAllValues, SchemaFieldNames, SchemaPartialValues, SchemaPublicFieldNames, SchemaPublicValues, SchemaValues } from '@sprucelabs/schema';
-import AbstractMutexer from '../mutexers/AbstractMutexer';
-import { Database } from '../types/database.types';
-import { QueryBuilder, QueryOptions } from '../types/query.types';
-import { PrepareOptions, PrepareResults, SaveOperations } 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> & SaveOperations> extends AbstractMutexer {
-    abstract readonly name: string;
-    protected abstract collectionName: string;
-    protected abstract createSchema: CreateSchema;
-    protected abstract updateSchema: UpdateSchema;
-    protected abstract fullSchema: FullSchema;
-    protected abstract databaseSchema: DatabaseSchema;
-    protected scrambleFields?: string[];
-    protected db: Database;
-    initialize?(): Promise<void>;
-    protected prepareRecord?<IncludePrivateFields extends boolean, F extends SchemaFieldNames<FullSchema> = SchemaFieldNames<FullSchema>>(record: DatabaseRecord, options?: PrepareOptions<IncludePrivateFields, FullSchema, F>): Promise<PrepareResults<FullSchema, IncludePrivateFields>>;
-    protected willCreate?(values: CreateRecord): Promise<Omit<DatabaseRecord, 'id'>>;
-    protected didCreate?(values: CreateRecord): Promise<void>;
-    protected willUpdate?(updates: UpdateRecord, values: DatabaseRecord): Promise<Partial<DatabaseRecord>>;
-    protected didUpdate?(old: DatabaseRecord, updated: DatabaseRecord): Promise<void>;
-    protected willScramble?(values: Partial<DatabaseRecord> & {
-        _isScrambled: true;
-    }): Promise<Partial<DatabaseRecord>>;
-    protected constructor(db: Database, collectionName?: string);
-    private setCollectionName;
-    protected prepareAndNormalizeRecord<IncludePrivateFields extends boolean = true, CreateEntityInstances extends boolean = false, F extends SchemaFieldNames<FullSchema> = SchemaFieldNames<FullSchema>, PF extends SchemaPublicFieldNames<FullSchema> = SchemaPublicFieldNames<FullSchema>>(record: any, options?: PrepareOptions<IncludePrivateFields, FullSchema, F>): Promise<Response<FullSchema, CreateEntityInstances, IncludePrivateFields, PF, F>>;
-    create<IncludePrivateFields extends boolean = true, CreateEntityInstances extends boolean = false, F extends SchemaFieldNames<FullSchema> = SchemaFieldNames<FullSchema>, PF extends SchemaPublicFieldNames<FullSchema> = SchemaPublicFieldNames<FullSchema>>(values: CreateRecord[], options?: PrepareOptions<CreateEntityInstances, FullSchema, F>): Promise<Response<FullSchema, CreateEntityInstances, IncludePrivateFields, PF, F>[]>;
-    createOne<CreateEntityInstances extends boolean, F extends SchemaFieldNames<FullSchema> = SchemaFieldNames<FullSchema>>(values: CreateRecord, options?: PrepareOptions<CreateEntityInstances, FullSchema, F>): Promise<Response<FullSchema, false, CreateEntityInstances, SchemaPublicFieldNames<FullSchema>, F>>;
-    findOne<CreateEntityInstances extends boolean, F extends SchemaFieldNames<FullSchema> = SchemaFieldNames<FullSchema>>(query: QueryBuilder<QueryRecord>, options?: PrepareOptions<CreateEntityInstances, FullSchema, F>): Promise<Response<FullSchema, false, CreateEntityInstances, SchemaPublicFieldNames<FullSchema>, F> | null>;
-    count(query?: QueryBuilder<QueryRecord>): Promise<number>;
-    find<CreateEntityInstances extends boolean, F extends SchemaFieldNames<FullSchema> = SchemaFieldNames<FullSchema>>(query: QueryBuilder<QueryRecord>, queryOptions?: Omit<QueryOptions, 'includeFields'>, options?: PrepareOptions<CreateEntityInstances, FullSchema, F>): Promise<Awaited<Response<FullSchema, false, CreateEntityInstances, SchemaPublicFieldNames<FullSchema>, F>>[]>;
-    upsertOne<IncludePrivateFields extends boolean = true, CreateEntityInstances extends boolean = false, F extends SchemaFieldNames<FullSchema> = SchemaFieldNames<FullSchema>, PF extends SchemaPublicFieldNames<FullSchema> = SchemaPublicFieldNames<FullSchema>>(query: QueryBuilder<QueryRecord>, updates: UpdateRecord & CreateRecord & {
-        id?: string;
-    }, options?: PrepareOptions<IncludePrivateFields, FullSchema, F>): Promise<Response<FullSchema, CreateEntityInstances, IncludePrivateFields, PF, F>>;
-    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;
-    deleteOne(query: QueryBuilder<QueryRecord>): Promise<number>;
-    delete(query: QueryBuilder<QueryRecord>): Promise<number>;
-}
-export {};