remult 0.22.3 → 0.22.4

package/esm/core/postgres/schema-builder.js

@@ -0,0 +1,153 @@
+import { allEntities } from '../src/context';
+import { dbNamesOf, isDbReadonly } from '../src/filter/filter-consumer-bridge-to-sql-request';
+import { remult as defaultRemult } from '../src/remult-proxy';
+import { isAutoIncrement } from '../src/remult3';
+import { ValueConverters } from '../src/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 {
+    pool;
+    //@internal
+    static logToConsole = true;
+    async verifyStructureOfAllEntities(remult) {
+        if (!remult) {
+            remult = defaultRemult;
+        }
+        const completed = new Set();
+        const entities = [];
+        for (const entityClass of [...allEntities].reverse()) {
+            let entity = remult.repo(entityClass).metadata;
+            let e = await dbNamesOf(entity);
+            if (completed.has(e.$entityName))
+                continue;
+            completed.add(e.$entityName);
+            entities.push(entity);
+        }
+        await this.ensureSchema(entities);
+    }
+    async ensureSchema(entities) {
+        for (const entity of entities) {
+            let e = await dbNamesOf(entity);
+            try {
+                if (!entity.options.sqlExpression) {
+                    if (e.$entityName.toLowerCase().indexOf('from ') < 0) {
+                        await this.createIfNotExist(entity);
+                        await this.verifyAllColumns(entity);
+                    }
+                }
+            }
+            catch (err) {
+                console.error("failed verify structure of " + e.$entityName + " ", err);
+            }
+        }
+    }
+    async createIfNotExist(entity) {
+        var c = this.pool.createCommand();
+        let e = await dbNamesOf(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 (!isDbReadonly(x, e) || isAutoIncrement(x)) {
+                        if (result.length != 0)
+                            result += ',';
+                        result += '\r\n  ';
+                        if (isAutoIncrement(x))
+                            result += e.$dbNameOf(x) + ' serial';
+                        else {
+                            result += postgresColumnSyntax(x, e.$dbNameOf(x));
+                        }
+                        if (x == entity.idMetadata.field)
+                            result += ' primary key';
+                    }
+                }
+                let sql = 'create table ' + e.$entityName + ' (' + result + '\r\n)';
+                if (PostgresSchemaBuilder.logToConsole)
+                    console.info(sql);
+                await this.pool.execute(sql);
+            }
+        });
+    }
+    async addColumnIfNotExist(entity, c) {
+        let e = await dbNamesOf(entity);
+        if (isDbReadonly(c(entity), e))
+            return;
+        try {
+            let cmd = this.pool.createCommand();
+            const colName = e.$dbNameOf(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)}`;
+                if (PostgresSchemaBuilder.logToConsole)
+                    console.info(sql);
+                await this.pool.execute(sql);
+            }
+        }
+        catch (err) {
+            console.error(err);
+        }
+    }
+    async verifyAllColumns(entity) {
+        try {
+            let cmd = this.pool.createCommand();
+            let e = await dbNamesOf(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.toLocaleLowerCase());
+            for (const col of entity.fields) {
+                if (!isDbReadonly(col, e)) {
+                    let colName = e.$dbNameOf(col).toLocaleLowerCase();
+                    if (colName.startsWith('"') && colName.endsWith('"'))
+                        colName = colName.substring(1, colName.length - 1);
+                    if (!cols.includes(colName)) {
+                        let sql = `alter table ${e.$entityName} add column ${postgresColumnSyntax(col, e.$dbNameOf(col))}`;
+                        if (PostgresSchemaBuilder.logToConsole)
+                            console.info(sql);
+                        await this.pool.execute(sql);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error(err);
+        }
+    }
+    additionalWhere = '';
+    constructor(pool, schema) {
+        this.pool = pool;
+        if (schema) {
+            this.additionalWhere = ' and table_schema=\'' + schema + '\'';
+        }
+    }
+}

package/esm/core/remult-fresh.d.ts

@@ -0,0 +1,17 @@
+import { RemultServerOptions, RemultServerCore } from "./server/expressBridge";
+export declare function remultFresh(options: RemultServerOptions<FreshRequest>, response: FreshResponse): RemultFresh;
+export interface RemultFresh extends RemultServerCore<FreshRequest> {
+    handle(req: FreshRequest, ctx: FreshContext): Promise<any>;
+}
+export interface FreshRequest {
+    url: string;
+    method: string;
+    json: () => Promise<any>;
+}
+export interface FreshContext {
+    next: () => Promise<any>;
+}
+export interface FreshResponse {
+    new (body?: any | undefined, init?: ResponseInit): any;
+    json(data: unknown, init?: ResponseInit): any;
+}

package/esm/core/remult-fresh.js

@@ -0,0 +1,29 @@
+import { createRemultServerCore } from "./server/expressBridge";
+export function remultFresh(options, response) {
+    const server = createRemultServerCore(options, {
+        buildGenericRequestInfo: r => r,
+        getRequestBody: req => req.json()
+    });
+    return {
+        getRemult: r => server.getRemult(r),
+        openApiDoc: x => server.openApiDoc(x),
+        handle: async (req, ctx) => {
+            let init = {};
+            const res = await server.handle(req);
+            if (res) {
+                init.status = res.statusCode;
+                if (res.data) {
+                    return response.json(res.data, init);
+                }
+                else
+                    return new response(undefined, init);
+            }
+            else {
+                return ctx.next();
+            }
+            ;
+        },
+    };
+}
+;
+;

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

@@ -0,0 +1,30 @@
+import type { Knex } from 'knex';
+import { Remult } from "../src/context";
+import { EntityFilter, EntityMetadata, RepositoryOverloads } 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);
+    static getDb(remult?: Remult): Knex<any, any[]>;
+    getEntityDataProvider(entity: EntityMetadata<any>): EntityDataProvider;
+    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
+    static rawFilter(build: CustomKnexFilterBuilderFunction): EntityFilter<any>;
+    static filterToRaw<entityType>(entity: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>): Promise<(knex: any) => void>;
+    isProxy?: boolean;
+    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
+}
+export type CustomKnexFilterBuilderFunction = () => Promise<(builder: Knex.QueryBuilder) => void>;
+export declare class KnexSchemaBuilder {
+    private knex;
+    static logToConsole: boolean;
+    verifyStructureOfAllEntities(remult?: Remult): Promise<void>;
+    ensureSchema(entities: EntityMetadata<any>[]): 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, supportsJson?: boolean): void;
+export declare function createKnexDataProvider(config: Knex.Config): Promise<KnexDataProvider>;

package/esm/core/remult-knex/index.js

@@ -0,0 +1,446 @@
+import { customDatabaseFilterToken, Filter } from "../src/filter/filter-interfaces";
+import { dbNamesOf, isDbReadonly } from "../src/filter/filter-consumer-bridge-to-sql-request";
+import { allEntities } from "../src/context";
+import { isAutoIncrement, getRepository } from "../src/remult3";
+import { ValueConverters } from "../src/valueConverters";
+import { CompoundIdField } from '../src/column';
+import { Sort } from '../src/sort';
+import { remult as remultContext } from '../src/remult-proxy';
+export class KnexDataProvider {
+    knex;
+    constructor(knex) {
+        this.knex = knex;
+    }
+    static getDb(remult) {
+        const r = (remult || remultContext).dataProvider;
+        if (!r.knex)
+            throw "the data provider is not an KnexDataProvider";
+        return r.knex;
+    }
+    getEntityDataProvider(entity) {
+        if (!supportsJson(this.knex))
+            for (const f of entity.fields.toArray()) {
+                if (f.valueConverter.fieldTypeInDb === "json") {
+                    //@ts-ignore
+                    f.valueConverter = { ...f.valueConverter, toDb: ValueConverters.JsonString.toDb, fromDb: ValueConverters.JsonString.fromDb };
+                }
+            }
+        return new KnexEntityDataProvider(entity, this.knex);
+    }
+    async transaction(action) {
+        let t = await this.knex.transaction();
+        try {
+            await action(new KnexDataProvider(t));
+            await t.commit();
+        }
+        catch (err) {
+            await t.rollback();
+            throw err;
+        }
+    }
+    static rawFilter(build) {
+        return {
+            [customDatabaseFilterToken]: {
+                buildKnex: build
+            }
+        };
+    }
+    static async filterToRaw(entity, condition) {
+        const repo = getRepository(entity);
+        var b = new FilterConsumerBridgeToKnexRequest(await dbNamesOf(repo.metadata));
+        b._addWhere = false;
+        await (await (repo.translateWhereToFilter(condition))).__applyToConsumer(b);
+        let r = await b.resolveWhere();
+        return knex => r.forEach(y => y(knex));
+    }
+    isProxy;
+    async ensureSchema(entities) {
+        var sb = new KnexSchemaBuilder(this.knex);
+        await sb.ensureSchema(entities);
+    }
+}
+class KnexEntityDataProvider {
+    entity;
+    knex;
+    constructor(entity, knex) {
+        this.entity = entity;
+        this.knex = knex;
+    }
+    async count(where) {
+        const e = await this.init();
+        const br = new FilterConsumerBridgeToKnexRequest(e);
+        where.__applyToConsumer(br);
+        let r = await br.resolveWhere();
+        const result = (await this.knex(e.$entityName)
+            .count().where(b => r.forEach(w => w(b))));
+        var row = result[0];
+        for (const key in row) {
+            if (Object.prototype.hasOwnProperty.call(row, key)) {
+                const element = row[key];
+                return +element;
+            }
+        }
+    }
+    async find(options) {
+        const e = await this.init();
+        let cols = [];
+        let colKeys = [];
+        for (const x of this.entity.fields) {
+            if (x.isServerExpression) {
+            }
+            else {
+                cols.push(e.$dbNameOf(x));
+                colKeys.push(x);
+            }
+        }
+        let query = this.knex(e.$entityName).select(cols);
+        if (options?.where) {
+            const br = new FilterConsumerBridgeToKnexRequest(e);
+            options.where.__applyToConsumer(br);
+            let r = await br.resolveWhere();
+            query.where(b => r.forEach(y => y(b)));
+        }
+        if (!options.orderBy) {
+            options.orderBy = Sort.createUniqueSort(this.entity, new Sort());
+        }
+        if (options.orderBy) {
+            query = query.orderBy(options.orderBy.Segments.map(s => ({
+                column: e.$dbNameOf(s.field),
+                order: s.isDescending ? "desc" : "asc"
+            })));
+        }
+        if (options.limit) {
+            query = query.limit(options.limit);
+            if (options.page)
+                query = query.offset((options.page - 1) * options.limit);
+        }
+        const r = await query;
+        return r.map(y => {
+            let result = {};
+            let i = 0;
+            for (let m in y) {
+                let field = colKeys[i++];
+                try {
+                    result[field.key] = field.valueConverter.fromDb(y[m]);
+                }
+                catch (err) {
+                    throw new Error("Failed to load from db:" + field.key + "\r\n" + err);
+                }
+            }
+            return result;
+        });
+    }
+    async init() {
+        return await dbNamesOf(this.entity);
+    }
+    async update(id, data) {
+        const e = await this.init();
+        let f = new FilterConsumerBridgeToKnexRequest(e);
+        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
+        let resultFilter = this.entity.idMetadata.getIdFilter(id);
+        if (data.id != undefined)
+            resultFilter = this.entity.idMetadata.getIdFilter(data.id);
+        let updateObject = {};
+        for (const x of this.entity.fields) {
+            if (isDbReadonly(x, e)) { }
+            else if (data[x.key] !== undefined) {
+                let v = translateValueAndHandleArrayAndHandleArray(x, data[x.key]);
+                if (v !== undefined) {
+                    let key = await e.$dbNameOf(x);
+                    updateObject[key] = v;
+                }
+            }
+        }
+        let where = await f.resolveWhere();
+        await this.knex(e.$entityName).update(updateObject).where(b => where.forEach(w => w(b)));
+        return this.find({ where: Filter.fromEntityFilter(this.entity, resultFilter) }).then(y => y[0]);
+    }
+    async delete(id) {
+        const e = await this.init();
+        let f = new FilterConsumerBridgeToKnexRequest(e);
+        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
+        let where = await f.resolveWhere();
+        await this.knex(e.$entityName).delete().where(b => where.forEach(w => w(b)));
+    }
+    async insert(data) {
+        const e = await this.init();
+        let resultFilter;
+        if (this.entity.idMetadata.field instanceof CompoundIdField)
+            resultFilter = this.entity.idMetadata.field.resultIdFilter(undefined, data);
+        else
+            resultFilter = Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(data[this.entity.idMetadata.field.key]));
+        let insertObject = {};
+        for (const x of this.entity.fields) {
+            if (isDbReadonly(x, e)) { }
+            else {
+                let v = translateValueAndHandleArrayAndHandleArray(x, data[x.key]);
+                if (v != undefined) {
+                    let key = await e.$dbNameOf(x);
+                    insertObject[key] = v;
+                }
+            }
+        }
+        let insert = this.knex(e.$entityName).insert(insertObject);
+        if (isAutoIncrement(this.entity.idMetadata.field)) {
+            let newId;
+            if (this.knex.client.config.client === 'mysql2') {
+                let result = await insert;
+                newId = result[0];
+            }
+            else {
+                let result = await insert.returning(this.entity.idMetadata.field.key);
+                newId = result[0].id;
+            }
+            resultFilter = new Filter(x => x.isEqualTo(this.entity.idMetadata.field, newId));
+        }
+        else
+            await insert;
+        return this.find({ where: resultFilter }).then(y => {
+            return y[0];
+        });
+    }
+}
+class FilterConsumerBridgeToKnexRequest {
+    nameProvider;
+    _addWhere = true;
+    promises = [];
+    result = [];
+    async resolveWhere() {
+        while (this.promises.length > 0) {
+            let p = this.promises;
+            this.promises = [];
+            for (const pr of p) {
+                await pr;
+            }
+        }
+        return this.result;
+    }
+    constructor(nameProvider) {
+        this.nameProvider = nameProvider;
+    }
+    custom(key, customItem) {
+        throw new Error("Custom filter should be translated before it gets here");
+    }
+    or(orElements) {
+        this.promises.push((async () => {
+            const result = [];
+            for (const element of orElements) {
+                let f = new FilterConsumerBridgeToKnexRequest(this.nameProvider);
+                f._addWhere = false;
+                element.__applyToConsumer(f);
+                let where = await f.resolveWhere();
+                if (where.length > 0) {
+                    result.push(b => {
+                        b.orWhere(b => {
+                            where.forEach(x => x(b));
+                        });
+                    });
+                }
+                else
+                    return; //empty or means all rows
+            }
+            if (result.length > 0) {
+                this.result.push(b => b.where(x => result.find(y => y(x))));
+            }
+        })());
+    }
+    isNull(col) {
+        this.result.push(b => b.whereNull(this.nameProvider.$dbNameOf(col)));
+    }
+    isNotNull(col) {
+        this.result.push(b => b.whereNotNull(this.nameProvider.$dbNameOf(col)));
+    }
+    isIn(col, val) {
+        this.result.push(knex => knex.whereIn(this.nameProvider.$dbNameOf(col), val.map(x => translateValueAndHandleArrayAndHandleArray(col, x))));
+    }
+    isEqualTo(col, val) {
+        this.add(col, val, "=");
+    }
+    isDifferentFrom(col, val) {
+        this.add(col, val, "<>");
+    }
+    isGreaterOrEqualTo(col, val) {
+        this.add(col, val, ">=");
+    }
+    isGreaterThan(col, val) {
+        this.add(col, val, ">");
+    }
+    isLessOrEqualTo(col, val) {
+        this.add(col, val, "<=");
+    }
+    isLessThan(col, val) {
+        this.add(col, val, "<");
+    }
+    containsCaseInsensitive(col, val) {
+        this.result.push(b => b.whereRaw('lower (' + b.client.ref(this.nameProvider.$dbNameOf(col)) + ") like lower ('%" + val.replace(/'/g, '\'\'') + "%')"));
+        this.promises.push((async () => {
+        })());
+    }
+    add(col, val, operator) {
+        this.result.push(b => b.where(this.nameProvider.$dbNameOf(col), operator, translateValueAndHandleArrayAndHandleArray(col, val)));
+    }
+    databaseCustom(databaseCustom) {
+        this.promises.push((async () => {
+            if (databaseCustom?.buildKnex) {
+                this.result.push(await databaseCustom.buildKnex());
+            }
+        })());
+    }
+}
+export class KnexSchemaBuilder {
+    knex;
+    //@internal
+    static logToConsole = true;
+    async verifyStructureOfAllEntities(remult) {
+        if (!remult)
+            remult = remultContext;
+        const entities = allEntities.map(x => remult.repo(x).metadata);
+        this.ensureSchema(entities);
+    }
+    async ensureSchema(entities) {
+        for (const entity of entities) {
+            let e = await dbNamesOf(entity);
+            try {
+                if (!entity.options.sqlExpression) {
+                    if (e.$entityName.toLowerCase().indexOf('from ') < 0) {
+                        await this.createIfNotExist(entity);
+                        await this.verifyAllColumns(entity);
+                    }
+                }
+            }
+            catch (err) {
+                console.error("failed ensure schema of " + e.$entityName + " ", err);
+            }
+        }
+    }
+    async createIfNotExist(entity) {
+        const e = await dbNamesOf(entity);
+        if (!await this.knex.schema.hasTable(e.$entityName)) {
+            let cols = new Map();
+            for (const f of entity.fields) {
+                cols.set(f, {
+                    name: e.$dbNameOf(f),
+                    readonly: isDbReadonly(f, e)
+                });
+            }
+            await logSql(this.knex.schema.createTable(e.$entityName, b => {
+                for (const x of entity.fields) {
+                    if (!cols.get(x).readonly || isAutoIncrement(x)) {
+                        if (isAutoIncrement(x))
+                            b.increments(cols.get(x).name);
+                        else {
+                            buildColumn(x, cols.get(x).name, b, supportsJson(this.knex));
+                            if (x == entity.idMetadata.field)
+                                b.primary([cols.get(x).name]);
+                        }
+                    }
+                }
+            }));
+        }
+    }
+    async addColumnIfNotExist(entity, c) {
+        let e = await dbNamesOf(entity);
+        if (isDbReadonly(c(entity), e))
+            return;
+        let col = c(entity);
+        let colName = e.$dbNameOf(col);
+        if (!await this.knex.schema.hasColumn(e.$entityName, colName)) {
+            await logSql(this.knex.schema.alterTable(e.$entityName, b => {
+                buildColumn(col, colName, b, supportsJson(this.knex));
+            }));
+        }
+    }
+    async verifyAllColumns(entity) {
+        let e = await dbNamesOf(entity);
+        try {
+            for (const col of entity.fields.toArray()) {
+                if (!isDbReadonly(col, e)) {
+                    await this.addColumnIfNotExist(entity, () => col);
+                }
+            }
+        }
+        catch (err) {
+            console.error(err);
+        }
+    }
+    additionalWhere = '';
+    constructor(knex) {
+        this.knex = knex;
+    }
+}
+function supportsJson(knex) {
+    const client = knex.client.config.client;
+    if (client?.includes("sqlite3") || client?.includes("mssql"))
+        return false;
+    return true;
+}
+export function buildColumn(x, dbName, b, supportsJson = true) {
+    if (x.valueType == Number) {
+        if (!x.valueConverter.fieldTypeInDb) {
+            let c = b.decimal(dbName);
+            if (!x.allowNull) {
+                c.defaultTo(0).notNullable();
+            }
+        }
+        else if (x.valueConverter.fieldTypeInDb == "integer") {
+            let c = b.integer(dbName);
+            if (!x.allowNull) {
+                c.defaultTo(0).notNullable();
+            }
+        }
+        else
+            b.specificType(dbName, x.valueConverter.fieldTypeInDb);
+    }
+    else if (x.valueType == Date) {
+        if (!x.valueConverter.fieldTypeInDb)
+            if (x.valueConverter == ValueConverters.DateOnly)
+                b.date(dbName);
+            else
+                b.dateTime(dbName);
+        else if (x.valueConverter.fieldTypeInDb == "date")
+            b.date(dbName);
+        else
+            b.specificType(dbName, x.valueConverter.fieldTypeInDb);
+    }
+    else if (x.valueType == Boolean) {
+        let c = b.boolean(dbName);
+        if (!x.allowNull)
+            c.defaultTo(false).notNullable();
+    }
+    else if (x.valueConverter.fieldTypeInDb) {
+        if (x.valueConverter.fieldTypeInDb == "integer") {
+            let c = b.integer(dbName);
+            if (!x.allowNull) {
+                c.defaultTo(0).notNullable();
+            }
+        }
+        else if (x.valueConverter.fieldTypeInDb == "json")
+            if (supportsJson)
+                b.json(dbName);
+            else
+                b.text(dbName);
+        else
+            b.specificType(dbName, x.valueConverter.fieldTypeInDb);
+    }
+    else {
+        let c = b.string(dbName, x.options.maxLength);
+        if (!x.allowNull)
+            c.defaultTo('').notNullable();
+    }
+}
+function logSql(who) {
+    if (KnexSchemaBuilder.logToConsole)
+        console.info(who.toSQL());
+    return who;
+}
+export async function createKnexDataProvider(config) {
+    let k = (await import('knex')).default(config);
+    let result = new KnexDataProvider(k);
+    return result;
+}
+function translateValueAndHandleArrayAndHandleArray(field, val) {
+    let result = field.valueConverter.toDb(val);
+    if (Array.isArray(result))
+        return JSON.stringify(result);
+    return result;
+}