remult 0.14.7 → 0.14.8

package/esm/remult-knex/index.js

@@ -0,0 +1,381 @@
+import knex from 'knex';
+import { customDatabaseFilterToken, Filter } from "../src/filter/filter-interfaces";
+import { getDbNameProvider } from "../src/filter/filter-consumer-bridge-to-sql-request";
+import { allEntities, Remult } from "../src/context";
+import { isAutoIncrement } from "../src/remult3";
+import { ValueConverters } from "../valueConverters";
+import { CompoundIdField } from '../src/column';
+export class KnexDataProvider {
+    constructor(knex) {
+        this.knex = knex;
+    }
+    getEntityDataProvider(entity) {
+        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 customFilter(build) {
+        return {
+            [customDatabaseFilterToken]: {
+                buildKnex: build
+            }
+        };
+    }
+}
+class KnexEntityDataProvider {
+    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.nameOf(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) {
+            query = query.orderBy(options.orderBy.Segments.map(s => ({
+                column: e.nameOf(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 getDbNameProvider(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 (e.isDbReadonly(x)) { }
+            else if (data[x.key] !== undefined) {
+                let v = x.valueConverter.toDb(data[x.key]);
+                if (v !== undefined) {
+                    let key = await e.nameOf(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 (e.isDbReadonly(x)) { }
+            else {
+                let v = x.valueConverter.toDb(data[x.key]);
+                if (v != undefined) {
+                    let key = await e.nameOf(x);
+                    insertObject[key] = v;
+                }
+            }
+        }
+        let insert = this.knex(e.entityName).insert(insertObject);
+        if (isAutoIncrement(this.entity.idMetadata.field)) {
+            let result = await insert.returning(this.entity.idMetadata.field.key);
+            let 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];
+        });
+    }
+}
+export class FilterConsumerBridgeToKnexRequest {
+    constructor(nameProvider) {
+        this.nameProvider = nameProvider;
+        this._addWhere = true;
+        this.promises = [];
+        this.result = [];
+    }
+    async resolveWhere() {
+        while (this.promises.length > 0) {
+            let p = this.promises;
+            this.promises = [];
+            for (const pr of p) {
+                await pr;
+            }
+        }
+        return this.result;
+    }
+    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.nameOf(col)));
+    }
+    isNotNull(col) {
+        this.result.push(b => b.whereNotNull(this.nameProvider.nameOf(col)));
+    }
+    isIn(col, val) {
+        this.result.push(knex => knex.whereIn(this.nameProvider.nameOf(col), val.map(x => col.valueConverter.toDb(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 (' + this.nameProvider.nameOf(col) + ") like lower ('%" + val.replace(/'/g, '\'\'') + "%')"));
+        this.promises.push((async () => {
+        })());
+    }
+    add(col, val, operator) {
+        this.result.push(b => b.where(this.nameProvider.nameOf(col), operator, col.valueConverter.toDb(val)));
+    }
+    databaseCustom(databaseCustom) {
+        this.promises.push((async () => {
+            if (databaseCustom?.buildKnex) {
+                this.result.push(await databaseCustom.buildKnex());
+            }
+        })());
+    }
+}
+export class KnexSchemaBuilder {
+    constructor(knex) {
+        this.knex = knex;
+        this.additionalWhere = '';
+    }
+    async verifyStructureOfAllEntities(remult) {
+        console.log("start verify structure");
+        for (const entity of allEntities) {
+            let metadata = remult.repo(entity).metadata;
+            try {
+                if (!metadata.options.sqlExpression) {
+                    if ((await metadata.getDbName()).toLowerCase().indexOf('from ') < 0) {
+                        await this.createIfNotExist(metadata);
+                        await this.verifyAllColumns(metadata);
+                    }
+                }
+            }
+            catch (err) {
+                console.log("failed verify structure of " + await metadata.getDbName() + " ", err);
+            }
+        }
+    }
+    async createIfNotExist(entity) {
+        const e = await getDbNameProvider(entity);
+        if (!await this.knex.schema.hasTable(e.entityName)) {
+            let cols = new Map();
+            for (const f of entity.fields) {
+                cols.set(f, {
+                    name: e.nameOf(f),
+                    readonly: e.isDbReadonly(f)
+                });
+            }
+            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);
+                            if (x == entity.idMetadata.field)
+                                b.primary([cols.get(x).name]);
+                        }
+                    }
+                }
+            }));
+        }
+    }
+    async addColumnIfNotExist(entity, c) {
+        let e = await getDbNameProvider(entity);
+        if (e.isDbReadonly(c(entity)))
+            return;
+        let col = c(entity);
+        let colName = e.nameOf(col);
+        if (!await this.knex.schema.hasColumn(e.entityName, colName)) {
+            await this.knex.schema.alterTable(e.entityName, b => {
+                buildColumn(col, colName, b);
+            });
+        }
+    }
+    async verifyAllColumns(entity) {
+        let e = await getDbNameProvider(entity);
+        try {
+            for (const col of entity.fields) {
+                if (!e.isDbReadonly(col)) {
+                    await this.addColumnIfNotExist(entity, () => col);
+                }
+            }
+        }
+        catch (err) {
+            console.log(err);
+        }
+    }
+}
+export function buildColumn(x, dbName, b) {
+    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
+            b.specificType(dbName, x.valueConverter.fieldTypeInDb);
+    }
+    else {
+        let c = b.string(dbName, x.options.maxLength);
+        if (!x.allowNull)
+            c.defaultTo('').notNullable();
+    }
+}
+function logSql(who) {
+    //console.log(who.toSQL().sql);
+    return who;
+}
+export async function createKnexDataProvider(config, autoCreateTables = true) {
+    let k = knex(config);
+    let result = new KnexDataProvider(k);
+    if (autoCreateTables)
+        await new KnexSchemaBuilder(k).verifyStructureOfAllEntities(new Remult(result));
+    return result;
+}

package/esm/remult-middleware.d.ts

@@ -0,0 +1,2 @@
+import { RemultMiddlewareOptions } from './server/expressBridge';
+export declare function remultMiddleware(options?: RemultMiddlewareOptions): import("./server/expressBridge").RemultExpressBridge;

package/esm/remult-middleware.js

@@ -0,0 +1,63 @@
+import { remultMiddlewareBase } from './server/expressBridge';
+export function remultMiddleware(options) {
+    const m = new middleware();
+    let app = Object.assign(m, (req, res, next) => m.handleRequest(req, res, next));
+    return remultMiddlewareBase(app, options);
+}
+class middleware {
+    constructor() {
+        this.map = new Map();
+    }
+    route(path) {
+        //consider using:
+        //* https://raw.githubusercontent.com/cmorten/opine/main/src/utils/pathToRegex.ts
+        //* https://github.com/pillarjs/path-to-regexp
+        let r = path.toLowerCase();
+        let m = new Map();
+        this.map.set(r, m);
+        const route = {
+            get: (h) => {
+                m.set("get", h);
+                return route;
+            },
+            put: (h) => {
+                m.set("put", h);
+                return route;
+            },
+            post: (h) => {
+                m.set("post", h);
+                return route;
+            },
+            delete: (h) => {
+                m.set("delete", h);
+                return route;
+            }
+        };
+        return route;
+    }
+    handleRequest(req, res, next) {
+        let lowerPath = req.path.toLowerCase();
+        let m = this.map.get(lowerPath);
+        if (m) {
+            let h = m.get(req.method.toLowerCase());
+            if (h) {
+                h(req, res, next);
+                return;
+            }
+        }
+        let idPosition = req.path.lastIndexOf('/');
+        if (idPosition >= 0) {
+            lowerPath = req.path.substring(0, idPosition) + '/:id';
+            m = this.map.get(lowerPath);
+            if (m) {
+                let h = m.get(req.method.toLowerCase());
+                if (h) {
+                    req.params.id = req.path.substring(idPosition + 1);
+                    h(req, res, next);
+                    return;
+                }
+            }
+        }
+        next();
+    }
+}

package/esm/remult-mongo.d.ts

@@ -0,0 +1,9 @@
+import { MongoClient, Db } from 'mongodb';
+import { DataProvider, EntityDataProvider, EntityMetadata } from '.';
+export declare class MongoDataProvider implements DataProvider {
+    private db;
+    private client;
+    constructor(db: Db, client: MongoClient);
+    getEntityDataProvider(entity: EntityMetadata<any>): EntityDataProvider;
+    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
+}

package/esm/remult-mongo.js

@@ -0,0 +1,220 @@
+import { CompoundIdField, Filter } from '.';
+import { getDbNameProvider } from './src/filter/filter-consumer-bridge-to-sql-request';
+export class MongoDataProvider {
+    constructor(db, client) {
+        this.db = db;
+        this.client = client;
+    }
+    getEntityDataProvider(entity) {
+        return new MongoEntityDataProvider(this.db, entity);
+    }
+    async transaction(action) {
+        let session = await this.client.startSession();
+        session.startTransaction();
+        try {
+            await action(new MongoDataProvider(this.db, undefined));
+            await session.commitTransaction();
+        }
+        catch (err) {
+            await session.abortTransaction();
+            throw err;
+        }
+    }
+}
+const NULL = { $null: "$null" };
+function isNull(x) {
+    return x?.$null === NULL.$null;
+}
+class MongoEntityDataProvider {
+    constructor(db, entity) {
+        this.db = db;
+        this.entity = entity;
+    }
+    translateFromJson(row, nameProvider) {
+        let result = {};
+        for (const col of this.entity.fields) {
+            result[col.key] = col.valueConverter.fromDb(row[nameProvider.nameOf(col)]);
+            if (isNull(result[col.key]))
+                result[col.key] = null;
+        }
+        return result;
+    }
+    translateToJson(row, nameProvider) {
+        let result = {};
+        for (const col of this.entity.fields) {
+            let val = col.valueConverter.toDb(row[col.key]);
+            if (val === null)
+                val = NULL;
+            result[nameProvider.nameOf(col)] = val;
+        }
+        return result;
+    }
+    async count(where) {
+        const { collection, e } = await this.collection();
+        let x = new FilterConsumerBridgeToMongo(e);
+        where.__applyToConsumer(x);
+        let w = await x.resolveWhere();
+        return await collection.countDocuments(w);
+    }
+    async find(options) {
+        let { collection, e } = await this.collection();
+        let x = new FilterConsumerBridgeToMongo(e);
+        if (options?.where)
+            options.where.__applyToConsumer(x);
+        let where = await x.resolveWhere();
+        let op = {};
+        if (options.limit) {
+            op.limit = options.limit;
+            if (options.page) {
+                op.skip = (options.page - 1) * options.limit;
+            }
+        }
+        if (options.orderBy) {
+            op.sort = {};
+            for (const s of options.orderBy.Segments) {
+                op.sort[e.nameOf(s.field)] = s.isDescending ? -1 : 1;
+            }
+        }
+        return await Promise.all(await collection.find(where, op).map(x => this.translateFromJson(x, e)).toArray());
+    }
+    async update(id, data) {
+        let { collection, e } = await this.collection();
+        let f = new FilterConsumerBridgeToMongo(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);
+        for (const x of this.entity.fields) {
+            if (x instanceof CompoundIdField) {
+                resultFilter = x.resultIdFilter(id, data);
+            }
+        }
+        let newR = {};
+        let keys = Object.keys(data);
+        for (const f of this.entity.fields) {
+            if (!f.dbReadOnly && !f.isServerExpression) {
+                if (keys.includes(f.key)) {
+                    newR[f.key] = f.valueConverter.toJson(data[f.key]);
+                }
+            }
+        }
+        let r = await collection.updateOne(await f.resolveWhere(), {
+            $set: newR
+        });
+        return this.find({ where: Filter.fromEntityFilter(this.entity, resultFilter) }).then(y => y[0]);
+    }
+    async delete(id) {
+        const { e, collection } = await this.collection();
+        let f = new FilterConsumerBridgeToMongo(e);
+        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
+        collection.deleteOne(await f.resolveWhere());
+    }
+    async insert(data) {
+        let { collection, e } = await this.collection();
+        let r = await collection.insertOne(await this.translateToJson(data, e));
+        return await this.translateFromJson(await collection.findOne({ _id: r.insertedId }), e);
+    }
+    async collection() {
+        const e = await getDbNameProvider(this.entity);
+        const collection = this.db.collection(e.entityName);
+        return { e, collection };
+    }
+}
+class FilterConsumerBridgeToMongo {
+    constructor(nameProvider) {
+        this.nameProvider = nameProvider;
+        this._addWhere = true;
+        this.promises = [];
+        this.result = [];
+    }
+    async resolveWhere() {
+        while (this.promises.length > 0) {
+            let p = this.promises;
+            this.promises = [];
+            for (const pr of p) {
+                await pr;
+            }
+        }
+        if (this.result.length > 0)
+            return { $and: this.result.map(x => x()) };
+        else
+            return {};
+    }
+    custom(key, customItem) {
+        throw new Error("Custom filter should be translated before it gets here");
+    }
+    or(orElements) {
+        this.promises.push((async () => {
+            let result = [];
+            for (const element of orElements) {
+                let f = new FilterConsumerBridgeToMongo(this.nameProvider);
+                f._addWhere = false;
+                element.__applyToConsumer(f);
+                let where = await f.resolveWhere();
+                if (where?.$and?.length > 0) {
+                    result.push(where);
+                }
+                else
+                    return; //since empty or is all rows;
+            }
+            this.result.push(() => ({
+                $or: result
+            }));
+        })());
+    }
+    isNull(col) {
+        this.add(col, NULL, "$eq");
+    }
+    isNotNull(col) {
+        this.add(col, NULL, "$ne");
+    }
+    isIn(col, val) {
+        this.result.push(() => ({
+            [this.nameProvider.nameOf(col)]: {
+                $in: val.map(x => col.valueConverter.toDb(x))
+            }
+        }));
+    }
+    isEqualTo(col, val) {
+        this.add(col, val, "$eq");
+    }
+    isDifferentFrom(col, val) {
+        this.add(col, val, "$ne");
+    }
+    isGreaterOrEqualTo(col, val) {
+        this.add(col, val, "$gte");
+    }
+    isGreaterThan(col, val) {
+        this.add(col, val, "$gt");
+    }
+    isLessOrEqualTo(col, val) {
+        this.add(col, val, "$lte");
+    }
+    isLessThan(col, val) {
+        this.add(col, val, "$lt");
+    }
+    containsCaseInsensitive(col, val) {
+        throw "containsCaseInsensitive not yet implemented";
+        // this.promises.push(col.getDbName().then(colName => {
+        //     this.result.push(b => b.whereRaw(
+        //         'lower (' + colName + ") like lower ('%" + val.replace(/'/g, '\'\'') + "%')"));
+        // }));
+    }
+    add(col, val, operator) {
+        this.result.push(() => ({
+            [this.nameProvider.nameOf(col)]: { [operator]: isNull(val) ? val : col.valueConverter.toDb(val) }
+        }));
+    }
+    databaseCustom(databaseCustom) {
+        throw "error";
+        //   this.promises.push((async () => {
+        //     if (databaseCustom?.buildSql) {
+        //       let item = new CustomSqlFilterBuilder(this.knex);
+        //       await databaseCustom.buildSql(item);
+        //       if (item.sql) {
+        //         this.addToWhere("(" + item.sql + ")");
+        //       }
+        //     }
+        //   })());
+    }
+}

package/esm/server/JsonEntityFileStorage.d.ts

@@ -0,0 +1,7 @@
+import { JsonEntityStorage } from '../index';
+export declare class JsonEntityFileStorage implements JsonEntityStorage {
+    private folderPath;
+    getItem(entityDbName: string): string;
+    setItem(entityDbName: string, json: string): void;
+    constructor(folderPath: string);
+}