@sprucelabs/spruce-cli 17.1.11 → 17.1.14

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

@@ -0,0 +1,38 @@
+"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 MongoDatabase_1 = __importDefault(require("../databases/MongoDatabase"));
+const NeDbDatabase_1 = __importDefault(require("../databases/NeDbDatabase"));
+class DatabaseFactory {
+    constructor() { }
+    static Database(options) {
+        const { dbName, dbConnectionString } = options;
+        let database;
+        if (!dbConnectionString) {
+            throw new schema_1.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_1.default();
+            }
+            else {
+                database = new MongoDatabase_1.default(dbConnectionString, { dbName });
+            }
+            this.cache[cacheKey] = database;
+        }
+        return this.cache[cacheKey];
+    }
+    static reset() {
+        this.cache = {};
+    }
+}
+exports.default = DatabaseFactory;
+DatabaseFactory.cache = {};

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

@@ -0,0 +1,25 @@
+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/factories/StoreFactory.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
+const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
+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.
+     */
+    async Store(name, options) {
+        var _a;
+        const Store = this.storeMap[name];
+        if (Store) {
+            if (!Store.Store) {
+                throw new SpruceError_1.default({
+                    code: 'INVALID_STORE',
+                    friendlyMessage: `You have to have ${spruce_skill_utils_1.namesUtil.toPascal(name)}.Store(options: UniversalStoreOptions) factory method on your store that returns \`new this(...)\`.`,
+                });
+            }
+            const instance = await Store.Store(Object.assign({ db: this.db, storeFactory: this }, options));
+            if (!StoreFactory.initializations[name]) {
+                StoreFactory.initializations[name] = true;
+                await ((_a = instance.initialize) === null || _a === void 0 ? void 0 : _a.call(instance));
+            }
+            return instance;
+        }
+        throw new SpruceError_1.default({
+            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;
+    }
+    async getStore(name) {
+        if (!this.stores[name]) {
+            this.stores[name] = await this.Store(name);
+        }
+        return this.stores[name];
+    }
+    static reset() {
+        this.initializations = {};
+    }
+}
+exports.default = StoreFactory;
+StoreFactory.initializations = {};

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

@@ -0,0 +1,22 @@
+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/fixtures/DatabaseFixture.js

@@ -0,0 +1,86 @@
+"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 MongoDatabase_1 = require("../databases/MongoDatabase");
+const DatabaseFactory_1 = __importDefault(require("../factories/DatabaseFactory"));
+const MEMORY = 'memory://';
+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 schema_1.SchemaError({
+                code: 'MISSING_PARAMETERS',
+                parameters: missing,
+            });
+        }
+        this.dbName = dbName;
+        this.dbConnectionString = dbConnectionString;
+    }
+    async connectToDatabase() {
+        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 = MongoDatabase_1.MONGO_TEST_URI;
+        }
+        const database = await DatabaseFixture.connect(options);
+        return database;
+    }
+    static async connect(options) {
+        const database = DatabaseFactory_1.default.Database(options);
+        await 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 async destroy() {
+        if (this.defaultOptions && this.activeDatabases.length === 0) {
+            await DatabaseFixture.connect(this.defaultOptions);
+        }
+        for (const db of this.activeDatabases) {
+            if (db.isConnected()) {
+                await db.dropDatabase();
+                await db.close();
+            }
+        }
+        this.activeDatabases = [];
+        DatabaseFactory_1.default.reset();
+    }
+    static beforeAll() { }
+    static async beforeEach() {
+        await this.destroy();
+    }
+    static async afterEach() {
+        await this.destroy();
+    }
+}
+exports.default = DatabaseFixture;
+DatabaseFixture.dbCount = 0;
+DatabaseFixture.activeDatabases = [];

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

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

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

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const StoreLoader_1 = __importDefault(require("../loaders/StoreLoader"));
+const DatabaseFixture_1 = __importDefault(require("./DatabaseFixture"));
+class StoreFixture {
+    constructor(activeDir) {
+        this.activeDir = activeDir;
+    }
+    async Factory() {
+        const dbFixture = new DatabaseFixture_1.default();
+        const db = await dbFixture.connectToDatabase();
+        const loader = await StoreLoader_1.default.Loader(this.activeDir, db);
+        const factory = await loader.loadStores();
+        return factory;
+    }
+}
+exports.default = StoreFixture;

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

@@ -0,0 +1,21 @@
+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/index.js

@@ -0,0 +1,53 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CursorPagerFaker = exports.CursorPager = exports.generateId = exports.mongoUtil = exports.NeDbDatabase = exports.MongoDatabase = exports.StoreLoader = exports.DatabaseFactory = exports.StoreFactory = exports.AbstractStore = exports.DatabaseFixture = exports.AbstractDatabaseTest = void 0;
+var AbstractDatabaseTest_1 = require("./tests/AbstractDatabaseTest");
+Object.defineProperty(exports, "AbstractDatabaseTest", { enumerable: true, get: function () { return __importDefault(AbstractDatabaseTest_1).default; } });
+var DatabaseFixture_1 = require("./fixtures/DatabaseFixture");
+Object.defineProperty(exports, "DatabaseFixture", { enumerable: true, get: function () { return __importDefault(DatabaseFixture_1).default; } });
+__exportStar(require("./fixtures/DatabaseFixture"), exports);
+var AbstractStore_1 = require("./stores/AbstractStore");
+Object.defineProperty(exports, "AbstractStore", { enumerable: true, get: function () { return __importDefault(AbstractStore_1).default; } });
+var StoreFactory_1 = require("./factories/StoreFactory");
+Object.defineProperty(exports, "StoreFactory", { enumerable: true, get: function () { return __importDefault(StoreFactory_1).default; } });
+var DatabaseFactory_1 = require("./factories/DatabaseFactory");
+Object.defineProperty(exports, "DatabaseFactory", { enumerable: true, get: function () { return __importDefault(DatabaseFactory_1).default; } });
+var StoreLoader_1 = require("./loaders/StoreLoader");
+Object.defineProperty(exports, "StoreLoader", { enumerable: true, get: function () { return __importDefault(StoreLoader_1).default; } });
+var MongoDatabase_1 = require("./databases/MongoDatabase");
+Object.defineProperty(exports, "MongoDatabase", { enumerable: true, get: function () { return __importDefault(MongoDatabase_1).default; } });
+__exportStar(require("./databases/MongoDatabase"), exports);
+var NeDbDatabase_1 = require("./databases/NeDbDatabase");
+Object.defineProperty(exports, "NeDbDatabase", { enumerable: true, get: function () { return __importDefault(NeDbDatabase_1).default; } });
+var mongo_utility_1 = require("./utilities/mongo.utility");
+Object.defineProperty(exports, "mongoUtil", { enumerable: true, get: function () { return __importDefault(mongo_utility_1).default; } });
+__exportStar(require("./databases/NeDbDatabase"), exports);
+__exportStar(require("./types/database.types"), exports);
+__exportStar(require("./types/query.types"), exports);
+__exportStar(require("./types/stores.types"), exports);
+__exportStar(require("./constants"), exports);
+var generateIdDeprecated_1 = require("./utilities/generateIdDeprecated");
+Object.defineProperty(exports, "generateId", { enumerable: true, get: function () { return __importDefault(generateIdDeprecated_1).default; } });
+var CursorPager_1 = require("./cursors/CursorPager");
+Object.defineProperty(exports, "CursorPager", { enumerable: true, get: function () { return __importDefault(CursorPager_1).default; } });
+__exportStar(require("./cursors/CursorPager"), exports);
+var CursorPagerFaker_1 = require("./cursors/CursorPagerFaker");
+Object.defineProperty(exports, "CursorPagerFaker", { enumerable: true, get: function () { return __importDefault(CursorPagerFaker_1).default; } });
+__exportStar(require("./cursors/CursorPager"), exports);

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

@@ -0,0 +1,25 @@
+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/loaders/StoreLoader.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const schema_1 = require("@sprucelabs/schema");
+const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
+const globby_1 = __importDefault(require("globby"));
+const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
+const StoreFactory_1 = __importDefault(require("../factories/StoreFactory"));
+class StoreLoader {
+    constructor(activeDir, db) {
+        this.activeDir = activeDir;
+        this.db = db;
+    }
+    static setStoreDir(dir) {
+        this.defaultStoreDir = dir;
+    }
+    static setDatabase(db) {
+        this.defaultDb = db;
+    }
+    static async Loader(activeDir, db) {
+        return new this(activeDir, db);
+    }
+    static async getInstance(cwd, database) {
+        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 schema_1.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];
+    }
+    async loadStores() {
+        const { factory, errors } = await this.loadStoresAndErrors();
+        if (errors.length > 0) {
+            throw new SpruceError_1.default({ code: 'FAILED_TO_LOAD_STORES', errors });
+        }
+        return factory;
+    }
+    async loadStoresAndErrors() {
+        const { stores, errors } = await this.loadStoreClassesWithErrors();
+        const factory = StoreFactory_1.default.Factory(this.db);
+        for (const store of stores) {
+            factory.setStoreClass(spruce_skill_utils_1.namesUtil.toCamel(store.namePascal), store.Class);
+        }
+        return { factory, errors };
+    }
+    async loadStoreClassesWithErrors() {
+        var _a, _b;
+        const combinedFile = spruce_skill_utils_1.diskUtil.resolveFile(this.activeDir, spruce_skill_utils_1.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 = spruce_skill_utils_1.diskUtil.resolvePath(this.activeDir, '**', '*.store.[j|t]s');
+            const matches = await (0, globby_1.default)(pattern);
+            for (const match of matches) {
+                const namePascal = (_b = (_a = match.split(path_1.default.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_1.default({
+                        code: 'FAILED_TO_LOAD_STORE',
+                        originalError: err,
+                        name: namePascal,
+                    });
+                    //@ts-ignore
+                    errors.push(spruceError);
+                }
+            }
+        }
+        return { stores: Stores, errors };
+    }
+    static clearInstance() {
+        this.instance = {};
+    }
+}
+exports.default = StoreLoader;
+StoreLoader.instance = {};

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

@@ -0,0 +1,6 @@
+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/mutexers/AbstractMutexer.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AbstractMutexer {
+    constructor() {
+        this.mutexesByKey = {};
+    }
+    async lock(key) {
+        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]();
+            }
+        }
+    }
+    async isLocked(key) {
+        return !!this.mutexesByKey[key];
+    }
+}
+exports.default = AbstractMutexer;

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

@@ -0,0 +1,48 @@
+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 {};