wirejs-resources 0.1.58 → 0.1.60-realtime

package/dist/client/index.js

@@ -52,6 +52,50 @@ async function callApi(INTERNAL_API_URL, method, ...args) {
         throw new Error(error);
     }
     const value = body[0].data;
+    if (typeof value === 'object' && value.__wjstype === 'realtime') {
+        const subscribers = [];
+        const ws = new WebSocket(value.url, value.protocol);
+        ws.onmessage = (event) => {
+            const data = JSON.parse(event.data);
+            if (data.data) {
+                for (const subscriber of subscribers) {
+                    try {
+                        subscriber.onmessage(data.data);
+                    }
+                    catch (error) {
+                        console.error('Error in subscriber onmessage:', error);
+                    }
+                }
+            }
+        };
+        ws.onclose = event => {
+            for (const subscriber of subscribers) {
+                if (subscriber.onclose) {
+                    try {
+                        subscriber.onclose();
+                    }
+                    catch (error) {
+                        console.error('Error in subscriber onclose:', error);
+                    }
+                }
+            }
+            console.log('closed', event);
+        };
+        return {
+            subscribe(subscriber) {
+                subscribers.push(subscriber);
+                return () => {
+                    const index = subscribers.indexOf(subscriber);
+                    if (index !== -1) {
+                        subscribers.splice(index, 1);
+                    }
+                    if (subscribers.length === 0) {
+                        ws.close();
+                    }
+                };
+            }
+        };
+    }
     return value;
 }
 ;

package/dist/index.d.ts

@@ -10,3 +10,4 @@ export { DistributedTable, PassThruParser, matchesFilter, indexName } from './re
 export type * from './resources/distributed-table.js';
 export * from './types/index.js';
 export * from './derived-types.js';
+export * from './services/realtime.js';

package/dist/index.js

@@ -9,3 +9,4 @@ export { Secret } from './resources/secret.js';
 export { DistributedTable, PassThruParser, matchesFilter, indexName } from './resources/distributed-table.js';
 export * from './types/index.js';
 export * from './derived-types.js';
+export * from './services/realtime.js';

package/dist/overrides.d.ts

@@ -1,6 +1,7 @@
 import type { FileService } from "./services/file";
 import type { AuthenticationService } from "./services/authentication";
 import type { Secret } from "./resources/secret";
+import type { RealtimeService } from "./services/realtime";
 /**
  * Used by hosting providers to provide service overrides.
  */
@@ -9,4 +10,5 @@ export declare const overrides: {
     DistributedTable?: typeof AuthenticationService;
     FileService?: typeof FileService;
     Secret?: typeof Secret;
+    RealtimeService?: typeof RealtimeService;
 };

package/dist/resources/distributed-table.js

@@ -158,48 +158,3 @@ export class DistributedTable extends Resource {
         });
     }
 }
-// export type Todo = {
-// 	id: string;
-// 	text: string;
-// 	order: number;
-// };
-// const userTodos = new DistributedTable('app', 'userTodos', {
-// 	parse: PassThruParser<Todo & { userId: string }>,
-// 	key: {
-// 		partition: { field: 'userId', type: 'string' },
-// 		sort: { field: 'order', type: 'number' }
-// 		// sort: { field: 'id', type: 'string' }
-// 		// sort: { }
-// 	},
-// 	indexes: [
-// 		{
-// 			partition: { field: 'text', type: 'string' },
-// 			sort: { field: 'userId', type: 'string' }
-// 			// sort: { field: 'order', type: 'number' }
-// 		}
-// 	]
-// });
-// type I = typeof userTodos['key'];
-// type T1 = typeof userTodos['key']['partition']['field'];
-// type T2 = typeof userTodos['key']['sort']['field'];
-// type T3 = typeof userTodos['indexes'];
-// type TTT1 = AllIndexes<typeof userTodos>;
-// type TTT2 = AllIndexesByName<typeof userTodos>;
-// type AnyIndex = Index<any>;
-// type TEST1 = I extends Index<any> ? 'yes' : 'no';
-// userTodos.query({
-// 	by: 'userId-order',
-// 	where: {
-// 		// maybe the key here can be the actual name of the field.
-// 		// maybe even follow the filter pattern, but only expose the `eq` operation:
-// 		// { [field]: { eq: T } }
-// 		userId: { eq: 'something' },
-// 		// id: {
-// 		// 	eq: 'something'
-// 		// }
-// 		// same here. name of the actual sort key field.
-// 		// id: {
-// 		// 	beginsWith: 'something'
-// 		// },
-// 	},
-// })

package/dist/services/realtime.d.ts

@@ -0,0 +1,20 @@
+import { Resource } from '../resource.js';
+export type MessageStream<T = any> = {
+    /**
+     * Returns a function to close the subscription.
+     */
+    subscribe(subscriber: {
+        onmessage: (data: T) => void;
+        onclose?: () => void;
+    }): () => void;
+};
+export declare class RealtimeService<T = any> extends Resource {
+    #private;
+    constructor(scope: Resource | string, id: string);
+    /**
+     * The address the client will need to connect to.
+     */
+    get address(): string;
+    publish(channel: string, data: T): Promise<void>;
+    getStream(channel: string): Promise<MessageStream<T>>;
+}

package/dist/services/realtime.js

@@ -0,0 +1,150 @@
+import * as jose from 'jose';
+import { WebSocketServer, WebSocket } from 'ws';
+import { Resource } from '../resource.js';
+import { Secret } from '../resources/secret.js';
+import { overrides } from '../overrides.js';
+const servers = new Map();
+const channels = new Map();
+export class RealtimeService extends Resource {
+    #channels;
+    #secret;
+    #server;
+    constructor(scope, id) {
+        super(scope, id);
+        this.#secret = new (overrides.Secret || Secret)(this, 'auth-secret');
+        if (servers.has(this.absoluteId)) {
+            console.log('existing realtime service found');
+            this.#server = servers.get(this.absoluteId);
+        }
+        if (channels.has(this.absoluteId)) {
+            console.log('existing channel entries found');
+            this.#channels = channels.get(this.absoluteId);
+        }
+        else {
+            this.#channels = new Map();
+            channels.set(this.absoluteId, this.#channels);
+        }
+    }
+    #requireServer() {
+        if (this.#server)
+            return;
+        console.log('Starting WebSocket server...');
+        this.#server = new WebSocketServer({ port: 0 });
+        servers.set(this.absoluteId, this.#server);
+        this.#server.on('connection', async (ws, req) => {
+            const encodedChannel = req.url?.split('/')[1];
+            let channel;
+            const protocol = ws.protocol;
+            console.log('ws connection', { encodedChannel, protocol });
+            if (!encodedChannel) {
+                console.log('No channel specified');
+                ws.close(4000, 'Channel not specified');
+                return;
+            }
+            try {
+                channel = Buffer.from(encodedChannel, 'base64').toString('utf-8');
+                console.log('Decoded channel:', channel);
+            }
+            catch (err) {
+                console.log('Invalid channel encoding');
+                ws.close(4004, 'Invalid channel encoding');
+                return;
+            }
+            if (!protocol) {
+                console.log('No protocol specified');
+                ws.close(4001, 'Protocol not specified');
+                return;
+            }
+            try {
+                const { payload } = await jose.jwtVerify(protocol, new TextEncoder().encode(await this.#secret.read()));
+                if (payload.channel !== channel) {
+                    console.log('Channel mismatch');
+                    ws.close(4003, 'Channel mismatch');
+                    return;
+                }
+            }
+            catch (err) {
+                console.log('Invalid token', err);
+                ws.close(4002, 'Invalid token');
+                return;
+            }
+            this.#channels.set(channel, this.#channels.get(channel) || []);
+            this.#channels.get(channel).push(ws);
+            ws.onclose = () => {
+                this.#channels.set(channel, this.#channels.get(channel).filter((w) => w !== ws));
+            };
+            console.log('WebSocket connection established:', channel);
+        });
+    }
+    /**
+     * Ensures channel name will be supported by known, major cloud provers using
+     * "serverless" solutions.
+     *
+     * Least common denominator on channel naming appears to be AWS AppSync:
+     * Ref: https://docs.aws.amazon.com/appsync/latest/eventapi/event-api-websocket-protocol.html#realtime-websocket-operations
+     *
+     * AFAIK, other providers allow 255 and beyond with a similar limitations. GCP PubSub
+     * doesn't support slashes in the topic name. But, on GCP, we can probably replaces
+     * slashes with underscores, and actual underscores with double-underscores...
+     *
+     * @param name
+     */
+    #validateChannelName(name) {
+        if (!name.match(/^\/?[A-Za-z0-9](?:[A-Za-z0-9-]{0,48}[A-Za-z0-9])?(?:\/[A-Za-z0-9](?:[A-Za-z0-9-]{0,48}[A-Za-z0-9])?){0,4}\/?$/)) {
+            throw new Error("Channel name must be no more than 5 segments of 1-50 alphanumeric characters and dashes each.");
+        }
+    }
+    /**
+     * The address the client will need to connect to.
+     */
+    get address() {
+        this.#requireServer();
+        const address = this.#server.address();
+        if (typeof address === 'string') {
+            return address;
+        }
+        else if (typeof address === 'object' && address !== null) {
+            const { port } = address;
+            return `ws://localhost:${port}`;
+        }
+        else {
+            throw new Error('Server address is not available');
+        }
+    }
+    async publish(channel, data) {
+        this.#requireServer();
+        this.#validateChannelName(channel);
+        console.log('Publishing to channel:', channel, data);
+        (this.#channels.get(channel) || []).forEach((ws) => {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({ data }));
+            }
+        });
+    }
+    async getStream(channel) {
+        this.#requireServer();
+        this.#validateChannelName(channel);
+        const channelString = Buffer.from(channel).toString('base64');
+        const payload = { channel };
+        const jwt = await new jose.SignJWT(payload)
+            .setProtectedHeader({ alg: 'HS256' })
+            .setIssuedAt()
+            .setExpirationTime(`10s`)
+            .sign(new TextEncoder().encode(await this.#secret.read()));
+        // The type we return is not at all what we actually return.
+        // It's the metadata needed to satisfy the contract client-side.
+        return {
+            __wjstype: 'realtime',
+            url: `${this.address}/${channelString}`,
+            protocol: jwt
+        };
+    }
+}
+// TEMP. playing with API interface.
+// TODO: figure out when/where a `parse` option would be used.
+// probably just server-side when sending messages to clients. when
+// clients send messages to the server, the server could also parse
+// the message to validate it. 
+// 
+// const rt = new RealtimeService<{ message: string }>('app', 'rt');
+// rt.publish('test', { message: 'test' });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wirejs-resources",
-	"version": "0.1.58",
+	"version": "0.1.60-realtime",
 	"description": "Basic services and server-side resources for wirejs apps",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -34,9 +34,11 @@
 	},
 	"homepage": "https://github.com/svidgen/create-wirejs-app#readme",
 	"dependencies": {
-		"jose": "^5.9.6"
+		"jose": "^5.9.6",
+		"ws": "^8.18.2"
 	},
 	"devDependencies": {
+		"@types/ws": "^8.18.1",
 		"typescript": "^5.7.3"
 	},
 	"files": [