remult 0.16.3 → 0.16.4

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 this.knex(e.entityName).insert(insertObject, this.entity.idMetadata.field.key);
+                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

package/esm/src/backend-tests/backend-database-test-setup.backend-spec.d.ts

@@ -1,5 +1,6 @@
 import { dbTestWhatSignature } from "../shared-tests/db-tests-setup";
 export declare const testKnexPGSqlImpl: (key: string, what: dbTestWhatSignature, focus?: boolean) => void;
+export declare const mySqlTest: import("../shared-tests/db-tests-setup").dbTestMethodSignature;
 export declare function testPostgresImplementation(key: string, what: dbTestWhatSignature, focus?: boolean): void;
 export declare function testMongo(key: string, what: dbTestWhatSignature, focus?: boolean): void;
 import '../shared-tests';

package/esm/src/backend-tests/backend-database-test-setup.backend-spec.js

@@ -53,6 +53,16 @@ if (true)
             filename: ":memory:"
         },
     }), "sqlite3"));
+export const mySqlTest = addDatabaseToTest(testKnexSqlImpl(Knex.default({
+    client: 'mysql2',
+    connection: {
+        user: 'root',
+        password: 'MASTERKEY',
+        host: '127.0.0.1',
+        database: 'test'
+    }
+    //debug: true
+}), "mysql2"));
 let pg = createPostgresConnection({
     autoCreateTables: false
 });

package/esm/src/live-query/EventSourceLiveQuery.d.ts

@@ -0,0 +1,5 @@
+import { LiveQueryClient } from './LiveQuery';
+export declare class EventSourceLiveQuery extends LiveQueryClient {
+    private wrapMessage?;
+    constructor(wrapMessage?: (what: () => void) => void);
+}

package/esm/src/live-query/EventSourceLiveQuery.js

@@ -0,0 +1,48 @@
+import { LiveQueryClient, streamUrl } from './LiveQuery';
+import { fetchEventSource } from '@microsoft/fetch-event-source';
+import { remult } from '../remult-proxy';
+export class EventSourceLiveQuery extends LiveQueryClient {
+    constructor(wrapMessage) {
+        super(new EventSourceLiveQueryProvider(wrapMessage));
+        this.wrapMessage = wrapMessage;
+    }
+}
+class EventSourceLiveQueryProvider {
+    constructor(wrapMessage, url = undefined, jwtToken) {
+        this.wrapMessage = wrapMessage;
+        this.url = url;
+        this.jwtToken = jwtToken;
+        this.lastId = 0;
+        if (!this.wrapMessage)
+            this.wrapMessage = x => x();
+        if (!this.url) {
+            this.url = remult.apiClient.url + '/' + streamUrl;
+        }
+    }
+    openStreamAndReturnCloseFunction(clientId, onMessage) {
+        const ctrl = new AbortController();
+        const headers = {
+            "client-id": clientId
+        };
+        if (this.jwtToken) {
+            headers["Authorization"] = "Bearer " + this.jwtToken;
+        }
+        fetchEventSource(this.url, {
+            headers,
+            onmessage: message => {
+                const mid = +message.id;
+                if (mid <= this.lastId && this.lastId - mid < 10)
+                    return;
+                this.lastId = mid;
+                console.log(message.data);
+                if (message.event !== 'keep-alive') {
+                    this.wrapMessage(() => onMessage(message));
+                }
+            },
+            onopen: async () => {
+            },
+            signal: ctrl.signal,
+        });
+        return () => ctrl.abort();
+    }
+}

package/esm/src/live-query/EventSourceLiveQueryProvider.d.ts

@@ -0,0 +1,6 @@
+import { LiveQueryProvider, MessageHandler } from "./LiveQuery";
+export declare class EventSourceLiveQueryProvider implements LiveQueryProvider {
+    private wrapMessage?;
+    constructor(wrapMessage?: (what: () => void) => void);
+    openStreamAndReturnCloseFunction(clientId: string, onMessage: MessageHandler): Promise<VoidFunction>;
+}

package/esm/src/live-query/EventSourceLiveQueryProvider.js

@@ -0,0 +1,24 @@
+import { remult } from "../remult-proxy";
+import { streamUrl } from "./LiveQuery";
+export class EventSourceLiveQueryProvider {
+    constructor(wrapMessage) {
+        this.wrapMessage = wrapMessage;
+        if (!this.wrapMessage)
+            this.wrapMessage = x => x();
+    }
+    openStreamAndReturnCloseFunction(clientId, onMessage) {
+        const source = new EventSource(remult.apiClient.url + '/' + streamUrl + "?id=" + clientId, {
+            withCredentials: true
+        });
+        source.onmessage = e => {
+            this.wrapMessage(() => onMessage(JSON.parse(e.data)));
+        };
+        return new Promise((res) => {
+            source.onopen = e => {
+                res(() => {
+                    source.close();
+                });
+            };
+        });
+    }
+}

package/esm/src/live-query/LiveQuery.d.ts

@@ -0,0 +1,67 @@
+import { EntityOrderBy, FindOptions, Remult, Repository, RestDataProviderHttpProvider } from '../../index';
+import { Allowed } from '../context';
+import { ServerEventDispatcher } from './LiveQueryManager';
+export declare const streamUrl = "stream1";
+export interface LiveQueryProvider {
+    openStreamAndReturnCloseFunction(clientId: string, onMessage: MessageHandler): Promise<VoidFunction>;
+}
+export declare type MessageHandler = (message: {
+    data: any;
+    event: string;
+}) => void;
+export declare class LiveQueryClient {
+    lqp: LiveQueryProvider;
+    private provider?;
+    clientId: any;
+    private queries;
+    private channels;
+    constructor(lqp: LiveQueryProvider, provider?: RestDataProviderHttpProvider);
+    runPromise(p: Promise<any>): Promise<any>;
+    close(): void;
+    subscribeChannel<T>(key: string, onResult: (item: T) => void): () => void;
+    private closeIfNoListeners;
+    subscribe<entityType>(repo: Repository<entityType>, options: FindOptions<entityType>, onResult: (reducer: (prevState: entityType[]) => entityType[]) => void): () => void;
+    closeListener: Promise<VoidFunction>;
+    private openIfNoOpened;
+}
+export declare type listener = (message: any) => void;
+export interface SubscribeToQueryArgs<entityType = any> {
+    entityKey: string;
+    orderBy?: EntityOrderBy<entityType>;
+}
+export declare type liveQueryMessage = {
+    type: "all";
+    data: any[];
+} | {
+    type: "add";
+    data: any;
+} | {
+    type: 'replace';
+    data: {
+        oldId: any;
+        item: any;
+    };
+} | {
+    type: "remove";
+    data: {
+        id: any;
+    };
+};
+export interface SubscribeResult {
+    result: [];
+    id: string;
+}
+export interface ChannelSubscribe {
+    clientId: string;
+    channel: string;
+    remove: boolean;
+}
+export declare class AMessageChannel<messageType> {
+    private subscribedAllowed;
+    userCanSubscribe(channel: string, remult: Remult): boolean;
+    private key;
+    constructor(key: (string | ((remult: Remult) => string)), subscribedAllowed: Allowed);
+    send(what: messageType, remult?: Remult): void;
+    subscribe(client: LiveQueryClient, onValue: (value: messageType) => void, remult?: Remult): void;
+    dispatcher: ServerEventDispatcher;
+}

package/esm/src/live-query/LiveQuery.js

@@ -0,0 +1,222 @@
+import { getEntityRef, remult as defaultRemult, Sort } from '../../index';
+import { v4 as uuid } from 'uuid';
+import { RestEntityDataProvider } from '../data-providers/rest-data-provider';
+import { buildRestDataProvider } from '../context';
+export const streamUrl = 'stream1';
+class LiveQueryOnFrontEnd {
+    constructor(repo, query) {
+        this.repo = repo;
+        this.query = query;
+        this.items = [];
+        this.listeners = [];
+    }
+    async setAllItems(result) {
+        const items = await Promise.all(result.map(item => this.repo.fromJson(item)));
+        this.forListeners(listener => {
+            listener(x => {
+                return items;
+            });
+        });
+    }
+    forListeners(what) {
+        for (const l of this.listeners) {
+            what(l);
+        }
+    }
+    async handle(message) {
+        const sort = (items) => {
+            if (this.query.orderBy) {
+                const o = Sort.translateOrderByToSort(this.repo.metadata, this.query.orderBy);
+                items.sort((a, b) => o.compare(a, b));
+            }
+            return items;
+        };
+        switch (message.type) {
+            case "all":
+                this.setAllItems(message.data);
+                break;
+            case "replace": {
+                const item = await this.repo.fromJson(message.data.item);
+                this.forListeners(listener => {
+                    listener(items => {
+                        if (!items)
+                            items = [];
+                        return sort(items.map(x => this.repo.getEntityRef(x).getId() === message.data.oldId ? item : x));
+                    });
+                });
+                break;
+            }
+            case "add":
+                {
+                    const item = await this.repo.fromJson(message.data.item);
+                    this.forListeners(listener => listener(items => {
+                        if (!items)
+                            items = [];
+                        items.push(item);
+                        return sort(items);
+                    }));
+                    break;
+                }
+            case "remove":
+                this.forListeners(listener => listener(items => {
+                    if (!items)
+                        items = [];
+                    return this.items.filter(x => getEntityRef(x).getId() !== message.data.id);
+                }));
+                break;
+        }
+        ;
+    }
+}
+class MessageChannel {
+    constructor() {
+        this.listeners = [];
+    }
+    async handle(message) {
+        for (const l of this.listeners) {
+            l(message);
+        }
+    }
+}
+export class LiveQueryClient {
+    constructor(lqp, provider) {
+        this.lqp = lqp;
+        this.provider = provider;
+        this.clientId = uuid();
+        this.queries = new Map();
+        this.channels = new Map();
+    }
+    runPromise(p) {
+        return p;
+    }
+    close() {
+        this.queries.clear();
+        this.channels.clear();
+        this.closeIfNoListeners();
+    }
+    subscribeChannel(key, onResult) {
+        let onUnsubscribe = () => { };
+        this.openIfNoOpened().then(() => {
+            let q = this.channels.get(key);
+            if (!q) {
+                this.channels.set(key, q = new MessageChannel());
+                this.provider.post(defaultRemult.apiClient.url + '/' + streamUrl, {
+                    channel: key,
+                    clientId: this.clientId,
+                    remove: false
+                });
+            }
+            else {
+            }
+            q.listeners.push(onResult);
+            onUnsubscribe = () => {
+                q.listeners.splice(q.listeners.indexOf(onResult), 1);
+                if (q.listeners.length == 0) {
+                    this.channels.delete(key);
+                }
+                this.closeIfNoListeners();
+            };
+        });
+        return () => {
+            onUnsubscribe();
+        };
+    }
+    closeIfNoListeners() {
+        if (this.queries.size === 0 && this.channels.size === 0) {
+            this.runPromise(this.closeListener.then(x => x()));
+            this.closeListener = undefined;
+        }
+    }
+    subscribe(repo, options, onResult) {
+        let alive = true;
+        let onUnsubscribe = () => { };
+        this.runPromise(this.openIfNoOpened().then(() => repo.buildEntityDataProviderFindOptions(options)
+            .then(opts => {
+            if (!alive)
+                return;
+            const { url, filterObject } = new RestEntityDataProvider(() => defaultRemult.apiClient.url + '/' + repo.metadata.key, () => this.provider, repo.metadata)
+                .buildFindRequest(opts);
+            const eventTypeKey = JSON.stringify({ url, filterObject });
+            let q = this.queries.get(eventTypeKey);
+            if (!q) {
+                this.queries.set(eventTypeKey, q = new LiveQueryOnFrontEnd(repo, { entityKey: repo.metadata.key, orderBy: options.orderBy }));
+                url.add("__action", 'subscribe|' + this.clientId);
+                const thenResult = (r) => {
+                    this.runPromise(q.setAllItems(r.result));
+                    q.id = r.id;
+                };
+                if (filterObject) {
+                    this.runPromise(this.provider.post(url.url, filterObject).then(thenResult));
+                }
+                else
+                    this.runPromise(this.provider.get(url.url).then(thenResult));
+            }
+            else {
+                onResult(x => q.items);
+            }
+            q.listeners.push(onResult);
+            onUnsubscribe = () => {
+                q.listeners.splice(q.listeners.indexOf(onResult), 1);
+                if (q.listeners.length == 0) {
+                    this.queries.delete(eventTypeKey);
+                }
+                this.closeIfNoListeners();
+            };
+        })));
+        return () => {
+            alive = false;
+            onUnsubscribe();
+        };
+    }
+    openIfNoOpened() {
+        if (!this.provider) {
+            this.provider = buildRestDataProvider(defaultRemult.apiClient.httpClient);
+        }
+        if (!this.closeListener)
+            return this.runPromise(this.closeListener = this.lqp.openStreamAndReturnCloseFunction(this.clientId, message => {
+                for (const q of this.queries.values()) {
+                    if (q.id === message.event) {
+                        this.runPromise(q.handle(message.data));
+                    }
+                }
+                const channel = this.channels.get(message.event);
+                if (channel) {
+                    channel.handle(message.data);
+                }
+            }));
+        return this.closeListener;
+    }
+}
+export class AMessageChannel {
+    constructor(key, subscribedAllowed) {
+        this.subscribedAllowed = subscribedAllowed;
+        if (typeof key === "string")
+            this.key = () => key;
+        else
+            this.key = key;
+    }
+    userCanSubscribe(channel, remult) {
+        if (!remult)
+            remult = defaultRemult;
+        if (channel == this.key(remult) && remult.isAllowed(this.subscribedAllowed))
+            return true;
+        return false;
+    }
+    send(what, remult) {
+        if (!this.dispatcher)
+            throw new Error("Message couldn't be send since no dispatcher was set");
+        this.dispatcher.sendChannelMessage(this.key(remult || defaultRemult), what);
+    }
+    subscribe(client, onValue, remult) {
+        client.subscribeChannel(this.key(remult || defaultRemult), onValue);
+    }
+}
+/*
+[V] use entity normal http route for this - with __action.
+[] move id from header to url in stream registration.
+[] transaction accumulates messages.
+[] on unsubscribe, also unsubscribe on server
+[] consolidate channel & query
+[] fix stream api url on server
+[] remove client id from header
+*/ 

package/esm/src/live-query/LiveQueryManager.d.ts

@@ -0,0 +1,33 @@
+import { Remult } from '../..';
+import { Repository, EntityRef, FindOptions } from '../remult3';
+import { LiveQueryProvider } from '../data-api';
+import { liveQueryMessage } from './LiveQuery';
+export declare class LiveQueryManager implements LiveQueryProvider {
+    private dispatcher;
+    constructor(dispatcher: ServerEventDispatcher);
+    subscribe(repo: Repository<any>, clientId: string, findOptions: FindOptions<any>, remult: Remult, ids: any[]): string;
+    clients: clientInfo[];
+    sendMessage(key: string, message: liveQueryMessage): void;
+    hasListeners(ref: EntityRef<any>): boolean;
+    runPromise(p: Promise<any>): void;
+    saved(ref: EntityRef<any>): void;
+    deleted(ref: EntityRef<any>): void;
+}
+export interface clientInfo {
+    clientId: string;
+    queries: ({
+        id: string;
+        repo: Repository<any>;
+        findOptions: FindOptions<any>;
+        ids: any[];
+    })[];
+}
+export interface ServerEventDispatcher {
+    sendQueryMessage(message: ServerEventMessage): void;
+    sendChannelMessage<T>(channel: string, message: any): void;
+}
+export interface ServerEventMessage {
+    clientId: string;
+    queryId: string;
+    message: liveQueryMessage;
+}

package/esm/src/live-query/LiveQueryManager.js

@@ -0,0 +1,97 @@
+import { v4 as uuid } from 'uuid';
+export class LiveQueryManager {
+    constructor(dispatcher) {
+        this.dispatcher = dispatcher;
+        this.clients = [];
+    }
+    subscribe(repo, clientId, findOptions, remult, ids) {
+        let client = this.clients.find(c => c.clientId === clientId);
+        if (!client) {
+            this.clients.push(client = { clientId: clientId, queries: [] });
+        }
+        const id = uuid();
+        console.log({ ids });
+        client.queries.push({
+            id,
+            findOptions: findOptions,
+            repo,
+            ids
+        });
+        return id;
+    }
+    sendMessage(key, message) {
+        for (const c of this.clients) {
+            for (const q of c.queries) {
+                if (q.repo.metadata.key === key) {
+                    this.dispatcher.sendQueryMessage({ clientId: c.clientId, queryId: q.id, message });
+                }
+            }
+        }
+    }
+    hasListeners(ref) {
+        for (const c of this.clients) {
+            for (const q of c.queries) {
+                if (q.repo.metadata.key === ref.metadata.key)
+                    return true;
+            }
+        }
+        return false;
+    }
+    runPromise(p) {
+    }
+    //TODO - reconsider usage of zone
+    saved(ref) {
+        const isNew = ref.isNew();
+        const origId = isNew ? ref.getId() : ref.getOriginalId();
+        for (const c of this.clients) {
+            for (const q of c.queries) {
+                if (q.repo.metadata.key === ref.metadata.key) {
+                    this.runPromise(q.repo.find(q.findOptions).then(currentItems => {
+                        const currentIds = currentItems.map(x => q.repo.getEntityRef(x).getId());
+                        const sendMessage = (message) => {
+                            console.log({ message: message.type });
+                            this.dispatcher.sendQueryMessage({ clientId: c.clientId, queryId: q.id, message });
+                        };
+                        console.log({ ids: q.ids, currentIds });
+                        for (const id of q.ids.filter(y => !currentIds.includes(y))) {
+                            if (id != origId || !currentIds.includes(ref.getId()))
+                                sendMessage({
+                                    type: "remove",
+                                    data: {
+                                        id: id
+                                    }
+                                });
+                        }
+                        for (const item of currentItems) {
+                            const itemRef = q.repo.getEntityRef(item);
+                            if (itemRef.getId() == ref.getId() && q.ids.includes(origId)) {
+                                sendMessage({
+                                    type: "replace",
+                                    data: {
+                                        oldId: origId,
+                                        item: itemRef.toApiJson()
+                                    }
+                                });
+                            }
+                            else if (!q.ids.includes(itemRef.getId())) {
+                                sendMessage({
+                                    type: "add",
+                                    data: { item: itemRef.toApiJson() }
+                                });
+                            }
+                        }
+                        q.ids = currentIds;
+                    }));
+                }
+            }
+        }
+    }
+    deleted(ref) {
+        if (!this.hasListeners(ref))
+            return;
+        this.sendMessage(ref.metadata.key, {
+            type: "remove",
+            data: { id: ref.getId() }
+        });
+    }
+}

package/esm/src/shared-tests/db-tests-setup.d.ts

@@ -6,7 +6,7 @@ import { CategoriesForTesting } from "../tests/remult-3-entities";
 import { Status } from "../tests/testModel/models";
 export declare function itWithFocus(key: string, what: () => Promise<void>, focus?: boolean): void;
 export declare function testAll(key: string, what: dbTestWhatSignature, focus?: boolean): void;
-export declare function addDatabaseToTest(tester: dbTestMethodSignature): void;
+export declare function addDatabaseToTest(tester: dbTestMethodSignature): dbTestMethodSignature;
 export declare function testInMemory(key: string, what: dbTestWhatSignature, focus?: boolean): void;
 export declare type dbTestWhatSignature = (db: {
     db: DataProvider;

package/esm/src/shared-tests/db-tests-setup.js

@@ -22,6 +22,7 @@ export function addDatabaseToTest(tester) {
         test(tester);
     }
     databasesTesters.push(tester);
+    return tester;
 }
 export function testInMemory(key, what, focus = false) {
     itWithFocus(key + " - in memory", async () => {

package/esm/src/valueConverters.js

@@ -100,6 +100,8 @@ ValueConverters.Boolean = {
     fromJson: value => {
         if (typeof value === "boolean")
             return value;
+        if (value === 1)
+            return true;
         if (value !== undefined && value !== null) {
             return value.toString().trim().toLowerCase() == 'true';
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.16.3",
+    "version": "0.16.4",
     "description": "A CRUD framework for full-stack TypeScript",
     "main": "index.js",
     "types": "index.d.ts",

package/remult-knex/index.js

@@ -257,7 +257,7 @@ var KnexEntityDataProvider = /** @class */ (function () {
     };
     KnexEntityDataProvider.prototype.insert = function (data) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var e, resultFilter, insertObject, _a, _b, x, v, key, e_3_1, insert, result, newId_1;
+            var e, resultFilter, insertObject, _a, _b, x, v, key, e_3_1, insert, newId_1, result, result;
             var e_3, _c;
             var _this = this;
             return tslib_1.__generator(this, function (_d) {
@@ -304,18 +304,26 @@ var KnexEntityDataProvider = /** @class */ (function () {
                         return [7 /*endfinally*/];
                     case 10:
                         insert = this.knex(e.entityName).insert(insertObject);
-                        if (!remult3_1.isAutoIncrement(this.entity.idMetadata.field)) return [3 /*break*/, 12];
-                        return [4 /*yield*/, insert.returning(this.entity.idMetadata.field.key)];
+                        if (!remult3_1.isAutoIncrement(this.entity.idMetadata.field)) return [3 /*break*/, 15];
+                        if (!(this.knex.client.config.client === 'mysql2')) return [3 /*break*/, 12];
+                        return [4 /*yield*/, this.knex(e.entityName).insert(insertObject, this.entity.idMetadata.field.key)];
                     case 11:
                         result = _d.sent();
-                        newId_1 = result[0].id;
-                        resultFilter = new filter_interfaces_1.Filter(function (x) { return x.isEqualTo(_this.entity.idMetadata.field, newId_1); });
+                        newId_1 = result[0];
                         return [3 /*break*/, 14];
-                    case 12: return [4 /*yield*/, insert];
+                    case 12: return [4 /*yield*/, insert.returning(this.entity.idMetadata.field.key)];
                     case 13:
-                        _d.sent();
+                        result = _d.sent();
+                        newId_1 = result[0].id;
                         _d.label = 14;
-                    case 14: return [2 /*return*/, this.find({ where: resultFilter }).then(function (y) {
+                    case 14:
+                        resultFilter = new filter_interfaces_1.Filter(function (x) { return x.isEqualTo(_this.entity.idMetadata.field, newId_1); });
+                        return [3 /*break*/, 17];
+                    case 15: return [4 /*yield*/, insert];
+                    case 16:
+                        _d.sent();
+                        _d.label = 17;
+                    case 17: return [2 /*return*/, this.find({ where: resultFilter }).then(function (y) {
                             return y[0];
                         })];
                 }

package/src/backend-tests/backend-database-test-setup.backend-spec.d.ts

@@ -1,5 +1,6 @@
 import { dbTestWhatSignature } from "../shared-tests/db-tests-setup";
 export declare const testKnexPGSqlImpl: (key: string, what: dbTestWhatSignature, focus?: boolean) => void;
+export declare const mySqlTest: import("../shared-tests/db-tests-setup").dbTestMethodSignature;
 export declare function testPostgresImplementation(key: string, what: dbTestWhatSignature, focus?: boolean): void;
 export declare function testMongo(key: string, what: dbTestWhatSignature, focus?: boolean): void;
 import '../shared-tests';

package/src/backend-tests/backend-database-test-setup.backend-spec.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testMongo = exports.testPostgresImplementation = exports.testKnexPGSqlImpl = void 0;
+exports.testMongo = exports.testPostgresImplementation = exports.mySqlTest = exports.testKnexPGSqlImpl = void 0;
 var tslib_1 = require("tslib");
 var context_1 = require("../context");
 var remult_knex_1 = require("../../remult-knex");
@@ -87,6 +87,16 @@ if (true)
             filename: ":memory:"
         },
     }), "sqlite3"));
+exports.mySqlTest = db_tests_setup_1.addDatabaseToTest(testKnexSqlImpl(Knex.default({
+    client: 'mysql2',
+    connection: {
+        user: 'root',
+        password: 'MASTERKEY',
+        host: '127.0.0.1',
+        database: 'test'
+    }
+    //debug: true
+}), "mysql2"));
 var pg = postgres_1.createPostgresConnection({
     autoCreateTables: false
 });

package/src/live-query/EventSourceLiveQuery.d.ts

@@ -0,0 +1,5 @@
+import { LiveQueryClient } from './LiveQuery';
+export declare class EventSourceLiveQuery extends LiveQueryClient {
+    private wrapMessage?;
+    constructor(wrapMessage?: (what: () => void) => void);
+}