@rapidmx/meet-plugin 0.1.0

package/dist/apps/shared/webrtc/MeshConnectionManager.js

@@ -0,0 +1,262 @@
+/** The lexicographically smaller uid is always the offerer for that pair - see this module's doc comment. */
+export function isOfferer(selfUid, peerUid) {
+    return selfUid < peerUid;
+}
+export class MeshConnectionManager {
+    constructor(options) {
+        this.options = options;
+        this.peers = new Map();
+        this.listeners = new Set();
+        this.started = false;
+        this.stopped = false;
+    }
+    get participants() {
+        return [...this.peers.values()].map((peer) => ({ uid: peer.uid, name: peer.name }));
+    }
+    get presenterUid() {
+        return this.currentPresenterUid;
+    }
+    onEvent(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    /** Subscribes to the channel and announces this participant. Idempotent - a second call is a no-op. */
+    start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        this.unsubscribe = this.options.channel.onMessage((message) => this.handleMessage(message));
+        this.sendHello();
+    }
+    /** Announces departure, closes every peer connection and unsubscribes - idempotent, and safe to call whether
+     * or not `start()` ever ran. Never removes the camera/microphone indicator itself - stopping `localStream`'s
+     * own tracks is the caller's job (see `deviceMedia.ts`'s `stopStream()`), since this manager never owns that
+     * stream's lifecycle, only attaches it. */
+    stop() {
+        if (this.stopped) {
+            return;
+        }
+        this.stopped = true;
+        if (this.started) {
+            this.send({ kind: "bye" });
+        }
+        this.unsubscribe?.();
+        this.unsubscribe = undefined;
+        for (const peer of this.peers.values()) {
+            peer.pc.close();
+        }
+        this.peers.clear();
+        this.listeners.clear();
+    }
+    /** Swaps every peer connection's outgoing video track (presentation mode) - see this module's doc comment.
+     * `track` is `null` to stop sending video at all (never used by this plugin's UI today, which always has a
+     * camera-or-screen track to fall back to, but kept correct since `RTCRtpSender.replaceTrack()` itself allows
+     * it). */
+    replaceLocalVideoTrack(track) {
+        for (const peer of this.peers.values()) {
+            const sender = peer.pc.getSenders().find((s) => s.track?.kind === "video");
+            void sender?.replaceTrack(track);
+        }
+    }
+    /** Claims presenter status for the local participant. Refuses (returns `false`, sends nothing) when someone
+     * else already presents - the caller (`_CallView.tsx`) uses this to disable its own "share screen" control
+     * rather than let a claim silently do nothing. */
+    claimPresenter() {
+        if (this.currentPresenterUid !== undefined && this.currentPresenterUid !== this.options.selfUid) {
+            return false;
+        }
+        this.currentPresenterUid = this.options.selfUid;
+        this.send({ kind: "presenter-claim" });
+        this.emit({ type: "presenter-changed", uid: this.currentPresenterUid });
+        return true;
+    }
+    /** Releases presenter status - a no-op unless the local participant currently holds it. */
+    releasePresenter() {
+        if (this.currentPresenterUid !== this.options.selfUid) {
+            return;
+        }
+        this.currentPresenterUid = undefined;
+        this.send({ kind: "presenter-release" });
+        this.emit({ type: "presenter-changed", uid: undefined });
+    }
+    sendHello() {
+        this.send({ kind: "hello", name: this.options.selfName });
+    }
+    send(partial) {
+        this.options.channel.send({ type: "video-meeting-signal", from: this.options.selfUid, ...partial });
+    }
+    emit(event) {
+        for (const listener of [...this.listeners]) {
+            listener(event);
+        }
+    }
+    handleMessage(message) {
+        if (message.type !== "video-meeting-signal" || message.from === this.options.selfUid) {
+            return;
+        }
+        if (message.to !== undefined && message.to !== this.options.selfUid) {
+            return;
+        }
+        switch (message.kind) {
+            case "hello":
+                this.handleHello(message);
+                return;
+            case "bye":
+                this.handleBye(message.from);
+                return;
+            case "offer":
+                void this.handleOffer(message);
+                return;
+            case "answer":
+                void this.handleAnswer(message);
+                return;
+            case "ice-candidate":
+                void this.handleIceCandidate(message);
+                return;
+            case "presenter-claim":
+                this.handlePresenterClaim(message.from);
+                return;
+            case "presenter-release":
+                this.handlePresenterRelease(message.from);
+                return;
+        }
+    }
+    handleHello(message) {
+        if (this.peers.has(message.from)) {
+            return;
+        }
+        const name = message.name ?? message.from;
+        const peer = this.createPeer(message.from, name);
+        this.emit({ type: "participant-joined", participant: { uid: peer.uid, name: peer.name } });
+        // Let a newcomer who couldn't have seen our own original `hello` learn about us too - see this module's
+        // doc comment on roster discovery.
+        this.sendHello();
+        if (isOfferer(this.options.selfUid, message.from)) {
+            void this.initiateOffer(peer);
+        }
+    }
+    handleBye(uid) {
+        const peer = this.peers.get(uid);
+        if (!peer) {
+            return;
+        }
+        peer.pc.close();
+        this.peers.delete(uid);
+        this.emit({ type: "participant-left", uid });
+        if (this.currentPresenterUid === uid) {
+            this.currentPresenterUid = undefined;
+            this.emit({ type: "presenter-changed", uid: undefined });
+        }
+    }
+    createPeer(uid, name) {
+        const pc = this.options.createPeerConnection({ iceServers: this.options.iceServers });
+        const peer = { uid, name, pc, remoteDescriptionSet: false, pendingCandidates: [] };
+        this.peers.set(uid, peer);
+        for (const track of this.options.localStream.getTracks()) {
+            pc.addTrack(track, this.options.localStream);
+        }
+        pc.onicecandidate = (event) => {
+            if (event.candidate) {
+                this.send({ kind: "ice-candidate", to: uid, candidate: event.candidate });
+            }
+        };
+        pc.ontrack = (event) => {
+            const stream = event.streams[0];
+            if (stream) {
+                this.emit({ type: "remote-stream", uid, stream });
+            }
+        };
+        pc.onconnectionstatechange = () => {
+            if (pc.connectionState === "failed" || pc.connectionState === "closed") {
+                this.handleBye(uid);
+            }
+        };
+        return peer;
+    }
+    async initiateOffer(peer) {
+        const offer = await peer.pc.createOffer();
+        await peer.pc.setLocalDescription(offer);
+        this.send({ kind: "offer", to: peer.uid, sdp: offer });
+    }
+    async handleOffer(message) {
+        if (!message.sdp) {
+            return;
+        }
+        let peer = this.peers.get(message.from);
+        const isNew = !peer;
+        if (!peer) {
+            peer = this.createPeer(message.from, message.from);
+        }
+        await peer.pc.setRemoteDescription(message.sdp);
+        this.flushPendingCandidates(peer);
+        if (isNew) {
+            this.emit({ type: "participant-joined", participant: { uid: peer.uid, name: peer.name } });
+        }
+        const answer = await peer.pc.createAnswer();
+        await peer.pc.setLocalDescription(answer);
+        this.send({ kind: "answer", to: peer.uid, sdp: answer });
+    }
+    async handleAnswer(message) {
+        const peer = this.peers.get(message.from);
+        if (!peer || !message.sdp) {
+            return;
+        }
+        await peer.pc.setRemoteDescription(message.sdp);
+        this.flushPendingCandidates(peer);
+    }
+    async handleIceCandidate(message) {
+        if (!message.candidate) {
+            return;
+        }
+        const peer = this.peers.get(message.from);
+        if (!peer) {
+            // No connection tracked for this peer yet (a candidate that raced ahead of its own offer/answer) -
+            // nothing to buffer it against, and one lost trickle-ICE candidate does not by itself break a
+            // connection (there are normally several). See this module's known-limitations note in the Phase 2
+            // report.
+            return;
+        }
+        if (!peer.remoteDescriptionSet) {
+            peer.pendingCandidates.push(message.candidate);
+            return;
+        }
+        await peer.pc.addIceCandidate(message.candidate);
+    }
+    flushPendingCandidates(peer) {
+        peer.remoteDescriptionSet = true;
+        const pending = peer.pendingCandidates;
+        peer.pendingCandidates = [];
+        for (const candidate of pending) {
+            void peer.pc.addIceCandidate(candidate);
+        }
+    }
+    handlePresenterClaim(from) {
+        if (this.currentPresenterUid === undefined) {
+            this.currentPresenterUid = from;
+            this.emit({ type: "presenter-changed", uid: from });
+            return;
+        }
+        if (this.currentPresenterUid === from) {
+            return;
+        }
+        // Collision: a claim from someone other than the presenter we already recorded. Resolve deterministically
+        // - see this module's doc comment - so every participant converges on the same winner. When the
+        // already-recorded presenter has the smaller uid, it wins and nothing changes here - including when that
+        // presenter is `this.options.selfUid` itself, whose own optimistic claim simply stays in place.
+        if (from < this.currentPresenterUid) {
+            const loser = this.currentPresenterUid;
+            this.currentPresenterUid = from;
+            this.emit({ type: "presenter-changed", uid: from });
+            if (loser === this.options.selfUid) {
+                this.send({ kind: "presenter-release" });
+            }
+        }
+    }
+    handlePresenterRelease(from) {
+        if (this.currentPresenterUid === from) {
+            this.currentPresenterUid = undefined;
+            this.emit({ type: "presenter-changed", uid: undefined });
+        }
+    }
+}

package/dist/apps/shared/webrtc/realPeerConnection.d.ts

@@ -0,0 +1,7 @@
+/** Adapts the real browser `RTCPeerConnection` to `RTCPeerConnectionLike` (`types.ts`) - `MeshConnectionManager`'s
+ * own tests never use this (they inject a fake `RTCPeerConnectionLike` directly); `apps/meet/_CallView.tsx` is
+ * this factory's only real caller. `createBrowserPeerConnection` is a plain function value, never invoked at
+ * module scope, so importing this file is safe during this plugin's page SSR, where `RTCPeerConnection` does not
+ * exist at all - it would only throw if actually *called* outside a browser. */
+import type { RTCPeerConnectionFactory } from "./types.js";
+export declare const createBrowserPeerConnection: RTCPeerConnectionFactory;

package/dist/apps/shared/webrtc/realPeerConnection.js

@@ -0,0 +1,26 @@
+export const createBrowserPeerConnection = (config) => {
+    const pc = new RTCPeerConnection(config);
+    const like = {
+        addTrack: (track, stream) => pc.addTrack(track, stream),
+        getSenders: () => pc.getSenders(),
+        createOffer: () => pc.createOffer(),
+        createAnswer: () => pc.createAnswer(),
+        setLocalDescription: (description) => pc.setLocalDescription(description),
+        setRemoteDescription: (description) => pc.setRemoteDescription(description),
+        addIceCandidate: (candidate) => pc.addIceCandidate(candidate),
+        close: () => pc.close(),
+        onicecandidate: null,
+        ontrack: null,
+        onconnectionstatechange: null,
+        get connectionState() {
+            return pc.connectionState;
+        },
+    };
+    // Forwards the real browser events to whatever handler `MeshConnectionManager` has currently assigned on
+    // `like` - a level of indirection needed because `like`'s own handler properties are reassigned *after* this
+    // adapter object is constructed and returned (see `MeshConnectionManager.createPeer()`).
+    pc.onicecandidate = (event) => like.onicecandidate?.({ candidate: event.candidate ? event.candidate.toJSON() : null });
+    pc.ontrack = (event) => like.ontrack?.({ streams: event.streams });
+    pc.onconnectionstatechange = () => like.onconnectionstatechange?.();
+    return like;
+};

package/dist/apps/shared/webrtc/types.d.ts

@@ -0,0 +1,94 @@
+/** Shared types for `MeshConnectionManager.ts` and its signaling transport (`apps/shared/push/GuestSignalingClient.ts`) -
+ * kept in their own module so a test can depend on the shapes alone. `GuestSignalingClient` itself now also serves
+ * an already-authenticated real caller (`VideoMeetingJoinResult.authenticated`), not only a synthetic guest - see
+ * its own doc comment. */
+/**
+ * One WebRTC signaling message, published as the JSON body of `POST /push/:meetingUid` (`BasePushRoute.send()`)
+ * and received back over `/push`'s WebSocket, exactly as `BaseVideoMeetingRoute`'s doc comment describes ("SDP
+ * offers/answers and ICE candidates are ordinary `NotificationUtils.sendMessage()` payloads"). `type` is a fixed
+ * literal so a listener on the meeting's channel (which will also see other frame shapes if this server ever
+ * grows other push consumers) can cheaply recognize and skip anything that isn't one of these.
+ *
+ * `hello`/`bye`/`presenter-claim`/`presenter-release` are broadcast (`to` left unset - every participant is
+ * relevant); `offer`/`answer`/`ice-candidate` are point-to-point (`to` is the intended peer's uid) - a recipient
+ * that isn't `to` (when set) ignores the message, since a channel's pub/sub fans every message out to every
+ * subscriber, sender included.
+ */
+export interface SignalMessage {
+    type: "video-meeting-signal";
+    kind: "hello" | "bye" | "offer" | "answer" | "ice-candidate" | "presenter-claim" | "presenter-release";
+    /** The sender's uid - the real, already-authenticated caller's own uid when `join()` returned
+     * `authenticated: true`, else the `guest:<random>` uid `BaseVideoMeetingRoute.join()` minted (either way, see
+     * `VideoMeetingJoinResult.selfUid`). */
+    from: string;
+    /** Set only on a point-to-point message (`offer`/`answer`/`ice-candidate`). */
+    to?: string;
+    /** `hello` only - the display name the sender chose in the lobby. */
+    name?: string;
+    /** `offer`/`answer` only. */
+    sdp?: RTCSessionDescriptionInit;
+    /** `ice-candidate` only. */
+    candidate?: RTCIceCandidateInit;
+}
+/** What `MeshConnectionManager` needs from a signaling transport - implemented by
+ * `apps/shared/push/GuestSignalingClient.ts` for a real call, and by an in-memory fake for `MeshConnectionManager`'s own
+ * tests (see `test/webrtc/MeshConnectionManager.test.ts`), which never opens a real network connection. */
+export interface SignalingChannel {
+    send(message: SignalMessage): void;
+    /** Calls `handler` with every message received on the channel (including, per the pub/sub fan-out this
+     * transport is built on, this same client's own sends - `MeshConnectionManager` filters those out itself
+     * rather than relying on the transport to). Returns the function that stops listening. */
+    onMessage(handler: (message: SignalMessage) => void): () => void;
+}
+/** The subset of `RTCRtpSender` `MeshConnectionManager.replaceLocalVideoTrack()` uses (presentation mode - see
+ * this plugin's Phase 2 `.claude/NOTES.md` entry: sharing replaces the outgoing camera track rather than adding a
+ * second video track, so no renegotiation is ever needed). A real `RTCRtpSender` already satisfies this shape. */
+export interface RTCRtpSenderLike {
+    track: MediaStreamTrack | null;
+    replaceTrack(track: MediaStreamTrack | null): Promise<void>;
+}
+/** The subset of `RTCPeerConnection` `MeshConnectionManager` uses - what a test's fake implements, and what
+ * `apps/shared/webrtc/realPeerConnection.ts` adapts the real browser constructor to. Event handlers are plain settable
+ * properties (`RTCPeerConnection`'s own `on*` style) rather than `addEventListener`, matching the browser API
+ * this stands in for and keeping a test fake to the bare minimum. */
+export interface RTCPeerConnectionLike {
+    addTrack(track: MediaStreamTrack, stream: MediaStream): RTCRtpSenderLike;
+    getSenders(): RTCRtpSenderLike[];
+    createOffer(): Promise<RTCSessionDescriptionInit>;
+    createAnswer(): Promise<RTCSessionDescriptionInit>;
+    setLocalDescription(description: RTCSessionDescriptionInit): Promise<void>;
+    setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void>;
+    addIceCandidate(candidate: RTCIceCandidateInit): Promise<void>;
+    close(): void;
+    onicecandidate: ((event: {
+        candidate: RTCIceCandidateInit | null;
+    }) => void) | null;
+    ontrack: ((event: {
+        streams: readonly MediaStream[];
+    }) => void) | null;
+    onconnectionstatechange: (() => void) | null;
+    connectionState: string;
+}
+export type RTCPeerConnectionFactory = (config: {
+    iceServers: RTCIceServer[];
+}) => RTCPeerConnectionLike;
+/** One other participant currently known to be in the call - `MeshConnectionManager.participants` never includes
+ * the local participant themselves (the UI already knows its own name/uid without asking the manager). */
+export interface MeshParticipant {
+    uid: string;
+    name: string;
+}
+export type MeshEvent = {
+    type: "participant-joined";
+    participant: MeshParticipant;
+} | {
+    type: "participant-left";
+    uid: string;
+} | {
+    type: "remote-stream";
+    uid: string;
+    stream: MediaStream;
+} | {
+    type: "presenter-changed";
+    uid: string | undefined;
+};

package/dist/apps/shared/webrtc/types.js

@@ -0,0 +1,9 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+/** Shared types for `MeshConnectionManager.ts` and its signaling transport (`apps/shared/push/GuestSignalingClient.ts`) -
+ * kept in their own module so a test can depend on the shapes alone. `GuestSignalingClient` itself now also serves
+ * an already-authenticated real caller (`VideoMeetingJoinResult.authenticated`), not only a synthetic guest - see
+ * its own doc comment. */
+export {};

package/dist/lib/index.js

@@ -0,0 +1,25 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * Private and public WebRTC video conferencing for a `@rapidmx/restapi`-based mail server: a mailbox owner creates
+ * a `VideoMeeting` (private, with one join link per invitee, or public, with a single shareable link), and a
+ * participant - the owner or an anonymous guest holding a valid link - joins it and exchanges WebRTC signaling
+ * over the server's existing `/push` channel (see `BaseVideoMeetingRoute`'s class doc comment).
+ *
+ * This module exports only the backend-agnostic surface: the entity interfaces, the pure ICE-server/public-URL/
+ * token utilities, the abstract route, and `createSingleInviteeVideoMeeting()` - the small integration function
+ * another plugin (`booking-plugin`, today) calls in-process to mint a private meeting without either package
+ * taking a hard dependency on the other (see `util/BookingIntegrationUtils.ts`'s doc comment). The concrete
+ * Mongo/SQL classes a server loads (models and the route mounted at `/api/mail/video-meetings`) come from this
+ * package's `./mongo` and `./sql` entry points.
+ */
+export * from "./models/types.js";
+export * from "./util/BookingIntegrationUtils.js";
+export * from "./util/IceServerUtils.js";
+export * from "./util/PublicUrlUtils.js";
+export * from "./util/RouteAccessUtils.js";
+export * from "./util/TokenUtils.js";
+export * from "./routes/BaseVideoMeetingRoute.js";
+//# sourceMappingURL=index.js.map

package/dist/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,mEAAmE;AACnE,mCAAmC;AACnC,+EAA+E;AAC/E;;;;;;;;;;;;GAYG;AACH,cAAc,mBAAmB,CAAC;AAClC,cAAc,mCAAmC,CAAC;AAClD,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,mCAAmC,CAAC"}

package/dist/lib/models/mongo/VideoMeetingInviteeMongo.js

@@ -0,0 +1,87 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { ObjectDecorators } from "@rapidrest/core";
+import { BaseMongoEntity, DocDecorators, ModelDecorators, PersistenceDecorators } from "@rapidrest/service-core";
+import { MailboxScopedData } from "@rapidmx/restapi";
+const { Description } = DocDecorators;
+const { DataStore, Protect } = ModelDecorators;
+const { Column, Entity, Index } = PersistenceDecorators;
+const { Nullable } = ObjectDecorators;
+/**
+ * Implementation of the `VideoMeetingInvitee` interface for storage in a MongoDB database. If SQL is desired,
+ * please use `models.sql.VideoMeetingInviteeSQL` instead.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+let VideoMeetingInviteeMongo = class VideoMeetingInviteeMongo extends BaseMongoEntity {
+    constructor(other) {
+        super(other);
+        this.meetingUid = "";
+        this.mailboxUid = "";
+        this.email = "";
+        this.joinToken = "";
+        if (other) {
+            this.meetingUid = other.meetingUid !== undefined ? other.meetingUid : this.meetingUid;
+            this.mailboxUid = other.mailboxUid !== undefined ? other.mailboxUid : this.mailboxUid;
+            this.email = other.email !== undefined ? other.email : this.email;
+            this.displayName = "displayName" in other ? other.displayName : this.displayName;
+            this.joinToken = other.joinToken !== undefined ? other.joinToken : this.joinToken;
+        }
+    }
+};
+__decorate([
+    Column(),
+    Description("The unique identifier of the `VideoMeeting` this invitee belongs to."),
+    __metadata("design:type", String)
+], VideoMeetingInviteeMongo.prototype, "meetingUid", void 0);
+__decorate([
+    Column(),
+    Description("The unique identifier of the host `Mailbox`, denormalized from the meeting."),
+    __metadata("design:type", String)
+], VideoMeetingInviteeMongo.prototype, "mailboxUid", void 0);
+__decorate([
+    Column(),
+    Description("The invitee's email address, normalized to lowercase."),
+    __metadata("design:type", String)
+], VideoMeetingInviteeMongo.prototype, "email", void 0);
+__decorate([
+    Column({ nullable: true }),
+    Description("The invitee's display name, if supplied."),
+    Nullable,
+    __metadata("design:type", String)
+], VideoMeetingInviteeMongo.prototype, "displayName", void 0);
+__decorate([
+    Column(),
+    Description("The unguessable token embedded in this invitee's join link. Minted server-side, immutable."),
+    __metadata("design:type", String)
+], VideoMeetingInviteeMongo.prototype, "joinToken", void 0);
+VideoMeetingInviteeMongo = __decorate([
+    DataStore("mongo"),
+    Entity(),
+    MailboxScopedData(),
+    Description("One invited participant of a PRIVATE VideoMeeting, identified by an unguessable join token."),
+    Index("videomeetinginvitee_join_token", ["joinToken"], { unique: true }),
+    Index("videomeetinginvitee_meeting", ["meetingUid"]),
+    Index("videomeetinginvitee_mailbox", ["mailboxUid"]),
+    Protect({
+        uid: "VideoMeetingInvitee",
+        records: [
+            { userOrRoleId: "anonymous", actions: [] },
+            { userOrRoleId: ".*", actions: [] },
+        ],
+    }, false),
+    __metadata("design:paramtypes", [Object])
+], VideoMeetingInviteeMongo);
+export { VideoMeetingInviteeMongo };
+//# sourceMappingURL=VideoMeetingInviteeMongo.js.map

package/dist/lib/models/mongo/VideoMeetingInviteeMongo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VideoMeetingInviteeMongo.js","sourceRoot":"","sources":["../../../../src/models/mongo/VideoMeetingInviteeMongo.ts"],"names":[],"mappings":"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"}

package/dist/lib/models/mongo/VideoMeetingMongo.js

@@ -0,0 +1,126 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { ObjectDecorators } from "@rapidrest/core";
+import { BaseMongoEntity, DocDecorators, ModelDecorators, PersistenceDecorators } from "@rapidrest/service-core";
+import { MailboxScopedData } from "@rapidmx/restapi";
+import { VideoMeetingStatus, VideoMeetingVisibility } from "../types.js";
+const { Description } = DocDecorators;
+const { DataStore, Protect } = ModelDecorators;
+const { Column, Entity, Index } = PersistenceDecorators;
+const { Nullable } = ObjectDecorators;
+/**
+ * Implementation of the `VideoMeeting` interface for storage in a MongoDB database. If SQL is desired, please use
+ * `models.sql.VideoMeetingSQL` instead.
+ *
+ * `recordACL: true` - see the `VideoMeeting` interface's own doc comment for why this entity, unlike most of this
+ * codebase's mailbox-scoped data, gets its own per-record `AccessControlList`.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+let VideoMeetingMongo = class VideoMeetingMongo extends BaseMongoEntity {
+    constructor(other) {
+        super(other);
+        this.mailboxUid = "";
+        this.title = "";
+        this.visibility = VideoMeetingVisibility.PRIVATE;
+        this.status = VideoMeetingStatus.SCHEDULED;
+        if (other) {
+            this.mailboxUid = other.mailboxUid !== undefined ? other.mailboxUid : this.mailboxUid;
+            this.calendarEventUid = "calendarEventUid" in other ? other.calendarEventUid : this.calendarEventUid;
+            this.title = other.title !== undefined ? other.title : this.title;
+            this.visibility = other.visibility !== undefined ? other.visibility : this.visibility;
+            this.publicSlug = "publicSlug" in other ? other.publicSlug : this.publicSlug;
+            this.organizerSlug = "organizerSlug" in other ? other.organizerSlug : this.organizerSlug;
+            this.status = other.status !== undefined ? other.status : this.status;
+            this.startTime = "startTime" in other ? other.startTime : this.startTime;
+            this.endTime = "endTime" in other ? other.endTime : this.endTime;
+        }
+    }
+};
+__decorate([
+    Column(),
+    Description("The unique identifier of the `Mailbox` that owns this meeting."),
+    __metadata("design:type", String)
+], VideoMeetingMongo.prototype, "mailboxUid", void 0);
+__decorate([
+    Column({ nullable: true }),
+    Description("The unique identifier of the `CalendarEvent` this meeting was minted for, if any."),
+    Nullable,
+    __metadata("design:type", String)
+], VideoMeetingMongo.prototype, "calendarEventUid", void 0);
+__decorate([
+    Column(),
+    Description("The meeting's display title."),
+    __metadata("design:type", String)
+], VideoMeetingMongo.prototype, "title", void 0);
+__decorate([
+    Column(),
+    Description("Whether this meeting is joinable only by its invitees or by anyone holding its public link."),
+    __metadata("design:type", String)
+], VideoMeetingMongo.prototype, "visibility", void 0);
+__decorate([
+    Column({ nullable: true }),
+    Description("The public join link's unique identifier, set only when visibility is PUBLIC."),
+    Nullable,
+    __metadata("design:type", String)
+], VideoMeetingMongo.prototype, "publicSlug", void 0);
+__decorate([
+    Column({ nullable: true }),
+    Description("The organizer's own join link identifier, set only when visibility is PRIVATE."),
+    Nullable,
+    __metadata("design:type", String)
+], VideoMeetingMongo.prototype, "organizerSlug", void 0);
+__decorate([
+    Column(),
+    Description("The current lifecycle state of this meeting."),
+    __metadata("design:type", String)
+], VideoMeetingMongo.prototype, "status", void 0);
+__decorate([
+    Column({ nullable: true }),
+    Description("Informational only: not used for any availability or conflict checking."),
+    Nullable,
+    __metadata("design:type", Date)
+], VideoMeetingMongo.prototype, "startTime", void 0);
+__decorate([
+    Column({ nullable: true }),
+    Description("Informational only: not used for any availability or conflict checking."),
+    Nullable,
+    __metadata("design:type", Date)
+], VideoMeetingMongo.prototype, "endTime", void 0);
+VideoMeetingMongo = __decorate([
+    DataStore("mongo"),
+    Entity(),
+    MailboxScopedData(),
+    Description("A WebRTC video meeting, joinable directly or from a calendar invite."),
+    Index("videomeeting_mailbox", ["mailboxUid"])
+    // Single-field, not `["mailboxUid", "publicSlug"]`: a compound sparse index still indexes a document carrying at
+    // least one of its keys, so every document has `mailboxUid` and would be indexed regardless of whether `publicSlug`
+    // is set - two private meetings in the same mailbox (both missing `publicSlug`) would then collide on `(mailboxUid,
+    // null)`, rejecting the second one outright. A single-field sparse index skips a document missing the field
+    // entirely, matching the global (not per-mailbox) lookup `join()` actually performs - see `VideoMeeting.publicSlug`'s
+    // own doc comment on that tradeoff. `organizerSlug` below hit the exact same pitfall and is fixed the same way.
+    ,
+    Index("videomeeting_public_slug", ["publicSlug"], { unique: true, sparse: true }),
+    Index("videomeeting_organizer_slug", ["organizerSlug"], { unique: true, sparse: true }),
+    Protect({
+        uid: "VideoMeeting",
+        records: [
+            { userOrRoleId: "anonymous", actions: [] },
+            { userOrRoleId: ".*", actions: [] },
+        ],
+    }, true),
+    __metadata("design:paramtypes", [Object])
+], VideoMeetingMongo);
+export { VideoMeetingMongo };
+//# sourceMappingURL=VideoMeetingMongo.js.map