remult 0.18.1-exp.2 → 0.18.1-exp.21

package/esm/remult-knex/index.js

@@ -1,15 +1,21 @@
-import knex from 'knex';
 import { customDatabaseFilterToken, Filter } from "../src/filter/filter-interfaces";
-import { getDbNameProvider } from "../src/filter/filter-consumer-bridge-to-sql-request";
+import { dbNamesOf, isDbReadonly } from "../src/filter/filter-consumer-bridge-to-sql-request";
 import { allEntities, Remult } from "../src/context";
-import { isAutoIncrement } from "../src/remult3";
+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, RemultProxy } from '../src/remult-proxy';
 export class KnexDataProvider {
     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) {
         return new KnexEntityDataProvider(entity, this.knex);
     }
@@ -24,13 +30,21 @@ export class KnexDataProvider {
             throw err;
         }
     }
-    static customFilter(build) {
+    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));
+    }
 }
 class KnexEntityDataProvider {
     constructor(entity, knex) {
@@ -42,7 +56,7 @@ class KnexEntityDataProvider {
         const br = new FilterConsumerBridgeToKnexRequest(e);
         where.__applyToConsumer(br);
         let r = await br.resolveWhere();
-        const result = (await this.knex(e.entityName)
+        const result = (await this.knex(e.$entityName)
             .count().where(b => r.forEach(w => w(b))));
         var row = result[0];
         for (const key in row) {
@@ -60,11 +74,11 @@ class KnexEntityDataProvider {
             if (x.isServerExpression) {
             }
             else {
-                cols.push(e.nameOf(x));
+                cols.push(e.$dbNameOf(x));
                 colKeys.push(x);
             }
         }
-        let query = this.knex(e.entityName).select(cols);
+        let query = this.knex(e.$entityName).select(cols);
         if (options?.where) {
             const br = new FilterConsumerBridgeToKnexRequest(e);
             options.where.__applyToConsumer(br);
@@ -76,7 +90,7 @@ class KnexEntityDataProvider {
         }
         if (options.orderBy) {
             query = query.orderBy(options.orderBy.Segments.map(s => ({
-                column: e.nameOf(s.field),
+                column: e.$dbNameOf(s.field),
                 order: s.isDescending ? "desc" : "asc"
             })));
         }
@@ -102,7 +116,7 @@ class KnexEntityDataProvider {
         });
     }
     async init() {
-        return await getDbNameProvider(this.entity);
+        return await dbNamesOf(this.entity);
     }
     async update(id, data) {
         const e = await this.init();
@@ -113,17 +127,17 @@ class KnexEntityDataProvider {
             resultFilter = this.entity.idMetadata.getIdFilter(data.id);
         let updateObject = {};
         for (const x of this.entity.fields) {
-            if (e.isDbReadonly(x)) { }
+            if (isDbReadonly(x, e)) { }
             else if (data[x.key] !== undefined) {
                 let v = x.valueConverter.toDb(data[x.key]);
                 if (v !== undefined) {
-                    let key = await e.nameOf(x);
+                    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)));
+        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) {
@@ -131,7 +145,7 @@ class KnexEntityDataProvider {
         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)));
+        await this.knex(e.$entityName).delete().where(b => where.forEach(w => w(b)));
     }
     async insert(data) {
         const e = await this.init();
@@ -142,19 +156,26 @@ class KnexEntityDataProvider {
             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)) { }
+            if (isDbReadonly(x, e)) { }
             else {
                 let v = x.valueConverter.toDb(data[x.key]);
                 if (v != undefined) {
-                    let key = await e.nameOf(x);
+                    let key = await e.$dbNameOf(x);
                     insertObject[key] = v;
                 }
             }
         }
-        let insert = this.knex(e.entityName).insert(insertObject);
+        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;
+            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
@@ -164,7 +185,7 @@ class KnexEntityDataProvider {
         });
     }
 }
-export class FilterConsumerBridgeToKnexRequest {
+class FilterConsumerBridgeToKnexRequest {
     constructor(nameProvider) {
         this.nameProvider = nameProvider;
         this._addWhere = true;
@@ -208,13 +229,13 @@ export class FilterConsumerBridgeToKnexRequest {
         })());
     }
     isNull(col) {
-        this.result.push(b => b.whereNull(this.nameProvider.nameOf(col)));
+        this.result.push(b => b.whereNull(this.nameProvider.$dbNameOf(col)));
     }
     isNotNull(col) {
-        this.result.push(b => b.whereNotNull(this.nameProvider.nameOf(col)));
+        this.result.push(b => b.whereNotNull(this.nameProvider.$dbNameOf(col)));
     }
     isIn(col, val) {
-        this.result.push(knex => knex.whereIn(this.nameProvider.nameOf(col), val.map(x => col.valueConverter.toDb(x))));
+        this.result.push(knex => knex.whereIn(this.nameProvider.$dbNameOf(col), val.map(x => col.valueConverter.toDb(x))));
     }
     isEqualTo(col, val) {
         this.add(col, val, "=");
@@ -235,12 +256,12 @@ export class FilterConsumerBridgeToKnexRequest {
         this.add(col, val, "<");
     }
     containsCaseInsensitive(col, val) {
-        this.result.push(b => b.whereRaw('lower (' + this.nameProvider.nameOf(col) + ") like lower ('%" + val.replace(/'/g, '\'\'') + "%')"));
+        this.result.push(b => b.whereRaw('lower (' + 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.nameOf(col), operator, col.valueConverter.toDb(val)));
+        this.result.push(b => b.where(this.nameProvider.$dbNameOf(col), operator, col.valueConverter.toDb(val)));
     }
     databaseCustom(databaseCustom) {
         this.promises.push((async () => {
@@ -256,7 +277,10 @@ export class KnexSchemaBuilder {
         this.additionalWhere = '';
     }
     async verifyStructureOfAllEntities(remult) {
-        console.info("start verify structure");
+        if (!remult)
+            remult = RemultProxy.defaultRemult;
+        if (KnexSchemaBuilder.logToConsole)
+            console.time("Knex Auto create tables and columns");
         for (const entity of allEntities) {
             let metadata = remult.repo(entity).metadata;
             try {
@@ -268,21 +292,23 @@ export class KnexSchemaBuilder {
                 }
             }
             catch (err) {
-                console.log("failed verify structure of " + await metadata.getDbName() + " ", err);
+                console.error("failed verify structure of " + await metadata.getDbName() + " ", err);
             }
         }
+        if (KnexSchemaBuilder.logToConsole)
+            console.timeEnd("Knex Auto create tables and columns");
     }
     async createIfNotExist(entity) {
-        const e = await getDbNameProvider(entity);
-        if (!await this.knex.schema.hasTable(e.entityName)) {
+        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.nameOf(f),
-                    readonly: e.isDbReadonly(f)
+                    name: e.$dbNameOf(f),
+                    readonly: isDbReadonly(f, e)
                 });
             }
-            await logSql(this.knex.schema.createTable(e.entityName, b => {
+            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))
@@ -298,22 +324,22 @@ export class KnexSchemaBuilder {
         }
     }
     async addColumnIfNotExist(entity, c) {
-        let e = await getDbNameProvider(entity);
-        if (e.isDbReadonly(c(entity)))
+        let e = await dbNamesOf(entity);
+        if (isDbReadonly(c(entity), e))
             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 => {
+        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);
-            });
+            }));
         }
     }
     async verifyAllColumns(entity) {
-        let e = await getDbNameProvider(entity);
+        let e = await dbNamesOf(entity);
         try {
-            for (const col of entity.fields) {
-                if (!e.isDbReadonly(col)) {
+            for (const col of entity.fields.toArray()) {
+                if (!isDbReadonly(col, e)) {
                     await this.addColumnIfNotExist(entity, () => col);
                 }
             }
@@ -323,6 +349,8 @@ export class KnexSchemaBuilder {
         }
     }
 }
+//@internal
+KnexSchemaBuilder.logToConsole = true;
 export function buildColumn(x, dbName, b) {
     if (x.valueType == Number) {
         if (!x.valueConverter.fieldTypeInDb) {
@@ -373,11 +401,12 @@ export function buildColumn(x, dbName, b) {
     }
 }
 function logSql(who) {
-    //console.log(who.toSQL().sql);
+    if (KnexSchemaBuilder.logToConsole)
+        console.info(who.toSQL());
     return who;
 }
 export async function createKnexDataProvider(config, autoCreateTables = true) {
-    let k = knex(config);
+    let k = (await import('knex')).default(config);
     let result = new KnexDataProvider(k);
     if (autoCreateTables)
         await new KnexSchemaBuilder(k).verifyStructureOfAllEntities(new Remult(result));

package/esm/remult-mongo.d.ts

@@ -1,9 +1,16 @@
-import { MongoClient, Db } from 'mongodb';
-import { DataProvider, EntityDataProvider, EntityMetadata } from '.';
+import type { MongoClient, Db } from 'mongodb';
+import { DataProvider, EntityDataProvider, EntityFilter, EntityMetadata, Remult } from '.';
+import { RepositoryOverloads } from './src/remult3';
 export declare class MongoDataProvider implements DataProvider {
     private db;
     private client;
     constructor(db: Db, client: MongoClient);
+    static getDb(remult?: Remult): Db;
     getEntityDataProvider(entity: EntityMetadata<any>): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
+    static filterToRaw<entityType>(entity: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>): Promise<{
+        $and: any[];
+    } | {
+        $and?: undefined;
+    }>;
 }

package/esm/remult-mongo.js

@@ -1,10 +1,18 @@
 import { CompoundIdField, Filter } from '.';
-import { getDbNameProvider } from './src/filter/filter-consumer-bridge-to-sql-request';
+import { dbNamesOf } from './src/filter/filter-consumer-bridge-to-sql-request';
+import { getRepository } from './src/remult3';
+import { remult as remultContext } from './src/remult-proxy';
 export class MongoDataProvider {
     constructor(db, client) {
         this.db = db;
         this.client = client;
     }
+    static getDb(remult) {
+        const r = (remult || remultContext).dataProvider;
+        if (!r.db)
+            throw "the data provider is not a MongoDataProvider";
+        return r.db;
+    }
     getEntityDataProvider(entity) {
         return new MongoEntityDataProvider(this.db, entity);
     }
@@ -20,6 +28,14 @@ export class MongoDataProvider {
             throw err;
         }
     }
+    static async filterToRaw(entity, condition) {
+        const repo = getRepository(entity);
+        var b = new FilterConsumerBridgeToMongo(await dbNamesOf(repo.metadata));
+        b._addWhere = false;
+        await (await (repo.translateWhereToFilter(condition))).__applyToConsumer(b);
+        let r = await b.resolveWhere();
+        return r;
+    }
 }
 const NULL = { $null: "$null" };
 function isNull(x) {
@@ -33,7 +49,7 @@ class MongoEntityDataProvider {
     translateFromJson(row, nameProvider) {
         let result = {};
         for (const col of this.entity.fields) {
-            let val = row[nameProvider.nameOf(col)];
+            let val = row[nameProvider.$dbNameOf(col)];
             if (isNull(val))
                 val = null;
             result[col.key] = col.valueConverter.fromDb(val);
@@ -46,7 +62,7 @@ class MongoEntityDataProvider {
             let val = col.valueConverter.toDb(row[col.key]);
             if (val === null)
                 val = NULL;
-            result[nameProvider.nameOf(col)] = val;
+            result[nameProvider.$dbNameOf(col)] = val;
         }
         return result;
     }
@@ -73,7 +89,7 @@ class MongoEntityDataProvider {
         if (options.orderBy) {
             op.sort = {};
             for (const s of options.orderBy.Segments) {
-                op.sort[e.nameOf(s.field)] = s.isDescending ? -1 : 1;
+                op.sort[e.$dbNameOf(s.field)] = s.isDescending ? -1 : 1;
             }
         }
         return await Promise.all(await collection.find(where, op).map(x => this.translateFromJson(x, e)).toArray());
@@ -116,8 +132,8 @@ class MongoEntityDataProvider {
         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);
+        const e = await dbNamesOf(this.entity);
+        const collection = this.db.collection(e.$entityName);
         return { e, collection };
     }
 }
@@ -171,7 +187,7 @@ class FilterConsumerBridgeToMongo {
     }
     isIn(col, val) {
         this.result.push(() => ({
-            [this.nameProvider.nameOf(col)]: {
+            [this.nameProvider.$dbNameOf(col)]: {
                 $in: val.map(x => col.valueConverter.toDb(x))
             }
         }));
@@ -203,7 +219,7 @@ class FilterConsumerBridgeToMongo {
     }
     add(col, val, operator) {
         this.result.push(() => ({
-            [this.nameProvider.nameOf(col)]: { [operator]: isNull(val) ? val : col.valueConverter.toDb(val) }
+            [this.nameProvider.$dbNameOf(col)]: { [operator]: isNull(val) ? val : col.valueConverter.toDb(val) }
         }));
     }
     databaseCustom(databaseCustom) {

package/esm/remult-next.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import type { GetServerSideProps, NextApiRequest, PreviewData, NextApiHandler } from "next";
+import type { ParsedUrlQuery } from "querystring";
+import { RemultServer, RemultServerOptions } from "./server";
+export declare function remultNext(options?: RemultServerOptions<NextApiRequest>): RemultServer & NextApiHandler & {
+    getServerSideProps<P extends {
+        [key: string]: any;
+    } = {
+        [key: string]: any;
+    }, Q extends ParsedUrlQuery = ParsedUrlQuery, D extends PreviewData = PreviewData>(getServerPropsFunction: GetServerSideProps<P, Q, D>): GetServerSideProps<P, Q, D>;
+};

package/esm/remult-next.js

@@ -0,0 +1,27 @@
+import { createRemultServer } from "./server";
+export function remultNext(options) {
+    let result = createRemultServer(options);
+    return Object.assign((req, res) => result.handle(req, res), result, {
+        getRemult: (...args) => result.getRemult(...args),
+        handle: (...args) => result.handle(...args),
+        openApiDoc: (...args) => result.openApiDoc(...args),
+        registerRouter: (...args) => result.registerRouter(...args),
+        withRemult: (...args) => result.withRemult(...args),
+    }, {
+        getServerSideProps: (getServerPropsFunction) => {
+            return (context) => {
+                return new Promise((res, err) => {
+                    result.withRemult(context, undefined, async () => {
+                        try {
+                            let r = await getServerPropsFunction(context);
+                            res(JSON.parse(JSON.stringify(r)));
+                        }
+                        catch (e) {
+                            err(e);
+                        }
+                    });
+                });
+            };
+        }
+    });
+}

package/esm/server/expressBridge.d.ts

@@ -1,11 +1,10 @@
-import { ActionInterface, queuedJobInfoResponse } from '../src/server-action';
+import { queuedJobInfoResponse } from '../src/server-action';
 import { DataProvider } from '../src/data-interfaces';
-import { DataApi, DataApiRequest, DataApiResponse } from '../src/data-api';
-import { AllowedForInstance, Remult, UserInfo } from '../src/context';
+import { Remult, UserInfo } from '../src/context';
 import { ClassType } from '../classType';
 import { Repository } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
-import { LiveQueryPublisher } from '../src/live-query/LiveQueryPublisher';
+import { LiveQueryStorage, SubscriptionServer } from '../src/live-query/SubscriptionServer';
 export interface RemultServerOptions<RequestType extends GenericRequest> {
     /** Sets a database connection for Remult.
      *
@@ -13,12 +12,14 @@ export interface RemultServerOptions<RequestType extends GenericRequest> {
     */
     dataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>);
     queueStorage?: QueueStorage;
-    initRequest?: (remult: Remult, origReq: RequestType) => Promise<void>;
+    liveQueryStorage?: LiveQueryStorage;
+    subscriptionServer?: SubscriptionServer;
+    initRequest?: (request: RequestType, options: InitRequestOptions) => Promise<void>;
     requestSerializer?: {
         toJson: (request: RequestType) => any;
         fromJson: (request: any) => RequestType;
     };
-    getUser?: (request: RequestType) => Promise<UserInfo>;
+    getUser?: (request: RequestType) => Promise<UserInfo | undefined>;
     initApi?: (remult: Remult) => void | Promise<void>;
     logApiEndPoints?: boolean;
     defaultGetLimit?: number;
@@ -26,7 +27,11 @@ export interface RemultServerOptions<RequestType extends GenericRequest> {
     controllers?: ClassType<any>[];
     rootPath?: string;
 }
-export declare function createRemultServer<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;
+export interface InitRequestOptions {
+    liveQueryStorage: LiveQueryStorage;
+    readonly remult: Remult;
+}
+export declare function createRemultServerCore<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;
 export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
 export interface ServerHandleResponse {
     data?: any;
@@ -63,39 +68,14 @@ export interface GenericResponse {
     status(statusCode: number): GenericResponse;
     end(): any;
 }
-export declare class RemultServerImplementation implements RemultServer {
-    queue: inProcessQueueHandler;
-    options: RemultServerOptions<GenericRequest>;
-    dataProvider: DataProvider | Promise<DataProvider>;
-    constructor(queue: inProcessQueueHandler, options: RemultServerOptions<GenericRequest>, dataProvider: DataProvider | Promise<DataProvider>);
-    liveQueryManager: LiveQueryPublisher;
-    withRemult<T>(req: GenericRequest, res: GenericResponse, next: VoidFunction): void;
-    routeImpl: RouteImplementation;
-    handle(req: GenericRequest, gRes?: GenericResponse): Promise<ServerHandleResponse>;
-    registeredRouter: boolean;
-    registerRouter(r: GenericRouter): void;
-    add(key: string, dataApiFactory: ((req: Remult) => DataApi), r: GenericRouter): void;
-    process(what: (remult: Remult, myReq: DataApiRequest, myRes: DataApiResponse, origReq: GenericRequest) => Promise<void>): (req: GenericRequest, res: GenericResponse) => Promise<void>;
-    getRemult(req: GenericRequest): Promise<Remult>;
-    hasQueue: boolean;
-    addAction(action: ActionInterface, r: GenericRouter): void;
-    openApiDoc(options: {
-        title: string;
-        version?: string;
-    }): any;
-    backendMethodsOpenApi: {
-        path: string;
-        allowed: AllowedForInstance<any>;
-        tag: string;
-    }[];
-}
-declare class inProcessQueueHandler {
-    private storage;
-    constructor(storage: QueueStorage);
-    submitJob(url: string, req: Remult, body: any): Promise<string>;
-    mapQueuedAction(url: string, what: (data: any, r: Remult, res: ApiActionResponse) => void): void;
-    actions: Map<string, (data: any, r: Remult, res: ApiActionResponse) => void>;
-    getJobInfo(queuedJobId: string): Promise<queuedJobInfo>;
+export declare class RemultAsyncLocalStorage {
+    private readonly remultObjectStorage;
+    static enable(): void;
+    static disable(): void;
+    constructor(remultObjectStorage: import('async_hooks').AsyncLocalStorage<Remult>);
+    run(remult: Remult, callback: VoidFunction): void;
+    getRemult(): Remult;
+    static instance: RemultAsyncLocalStorage;
 }
 export interface queuedJobInfo {
     info: queuedJobInfoResponse;
@@ -104,11 +84,6 @@ export interface queuedJobInfo {
     setResult(result: any): void;
     setProgress(progress: number): void;
 }
-export interface ApiActionResponse {
-    error(error: any): void;
-    success(result: any): void;
-    progress(progress: number): void;
-}
 export interface QueueStorage {
     createJob(url: string, userId: string): Promise<string>;
     getJobInfo(queuedJobId: string): Promise<queuedJobInfo>;
@@ -121,12 +96,6 @@ export declare class EntityQueueStorage implements QueueStorage {
     getJobInfo(queuedJobId: string): Promise<queuedJobInfo>;
     createJob(url: string, userId: string): Promise<string>;
 }
-declare class RouteImplementation {
-    map: Map<string, Map<string, GenericRequestHandler>>;
-    route(path: string): SpecificRoute;
-    handle(req: GenericRequest, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
-    middleware(req: GenericRequest, res: GenericResponse, next: VoidFunction): void;
-}
 export declare class JobsInQueueEntity extends IdEntity {
     userId: string;
     url: string;
@@ -137,4 +106,3 @@ export declare class JobsInQueueEntity extends IdEntity {
     error: boolean;
     progress: number;
 }
-export {};