warehouse/dist/schema.d.ts

Simple JSON-based database

import SchemaType from './schematype';
import * as Types from './types/index';
import BluebirdPromise from 'bluebird';
import SchemaTypeVirtual from './types/virtual';
import type { AddSchemaTypeOptions, Options, queryCallback, queryFilterCallback, queryParseCallback } from './types';
import type Model from './model';
import type Document from './document';
declare class Schema<T = any> {
    paths: Record<string, SchemaType<any>>;
    statics: Record<string, (this: Model<T>, ...args: any[]) => any>;
    methods: Record<string, (this: T, ...args: any[]) => any>;
    hooks: {
        pre: {
            save: ((data: any) => BluebirdPromise<any>)[];
            remove: ((data: any) => BluebirdPromise<any>)[];
        };
        post: {
            save: ((data: any) => BluebirdPromise<any>)[];
            remove: ((data: any) => BluebirdPromise<any>)[];
        };
    };
    stacks: {
        getter: ((data: object) => void)[];
        setter: ((data: object) => void)[];
        import: ((data: object) => void)[];
        export: ((data: object) => void)[];
    };
    /**
     * Schema constructor.
     *
     * @param {Object} [schema]
     */
    constructor(schema?: Record<string, AddSchemaTypeOptions>);
    /**
     * Adds paths.
     *
     * @param {Object} schema
     * @param {String} prefix
     */
    add(schema: Record<string, AddSchemaTypeOptions>, prefix?: string): void;
    /**
     * Gets/Sets a path.
     *
     * @param {String} name
     * @param {*} obj
     * @return {SchemaType | undefined}
     */
    path(name: string): SchemaType<any>;
    path(name: string, obj: AddSchemaTypeOptions): void;
    /**
     * Updates cache stacks.
     *
     * @param {String} name
     * @param {SchemaType} type
     * @private
     */
    _updateStack(name: string, type: SchemaType<unknown>): void;
    /**
     * Adds a virtual path.
     *
     * @param {String} name
     * @param {Function} [getter]
     * @return {SchemaType.Virtual}
     */
    virtual(name: string, getter?: (this: T) => any): SchemaTypeVirtual<T>;
    /**
     * Adds a pre-hook.
     *
     * @param {String} type Hook type. One of `save` or `remove`.
     * @param {Function} fn
     */
    pre(type: keyof Schema['hooks']['pre'], fn: (...args: any[]) => void): void;
    /**
     * Adds a post-hook.
     *
     * @param {String} type Hook type. One of `save` or `remove`.
     * @param {Function} fn
     */
    post(type: keyof Schema['hooks']['post'], fn: (...args: any[]) => void): void;
    /**
     * Adds a instance method.
     *
     * @param {String} name
     * @param {Function} fn
     */
    method(name: string, fn: (this: T, ...args: any[]) => any): void;
    /**
     * Adds a static method.
     *
     * @param {String} name
     * @param {Function} fn
     */
    static(name: string, fn: (this: Model<T>, ...args: any[]) => any): void;
    /**
     * Apply getters.
     *
     * @param {Object} data
     * @return {void}
     * @private
     */
    _applyGetters(data: object): void;
    /**
     * Apply setters.
     *
     * @param {Object} data
     * @return {void}
     * @private
     */
    _applySetters(data: object): void;
    /**
     * Parses database.
     *
     * @param {Object} data
     * @return {Object}
     * @private
     */
    _parseDatabase(data: object): any;
    /**
     * Exports database.
     *
     * @param {Object} data
     * @return {Object}
     * @private
     */
    _exportDatabase(data: object): any;
    /**
     * Parses updating expressions and returns a stack.
     *
     * @param {Object} updates
     * @return {queryCallback[]}
     * @private
     */
    _parseUpdate(updates: object): queryCallback<T>[];
    /**
     * Returns a function for querying.
     *
     * @param {Object} query
     * @return {queryFilterCallback}
     * @private
     */
    _execQuery(query: object): queryFilterCallback;
    /**
     * Parses sorting expressions and returns a stack.
     *
     * @param {Object} sorts
     * @param {string} [prefix]
     * @param {queryParseCallback[]} [stack]
     * @return {queryParseCallback[]}
     * @private
     */
    _parseSort(sorts: Record<string, number | string | Record<string, any>>, prefix?: string, stack?: queryParseCallback<Document<T>>[]): queryParseCallback<Document<T>>[];
    /**
     * Returns a function for sorting.
     *
     * @param {Object} sorts
     * @return {queryParseCallback}
     * @private
     */
    _execSort(sorts: Record<string, number | string | Record<string, any>>): queryParseCallback<Document<T>>;
    /**
     * Parses population expression and returns a stack.
     *
     * @param {String|Object} expr
     * @return {PopulateResult[]}
     * @private
     */
    _parsePopulate(expr: string | string[] | Partial<Options>[] | Partial<Options>): Partial<Options>[];
    Types: typeof Types;
    static Types: typeof Types;
}
export default Schema;