inibase/dist/index.d.ts

A file-based & memory-efficient, serverless, ACID compliant, relational database management system

import "dotenv/config";
export interface Data {
    id?: string | number;
    [key: string]: any;
    createdAt?: number;
    updatedAt?: number;
}
export type FieldType = "string" | "number" | "boolean" | "date" | "email" | "url" | "table" | "object" | "array" | "password" | "html" | "ip" | "json" | "id";
export type Field = {
    id?: number;
    key: string;
    type: FieldType | FieldType[];
    required?: boolean;
    table?: string;
    unique?: boolean | number | string;
    children?: FieldType | FieldType[] | Schema;
    regex?: string;
};
export type Schema = Field[];
export interface Options {
    page?: number;
    perPage?: number;
    columns?: string[] | string;
    sort?: Record<string, 1 | -1 | "asc" | "ASC" | "desc" | "DESC"> | string[] | string;
}
export interface TableConfig {
    compression?: boolean;
    cache?: boolean;
    prepend?: boolean;
    decodeID?: boolean;
}
export interface TableObject {
    schema?: Schema;
    config: TableConfig;
}
export type ComparisonOperator = "=" | "!=" | ">" | "<" | ">=" | "<=" | "*" | "!*" | "[]" | "![]";
export type pageInfo = {
    total?: number;
    totalPages?: number;
} & Options;
export type Criteria = ({
    [logic in "and" | "or"]?: Criteria | (string | number | boolean | null)[];
} & {
    [key: string]: string | number | boolean | undefined | Criteria | (string | number | boolean)[];
}) | null;
type Entries<T> = {
    [K in keyof T]: [K, T[K]];
}[keyof T][];
declare global {
    interface ObjectConstructor {
        entries<T extends object>(o: T): Entries<T>;
    }
}
export declare const ERROR_CODES: readonly ["GROUP_UNIQUE", "FIELD_UNIQUE", "FIELD_REQUIRED", "NO_SCHEMA", "TABLE_EMPTY", "INVALID_ID", "INVALID_TYPE", "INVALID_PARAMETERS", "NO_ENV", "TABLE_EXISTS", "TABLE_NOT_EXISTS", "INVALID_REGEX_MATCH"];
export type ErrorCode = (typeof ERROR_CODES)[number];
export type ErrorLang = "en" | "ar" | "fr" | "es";
export declare const globalConfig: {
    [database: string]: {
        tables?: Map<string, TableObject & {
            timestamp?: Date;
        }>;
    };
} & {
    salt?: string | Buffer;
};
/**
 * @param {string} database - Database name
 * @param {string} [mainFolder="."] - Main folder path
 * @param {ErrorLang} [language="en"] - Language for error messages
 */
export default class Inibase {
    pageInfo: Record<string, pageInfo>;
    language: ErrorLang;
    fileExtension: string;
    totalItems: Map<string, number>;
    private databasePath;
    private uniqueMap;
    private schemaFileExtension;
    constructor(database: string, mainFolder?: string, language?: ErrorLang);
    private static errorMessages;
    createError(name: ErrorCode, variable?: string | number | (string | number)[]): Error;
    private getFileExtension;
    private schemaToIdsPath;
    /**
     * Create a new table inside database, with predefined schema and config
     *
     * @param {string} tableName
     * @param {Schema} [schema]
     * @param {TableConfig} [config]
     */
    createTable(tableName: string, schema?: Schema, config?: TableConfig): Promise<void>;
    private replaceStringInFile;
    /**
     * Update table schema or config
     *
     * @param {string} tableName
     * @param {Schema} [schema]
     * @param {(TableConfig&{name?: string})} [config]
     */
    updateTable(tableName: string, schema?: Schema, config?: TableConfig & {
        name?: string;
    }): Promise<void>;
    /**
     * Get table schema and config
     *
     * @param {string} tableName
     * @return {*}  {Promise<TableObject | undefined>}
     */
    getTable(tableName: string): Promise<TableObject | undefined>;
    getTableSchema(tableName: string): Promise<Schema>;
    private throwErrorIfTableEmpty;
    validateData(data: Data | Data[], schema: Schema, skipRequiredField?: boolean): void;
    private validateTableData;
    private cleanObject;
    private formatField;
    private checkUnique;
    private formatData;
    private getDefaultValue;
    private _combineObjectsToArray;
    private _CombineData;
    private joinPathesContents;
    private _processSchemaDataHelper;
    private processSchemaData;
    private isSimpleField;
    private processSimpleField;
    private isArrayField;
    private processArrayField;
    private isObjectField;
    private processObjectField;
    private isTableField;
    private processTableField;
    private _setNestedKey;
    private applyCriteria;
    private _filterSchemaByColumns;
    /**
     * Clear table cache
     *
     * @param {string} tableName
     */
    clearCache(tableName: string): Promise<void>;
    /**
     * Retrieve item(s) from a table
     *
     * @param {string} tableName
     * @param {(string | number | (string | number)[] | Criteria)} [where]
     * @param {Options} [options]
     * @param {boolean} [onlyOne]
     * @param {boolean} [onlyLinesNumbers]
     * @return {*}  {(Promise<Data | number | (Data | number)[] | null>)}
     */
    get<TData extends Record<string, any> & Partial<Data>>(tableName: string, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: true, onlyLinesNumbers?: false, _whereIsLinesNumbers?: boolean): Promise<(Data & TData) | null>;
    get<TData extends Record<string, any> & Partial<Data>>(tableName: string, where: string | number, options?: Options, onlyOne?: boolean, onlyLinesNumbers?: false, _whereIsLinesNumbers?: boolean): Promise<(Data & TData) | null>;
    get<TData extends Record<string, any> & Partial<Data>>(tableName: string, where?: string | number | (string | number)[] | Criteria, options?: Options, onlyOne?: boolean, onlyLinesNumbers?: false, _whereIsLinesNumbers?: boolean): Promise<(Data & TData)[] | null>;
    get<_TData extends Record<string, any> & Partial<Data>>(tableName: string, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: false | undefined, onlyLinesNumbers: true, _whereIsLinesNumbers?: boolean): Promise<number[] | null>;
    get<_TData extends Record<string, any> & Partial<Data>>(tableName: string, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: true, onlyLinesNumbers: true, _whereIsLinesNumbers?: boolean): Promise<number | null>;
    /**
     * Create new item(s) in a table
     *
     * @param {string} tableName
     * @param {((Data & TData) | (Data & TData)[])} data Can be array of objects or a single object
     * @param {Options} [options] Pagination options, useful when the returnPostedData param is true
     * @param {boolean} [returnPostedData] By default function returns void, if you want to get the posted data, set this param to true
     * @return {*}  {Promise<Data | Data[] | null | void>}
     */
    post<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: Data & TData, options?: Options, returnPostedData?: boolean): Promise<string>;
    post<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: (Data & TData)[], options?: Options, returnPostedData?: boolean): Promise<string[]>;
    post<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: Data & TData, options: Options | undefined, returnPostedData: true): Promise<(Data & TData) | null>;
    post<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: (Data & TData)[], options: Options | undefined, returnPostedData: true): Promise<(Data & TData)[] | null>;
    /**
     * Update item(s) in a table
     *
     * @param {string} tableName
     * @param {(Data & TData) | (Data & TData[])} data
     * @param {(number | string | (number | string)[] | Criteria)} [where]
     * @param {Options} [options]
     * @param {boolean} [returnUpdatedData]
     * @return {*}  {Promise<Data | Data[] | null | undefined | void>}
     */
    put<TData extends Record<string, any> & Partial<Data>>(tableName: string, data?: (Data & TData) | (Data & TData)[], where?: number | string | (number | string)[] | Criteria | undefined, options?: Options | undefined, returnUpdatedData?: false, _whereIsLinesNumbers?: boolean): Promise<void>;
    put<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: Data & TData, where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: true | boolean, _whereIsLinesNumbers?: boolean): Promise<(Data & TData) | null>;
    put<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: (Data & TData)[], where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: true | boolean, _whereIsLinesNumbers?: boolean): Promise<(Data & TData)[] | null>;
    put<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: (Data & TData) | (Data & TData)[], where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: true | boolean, _whereIsLinesNumbers?: boolean): Promise<(Data & TData) | (Data & TData)[] | null>;
    /**
     * Delete item(s) in a table
     *
     * @param {string} tableName
     * @param {(number | string | (number | string)[] | Criteria)} [where]
     * @return {boolean | null}  {(Promise<boolean | null>)}
     */
    delete(tableName: string, where?: number | string | (number | string)[] | Criteria, _whereIsLinesNumbers?: boolean): Promise<boolean | null>;
    /**
     * Generate sum of column(s) in a table
     *
     * @param {string} tableName
     * @param {string} columns
     * @param {(number | string | (number | string)[] | Criteria)} [where]
     * @return {*}  {Promise<number | Record<string, number>>}
     */
    sum(tableName: string, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;
    sum(tableName: string, columns: string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
    /**
     * Generate max of column(s) in a table
     *
     * @param {string} tableName
     * @param {string} columns
     * @param {(number | string | (number | string)[] | Criteria)} [where]
     * @return {*}  {Promise<number>}
     */
    max(tableName: string, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;
    max(tableName: string, columns: string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
    /**
     * Generate min of column(s) in a table
     *
     * @param {string} tableName
     * @param {string} columns
     * @param {(number | string | (number | string)[] | Criteria)} [where]
     * @return {*}  {Promise<number>}
     */
    min(tableName: string, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;
    min(tableName: string, columns: string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
}
export {};