remult 0.14.7 → 0.14.8

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Noam Honig, Yoni Rapoport and contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/esm/assign.d.ts

@@ -0,0 +1 @@
+export declare function assign<T>(item: T, valuesToSet: Partial<T>): T;

package/esm/assign.js

@@ -0,0 +1,5 @@
+export function assign(item, valuesToSet) {
+    if (valuesToSet)
+        Object.assign(item, valuesToSet);
+    return item;
+}

package/esm/classType.d.ts

@@ -0,0 +1,3 @@
+export declare type ClassType<T> = {
+    new (...args: any[]): T;
+};

package/esm/classType.js

@@ -0,0 +1 @@
+export {};

package/esm/graphql.d.ts

@@ -0,0 +1,5 @@
+import { RemultExpressBridge } from "./server/expressBridge";
+export declare function remultGraphql(api: RemultExpressBridge): {
+    rootValue: {};
+    schema: string;
+};

package/esm/graphql.js

@@ -0,0 +1,102 @@
+import { Remult } from ".";
+import { allEntities } from "./src/context";
+import { getEntityKey } from "./src/remult3";
+import { DataApi } from "./src/data-api";
+export function remultGraphql(api) {
+    let r = new Remult();
+    let types = '';
+    let query = '';
+    let root = {};
+    for (const e of allEntities) {
+        let meta = r.repo(e).metadata;
+        let fields = '';
+        let filterFields = '';
+        let key = getEntityKey(e);
+        if (key) {
+            for (const f of meta.fields) {
+                {
+                    let type = "String";
+                    switch (f.valueType) {
+                        case Boolean:
+                            type = "Boolean";
+                        case Number:
+                            {
+                                if (f.valueConverter?.fieldTypeInDb == 'integer')
+                                    type = "Int";
+                                else
+                                    type = "Float";
+                            }
+                    }
+                    fields += "\n\t" + f.key + ":" + type;
+                    for (const operator of ["", "_ne"]) {
+                        filterFields += "\n\t" + f.key + operator + ":" + type;
+                    }
+                    if (f.valueType === String || f.valueType === Number)
+                        for (const operator of ["_gt", "_gte", "_lt", "_lte"]) {
+                            filterFields += "\n\t" + f.key + operator + ":" + type;
+                        }
+                    if (f.valueType === String)
+                        for (const operator of ["_st", "_contains"]) {
+                            filterFields += "\n\t" + f.key + operator + ":" + type;
+                        }
+                    if (f.allowNull)
+                        filterFields += "\n\t" + f.key + "_null:Boolean";
+                    filterFields += "\n\t" + f.key + "_in:[" + type + "]";
+                }
+            }
+            types += "type " + key + "{" + fields + "\n}\n";
+            types += "input " + key + "Filter{" + filterFields + "\n\tOR:[" + key + "Filter]\n}\n";
+            query += "\n\t" + key + "(options: options, filter:" + key + "Filter): [" + key + "]";
+            root[key] = async ({ options, filter }, req) => {
+                let remult = await api.getRemult(req);
+                let repo = remult.repo(e);
+                let dApi = new DataApi(repo, remult);
+                let result;
+                let err;
+                await dApi.getArray({
+                    success: x => result = x,
+                    created: undefined,
+                    deleted: undefined,
+                    error: x => err = x,
+                    forbidden: () => err = 'forbidden',
+                    notFound: () => err = 'not found',
+                    progress: undefined
+                }, {
+                    get: key => {
+                        if (options)
+                            switch (key) {
+                                case "_limit":
+                                    return options.limit;
+                                case "_page":
+                                    return options.page;
+                                case "_sort":
+                                    return options.sort;
+                                case "_order":
+                                    return options.order;
+                            }
+                    }
+                }, filter);
+                if (err)
+                    throw err;
+                return result;
+            };
+        }
+    }
+    if (query.length > 0) {
+        query = `type Query {${query}
+}`;
+    }
+    return {
+        rootValue: root,
+        schema: `
+input options{
+    limit:Int
+    page:Int
+    sort:String
+    order:String
+}
+${types}
+${query}
+`
+    };
+}

package/esm/index.d.ts

@@ -0,0 +1,36 @@
+export { Field, Fields, StringFieldOptions, FieldsMetadata, Entity, BuildEntity, EntityBase, ControllerBase, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FieldType, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, getFields, EntityRef, getEntityRef, SortSegments, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, OmitEB, Paginator, CaptionTransformer } from './src/remult3';
+export { EntityOptions } from './src/entity';
+export { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, ErrorInfo, RestDataProviderHttpProvider } from './src/data-interfaces';
+export { SqlCommand, SqlImplementation, SqlResult } from './src/sql-command';
+export { FieldMetadata, FieldOptions, FieldValidator, ValueConverter, ValueListItem, // reconsider, maybe it should go to remult angular as the abstraction ?
+ValueOrExpression } from './src/column-interfaces';
+export { RestDataProvider } from './src/data-providers/rest-data-provider';
+export { InMemoryDataProvider } from './src/data-providers/in-memory-database';
+export { ArrayEntityDataProvider } from './src/data-providers/array-entity-data-provider';
+export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider';
+export { SqlDatabase } from './src/data-providers/sql-database';
+export { JsonDataProvider, JsonEntityStorage } from './src/data-providers/json-data-provider';
+export { Controller, BackendMethodOptions, BackendMethod, ProgressListener } from './src/server-action';
+export { Allowed, Allow, Remult, isBackend, AllowedForInstance, EventDispatcher, EventSource, HttpProvider, Unobserve, UserInfo } from './src/context';
+export { IdEntity } from './src/id-entity';
+export { SortSegment, Sort } from './src/sort';
+export { OneToMany, CompoundIdField } from './src/column';
+export { Filter } from './src/filter/filter-interfaces';
+export { FilterConsumerBridgeToSqlRequest } from './src/filter/filter-consumer-bridge-to-sql-request';
+export { UrlBuilder } from './urlBuilder';
+export { Validators } from './src/validators';
+export { ValueConverters } from './valueConverters';
+export { ClassType } from "./classType";
+export { allEntities } from "./src/context";
+export { serializeError } from "./src/data-api";
+export { DataApiRequest } from "./src/data-api";
+export { DataApiResponse } from "./src/data-api";
+export { DataApi } from "./src/data-api";
+export { getEntityKey } from "./src/remult3/index";
+export { jobWasQueuedResult } from "./src/server-action";
+export { queuedJobInfoResponse } from "./src/server-action";
+export { Action, classBackendMethodsArray, serverActionField } from "./src/server-action";
+export { actionInfo } from "./src/server-action";
+export { registerActionsOnServer } from './server/register-actions-on-server';
+export { registerEntitiesOnServer } from './server/register-entities-on-server';
+/** db implementation required */ 

package/esm/index.js

@@ -0,0 +1,30 @@
+/*
+ * Public API Surface of remult
+ */
+export { Field, Fields, Entity, BuildEntity, EntityBase, ControllerBase, FieldType, getFields, getEntityRef, ValueListFieldType, getValueList, ValueListInfo, CaptionTransformer } from './src/remult3';
+export { RestDataProvider } from './src/data-providers/rest-data-provider'; //V
+export { InMemoryDataProvider } from './src/data-providers/in-memory-database'; //V
+export { ArrayEntityDataProvider } from './src/data-providers/array-entity-data-provider'; //V
+export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider'; //V
+export { SqlDatabase } from './src/data-providers/sql-database'; //V
+export { JsonDataProvider } from './src/data-providers/json-data-provider'; //V
+//export * from './src/data-api'; //reconsider if to make internal
+export { Controller, BackendMethod, ProgressListener } from './src/server-action';
+export { Allow, Remult, isBackend, EventSource } from './src/context';
+export { IdEntity } from './src/id-entity';
+export { Sort } from './src/sort';
+export { OneToMany, CompoundIdField } from './src/column';
+export { Filter } from './src/filter/filter-interfaces';
+export { FilterConsumerBridgeToSqlRequest } from './src/filter/filter-consumer-bridge-to-sql-request';
+export { UrlBuilder } from './urlBuilder';
+export { Validators } from './src/validators';
+export { ValueConverters } from './valueConverters';
+export { allEntities } from "./src/context";
+export { serializeError } from "./src/data-api";
+export { DataApi } from "./src/data-api";
+export { getEntityKey } from "./src/remult3/index";
+export { Action, classBackendMethodsArray, serverActionField } from "./src/server-action";
+export { actionInfo } from "./src/server-action";
+export { registerActionsOnServer } from './server/register-actions-on-server';
+export { registerEntitiesOnServer } from './server/register-entities-on-server';
+/** db implementation required */ 

package/esm/inputTypes.d.ts

@@ -0,0 +1,9 @@
+export declare class InputTypes {
+    static number: string;
+    static date: string;
+    static checkbox: string;
+    static password: string;
+    static email: string;
+    static tel: string;
+    static time: string;
+}

package/esm/inputTypes.js

@@ -0,0 +1,9 @@
+export class InputTypes {
+}
+InputTypes.number = 'number';
+InputTypes.date = 'date';
+InputTypes.checkbox = 'checkbox';
+InputTypes.password = 'password';
+InputTypes.email = 'email';
+InputTypes.tel = 'tel';
+InputTypes.time = "time";

package/esm/postgres/index.d.ts

@@ -0,0 +1,2 @@
+export * from './postgres-data-provider';
+export * from './schema-builder';

package/esm/postgres/index.js

@@ -0,0 +1,2 @@
+export * from './postgres-data-provider';
+export * from './schema-builder';

package/esm/postgres/postgres-data-provider.d.ts

@@ -0,0 +1,28 @@
+import { PoolConfig, QueryResult } from 'pg';
+import { EntityMetadata } from '../src/remult3';
+import { SqlCommand, SqlImplementation } from '../src/sql-command';
+import { SqlDatabase } from '../src/data-providers/sql-database';
+export interface PostgresPool extends PostgresCommandSource {
+    connect(): Promise<PostgresClient>;
+}
+export interface PostgresClient extends PostgresCommandSource {
+    release(): void;
+}
+export declare class PostgresDataProvider implements SqlImplementation {
+    private pool;
+    entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
+    getLimitSqlSyntax(limit: number, offset: number): string;
+    createCommand(): SqlCommand;
+    constructor(pool: PostgresPool);
+    transaction(action: (dataProvider: SqlImplementation) => Promise<void>): Promise<void>;
+}
+export interface PostgresCommandSource {
+    query(queryText: string, values?: any[]): Promise<QueryResult>;
+}
+export declare function createPostgresConnection(options?: {
+    connectionString?: string;
+    sslInDev?: boolean;
+    configuration?: "heroku" | PoolConfig;
+    autoCreateTables?: boolean;
+}): Promise<SqlDatabase>;
+export declare function preparePostgresQueueStorage(sql: SqlDatabase): Promise<import("../server/expressBridge").EntityQueueStorage>;

package/esm/postgres/postgres-data-provider.js

@@ -0,0 +1,97 @@
+import { Pool } from 'pg';
+import { Remult } from '../src/context';
+import { PostgresSchemaBuilder, verifyStructureOfAllEntities } from './schema-builder';
+import { SqlDatabase } from '../src/data-providers/sql-database';
+export class PostgresDataProvider {
+    constructor(pool) {
+        this.pool = pool;
+    }
+    async entityIsUsedForTheFirstTime(entity) {
+    }
+    getLimitSqlSyntax(limit, offset) {
+        return ' limit ' + limit + ' offset ' + offset;
+    }
+    createCommand() {
+        return new PostgresBridgeToSQLCommand(this.pool);
+    }
+    async transaction(action) {
+        let client = await this.pool.connect();
+        try {
+            await client.query('BEGIN');
+            await action({
+                createCommand: () => new PostgresBridgeToSQLCommand(client),
+                entityIsUsedForTheFirstTime: this.entityIsUsedForTheFirstTime,
+                transaction: () => { throw "nested transactions not allowed"; },
+                getLimitSqlSyntax: this.getLimitSqlSyntax
+            });
+            await client.query('COMMIT');
+        }
+        catch (err) {
+            await client.query('ROLLBACK');
+            throw err;
+        }
+        finally {
+            await client.release();
+        }
+    }
+}
+class PostgresBridgeToSQLCommand {
+    constructor(source) {
+        this.source = source;
+        this.values = [];
+    }
+    addParameterAndReturnSqlToken(val) {
+        this.values.push(val);
+        return '$' + this.values.length;
+    }
+    execute(sql) {
+        return this.source.query(sql, this.values).then(r => new PostgresBridgeToSQLQueryResult(r));
+    }
+}
+class PostgresBridgeToSQLQueryResult {
+    constructor(r) {
+        this.r = r;
+        this.rows = r.rows;
+    }
+    getColumnKeyInResultForIndexInSelect(index) {
+        return this.r.fields[index].name;
+    }
+}
+export async function createPostgresConnection(options) {
+    if (!options)
+        options = {};
+    let config = {};
+    if (options.configuration)
+        if (options.configuration == "heroku") {
+            config = {
+                connectionString: process.env.DATABASE_URL,
+                ssl: process.env.NODE_ENV !== "production" && !options.sslInDev ? false : {
+                    rejectUnauthorized: false
+                }
+            };
+        }
+        else
+            config = options.configuration;
+    else {
+        if (!options.connectionString)
+            options.connectionString = process.env.DATABASE_URL;
+    }
+    if (!config.connectionString && options.connectionString) {
+        config.connectionString = options.connectionString;
+    }
+    const db = new SqlDatabase(new PostgresDataProvider(new Pool(config)));
+    let remult = new Remult();
+    remult.setDataProvider(db);
+    if (options.autoCreateTables === undefined || options.autoCreateTables)
+        await verifyStructureOfAllEntities(db, remult);
+    return db;
+}
+export async function preparePostgresQueueStorage(sql) {
+    let c = new Remult();
+    c.setDataProvider(sql);
+    let JobsInQueueEntity = (await import('../server/expressBridge')).JobsInQueueEntity;
+    let e = c.repo(JobsInQueueEntity);
+    await new PostgresSchemaBuilder(sql).createIfNotExist(e.metadata);
+    await new PostgresSchemaBuilder(sql).verifyAllColumns(e.metadata);
+    return new (await import('../server/expressBridge')).EntityQueueStorage(c.repo(JobsInQueueEntity));
+}

package/esm/postgres/schema-builder.d.ts

@@ -0,0 +1,15 @@
+import { FieldMetadata } from '../src/column-interfaces';
+import { Remult } from '../src/context';
+import { SqlDatabase } from '../src/data-providers/sql-database';
+import { EntityMetadata } from '../src/remult3';
+export declare function postgresColumnSyntax(x: FieldMetadata, dbName: string): string;
+export declare function verifyStructureOfAllEntities(db: SqlDatabase, remult: Remult): Promise<void>;
+export declare class PostgresSchemaBuilder {
+    private pool;
+    verifyStructureOfAllEntities(remult: Remult): Promise<void>;
+    createIfNotExist(entity: EntityMetadata): Promise<void>;
+    addColumnIfNotExist<T extends EntityMetadata>(entity: T, c: ((e: T) => FieldMetadata)): Promise<void>;
+    verifyAllColumns<T extends EntityMetadata>(entity: T): Promise<void>;
+    additionalWhere: string;
+    constructor(pool: SqlDatabase, schema?: string);
+}

package/esm/postgres/schema-builder.js

@@ -0,0 +1,128 @@
+import { allEntities } from '../src/context';
+import { getDbNameProvider } from '../src/filter/filter-consumer-bridge-to-sql-request';
+import { isAutoIncrement } from '../src/remult3';
+import { ValueConverters } from '../valueConverters';
+export function postgresColumnSyntax(x, dbName) {
+    let result = dbName;
+    if (x.valueType == Number) {
+        if (!x.valueConverter.fieldTypeInDb)
+            result += " numeric" + (x.allowNull ? "" : " default 0 not null");
+        else
+            result += " " + x.valueConverter.fieldTypeInDb + (x.allowNull ? "" : " default 0 not null");
+    }
+    else if (x.valueType == Date) {
+        if (!x.valueConverter.fieldTypeInDb)
+            if (x.valueConverter == ValueConverters.DateOnly)
+                result += " date";
+            else
+                result += " timestamp";
+        else
+            result += " " + x.valueConverter.fieldTypeInDb;
+    }
+    else if (x.valueType == Boolean)
+        result += " boolean" + (x.allowNull ? "" : " default false not null");
+    else if (x.valueConverter.fieldTypeInDb) {
+        result += " " + x.valueConverter.fieldTypeInDb;
+        if (!x.allowNull && x.valueConverter.fieldTypeInDb == 'integer') {
+            result += " default 0 not null";
+        }
+    }
+    else
+        result += " varchar" + (x.allowNull ? "" : " default '' not null");
+    return result;
+}
+export async function verifyStructureOfAllEntities(db, remult) {
+    return await new PostgresSchemaBuilder(db).verifyStructureOfAllEntities(remult);
+}
+export class PostgresSchemaBuilder {
+    constructor(pool, schema) {
+        this.pool = pool;
+        this.additionalWhere = '';
+        if (schema) {
+            this.additionalWhere = ' and table_schema=\'' + schema + '\'';
+        }
+    }
+    async verifyStructureOfAllEntities(remult) {
+        console.log("start verify structure");
+        for (const entityClass of allEntities) {
+            let entity = remult.repo(entityClass).metadata;
+            let e = await getDbNameProvider(entity);
+            try {
+                if (!entity.options.sqlExpression) {
+                    if ((await e.entityName).toLowerCase().indexOf('from ') < 0) {
+                        await this.createIfNotExist(entity);
+                        await this.verifyAllColumns(entity);
+                    }
+                }
+            }
+            catch (err) {
+                console.log("failed verify structure of " + e.entityName + " ", err);
+            }
+        }
+    }
+    async createIfNotExist(entity) {
+        var c = this.pool.createCommand();
+        let e = await getDbNameProvider(entity);
+        await c.execute("select 1 from information_Schema.tables where table_name=" + c.addParameterAndReturnSqlToken((e.entityName).toLowerCase()) + this.additionalWhere).then(async (r) => {
+            if (r.rows.length == 0) {
+                let result = '';
+                for (const x of entity.fields) {
+                    if (!e.isDbReadonly(x) || isAutoIncrement(x)) {
+                        if (result.length != 0)
+                            result += ',';
+                        result += '\r\n  ';
+                        if (isAutoIncrement(x))
+                            result += e.nameOf(x) + ' serial';
+                        else {
+                            result += postgresColumnSyntax(x, e.nameOf(x));
+                            if (x == entity.idMetadata.field)
+                                result += ' primary key';
+                        }
+                    }
+                }
+                let sql = 'create table ' + e.entityName + ' (' + result + '\r\n)';
+                //console.log(sql);
+                await this.pool.execute(sql);
+            }
+        });
+    }
+    async addColumnIfNotExist(entity, c) {
+        let e = await getDbNameProvider(entity);
+        if (e.isDbReadonly(c(entity)))
+            return;
+        try {
+            let cmd = this.pool.createCommand();
+            const colName = e.nameOf(c(entity));
+            if ((await cmd.execute(`select 1   
+        FROM information_schema.columns 
+        WHERE table_name=${cmd.addParameterAndReturnSqlToken((e.entityName).toLocaleLowerCase())} and column_name=${cmd.addParameterAndReturnSqlToken((colName).toLocaleLowerCase())}` + this.additionalWhere)).rows.length == 0) {
+                let sql = `alter table ${e.entityName} add column ${postgresColumnSyntax(c(entity), colName)}`;
+                //console.log(sql);
+                await this.pool.execute(sql);
+            }
+        }
+        catch (err) {
+            console.log(err);
+        }
+    }
+    async verifyAllColumns(entity) {
+        try {
+            let cmd = this.pool.createCommand();
+            let e = await getDbNameProvider(entity);
+            let cols = (await cmd.execute(`select column_name   
+        FROM information_schema.columns 
+        WHERE table_name=${cmd.addParameterAndReturnSqlToken((e.entityName).toLocaleLowerCase())} ` + this.additionalWhere)).rows.map(x => x.column_name);
+            for (const col of entity.fields) {
+                if (!e.isDbReadonly(col))
+                    if (!cols.includes(e.nameOf(col).toLocaleLowerCase())) {
+                        let sql = `alter table ${e.entityName} add column ${postgresColumnSyntax(col, e.nameOf(col))}`;
+                        //console.log(sql);
+                        await this.pool.execute(sql);
+                    }
+            }
+        }
+        catch (err) {
+            console.log(err);
+        }
+    }
+}

package/esm/remult-express.d.ts

@@ -0,0 +1,5 @@
+import { RemultMiddlewareOptions } from './server/expressBridge';
+export declare function remultExpress(options?: RemultMiddlewareOptions & {
+    bodyParser?: boolean;
+    bodySizeLimit?: string;
+}): import("./server/expressBridge").RemultExpressBridge;

package/esm/remult-express.js

@@ -0,0 +1,16 @@
+import * as express from 'express';
+import { remultMiddlewareBase } from './server/expressBridge';
+export function remultExpress(options) {
+    let app = express.Router();
+    if (!options) {
+        options = {};
+    }
+    if (options.bodySizeLimit === undefined) {
+        options.bodySizeLimit = '10mb';
+    }
+    if (options?.bodyParser !== false) {
+        app.use(express.json({ limit: options.bodySizeLimit }));
+        app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
+    }
+    return remultMiddlewareBase(app, options);
+}

package/esm/remult-knex/index.d.ts

@@ -0,0 +1,51 @@
+import { Knex } from 'knex';
+import { Filter, FilterConsumer } from "../src/filter/filter-interfaces";
+import { dbNameProvider } from "../src/filter/filter-consumer-bridge-to-sql-request";
+import { Remult } from "../src/context";
+import { EntityFilter, EntityMetadata } from "../src/remult3";
+import { DataProvider, EntityDataProvider } from '../src/data-interfaces';
+import { FieldMetadata } from '../src/column-interfaces';
+export declare class KnexDataProvider implements DataProvider {
+    knex: Knex;
+    constructor(knex: Knex);
+    getEntityDataProvider(entity: EntityMetadata<any>): EntityDataProvider;
+    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
+    static customFilter(build: CustomKnexFilterBuilderFunction): EntityFilter<any>;
+    supportsCustomFilter?: boolean;
+}
+export declare type CustomKnexFilterBuilderFunction = () => Promise<(builder: Knex.QueryBuilder) => void>;
+export declare class FilterConsumerBridgeToKnexRequest implements FilterConsumer {
+    private nameProvider;
+    _addWhere: boolean;
+    promises: Promise<void>[];
+    result: ((builder: Knex.QueryBuilder) => void)[];
+    resolveWhere(): Promise<((builder: Knex.QueryBuilder<any, any>) => void)[]>;
+    constructor(nameProvider: dbNameProvider);
+    custom(key: string, customItem: any): void;
+    or(orElements: Filter[]): void;
+    isNull(col: FieldMetadata): void;
+    isNotNull(col: FieldMetadata): void;
+    isIn(col: FieldMetadata, val: any[]): void;
+    isEqualTo(col: FieldMetadata, val: any): void;
+    isDifferentFrom(col: FieldMetadata, val: any): void;
+    isGreaterOrEqualTo(col: FieldMetadata, val: any): void;
+    isGreaterThan(col: FieldMetadata, val: any): void;
+    isLessOrEqualTo(col: FieldMetadata, val: any): void;
+    isLessThan(col: FieldMetadata, val: any): void;
+    containsCaseInsensitive(col: FieldMetadata, val: any): void;
+    private add;
+    databaseCustom(databaseCustom: {
+        buildKnex: CustomKnexFilterBuilderFunction;
+    }): void;
+}
+export declare class KnexSchemaBuilder {
+    private knex;
+    verifyStructureOfAllEntities(remult: Remult): Promise<void>;
+    createIfNotExist(entity: EntityMetadata): Promise<void>;
+    addColumnIfNotExist<T extends EntityMetadata>(entity: T, c: ((e: T) => FieldMetadata)): Promise<void>;
+    verifyAllColumns<T extends EntityMetadata>(entity: T): Promise<void>;
+    additionalWhere: string;
+    constructor(knex: Knex);
+}
+export declare function buildColumn(x: FieldMetadata, dbName: string, b: Knex.CreateTableBuilder): void;
+export declare function createKnexDataProvider(config: Knex.Config, autoCreateTables?: boolean): Promise<KnexDataProvider>;