remult 0.17.0-exp.8 → 0.17.0

package/esm/index.d.ts

@@ -1,5 +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 { StringFieldOptions } from './src/remult3/RepositoryImplementation';
+export { Field, Fields, StringFieldOptions, 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 { describeClass } from './src/remult3/DecoratorReplacer';
 export { EntityOptions } from './src/entity';
 export { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, ErrorInfo, RestDataProviderHttpProvider } from './src/data-interfaces';

package/esm/postgres/schema-builder.js

@@ -43,7 +43,7 @@ export class PostgresSchemaBuilder {
         }
     }
     async verifyStructureOfAllEntities(remult) {
-        console.log("start verify structure"); //keep me
+        console.log("start verify structure");
         for (const entityClass of allEntities) {
             let entity = remult.repo(entityClass).metadata;
             let e = await getDbNameProvider(entity);
@@ -56,7 +56,7 @@ export class PostgresSchemaBuilder {
                 }
             }
             catch (err) {
-                /*keep me */ console.log("failed verify structure of " + e.entityName + " ", err);
+                console.log("failed verify structure of " + e.entityName + " ", err);
             }
         }
     }
@@ -102,7 +102,7 @@ export class PostgresSchemaBuilder {
             }
         }
         catch (err) {
-            console.error(err);
+            console.log(err);
         }
     }
     async verifyAllColumns(entity) {
@@ -122,7 +122,7 @@ export class PostgresSchemaBuilder {
             }
         }
         catch (err) {
-            console.error(err);
+            console.log(err);
         }
     }
 }

package/esm/remult-express.d.ts

@@ -1,30 +1,6 @@
 import * as express from 'express';
 import { RemultServer, RemultServerOptions } from './server/expressBridge';
-import { Remult } from './src/context';
-import { ServerEventChannelSubscribeDTO } from './src/live-query/LiveQuerySubscriber';
-import { ServerEventDispatcher } from './src/live-query/LiveQueryPublisher';
 export declare function remultExpress(options?: RemultServerOptions<express.Request> & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
-    serverEventDispatcher?: (router: express.Router, server: RemultServer) => ServerEventDispatcher;
 }): express.RequestHandler & RemultServer;
-export declare class ServerEventsController implements ServerEventDispatcher {
-    private canUserConnectToChannel?;
-    subscribeToChannel({ channel, clientId }: ServerEventChannelSubscribeDTO, res: import('express').Response, remult: Remult, remove?: boolean): void;
-    consoleInfo(): void;
-    connections: clientConnection[];
-    constructor(canUserConnectToChannel?: (channel: string, remult: Remult) => boolean);
-    sendChannelMessage<T>(channel: string, message: any): void;
-    openHttpServerStream(req: import('express').Request, res: import('express').Response): clientConnection;
-}
-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,9 +1,5 @@
 import * as express from 'express';
-import { createRemultServer } from './server/expressBridge';
-import { streamUrl } from './src/live-query/LiveQuerySubscriber';
-import { LiveQueryPublisher } from './src/live-query/LiveQueryPublisher';
-import { v4 as uuid } from 'uuid';
-import { remult } from './src/remult-proxy';
+import { createRemultServer } from './server/index';
 export function remultExpress(options) {
     let app = express.Router();
     if (!options) {
@@ -18,12 +14,6 @@ export function remultExpress(options) {
     }
     const server = createRemultServer(options);
     server.registerRouter(app);
-    if (!options.serverEventDispatcher) {
-        options.serverEventDispatcher = (router, server) => {
-            return buildHttpServerEventDispatcher(router, options.rootPath, server);
-        };
-    }
-    server.liveQueryManager = new LiveQueryPublisher(options.serverEventDispatcher(app, server));
     return Object.assign(app, {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),
@@ -31,105 +21,3 @@ export function remultExpress(options) {
         withRemult: (...args) => server.withRemult(...args)
     });
 }
-export class ServerEventsController {
-    constructor(canUserConnectToChannel) {
-        this.canUserConnectToChannel = canUserConnectToChannel;
-        this.connections = [];
-        if (!this.canUserConnectToChannel) {
-            this.canUserConnectToChannel = () => true;
-        }
-    }
-    subscribeToChannel({ channel, clientId }, res, remult, remove = false) {
-        for (const c of this.connections) {
-            if (c.connectionId === clientId) {
-                if (this.canUserConnectToChannel(channel, remult)) {
-                    c.channels[channel] = !remove;
-                    res.json("ok");
-                    return;
-                }
-                else {
-                    res.sendStatus(403);
-                    return;
-                }
-            }
-        }
-        res.sendStatus(404);
-    }
-    consoleInfo() {
-        console.info(this.connections.map(x => ({
-            client: x.connectionId,
-            channels: x.channels
-        })));
-    }
-    sendChannelMessage(channel, message) {
-        const data = JSON.stringify({ channel, data: message });
-        for (const sc of this.connections) {
-            if (sc.channels[channel]) {
-                sc.write(data);
-            }
-        }
-    }
-    openHttpServerStream(req, res) {
-        res.writeHead(200, {
-            'Content-Type': 'text/event-stream',
-            'Cache-Control': 'no-cache',
-            'Connection': 'keep-alive'
-        });
-        const cc = new clientConnection(res);
-        //const lastEventId = req.headers['last-event-id'];
-        this.connections.push(cc);
-        req.on("close", () => {
-            cc.close();
-            this.connections = this.connections.filter(s => s !== cc);
-        });
-        return cc;
-    }
-}
-class clientConnection {
-    constructor(response) {
-        this.response = response;
-        this.channels = {};
-        this.closed = false;
-        this.connectionId = uuid();
-        this.write(this.connectionId, "connectionId");
-        this.sendLiveMessage();
-    }
-    close() {
-        this.closed = true;
-    }
-    write(eventData, eventType = "message") {
-        let event = "event:" + eventType;
-        // if (id != undefined)
-        //     event += "\nid:" + id;
-        this.response.write(event + "\ndata:" + eventData + "\n\n");
-        let r = this.response;
-        if (r.flush)
-            r.flush();
-    }
-    sendLiveMessage() {
-        if (this.closed)
-            return;
-        this.write("", "keep-alive");
-        setTimeout(() => {
-            this.sendLiveMessage();
-        }, 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.liveQueryPublisher.dispatcher.openHttpServerStream(req, res);
-    });
-    router.post(streamPath + '/subscribe', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
-        remult.liveQueryPublisher.dispatcher.subscribeToChannel(req.body, res, remult);
-    });
-    router.post(streamPath + '/unsubscribe', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
-        remult.liveQueryPublisher.dispatcher.subscribeToChannel(req.body, res, remult, true);
-    });
-    router.get(streamPath + '/stats', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
-        remult.liveQueryPublisher.dispatcher.consoleInfo();
-        res.json("ok");
-    });
-    return httpServerEvents;
-}

package/esm/remult-fastify.js

@@ -1,4 +1,4 @@
-import { createRemultServer } from './server/expressBridge';
+import { createRemultServer } from './server/index';
 export function remultFastify(options) {
     function fastifyHandler(handler) {
         const response = (req, res) => {

package/esm/remult-fresh.js

@@ -1,6 +1,6 @@
-import { createRemultServer } from "./server/expressBridge";
+import { createRemultServerCore } from "./server/expressBridge";
 export function remultFresh(options, response) {
-    const server = createRemultServer(options);
+    const server = createRemultServerCore(options);
     return {
         getRemult: r => server.getRemult(r),
         openApiDoc: x => server.openApiDoc(x),

package/esm/remult-knex/index.js

@@ -153,8 +153,15 @@ class KnexEntityDataProvider {
         }
         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
@@ -256,7 +263,7 @@ export class KnexSchemaBuilder {
         this.additionalWhere = '';
     }
     async verifyStructureOfAllEntities(remult) {
-        console.info("start verify structure");
+        console.log("start verify structure");
         for (const entity of allEntities) {
             let metadata = remult.repo(entity).metadata;
             try {
@@ -319,7 +326,7 @@ export class KnexSchemaBuilder {
             }
         }
         catch (err) {
-            console.error(err);
+            console.log(err);
         }
     }
 }

package/esm/server/expressBridge.d.ts

@@ -1,11 +1,9 @@
-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';
 export interface RemultServerOptions<RequestType extends GenericRequest> {
     /** Sets a database connection for Remult.
      *
@@ -22,7 +20,7 @@ export interface RemultServerOptions<RequestType extends GenericRequest> {
     controllers?: ClassType<any>[];
     rootPath?: string;
 }
-export declare function createRemultServer<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;
+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;
@@ -59,39 +57,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;
@@ -117,12 +90,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;
@@ -133,4 +100,3 @@ export declare class JobsInQueueEntity extends IdEntity {
     error: boolean;
     progress: number;
 }
-export {};

package/esm/server/expressBridge.js

@@ -6,7 +6,7 @@ import { Entity, Fields, getEntityKey } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
 import { remult } from '../src/remult-proxy';
 ;
-export function createRemultServer(options) {
+export function createRemultServerCore(options) {
     if (!options) {
         options = {};
     }
@@ -30,30 +30,12 @@ export function createRemultServer(options) {
             return dp;
         return new (await import('./JsonEntityFileStorage')).JsonFileDataProvider('./db');
     });
-    if (!remultObjectStorage) {
-        dataProvider = dataProvider.then(async (dp) => {
-            try {
-                const asyncHooks = await import('async_hooks');
-                remultObjectStorage = new RemultAsyncLocalStorage(new asyncHooks.AsyncLocalStorage());
-            }
-            catch {
-                remultObjectStorage = new RemultAsyncLocalStorage(undefined);
-            }
-            remult.remultFactory = () => {
-                const r = remultObjectStorage.getRemult();
-                if (r)
-                    return r;
-                else
-                    throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
-            };
-            return dp;
-        });
-    }
+    RemultAsyncLocalStorage.enable();
     if (options.initApi) {
         dataProvider = dataProvider.then(async (dp) => {
             var remult = new Remult(dp);
             await new Promise((res) => {
-                remultObjectStorage.run(remult, async () => {
+                RemultAsyncLocalStorage.instance.run(remult, async () => {
                     await options.initApi(remult);
                     res({});
                 });
@@ -78,10 +60,22 @@ export function createRemultServer(options) {
     return bridge;
 }
 ;
-class RemultAsyncLocalStorage {
+export class RemultAsyncLocalStorage {
     constructor(remultObjectStorage) {
         this.remultObjectStorage = remultObjectStorage;
     }
+    static enable() {
+        remult.remultFactory = () => {
+            const r = RemultAsyncLocalStorage.instance.getRemult();
+            if (r)
+                return r;
+            else
+                throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
+        };
+    }
+    static disable() {
+        remult.resetFactory();
+    }
     run(remult, callback) {
         if (this.remultObjectStorage)
             this.remultObjectStorage.run(remult, callback);
@@ -90,13 +84,13 @@ class RemultAsyncLocalStorage {
     }
     getRemult() {
         if (!this.remultObjectStorage) {
-            throw "can't use static remult in this environment, `async_hooks` were not found";
+            throw new Error("can't use static remult in this environment, `async_hooks` were not initialized");
         }
         return this.remultObjectStorage.getStore();
     }
 }
-let remultObjectStorage;
-export class RemultServerImplementation {
+RemultAsyncLocalStorage.instance = new RemultAsyncLocalStorage(undefined);
+class RemultServerImplementation {
     constructor(queue, options, dataProvider) {
         this.queue = queue;
         this.options = options;
@@ -162,7 +156,7 @@ export class RemultServerImplementation {
     add(key, dataApiFactory, r) {
         let myRoute = this.options.rootPath + '/' + key;
         if (this.options.logApiEndPoints)
-            console.info("[remult] " + myRoute);
+            console.log("[remult] " + myRoute);
         r.route(myRoute)
             .get(this.process((c, req, res) => dataApiFactory(c).httpGet(res, req))).put(this.process(async (c, req, res, orig) => dataApiFactory(c).put(res, '', orig.body)))
             .delete(this.process(async (c, req, res, orig) => dataApiFactory(c).delete(res, '')))
@@ -180,10 +174,9 @@ export class RemultServerImplementation {
             let myReq = new ExpressRequestBridgeToDataApiRequest(req);
             let myRes = new ExpressResponseBridgeToDataApiResponse(res, req);
             let remult = new Remult();
-            remult.liveQueryPublisher = this.liveQueryManager;
             remult.dataProvider = (await this.dataProvider);
             await new Promise(res => {
-                remultObjectStorage.run(remult, async () => {
+                RemultAsyncLocalStorage.instance.run(remult, async () => {
                     if (req) {
                         let user;
                         if (this.options.getUser)
@@ -225,7 +218,7 @@ export class RemultServerImplementation {
             })();
             this.backendMethodsOpenApi.push({ path: myUrl, allowed, tag });
             if (this.options.logApiEndPoints)
-                console.info("[remult] " + myUrl);
+                console.log("[remult] " + myUrl);
             if (queue) {
                 this.hasQueue = true;
                 this.queue.mapQueuedAction(myUrl, what);

package/esm/server/index.d.ts

@@ -1,2 +1,4 @@
-export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, createRemultServer, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
+import { GenericRequest, RemultServer, RemultServerOptions } from './expressBridge';
+export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export declare function createRemultServer<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;

package/esm/server/index.js

@@ -1,2 +1,7 @@
-export { createRemultServer } from './expressBridge';
+import { createRemultServerCore } from './expressBridge';
+import { initAsyncHooks } from './initAsyncHooks';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export function createRemultServer(options) {
+    initAsyncHooks();
+    return createRemultServerCore(options);
+}

package/esm/src/column.d.ts

@@ -1,7 +1,7 @@
 import { ClassType } from '../classType';
 import { FieldMetadata, FieldOptions, ValueConverter } from './column-interfaces';
 import { Filter } from './filter/filter-interfaces';
-import { EntityFilter, FindOptions, idType, Repository, RepositoryImplementation } from './remult3';
+import { EntityFilter, FindOptions, Repository, RepositoryImplementation } from './remult3';
 export declare function makeTitle(name: string): string;
 export declare class CompoundIdField implements FieldMetadata<string> {
     fields: FieldMetadata[];
@@ -25,12 +25,12 @@ export declare class CompoundIdField implements FieldMetadata<string> {
 }
 export declare class LookupColumn<T> {
     private repository;
-    id: idType<T>;
+    id: string;
     setId(val: any): void;
     waitLoadOf(id: any): Promise<T>;
     get(id: any): any;
     set(item: T): void;
-    constructor(repository: RepositoryImplementation<T>, id: idType<T>);
+    constructor(repository: RepositoryImplementation<T>, id: string);
     get item(): T;
     waitLoad(): Promise<T>;
 }

package/esm/src/context.d.ts

@@ -2,8 +2,6 @@ import { DataProvider, RestDataProviderHttpProvider } from "./data-interfaces";
 import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
 import { EntityMetadata, EntityRef, FindOptions, Repository } from "./remult3";
 import { ClassType } from "../classType";
-import { LiveQueryClient } from "./live-query/LiveQuerySubscriber";
-import type { ServerEventDispatcher } from "../live-query";
 export interface ExternalHttpProvider {
     post(url: string, data: any): Promise<any> | {
         toPromise(): Promise<any>;
@@ -64,11 +62,9 @@ export declare class Remult {
     constructor(http: ExternalHttpProvider | typeof fetch | ApiClient);
     constructor(p: DataProvider);
     constructor();
-    liveQueryPublisher: LiveQueryPublisherInterface;
     call<T extends ((...args: any[]) => Promise<any>)>(backendMethod: T, classInstance?: any, ...args: GetArguments<T>): ReturnType<T>;
     /** The current data provider */
     dataProvider: DataProvider;
-    liveQuerySubscriber: LiveQueryClient;
     /** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
     static onFind: (metadata: EntityMetadata, options: FindOptions<any>) => void;
     clearAllCache(): any;
@@ -117,16 +113,3 @@ export declare class EventSource {
     fire(): Promise<void>;
     dispatcher: EventDispatcher;
 }
-export interface LiveQueryPublisherInterface {
-    stopLiveQuery(id: any): void;
-    sendChannelMessage<messageType>(channel: string, message: messageType): void;
-    defineLiveQueryChannel(repo: Repository<any>, options: FindOptions<any>, remult: Remult, ids: any[]): string;
-    itemChanged(entityKey: string, changes: itemChange[]): void;
-    dispatcher: ServerEventDispatcher;
-}
-export interface itemChange {
-    id: any;
-    oldId: any;
-    deleted: boolean;
-}
-export declare function doTransaction(remult: Remult, what: () => Promise<void>): Promise<void>;

package/esm/src/context.js

@@ -1,9 +1,6 @@
 import { actionInfo, serverActionField } from './server-action';
 import { RestDataProvider, RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
 import { RepositoryImplementation } from "./remult3/RepositoryImplementation";
-import { LiveQueryClient } from "./live-query/LiveQuerySubscriber";
-import { EventSourceLiveQueryProvider } from "./live-query/EventSourceLiveQueryProvider";
-import { RemultProxy } from "./remult-proxy";
 export class HttpProviderBridgeToRestDataProviderHttpProvider {
     constructor(http) {
         this.http = http;
@@ -98,20 +95,8 @@ export class Remult {
     constructor(provider) {
         /* @internal */
         this.repCache = new Map();
-        this.liveQueryPublisher = {
-            itemChanged: () => { },
-            defineLiveQueryChannel: () => "",
-            dispatcher: undefined,
-            sendChannelMessage: function (arg0, what) {
-                throw new Error("invalid publisher.");
-            },
-            stopLiveQuery: function (id) {
-                throw new Error("Function not implemented.");
-            }
-        };
         /** The current data provider */
         this.dataProvider = new RestDataProvider(() => this.apiClient);
-        this.liveQuerySubscriber = new LiveQueryClient(new EventSourceLiveQueryProvider());
         this.context = {};
         this.apiClient = {
             url: '/api'
@@ -202,7 +187,6 @@ export class Remult {
         else
             return this.isAllowed(allowed);
     }
-    //@ts-ignore // type error of typescript regarding args that doesn't appear in my normal development
     call(backendMethod, classInstance, ...args) {
         const z = (backendMethod[serverActionField]);
         if (!z.doWork)
@@ -216,7 +200,6 @@ export class Remult {
 }
 /** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
 Remult.onFind = (metadata, options) => { };
-RemultProxy.defaultRemult = new Remult();
 ;
 export const allEntities = [];
 export const classHelpers = new Map();
@@ -286,62 +269,3 @@ export class EventSource {
         }
     }
 }
-export async function doTransaction(remult, what) {
-    return await remult.dataProvider.transaction(async (ds) => {
-        remult.dataProvider = (ds);
-        const trans = new transactionLiveQueryPublisher(remult.liveQueryPublisher);
-        remult.liveQueryPublisher = trans;
-        await what();
-        trans.flush();
-    });
-}
-class transactionLiveQueryPublisher {
-    constructor(orig) {
-        this.orig = orig;
-        this.transactionItems = new Map();
-    }
-    stopLiveQuery(id) {
-        this.orig.stopLiveQuery(id);
-    }
-    itemChanged(entityKey, changes) {
-        let items = this.transactionItems.get(entityKey);
-        if (!items) {
-            this.transactionItems.set(entityKey, items = []);
-        }
-        for (const c of changes) {
-            if (c.oldId !== undefined) {
-                const item = items.find(y => y.id === c.oldId);
-                if (item !== undefined) {
-                    if (c.deleted)
-                        item.deleted = true;
-                    if (c.id != item.id)
-                        item.id = c.id;
-                }
-                else
-                    items.push(c);
-            }
-            else
-                items.push(c);
-        }
-    }
-    flush() {
-        //TODO - figure out and resolve
-        setTimeout(() => {
-            for (const key of this.transactionItems.keys()) {
-                this.orig.itemChanged(key, this.transactionItems.get(key));
-            }
-        }, 100);
-    }
-    sendChannelMessage(channel, message) {
-        this.orig.sendChannelMessage(channel, message);
-    }
-    defineLiveQueryChannel(repo, options, remult, ids) {
-        return this.orig.defineLiveQueryChannel(repo, options, remult, ids);
-    }
-    get dispatcher() {
-        return this.orig.dispatcher;
-    }
-    set dispatcher(value) {
-        this.orig.dispatcher = value;
-    }
-}