warehouse/dist/database.d.ts

Simple JSON-based database

import BluebirdPromise from 'bluebird';
import Model from './model';
import Schema from './schema';
import SchemaType from './schematype';
import type { AddSchemaTypeOptions, NodeJSLikeCallback } from './types';
interface DatabaseOptions {
    version: number;
    path: string;
    onUpgrade: (oldVersion: number, newVersion: number) => any;
    onDowngrade: (oldVersion: number, newVersion: number) => any;
}
declare class Database {
    options: DatabaseOptions;
    _models: Record<string, Model<any>>;
    Model: typeof Model;
    /**
     * Database constructor.
     *
     * @param {object} [options]
     *   @param {number} [options.version=0] Database version
     *   @param {string} [options.path] Database path
     *   @param {function} [options.onUpgrade] Triggered when the database is upgraded
     *   @param {function} [options.onDowngrade] Triggered when the database is downgraded
     */
    constructor(options?: {
        path: string;
    } & Partial<DatabaseOptions>);
    /**
     * Creates a new model.
     *
     * @param {string} name
     * @param {Schema|object} [schema]
     * @return {Model}
     */
    model<T = any>(name: string, schema?: Schema<T> | Record<string, AddSchemaTypeOptions>): Model<any>;
    /**
     * Loads database.
     *
     * @param {function} [callback]
     * @return {BluebirdPromise}
     */
    load(callback?: NodeJSLikeCallback<any>): BluebirdPromise<any>;
    /**
     * Saves database.
     *
     * @param {function} [callback]
     * @return {BluebirdPromise}
     */
    save(callback?: NodeJSLikeCallback<any>): BluebirdPromise<void>;
    toJSON(): {
        meta: {
            version: number;
            warehouse: string;
        };
        models: Record<string, Model<any>>;
    };
    static Schema: typeof Schema;
    Schema: typeof Schema;
    static SchemaType: typeof SchemaType;
    SchemaType: typeof SchemaType;
    static version: number;
}
export default Database;