remult 0.22.6 → 0.22.7-exp.1

package/esm/SseSubscriptionServer.js

@@ -1,104 +1,107 @@
-import { v4 as uuid } from 'uuid';
-import { ConnectionNotFoundError } from './src/live-query/SseSubscriptionClient';
-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) {
-                if (this.canUserConnectToChannel(channel, remult)) {
-                    if (remove)
-                        delete c.channels[channel];
-                    else
-                        c.channels[channel] = true;
-                    res.success({ status: 'ok' });
-                    this.debug();
-                    return;
-                }
-                else {
-                    res.forbidden();
-                    this.debug();
-                    return;
-                }
-            }
-        }
-        res.success(ConnectionNotFoundError);
-    }
-    async publishMessage(channel, message) {
-        const data = JSON.stringify({ channel, data: message });
-        for (const sc of this.connections) {
-            if (sc.channels[channel]) {
-                this.debugMessageFileSaver(sc.connectionId, channel, message);
-                sc.write(data);
-            }
-        }
-    }
-    //@internal
-    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);
-        this.debug();
-        //@ts-ignore
-        req.on('close', () => {
-            cc.close();
-            this.connections = this.connections.filter((s) => s !== cc);
-            this.debug();
-        });
-        return cc;
-    }
-    //@internal
-    debug() {
-        this.debugFileSaver(this.connections.map((x) => ({
-            id: x.connectionId,
-            channels: x.channels,
-        })));
-    }
-}
-export class clientConnection {
-    constructor(response) {
-        this.response = response;
-        this.channels = {};
-        this.closed = false;
-        this.connectionId = uuid();
-        this.write(this.connectionId, 'connectionId');
-        this.sendLiveMessage();
-    }
-    close() {
-        if (this.timeOutRef)
-            clearTimeout(this.timeOutRef);
-        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');
-        if (this.response.flush)
-            this.response.flush();
-    }
-    sendLiveMessage() {
-        if (this.closed)
-            return;
-        this.write('', 'keep-alive');
-        this.timeOutRef = setTimeout(() => {
-            this.sendLiveMessage();
-        }, 45000);
-    }
-}
+import { v4 as uuid } from 'uuid';
+import { ConnectionNotFoundError } from './src/live-query/SseSubscriptionClient';
+export class SseSubscriptionServer {
+    canUserConnectToChannel;
+    //@internal
+    subscribeToChannel({ channel, clientId }, res, remult, remove = false) {
+        for (const c of this.connections) {
+            if (c.connectionId === clientId) {
+                if (this.canUserConnectToChannel(channel, remult)) {
+                    if (remove)
+                        delete c.channels[channel];
+                    else
+                        c.channels[channel] = true;
+                    res.success({ status: 'ok' });
+                    this.debug();
+                    return;
+                }
+                else {
+                    res.forbidden();
+                    this.debug();
+                    return;
+                }
+            }
+        }
+        res.success(ConnectionNotFoundError);
+    }
+    //@internal
+    connections = [];
+    constructor(canUserConnectToChannel) {
+        this.canUserConnectToChannel = canUserConnectToChannel;
+        if (!this.canUserConnectToChannel) {
+            this.canUserConnectToChannel = () => true;
+        }
+    }
+    async publishMessage(channel, message) {
+        const data = JSON.stringify({ channel, data: message });
+        for (const sc of this.connections) {
+            if (sc.channels[channel]) {
+                this.debugMessageFileSaver(sc.connectionId, channel, message);
+                sc.write(data);
+            }
+        }
+    }
+    //@internal
+    debugMessageFileSaver = (id, channel, message) => { };
+    //@internal
+    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);
+        this.debug();
+        //@ts-ignore
+        req.on('close', () => {
+            cc.close();
+            this.connections = this.connections.filter((s) => s !== cc);
+            this.debug();
+        });
+        return cc;
+    }
+    //@internal
+    debug() {
+        this.debugFileSaver(this.connections.map((x) => ({
+            id: x.connectionId,
+            channels: x.channels,
+        })));
+    }
+    //@internal
+    debugFileSaver = () => { };
+}
+export class clientConnection {
+    response;
+    channels = {};
+    timeOutRef;
+    close() {
+        if (this.timeOutRef)
+            clearTimeout(this.timeOutRef);
+        this.closed = true;
+    }
+    closed = false;
+    write(eventData, eventType = 'message') {
+        let event = 'event:' + eventType;
+        // if (id != undefined)
+        //     event += "\nid:" + id;
+        this.response.write(event + '\ndata:' + eventData + '\n\n');
+        if (this.response.flush)
+            this.response.flush();
+    }
+    connectionId = uuid();
+    constructor(response) {
+        this.response = response;
+        this.write(this.connectionId, 'connectionId');
+        this.sendLiveMessage();
+    }
+    sendLiveMessage() {
+        if (this.closed)
+            return;
+        this.write('', 'keep-alive');
+        this.timeOutRef = setTimeout(() => {
+            this.sendLiveMessage();
+        }, 45000);
+    }
+}

package/esm/ably.d.ts

@@ -1,13 +1,13 @@
-import type * as Ably from '../../node_modules/ably';
-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 AblySubscriptionServer implements SubscriptionServer {
-    private ably;
-    constructor(ably: Ably.Types.RestPromise);
-    publishMessage<T>(channel: string, message: T): Promise<void>;
-}
+import type * as Ably from '../../node_modules/ably';
+import type { SubscriptionClient, SubscriptionClientConnection } from './src/live-query/SubscriptionChannel';
+import type { SubscriptionServer } from './src/live-query/SubscriptionServer';
+export declare class AblySubscriptionClient implements SubscriptionClient {
+    private ably;
+    constructor(ably: Ably.Types.RealtimePromise);
+    openConnection(onReconnect: VoidFunction): Promise<SubscriptionClientConnection>;
+}
+export declare class AblySubscriptionServer implements SubscriptionServer {
+    private ably;
+    constructor(ably: Ably.Types.RestPromise);
+    publishMessage<T>(channel: string, message: T): Promise<void>;
+}

package/esm/ably.js

@@ -1,28 +1,30 @@
-export class AblySubscriptionClient {
-    constructor(ably) {
-        this.ably = ably;
-    }
-    async openConnection(onReconnect) {
-        return {
-            close: () => {
-                // Since we did not open the connection, we do not close it
-            },
-            subscribe: async (channel, handler) => {
-                let myHandler = (y) => handler(y.data);
-                await this.ably.channels.get(channel).subscribe((y) => myHandler(y));
-                return () => {
-                    myHandler = () => { };
-                    this.ably.channels.get(channel).unsubscribe();
-                };
-            },
-        };
-    }
-}
-export class AblySubscriptionServer {
-    constructor(ably) {
-        this.ably = ably;
-    }
-    async publishMessage(channel, message) {
-        await this.ably.channels.get(channel).publish({ data: message });
-    }
-}
+export class AblySubscriptionClient {
+    ably;
+    constructor(ably) {
+        this.ably = ably;
+    }
+    async openConnection(onReconnect) {
+        return {
+            close: () => {
+                // Since we did not open the connection, we do not close it
+            },
+            subscribe: async (channel, handler) => {
+                let myHandler = (y) => handler(y.data);
+                await this.ably.channels.get(channel).subscribe((y) => myHandler(y));
+                return () => {
+                    myHandler = () => { };
+                    this.ably.channels.get(channel).unsubscribe();
+                };
+            },
+        };
+    }
+}
+export class AblySubscriptionServer {
+    ably;
+    constructor(ably) {
+        this.ably = ably;
+    }
+    async publishMessage(channel, message) {
+        await this.ably.channels.get(channel).publish({ data: message });
+    }
+}

package/esm/assign.d.ts

@@ -1 +1 @@
-export declare function assign<T>(item: T, valuesToSet: Partial<T>): T;
+export declare function assign<T>(item: T, valuesToSet: Partial<T>): T;

package/esm/assign.js

@@ -1,5 +1,5 @@
-export function assign(item, valuesToSet) {
-    if (valuesToSet)
-        Object.assign(item, valuesToSet);
-    return item;
-}
+export function assign(item, valuesToSet) {
+    if (valuesToSet)
+        Object.assign(item, valuesToSet);
+    return item;
+}

package/esm/classType.d.ts

@@ -1,3 +1,3 @@
-export declare type ClassType<T> = {
-    new (...args: any[]): T;
-};
+export type ClassType<T> = {
+    new (...args: any[]): T;
+};

package/esm/classType.js

@@ -1 +1 @@
-export {};
+export {};

package/esm/graphql.d.ts

@@ -1,14 +1,14 @@
-import { Remult } from './index';
-import type { ClassType } from './classType';
-export declare function remultGraphql(options: {
-    removeComments?: boolean;
-    entities: ClassType<any>[];
-    getRemultFromRequest?: (req: any) => Remult;
-}): {
-    resolvers: {
-        Query: Record<string, unknown>;
-        Mutation: Record<string, unknown>;
-    };
-    rootValue: Record<string, any>;
-    typeDefs: string;
-};
+import type { ClassType } from './classType';
+import { Remult } from './index';
+export declare function remultGraphql(options: {
+    removeComments?: boolean;
+    entities: ClassType<any>[];
+    getRemultFromRequest?: (req: any) => Remult;
+}): {
+    resolvers: {
+        Query: Record<string, unknown>;
+        Mutation: Record<string, unknown>;
+    };
+    rootValue: Record<string, any>;
+    typeDefs: string;
+};