remult 0.18.1-exp.3 → 0.18.1-exp.5

package/esm/index.d.ts

@@ -1,4 +1,4 @@
-export { Field, Fields, FieldsMetadata, Entity, 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 { Field, Fields, FieldsMetadata, Entity, 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, LiveQuery, LiveQueryChangeInfo } from './src/remult3';
 export { StringFieldOptions } from './src/remult3/RepositoryImplementation';
 export { describeClass } from './src/remult3/DecoratorReplacer';
 export { EntityOptions } from './src/entity';
@@ -11,7 +11,7 @@ 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 { CustomSqlFilterObject, CustomSqlFilterBuilder } from './src/filter/filter-consumer-bridge-to-sql-request';
+export { CustomSqlFilterObject, CustomSqlFilterBuilder, dbNamesOf } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { JsonDataProvider, JsonEntityStorage } from './src/data-providers/json-data-provider';
 export { Controller, BackendMethodOptions, BackendMethod, ProgressListener } from './src/server-action';
 export { Allowed, Allow, Remult, RemultContext, ApiClient, isBackend, AllowedForInstance, EventDispatcher, EventSource, Unobserve, UserInfo } from './src/context';
@@ -20,8 +20,9 @@ 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 './src/valueConverters';
 export { remult } from './src/remult-proxy';
+export { SubscriptionServer, LiveQueryStorage, StoredQuery, InMemoryLiveQueryStorage } from "./src/live-query/SubscriptionServer";
+export { SubscriptionListener, SubscriptionClientConnection, SubscriptionClient, SubscriptionChannel, LiveQueryChange, Unsubscribe } from './src/live-query/SubscriptionChannel';

package/esm/index.js

@@ -8,7 +8,7 @@ export { InMemoryDataProvider } from './src/data-providers/in-memory-database';
 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 { CustomSqlFilterBuilder } from './src/filter/filter-consumer-bridge-to-sql-request';
+export { CustomSqlFilterBuilder, dbNamesOf } from './src/filter/filter-consumer-bridge-to-sql-request';
 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';
@@ -17,8 +17,10 @@ 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 './src/valueConverters';
 export { remult } from './src/remult-proxy';
+//export { getId } from './src/remult3/getId';
+export { InMemoryLiveQueryStorage } from "./src/live-query/SubscriptionServer";
+export { SubscriptionChannel } from './src/live-query/SubscriptionChannel';

package/esm/live-query/ably.d.ts

@@ -1,12 +1,12 @@
 import type * as Ably from 'ably';
-import type { SubscriptionServer } from '../src/live-query/LiveQueryPublisher';
-import type { SubscriptionClient, SubscriptionClientConnection } from '../src/live-query/LiveQuerySubscriber';
-export declare class AblyLiveQueryProvider implements SubscriptionClient {
+import type { SubscriptionServer } from '../src/live-query/SubscriptionServer';
+import type { SubscriptionClient, SubscriptionClientConnection } from '../src/live-query/SubscriptionChannel';
+export declare class AblySubscriptionClient implements SubscriptionClient {
     private ably;
     constructor(ably: Ably.Types.RealtimePromise);
     openConnection(onReconnect: VoidFunction): Promise<SubscriptionClientConnection>;
 }
-export declare class AblyServerEventDispatcher implements SubscriptionServer {
+export declare class AblySubscriptionServer implements SubscriptionServer {
     private ably;
     constructor(ably: Ably.Types.RealtimePromise);
     publishMessage<T>(channel: string, message: T): void;

package/esm/live-query/ably.js

@@ -1,4 +1,4 @@
-export class AblyLiveQueryProvider {
+export class AblySubscriptionClient {
     constructor(ably) {
         this.ably = ably;
     }
@@ -15,7 +15,7 @@ export class AblyLiveQueryProvider {
         };
     }
 }
-export class AblyServerEventDispatcher {
+export class AblySubscriptionServer {
     constructor(ably) {
         this.ably = ably;
     }

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

@@ -1,4 +1,5 @@
-import { PoolConfig, QueryResult } from 'pg';
+import { ClientBase, PoolConfig, QueryResult } from 'pg';
+import { Remult } from '../src/context';
 import { EntityMetadata } from '../src/remult3';
 import { SqlCommand, SqlImplementation } from '../src/sql-command';
 import { SqlDatabase } from '../src/data-providers/sql-database';
@@ -10,6 +11,7 @@ export interface PostgresClient extends PostgresCommandSource {
 }
 export declare class PostgresDataProvider implements SqlImplementation {
     private pool;
+    static getDb(remult?: Remult): ClientBase;
     entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
     getLimitSqlSyntax(limit: number, offset: number): string;
     createCommand(): SqlCommand;

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

@@ -6,6 +6,14 @@ export class PostgresDataProvider {
     constructor(pool) {
         this.pool = pool;
     }
+    static getDb(remult) {
+        const sql = SqlDatabase.getDb(remult);
+        const me = sql._getSourceSql();
+        if (!me.pool) {
+            throw "the data provider is not a PostgresDataProvider";
+        }
+        return me.pool;
+    }
     async entityIsUsedForTheFirstTime(entity) {
     }
     getLimitSqlSyntax(limit, offset) {
@@ -22,7 +30,9 @@ export class PostgresDataProvider {
                 createCommand: () => new PostgresBridgeToSQLCommand(client),
                 entityIsUsedForTheFirstTime: this.entityIsUsedForTheFirstTime,
                 transaction: () => { throw "nested transactions not allowed"; },
-                getLimitSqlSyntax: this.getLimitSqlSyntax
+                getLimitSqlSyntax: this.getLimitSqlSyntax,
+                //@ts-ignore
+                pool: client
             });
             await client.query('COMMIT');
         }

package/esm/postgres/schema-builder.js

@@ -1,5 +1,5 @@
 import { allEntities } from '../src/context';
-import { getDbNameProvider } from '../src/filter/filter-consumer-bridge-to-sql-request';
+import { dbNamesOf, isDbReadonly } from '../src/filter/filter-consumer-bridge-to-sql-request';
 import { isAutoIncrement } from '../src/remult3';
 import { ValueConverters } from '../src/valueConverters';
 export function postgresColumnSyntax(x, dbName) {
@@ -43,61 +43,66 @@ export class PostgresSchemaBuilder {
         }
     }
     async verifyStructureOfAllEntities(remult) {
-        console.log("start verify structure"); //keep me
+        if (PostgresSchemaBuilder.logToConsole)
+            console.time("Postgres Auto create tables and columns");
         for (const entityClass of allEntities) {
             let entity = remult.repo(entityClass).metadata;
-            let e = await getDbNameProvider(entity);
+            let e = await dbNamesOf(entity);
             try {
                 if (!entity.options.sqlExpression) {
-                    if ((await e.entityName).toLowerCase().indexOf('from ') < 0) {
+                    if ((await e.$entityName).toLowerCase().indexOf('from ') < 0) {
                         await this.createIfNotExist(entity);
                         await this.verifyAllColumns(entity);
                     }
                 }
             }
             catch (err) {
-                /*keep me */ console.log("failed verify structure of " + e.entityName + " ", err);
+                console.error("failed verify structure of " + e.$entityName + " ", err);
             }
         }
+        if (PostgresSchemaBuilder.logToConsole)
+            console.timeEnd("Postgres Auto create tables and columns");
     }
     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) => {
+        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 (!e.isDbReadonly(x) || isAutoIncrement(x)) {
+                    if (!isDbReadonly(x, e) || isAutoIncrement(x)) {
                         if (result.length != 0)
                             result += ',';
                         result += '\r\n  ';
                         if (isAutoIncrement(x))
-                            result += e.nameOf(x) + ' serial';
+                            result += e.$dbNameOf(x) + ' serial';
                         else {
-                            result += postgresColumnSyntax(x, e.nameOf(x));
+                            result += postgresColumnSyntax(x, e.$dbNameOf(x));
                             if (x == entity.idMetadata.field)
                                 result += ' primary key';
                         }
                     }
                 }
-                let sql = 'create table ' + e.entityName + ' (' + result + '\r\n)';
-                //console.log(sql);
+                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 getDbNameProvider(entity);
-        if (e.isDbReadonly(c(entity)))
+        let e = await dbNamesOf(entity);
+        if (isDbReadonly(c(entity), e))
             return;
         try {
             let cmd = this.pool.createCommand();
-            const colName = e.nameOf(c(entity));
+            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)}`;
-                //console.log(sql);
+        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);
             }
         }
@@ -108,15 +113,16 @@ export class PostgresSchemaBuilder {
     async verifyAllColumns(entity) {
         try {
             let cmd = this.pool.createCommand();
-            let e = await getDbNameProvider(entity);
+            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);
+        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);
+                if (!isDbReadonly(col, e))
+                    if (!cols.includes(e.$dbNameOf(col).toLocaleLowerCase())) {
+                        let sql = `alter table ${e.$entityName} add column ${postgresColumnSyntax(col, e.$dbNameOf(col))}`;
+                        if (PostgresSchemaBuilder.logToConsole)
+                            console.info(sql);
                         await this.pool.execute(sql);
                     }
             }
@@ -126,3 +132,5 @@ export class PostgresSchemaBuilder {
         }
     }
 }
+//@internal
+PostgresSchemaBuilder.logToConsole = true;

package/esm/remult-express.d.ts

@@ -1,33 +1,14 @@
 import * as express from 'express';
 import { RemultServer, RemultServerOptions } from './server/expressBridge';
 import { Remult } from './src/context';
-import { ServerEventChannelSubscribeDTO } from './src/live-query/LiveQuerySubscriber';
-import { SubscriptionServer } from './src/live-query/LiveQueryPublisher';
-import { MessagePublisher } from './live-query';
+import { SubscriptionServer } from './src/live-query/SubscriptionServer';
 export declare function remultExpress(options?: RemultServerOptions<express.Request> & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
-    subscriptionServer?: (router: express.Router, server: RemultServer) => MessagePublisher;
 }): express.RequestHandler & RemultServer;
-export declare class ServerEventsController implements SubscriptionServer {
+export declare class SseSubscriptionServer implements SubscriptionServer {
     private canUserConnectToChannel?;
-    subscribeToChannel({ channel, clientId }: ServerEventChannelSubscribeDTO, res: import('express').Response, remult: Remult, remove?: boolean): void;
-    connections: clientConnection[];
     constructor(canUserConnectToChannel?: (channel: string, remult: Remult) => boolean);
     publishMessage<T>(channel: string, message: any): void;
-    debugMessageFileSaver: (id: any, channel: any, message: any) => void;
-    openHttpServerStream(req: import('express').Request, res: import('express').Response): clientConnection;
-    debug(): void;
-    debugFileSaver: (x: any) => void;
+    registerRoutes(router: express.Router, apiPath: string, server: RemultServer): void;
 }
-declare class clientConnection {
-    response: import('express').Response;
-    channels: Record<string, boolean>;
-    close(): void;
-    closed: boolean;
-    write(eventData: string, eventType?: string): void;
-    connectionId: any;
-    constructor(response: import('express').Response);
-    sendLiveMessage(): void;
-}
-export {};

package/esm/remult-express.js

@@ -1,6 +1,6 @@
 import * as express from 'express';
 import { createRemultServer } from './server/index';
-import { liveQueryKeepAliveRoute, streamUrl } from './src/live-query/LiveQuerySubscriber';
+import { liveQueryKeepAliveRoute, streamUrl } from './src/live-query/SubscriptionChannel';
 import { v4 as uuid } from 'uuid';
 import { remult } from './src/remult-proxy';
 import { getEntityKey } from './src/remult3';
@@ -16,15 +16,17 @@ export function remultExpress(options) {
         app.use(express.json({ limit: options.bodySizeLimit }));
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
+    if (!options.subscriptionServer) {
+        options.subscriptionServer = new SseSubscriptionServer();
+    }
     const server = createRemultServer(options);
     server.registerRouter(app);
-    if (!options.subscriptionServer) {
-        options.subscriptionServer = (router, server) => {
-            return buildHttpServerEventDispatcher(router, options.rootPath, server);
-        };
+    const canRegisterRoute = options.subscriptionServer;
+    if (canRegisterRoute.registerRoutes) {
+        canRegisterRoute.registerRoutes(app, options.rootPath, server);
     }
     app.post(options.rootPath + liveQueryKeepAliveRoute, (r, res, n) => server.withRemult(r, res, n), async (req, res) => {
-        res.send(await remult.liveQueryStorage.keepAliveAndReturnUnknownIds(req.body));
+        res.send(await remult.liveQueryStorage.keepAliveAndReturnUnknownQueryIds(req.body));
     });
     server.runWithRequest = async (req, entityKey, what) => {
         for (const e of options.entities) {
@@ -41,7 +43,6 @@ export function remultExpress(options) {
         }
         throw new Error("Couldn't find entity " + entityKey);
     };
-    server.subscriptionServer = options.subscriptionServer(app, server);
     return Object.assign(app, {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),
@@ -49,16 +50,20 @@ export function remultExpress(options) {
         withRemult: (...args) => server.withRemult(...args)
     });
 }
-export class ServerEventsController {
+export class SseSubscriptionServer {
     constructor(canUserConnectToChannel) {
         this.canUserConnectToChannel = canUserConnectToChannel;
+        //@internal
         this.connections = [];
+        //@internal
         this.debugMessageFileSaver = (id, channel, message) => { };
+        //@internal
         this.debugFileSaver = () => { };
         if (!this.canUserConnectToChannel) {
             this.canUserConnectToChannel = () => true;
         }
     }
+    //@internal
     subscribeToChannel({ channel, clientId }, res, remult, remove = false) {
         for (const c of this.connections) {
             if (c.connectionId === clientId) {
@@ -89,6 +94,7 @@ export class ServerEventsController {
             }
         }
     }
+    //@internal
     openHttpServerStream(req, res) {
         res.writeHead(200, {
             'Content-Type': 'text/event-stream',
@@ -106,12 +112,25 @@ export class ServerEventsController {
         });
         return cc;
     }
+    //@internal
     debug() {
         this.debugFileSaver(this.connections.map(x => ({
             id: x.connectionId,
             channels: x.channels
         })));
     }
+    registerRoutes(router, apiPath, server) {
+        const streamPath = apiPath + '/' + streamUrl;
+        router.get(streamPath, (r, res, next) => server.withRemult(r, res, next), (req, res) => {
+            remult.subscriptionServer.openHttpServerStream(req, res);
+        });
+        router.post(streamPath + '/subscribe', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
+            remult.subscriptionServer.subscribeToChannel(req.body, res, remult);
+        });
+        router.post(streamPath + '/unsubscribe', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
+            remult.subscriptionServer.subscribeToChannel(req.body, res, remult, true);
+        });
+    }
 }
 class clientConnection {
     constructor(response) {
@@ -143,17 +162,3 @@ class clientConnection {
         }, 45000);
     }
 }
-function buildHttpServerEventDispatcher(router, apiPath, server) {
-    const streamPath = apiPath + '/' + streamUrl;
-    let httpServerEvents = new ServerEventsController();
-    router.get(streamPath, (r, res, next) => server.withRemult(r, res, next), (req, res) => {
-        remult.subscriptionServer.openHttpServerStream(req, res);
-    });
-    router.post(streamPath + '/subscribe', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
-        remult.subscriptionServer.subscribeToChannel(req.body, res, remult);
-    });
-    router.post(streamPath + '/unsubscribe', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
-        remult.subscriptionServer.subscribeToChannel(req.body, res, remult, true);
-    });
-    return httpServerEvents;
-}

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

@@ -1,43 +1,19 @@
-import { Knex } from 'knex';
-import { Filter, FilterConsumer } from "../src/filter/filter-interfaces";
-import { dbNameProvider } from "../src/filter/filter-consumer-bridge-to-sql-request";
+import type { Knex } from 'knex';
 import { Remult } from "../src/context";
-import { EntityFilter, EntityMetadata } from "../src/remult3";
+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 customFilter(build: CustomKnexFilterBuilderFunction): EntityFilter<any>;
-    supportsCustomFilter?: boolean;
+    static rawFilter(build: CustomKnexFilterBuilderFunction): EntityFilter<any>;
+    static filterToRaw<entityType>(entity: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>): Promise<(knex: any) => void>;
+    supportsrawFilter?: 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>;