@carno.js/live 1.8.0

package/test/acceptance-fase-2.test.ts

@@ -0,0 +1,248 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+import { BaseEntity, Entity, PrimaryKey, Property, statementObserver } from '../../orm/dist/index.js';
+import { withDatabase } from '../../orm/dist/testing/with-database.js';
+import { Body, Controller, Get, Post, Query } from '@carno.js/core';
+import { createTestHarness } from '../../core/dist/testing/TestHarness.js';
+import { getDriverType } from '../../orm/src/driver/driver-factory';
+import { Live } from '../src/decorators/Live';
+import { LivePlugin } from '../src/LivePlugin';
+import { closeLiveRuntime } from '../src/runtime';
+import type { LiveAuthorizationRequest, LiveAuthorizer } from '../src/auth/authorizer';
+import type { ServerMessage } from '../src/shared/protocol';
+
+const TABLE_STATEMENTS = [
+    'CREATE TABLE live2_cards (id SERIAL PRIMARY KEY, title TEXT NOT NULL, done BOOLEAN NOT NULL DEFAULT FALSE);'
+];
+
+@Entity({ tableName: 'live2_cards' })
+class Card extends BaseEntity<Card> {
+    @PrimaryKey()
+    id!: number;
+
+    @Property()
+    title!: string;
+
+    @Property()
+    done!: boolean;
+}
+
+@Controller('/cards')
+class CardsController {
+    @Get('/')
+    @Live({ key: 'id', shared: 'public' })
+    async list(@Query('done') done?: string) {
+        const cards = await Card.find(done === undefined ? {} : { done: done === 'true' });
+        return cards.map(card => ({ id: card.id, title: card.title }));
+    }
+
+    @Post('/search')
+    @Live({ key: 'id', shared: 'public' })
+    async search(@Body() filter: { contains: string }) {
+        const cards = await Card.find({});
+        return cards
+            .filter(card => card.title.includes(filter.contains))
+            .map(card => ({ id: card.id, title: card.title }));
+    }
+}
+
+class DenyEveryone implements LiveAuthorizer {
+    authorize(request: LiveAuthorizationRequest): boolean {
+        void request;
+        return false;
+    }
+}
+
+/** Minimal protocol client over a real WebSocket. */
+class ProbeClient {
+    private readonly socket: WebSocket;
+    readonly received: ServerMessage[] = [];
+
+    private constructor(socket: WebSocket) {
+        this.socket = socket;
+        socket.onmessage = event => this.received.push(JSON.parse(String(event.data)));
+    }
+
+    static connect(port: number): Promise<ProbeClient> {
+        return new Promise((resolve, reject) => {
+            const socket = new WebSocket(`ws://127.0.0.1:${port}/live`);
+            socket.onopen = () => resolve(new ProbeClient(socket));
+            socket.onerror = reject;
+        });
+    }
+
+    send(message: unknown): void {
+        this.socket.send(JSON.stringify(message));
+    }
+
+    close(): void {
+        this.socket.close();
+    }
+
+    async wait(predicate: (message: ServerMessage) => boolean, timeoutMs = 4000): Promise<ServerMessage> {
+        const deadline = Date.now() + timeoutMs;
+
+        while (Date.now() < deadline) {
+            const found = this.received.find(predicate);
+
+            if (found) {
+                return found;
+            }
+
+            await new Promise(resolve => setTimeout(resolve, 10));
+        }
+
+        throw new Error(`Timed out. Received: ${JSON.stringify(this.received)}`);
+    }
+}
+
+const describePostgres = getDriverType() === 'postgres' ? describe : describe.skip;
+
+afterEach(async () => {
+    statementObserver.reset();
+    // Awaited, not fire-and-forget: the LISTEN socket has to be back in the
+    // pool before the next test asks Postgres for another one.
+    await closeLiveRuntime();
+});
+
+describePostgres('Live Resources phase 2 acceptance', () => {
+    test('a write that never touched the application reaches the screen (criterion 2)', async () => {
+        await withDatabase(TABLE_STATEMENTS, async ({ executeSql }) => {
+            const harness = await createTestHarness({
+                plugins: [LivePlugin.create({
+                    controllers: [CardsController],
+                    config: { coalesceMs: 5 },
+                    pgNotify: {
+                        tables: [{ table: 'live2_cards', primaryKey: 'id' }],
+                        channel: 'carno_live_acceptance'
+                    }
+                })],
+                listen: true
+            });
+
+            // The plugin installs the triggers from inside the WebSocket
+            // builder, which is not awaited: give the DDL a moment to land.
+            await new Promise(resolve => setTimeout(resolve, 500));
+
+            const probe = await ProbeClient.connect(harness.port);
+            probe.send({ t: 'hello', v: 1 });
+            probe.send({ t: 'sub', sid: 's1', resource: 'CardsController.list', inputs: { params: {}, query: {} } });
+            await probe.wait(message => message.t === 'snapshot');
+
+            // No entity, no repository, no ORM: a migration or a psql session.
+            await executeSql(`INSERT INTO live2_cards (title, done) VALUES ('from outside', false);`);
+
+            const patch = await probe.wait(message => message.t === 'patch');
+
+            probe.close();
+            await harness.close();
+
+            expect(patch).toMatchObject({ t: 'patch', sid: 's1' });
+            expect(JSON.stringify((patch as { ops: unknown[] }).ops)).toContain('from outside');
+        });
+    });
+
+    test('a live @Post() answers plain JSON and also updates over the socket', async () => {
+        await withDatabase(TABLE_STATEMENTS, async () => {
+            const harness = await createTestHarness({
+                plugins: [LivePlugin.create({
+                    controllers: [CardsController],
+                    config: { coalesceMs: 5 }
+                })],
+                listen: true
+            });
+
+            await Card.create({ title: 'alpha', done: false });
+
+            // The same route, over plain HTTP, with no WebSocket in sight.
+            const response = await fetch(`http://127.0.0.1:${harness.port}/cards/search`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ contains: 'alp' })
+            });
+
+            expect(response.status).toBe(200);
+            expect(await response.json()).toEqual([{ id: 1, title: 'alpha' }]);
+
+            const probe = await ProbeClient.connect(harness.port);
+            probe.send({ t: 'hello', v: 1 });
+            probe.send({
+                t: 'sub',
+                sid: 's1',
+                resource: 'CardsController.search',
+                inputs: { params: {}, query: {}, body: { contains: 'alp' } }
+            });
+
+            const snapshot = await probe.wait(message => message.t === 'snapshot');
+            expect((snapshot as { data: unknown }).data).toEqual([{ id: 1, title: 'alpha' }]);
+
+            await Card.create({ title: 'alphabet', done: false });
+            const patch = await probe.wait(message => message.t === 'patch');
+
+            probe.close();
+            await harness.close();
+
+            expect(JSON.stringify((patch as { ops: unknown[] }).ops)).toContain('alphabet');
+        });
+    });
+
+    test('two subscriptions with different bodies do not share an instance', async () => {
+        await withDatabase(TABLE_STATEMENTS, async () => {
+            const harness = await createTestHarness({
+                plugins: [LivePlugin.create({ controllers: [CardsController], config: { coalesceMs: 5 } })],
+                listen: true
+            });
+
+            await Card.create({ title: 'alpha', done: false });
+            await Card.create({ title: 'beta', done: false });
+
+            const probe = await ProbeClient.connect(harness.port);
+            probe.send({ t: 'hello', v: 1 });
+            probe.send({
+                t: 'sub',
+                sid: 'a',
+                resource: 'CardsController.search',
+                inputs: { params: {}, query: {}, body: { contains: 'alp' } }
+            });
+            probe.send({
+                t: 'sub',
+                sid: 'b',
+                resource: 'CardsController.search',
+                inputs: { params: {}, query: {}, body: { contains: 'bet' } }
+            });
+
+            const first = await probe.wait(message => message.t === 'snapshot' && message.sid === 'a');
+            const second = await probe.wait(message => message.t === 'snapshot' && message.sid === 'b');
+
+            probe.close();
+            await harness.close();
+
+            expect((first as { data: unknown }).data).toEqual([{ id: 1, title: 'alpha' }]);
+            expect((second as { data: unknown }).data).toEqual([{ id: 2, title: 'beta' }]);
+        });
+    });
+
+    test('an unauthorized connection is told so and gets no data', async () => {
+        await withDatabase(TABLE_STATEMENTS, async () => {
+            const harness = await createTestHarness({
+                plugins: [LivePlugin.create({
+                    controllers: [CardsController],
+                    authorizer: new DenyEveryone(),
+                    config: { coalesceMs: 5 }
+                })],
+                listen: true
+            });
+
+            const probe = await ProbeClient.connect(harness.port);
+            probe.send({ t: 'hello', v: 1 });
+            probe.send({ t: 'sub', sid: 's1', resource: 'CardsController.list', inputs: { params: {}, query: {} } });
+
+            const error = await probe.wait(message => message.t === 'error');
+
+            probe.close();
+            await harness.close();
+
+            expect(error).toMatchObject({ t: 'error', sid: 's1', code: 'forbidden' });
+            expect(probe.received.some(message => message.t === 'snapshot')).toBe(false);
+        });
+    });
+});

package/test/acceptance-fase-3.test.ts

@@ -0,0 +1,216 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+import { BaseEntity, Entity, PrimaryKey, Property, statementObserver } from '../../orm/dist/index.js';
+import { withDatabase } from '../../orm/dist/testing/with-database.js';
+import { Controller, Get } from '@carno.js/core';
+import { createTestHarness } from '../../core/dist/testing/TestHarness.js';
+import { getDriverType } from '../../orm/src/driver/driver-factory';
+import { liveIsland } from '../../views/src/live-island';
+import { Live } from '../src/decorators/Live';
+import { LiveClient, type LiveSocket } from '../src/client/core';
+import { LivePlugin } from '../src/LivePlugin';
+import { closeLiveRuntime, getLiveRuntime } from '../src/runtime';
+import { prefetchLive } from '../src/resource/prefetch';
+import { toHydrateMap } from '../src/client/hydrate';
+import type { ServerMessage } from '../src/shared/protocol';
+
+const TABLE_STATEMENTS = [
+    'CREATE TABLE live3_notes (id SERIAL PRIMARY KEY, body TEXT NOT NULL);'
+];
+
+@Entity({ tableName: 'live3_notes' })
+class Note extends BaseEntity<Note> {
+    @PrimaryKey()
+    id!: number;
+
+    @Property()
+    body!: string;
+}
+
+@Controller('/notes')
+class NotesController {
+    @Get('/')
+    @Live({ key: 'id', shared: 'public' })
+    async list() {
+        const notes = await Note.find({});
+        return notes.map(note => ({ id: note.id, body: note.body }));
+    }
+}
+
+const describePostgres = getDriverType() === 'postgres' ? describe : describe.skip;
+
+afterEach(async () => {
+    statementObserver.reset();
+    await closeLiveRuntime();
+});
+
+function probeSocket() {
+    const socket = {
+        sent: [] as string[],
+        received: [] as ServerMessage[],
+        send(data: string) { socket.sent.push(data); },
+        close() {},
+        onopen: null as (() => void) | null,
+        onmessage: null as ((event: { data: string }) => void) | null,
+        onclose: null as (() => void) | null,
+        onerror: null as ((error: unknown) => void) | null
+    };
+
+    return socket;
+}
+
+describePostgres('Live Resources phase 3 acceptance', () => {
+    test('a views page renders server-side and only the subscribed island updates (criterion 7)', async () => {
+        await withDatabase(TABLE_STATEMENTS, async ({ executeSql }) => {
+            await executeSql(`INSERT INTO live3_notes (body) VALUES ('first');`);
+
+            const harness = await createTestHarness({
+                plugins: [LivePlugin.create({
+                    controllers: [NotesController],
+                    config: { coalesceMs: 5 }
+                })],
+                listen: true
+            });
+
+            // --- the server renders the page, island payload included -------
+            const payload = await prefetchLive(getLiveRuntime().resources, 'NotesController.list');
+            const page = [
+                '<h1>Notes</h1>',
+                '<div id="static">rendered once, never subscribed</div>',
+                `<div id="island"></div>${liveIsland(payload)}`
+            ].join('');
+
+            expect(page).toContain('rendered once, never subscribed');
+            expect(page).toContain('data-carno-live');
+            expect(payload.data).toEqual([{ id: 1, body: 'first' }]);
+
+            // --- the client picks the payload up, and starts full -----------
+            const hydrate = toHydrateMap([JSON.parse(
+                page.slice(page.indexOf('data-carno-live>') + 'data-carno-live>'.length, page.lastIndexOf('</script>'))
+            )]);
+
+            const socket = probeSocket();
+            const client = new LiveClient({
+                url: `ws://127.0.0.1:${harness.port}/live`,
+                hydrate,
+                socketFactory: () => socket as unknown as LiveSocket
+            });
+
+            const store = client.store('NotesController.list', { params: {}, query: {} });
+
+            // No waterfall: the first paint has the data, not a spinner.
+            expect(store.getSnapshot().pending).toBe(false);
+            expect(store.getSnapshot().data).toEqual([{ id: 1, body: 'first' }]);
+
+            store.subscribe(() => {});
+            socket.onopen?.();
+
+            const sub = JSON.parse(socket.sent.find(raw => raw.includes('"t":"sub"'))!);
+            expect(sub.hash).toBe(payload.hash);
+
+            await harness.close();
+        });
+    });
+
+    test('an island subscribing over a real socket receives a patch, and the hash spares the first send', async () => {
+        await withDatabase(TABLE_STATEMENTS, async ({ executeSql }) => {
+            await executeSql(`INSERT INTO live3_notes (body) VALUES ('first');`);
+
+            const harness = await createTestHarness({
+                plugins: [LivePlugin.create({
+                    controllers: [NotesController],
+                    config: { coalesceMs: 5 }
+                })],
+                listen: true
+            });
+
+            const payload = await prefetchLive(getLiveRuntime().resources, 'NotesController.list');
+            const received: ServerMessage[] = [];
+            const socket = new WebSocket(`ws://127.0.0.1:${harness.port}/live`);
+
+            await new Promise<void>(resolve => { socket.onopen = () => resolve(); });
+            socket.onmessage = event => received.push(JSON.parse(String(event.data)));
+
+            socket.send(JSON.stringify({ t: 'hello', v: 1 }));
+            socket.send(JSON.stringify({
+                t: 'sub',
+                sid: 's1',
+                resource: 'NotesController.list',
+                inputs: { params: {}, query: {} },
+                hash: payload.hash
+            }));
+
+            const wait = async (predicate: (message: ServerMessage) => boolean) => {
+                const deadline = Date.now() + 4000;
+
+                while (Date.now() < deadline) {
+                    const found = received.find(predicate);
+                    if (found) return found;
+                    await new Promise(resolve => setTimeout(resolve, 10));
+                }
+
+                throw new Error(`timed out. Received: ${JSON.stringify(received)}`);
+            };
+
+            // The screen already holds this content, so nothing is sent.
+            const current = await wait(message => message.t === 'current');
+            expect(current).toMatchObject({ t: 'current', sid: 's1' });
+            expect(received.some(message => message.t === 'snapshot')).toBe(false);
+
+            await Note.create({ body: 'second' });
+
+            const patch = await wait(message => message.t === 'patch');
+            expect(patch).toMatchObject({ t: 'patch', sid: 's1' });
+
+            socket.close();
+            await harness.close();
+        });
+    });
+
+    test('an ORM update reaches a liveSignal, closing the Angular half of criterion 1', async () => {
+        await withDatabase(TABLE_STATEMENTS, async ({ executeSql }) => {
+            await executeSql(`INSERT INTO live3_notes (body) VALUES ('first');`);
+
+            const { Injector, runInInjectionContext } = await import('@angular/core');
+            const { liveSignal, provideLive, reconcileLiveSignal } = await import('../src/client/angular');
+
+            const harness = await createTestHarness({
+                plugins: [LivePlugin.create({
+                    controllers: [NotesController],
+                    config: { coalesceMs: 5 }
+                })],
+                listen: true
+            });
+
+            const client = new LiveClient({ url: `ws://127.0.0.1:${harness.port}/live` });
+            const injector = Injector.create({ providers: [provideLive(client)] });
+
+            const state = runInInjectionContext(injector, () => liveSignal<{ id: number; body: string }[]>(
+                'NotesController.list'
+            ));
+            reconcileLiveSignal(state);
+
+            const settle = async (predicate: () => boolean) => {
+                const deadline = Date.now() + 4000;
+
+                while (Date.now() < deadline) {
+                    if (predicate()) return;
+                    await new Promise(resolve => setTimeout(resolve, 20));
+                }
+
+                throw new Error(`timed out. Last state: ${JSON.stringify(state())}`);
+            };
+
+            await settle(() => state().data?.length === 1);
+
+            // No broadcast code anywhere: an ordinary repository write.
+            await Note.create({ body: 'second' });
+
+            await settle(() => state().data?.length === 2);
+            expect(state().data?.map(note => note.body)).toEqual(['first', 'second']);
+
+            injector.destroy();
+            client.close();
+            await harness.close();
+        });
+    });
+});