@base44-preview/platform 0.0.0-stage → 0.1.0-pr.312.2ef55e3

package/dist/modules/builder-socket.js

@@ -0,0 +1,251 @@
+import { io } from "socket.io-client";
+import { PlatformSocketError } from "../errors.js";
+import { appFromRoom, appPattern, decode, decodeSnapshot, eventNames, object, roomFor, roomNotices, sessionEndings } from "./builder-protocol.js";
+import { notify, Subscription } from "./builder-subscription.js";
+const MAX_DENIAL_RETRIES = 5;
+/** @internal */
+export class BuilderSocket {
+    constructor(config, options) {
+        this.subscriptions = new Map();
+        this.closed = false;
+        this.tokenFresh = false;
+        this.denialRetries = 0;
+        this.authAttempt = 0;
+        this.options = { ...config, onError: options.onError };
+        this.socket = io(config.socketUrl, {
+            path: "/ws/socket.io/", transports: ["websocket"], autoConnect: false,
+            forceNew: true, reconnectionAttempts: 5, reconnectionDelay: 1000, reconnectionDelayMax: 10000,
+            timeout: 20000,
+            auth: (callback) => { void this.authenticate(callback); },
+        });
+        this.socket.on("connect", () => {
+            var _a;
+            this.tokenFresh = false;
+            this.denialRetries = 0;
+            for (const subscription of this.subscriptions.values())
+                this.join(subscription);
+            (_a = this.resolveConnect) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.clearConnecting();
+        });
+        this.socket.on("disconnect", (reason) => {
+            ++this.authAttempt;
+            if (this.closed || reason !== "io server disconnect")
+                return; // Transport loss reconnects by itself.
+            const ending = this.ending;
+            this.ending = undefined;
+            if (ending === "session_expired")
+                this.socket.connect(); // Renew through getSessionToken.
+            else
+                this.connectionError(new PlatformSocketError(ending !== null && ending !== void 0 ? ending : "connection_failed"));
+        });
+        this.socket.on("connect_error", (error) => this.refused(error));
+        this.socket.io.on("reconnect_failed", () => this.connectionError(new PlatformSocketError("connection_failed")));
+        this.socket.on("app.snapshot", (raw) => {
+            var _a;
+            try {
+                const snapshot = decodeSnapshot(raw);
+                (_a = this.subscriptions.get(appFromRoom(snapshot.room))) === null || _a === void 0 ? void 0 : _a.snapshot(snapshot);
+            }
+            catch (_b) {
+                this.protocolError(raw);
+            }
+        });
+        this.socket.on("session.ended", (raw) => this.sessionEnded(raw));
+        for (const [name, code] of Object.entries(roomNotices))
+            this.socket.on(name, (raw) => this.roomNotice(code, raw));
+        for (const type of eventNames)
+            this.socket.on(type, (raw) => {
+                try {
+                    const appId = appFromRoom(object(raw).room);
+                    if (!appId)
+                        throw new Error("Invalid app");
+                    const event = decode(type, appId, raw);
+                    const subscription = this.subscriptions.get(appId);
+                    subscription === null || subscription === void 0 ? void 0 : subscription.event(event);
+                    // The server does not resend a snapshot after a rewrite of main: rejoining asks for one.
+                    if (subscription && event.type === "conversation.changed" && event.data.branch_id == null)
+                        this.join(subscription);
+                }
+                catch (_a) {
+                    this.protocolError(raw);
+                }
+            });
+    }
+    /** Connect with the session token. Resolves on CONNECT, before snapshots arrive.
+     * Transport loss retries up to five times and rejoins active subscriptions.
+     * Call again after a failure or `session_replaced`; concurrent calls share one attempt.
+     */
+    connect() {
+        if (this.closed)
+            return Promise.reject(new PlatformSocketError("client_closed"));
+        if (this.socket.connected)
+            return Promise.resolve();
+        if (this.connecting)
+            return this.connecting;
+        const promise = new Promise((resolve, reject) => {
+            this.resolveConnect = resolve;
+            this.rejectConnect = reject;
+        });
+        this.connecting = promise;
+        this.socket.connect();
+        return promise;
+    }
+    /** Subscribe before or after connecting. One subscription per app, maximum eight, each on the
+     * session's allowlist. Snapshots and events are awaited in order per app; a failed callback,
+     * an invalid frame or a server refusal ends the subscription.
+     */
+    subscribe(appId, options) {
+        if (this.closed)
+            throw new PlatformSocketError("client_closed");
+        if (!appPattern.test(appId))
+            throw new TypeError("appId must be 24 lowercase hexadecimal characters");
+        if (this.subscriptions.has(appId))
+            throw new TypeError("An app may only have one subscription per builder session");
+        if (this.subscriptions.size >= 8)
+            throw new PlatformSocketError("subscription_limit", appId);
+        const subscription = new Subscription(appId, { ...options }, () => {
+            this.subscriptions.delete(appId);
+            if (this.socket.connected)
+                this.socket.emit("leave", roomFor(appId));
+        });
+        this.subscriptions.set(appId, subscription);
+        if (this.socket.connected)
+            this.join(subscription);
+        return subscription;
+    }
+    /** Stop delivery, cancel reconnection and release all listeners. Idempotent and terminal. */
+    close() {
+        var _a, _b;
+        if (this.closed)
+            return;
+        this.closed = true;
+        ++this.authAttempt;
+        (_a = this.cancelAuth) === null || _a === void 0 ? void 0 : _a.call(this);
+        clearTimeout(this.retryTimer);
+        for (const subscription of this.subscriptions.values())
+            subscription.unsubscribe();
+        (_b = this.rejectConnect) === null || _b === void 0 ? void 0 : _b.call(this, new PlatformSocketError("client_closed"));
+        this.clearConnecting();
+        this.socket.removeAllListeners();
+        this.socket.io.removeAllListeners();
+        this.socket.disconnect();
+    }
+    join(subscription) {
+        this.socket.emit("join", roomFor(subscription.appId));
+    }
+    async authenticate(callback) {
+        var _a;
+        const attempt = ++this.authAttempt;
+        (_a = this.cancelAuth) === null || _a === void 0 ? void 0 : _a.call(this);
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error("Session token timeout")), 20000);
+            this.cancelAuth = () => { clearTimeout(timer); reject(new Error("Cancelled")); };
+        });
+        try {
+            if (!this.token) {
+                const token = await Promise.race([Promise.resolve().then(() => this.options.getSessionToken()), timeout]);
+                if (this.closed || attempt !== this.authAttempt)
+                    return;
+                if (typeof token !== "string" || !token.trim())
+                    throw new Error("Missing session token");
+                this.token = token;
+                this.tokenFresh = true;
+            }
+            callback({ session_token: this.token });
+        }
+        catch (_b) {
+            if (this.closed || attempt !== this.authAttempt)
+                return;
+            this.socket.disconnect();
+            this.connectionError(new PlatformSocketError("session_unavailable"));
+        }
+        finally {
+            clearTimeout(timer);
+            if (attempt === this.authAttempt)
+                this.cancelAuth = undefined;
+        }
+    }
+    /** A connect the server refused. Transport errors are Socket.IO's to retry. */
+    refused(error) {
+        var _a;
+        if (this.closed || error.message !== "connection_denied")
+            return;
+        if (((_a = error.data) === null || _a === void 0 ? void 0 : _a.retryable) === true) {
+            this.retryDenied();
+            return;
+        }
+        // A token this attempt did not just fetch may have expired: renew it once.
+        const renew = !this.tokenFresh;
+        this.token = undefined;
+        if (renew)
+            this.socket.connect();
+        else
+            this.connectionError(new PlatformSocketError("connection_denied"));
+    }
+    retryDenied() {
+        if (++this.denialRetries > MAX_DENIAL_RETRIES) {
+            this.denialRetries = 0;
+            this.connectionError(new PlatformSocketError("connection_failed"));
+            return;
+        }
+        const delay = Math.min(1000 * 2 ** (this.denialRetries - 1), 10000) * (0.5 + Math.random() / 2);
+        this.retryTimer = setTimeout(() => { this.retryTimer = undefined; if (!this.closed)
+            this.socket.connect(); }, delay);
+    }
+    clearConnecting() {
+        this.connecting = undefined;
+        this.resolveConnect = undefined;
+        this.rejectConnect = undefined;
+    }
+    connectionError(error) {
+        var _a;
+        (_a = this.rejectConnect) === null || _a === void 0 ? void 0 : _a.call(this, error);
+        this.clearConnecting();
+        if (!this.closed)
+            notify(this.options.onError, error);
+    }
+    sessionEnded(raw) {
+        try {
+            const reason = object(object(raw).data).reason;
+            const ending = typeof reason === "string" && Object.prototype.hasOwnProperty.call(sessionEndings, reason)
+                ? sessionEndings[reason] : undefined;
+            if (!ending)
+                throw new Error("Unknown reason");
+            // The server disconnects next; the disconnect handler renews or stops.
+            this.token = undefined;
+            this.ending = ending;
+        }
+        catch (_a) {
+            this.protocolError(raw);
+        }
+    }
+    roomNotice(code, raw) {
+        try {
+            const appId = appFromRoom(object(raw).room);
+            if (!appId)
+                throw new Error("Invalid app");
+            const subscription = this.subscriptions.get(appId);
+            if (code === "snapshot_unavailable")
+                subscription === null || subscription === void 0 ? void 0 : subscription.warn(code);
+            else
+                subscription === null || subscription === void 0 ? void 0 : subscription.fail(code);
+        }
+        catch (_a) {
+            this.protocolError(raw);
+        }
+    }
+    protocolError(raw) {
+        var _a;
+        const frame = raw && typeof raw === "object" ? raw : {};
+        const appId = appFromRoom(frame.room);
+        if (appId)
+            (_a = this.subscriptions.get(appId)) === null || _a === void 0 ? void 0 : _a.fail("protocol_error");
+        else {
+            // Unknown routing: no app can be told which update it missed.
+            for (const subscription of [...this.subscriptions.values()])
+                subscription.fail("protocol_error");
+            this.connectionError(new PlatformSocketError("protocol_error"));
+        }
+    }
+}

package/dist/modules/builder-subscription.d.ts

@@ -0,0 +1,23 @@
+import type { PlatformEvent, PlatformSnapshot } from "./builder.events.types.js";
+import { PlatformSocketError } from "../errors.js";
+import type { PlatformSocketErrorCode } from "../errors.types.js";
+import type { PlatformSubscription, SubscriptionOptions } from "./builder.types.js";
+/** @internal */
+export declare function notify(callback: (error: PlatformSocketError) => void, error: PlatformSocketError): void;
+/** @internal */
+export declare class Subscription implements PlatformSubscription {
+    readonly appId: string;
+    private options;
+    private remove;
+    active: boolean;
+    private pending;
+    private tail;
+    constructor(appId: string, options: SubscriptionOptions, remove: () => void);
+    private enqueue;
+    event(event: PlatformEvent): void;
+    snapshot(snapshot: PlatformSnapshot): void;
+    /** A non-fatal problem; the subscription keeps receiving events. */
+    warn(code: PlatformSocketErrorCode): void;
+    fail(code: PlatformSocketErrorCode): void;
+    unsubscribe(): void;
+}

package/dist/modules/builder-subscription.js

@@ -0,0 +1,55 @@
+import { PlatformSocketError } from "../errors.js";
+/** @internal */
+export function notify(callback, error) {
+    try {
+        callback(error);
+    }
+    catch ( /* An error observer cannot interrupt other app subscriptions. */_a) { /* An error observer cannot interrupt other app subscriptions. */ }
+}
+/** @internal */
+export class Subscription {
+    constructor(appId, options, remove) {
+        this.appId = appId;
+        this.options = options;
+        this.remove = remove;
+        this.active = true;
+        this.pending = 0;
+        this.tail = Promise.resolve();
+    }
+    enqueue(work) {
+        if (!this.active)
+            return;
+        if (this.pending >= 1000) {
+            this.fail("delivery_overflow");
+            return;
+        }
+        this.pending++;
+        this.tail = this.tail.then(async () => {
+            if (this.active)
+                await work();
+        }).catch(() => this.fail("handler_failed")).finally(() => { this.pending--; });
+    }
+    event(event) {
+        this.enqueue(() => this.options.onEvent(event));
+    }
+    snapshot(snapshot) {
+        this.enqueue(() => this.options.onSnapshot(snapshot));
+    }
+    /** A non-fatal problem; the subscription keeps receiving events. */
+    warn(code) {
+        if (this.active)
+            notify(this.options.onError, new PlatformSocketError(code, this.appId));
+    }
+    fail(code) {
+        if (!this.active)
+            return;
+        this.unsubscribe();
+        notify(this.options.onError, new PlatformSocketError(code, this.appId));
+    }
+    unsubscribe() {
+        if (!this.active)
+            return;
+        this.active = false;
+        this.remove();
+    }
+}

package/dist/modules/builder.d.ts

@@ -0,0 +1,4 @@
+import type { PlatformClientOptions } from "../client.types.js";
+import type { BuilderModule } from "./builder.types.js";
+/** @internal */
+export declare function createBuilder(config: PlatformClientOptions): BuilderModule;