openrtc 0.1.0

package/dist/core/PeerLifecycleManager.js

@@ -0,0 +1,330 @@
+function normalizeId(value) {
+    if (!value)
+        return null;
+    const trimmed = value.trim();
+    return trimmed ? trimmed.toLowerCase() : null;
+}
+function choosePeerId(input) {
+    return input.deviceId || input.deviceIdHint || input.peerId || null;
+}
+function sortedStrings(values) {
+    return [...values].sort();
+}
+function samePeerStateIgnoringLastSeen(left, right) {
+    if (!left) {
+        return false;
+    }
+    return left.peerId === right.peerId
+        && (left.deviceId ?? null) === (right.deviceId ?? null)
+        && (left.deviceIdHint ?? null) === (right.deviceIdHint ?? null)
+        && (left.nodeId ?? null) === (right.nodeId ?? null)
+        && (left.connectionId ?? null) === (right.connectionId ?? null)
+        && (left.ticket ?? null) === (right.ticket ?? null)
+        && !!left.online === !!right.online
+        && (left.deviceName ?? null) === (right.deviceName ?? null)
+        && (left.platformType ?? null) === (right.platformType ?? null)
+        && left.status === right.status
+        && left.health === right.health
+        && (left.transportState ?? null) === (right.transportState ?? null)
+        && (left.protocolState ?? null) === (right.protocolState ?? null)
+        && !!left.routable === !!right.routable
+        && (left.error ?? null) === (right.error ?? null)
+        && JSON.stringify(sortedStrings(left.connectionIds)) === JSON.stringify(sortedStrings(right.connectionIds))
+        && JSON.stringify(sortedStrings(left.scopes)) === JSON.stringify(sortedStrings(right.scopes));
+}
+export class PeerLifecycleManager {
+    constructor() {
+        this.peers = new Map();
+        this.aliases = new Map();
+        this.watchers = new Set();
+    }
+    resolveCanonicalPeerId(input) {
+        const candidates = [
+            input.deviceId,
+            input.deviceIdHint,
+            input.peerId,
+            // Transport metadata may locate an existing peer, but it must not
+            // become the canonical public peer identity.
+            input.connectionId,
+        ];
+        for (const candidate of candidates) {
+            const alias = normalizeId(candidate);
+            if (!alias)
+                continue;
+            const existing = this.aliases.get(alias);
+            if (existing)
+                return existing;
+        }
+        return choosePeerId(input);
+    }
+    setAlias(value, peerId) {
+        const alias = normalizeId(value);
+        if (!alias)
+            return;
+        this.aliases.set(alias, peerId);
+    }
+    snapshot(record) {
+        return {
+            peerId: record.peerId,
+            deviceId: record.deviceId,
+            deviceIdHint: record.deviceIdHint,
+            nodeId: record.nodeId,
+            connectionId: record.connectionId,
+            connectionIds: Array.from(record.connectionIds.values()),
+            ticket: record.ticket,
+            online: record.online,
+            deviceName: record.deviceName,
+            platformType: record.platformType,
+            status: record.status,
+            health: record.health,
+            transportState: record.transportState,
+            protocolState: record.protocolState,
+            routable: record.routable,
+            scopes: Array.from(record.scopes.values()),
+            lastSeenAt: record.lastSeenAt,
+            error: record.error,
+        };
+    }
+    emit() {
+        const peers = this.list();
+        this.watchers.forEach((watcher) => watcher(peers));
+    }
+    rekeyPeer(existingPeerId, nextPeerId) {
+        const existing = this.peers.get(existingPeerId);
+        if (!existing) {
+            throw new Error(`Cannot rekey missing peer ${existingPeerId}`);
+        }
+        if (existingPeerId === nextPeerId) {
+            return existing;
+        }
+        this.peers.delete(existingPeerId);
+        existing.peerId = nextPeerId;
+        this.peers.set(nextPeerId, existing);
+        for (const [alias, peerId] of this.aliases.entries()) {
+            if (peerId === existingPeerId) {
+                this.aliases.set(alias, nextPeerId);
+            }
+        }
+        return existing;
+    }
+    upsert(input) {
+        const canonicalPeerId = this.resolveCanonicalPeerId(input) ?? choosePeerId(input);
+        if (!canonicalPeerId) {
+            throw new Error('Peer lifecycle upsert requires a peer identifier.');
+        }
+        const preferredPeerId = choosePeerId(input) ?? canonicalPeerId;
+        let record = this.peers.get(canonicalPeerId);
+        const existed = !!record;
+        if (!record) {
+            record = {
+                peerId: canonicalPeerId,
+                connectionIds: new Set(),
+                status: input.status ?? 'disconnected',
+                health: input.health ?? 'unknown',
+                scopes: new Set(),
+            };
+            this.peers.set(canonicalPeerId, record);
+        }
+        const before = existed ? this.snapshot(record) : undefined;
+        if (preferredPeerId !== record.peerId) {
+            const nextPreferred = input.deviceId ||
+                record.deviceId ||
+                input.deviceIdHint ||
+                record.deviceIdHint ||
+                record.peerId;
+            if (nextPreferred && nextPreferred !== record.peerId) {
+                record = this.rekeyPeer(record.peerId, nextPreferred);
+            }
+        }
+        if (input.deviceId)
+            record.deviceId = input.deviceId;
+        if (input.deviceIdHint !== undefined)
+            record.deviceIdHint = input.deviceIdHint;
+        if (input.nodeId)
+            record.nodeId = input.nodeId;
+        if (input.connectionId) {
+            record.connectionId = input.connectionId;
+            record.connectionIds.add(input.connectionId);
+        }
+        if (input.ticket !== undefined)
+            record.ticket = input.ticket;
+        if (input.online !== undefined)
+            record.online = input.online;
+        if (input.deviceName !== undefined)
+            record.deviceName = input.deviceName;
+        if (input.platformType !== undefined)
+            record.platformType = input.platformType;
+        if (input.status) {
+            const shouldPreserveConnected = record.connectionIds.size > 0 &&
+                record.status === 'connected' &&
+                input.status === 'disconnected' &&
+                !input.connectionId &&
+                !input.transportState &&
+                !input.protocolState &&
+                !input.error;
+            if (!shouldPreserveConnected) {
+                record.status = input.status;
+            }
+        }
+        if (input.health)
+            record.health = input.health;
+        if (input.transportState !== undefined)
+            record.transportState = input.transportState;
+        if (input.protocolState !== undefined)
+            record.protocolState = input.protocolState;
+        if (input.routable !== undefined)
+            record.routable = input.routable;
+        if (input.error !== undefined)
+            record.error = input.error;
+        if (input.lastSeenAt !== undefined)
+            record.lastSeenAt = input.lastSeenAt;
+        if (input.scopes) {
+            for (const scope of input.scopes) {
+                record.scopes.add(scope);
+            }
+        }
+        this.setAlias(record.peerId, record.peerId);
+        this.setAlias(record.deviceId, record.peerId);
+        this.setAlias(record.deviceIdHint, record.peerId);
+        this.setAlias(record.nodeId, record.peerId);
+        this.setAlias(record.connectionId, record.peerId);
+        for (const connectionId of record.connectionIds) {
+            this.setAlias(connectionId, record.peerId);
+        }
+        const snapshot = this.snapshot(record);
+        if (!samePeerStateIgnoringLastSeen(before, snapshot)) {
+            this.emit();
+        }
+        return snapshot;
+    }
+    upsertDevice(device) {
+        return this.upsert({
+            deviceId: device.deviceId,
+            nodeId: device.nodeId,
+            ticket: device.ticket,
+            online: device.online,
+            deviceName: device.deviceName,
+            platformType: device.platformType,
+            status: device.online ? undefined : 'disconnected',
+            health: 'unknown',
+            lastSeenAt: typeof device.updatedAt === 'number'
+                ? device.updatedAt
+                : typeof device.lastSeenAt === 'number'
+                    ? device.lastSeenAt
+                    : Date.now(),
+        });
+    }
+    watch(callback) {
+        this.watchers.add(callback);
+        callback(this.list());
+        return () => {
+            this.watchers.delete(callback);
+        };
+    }
+    get(id) {
+        const alias = normalizeId(id);
+        const peerId = alias ? this.aliases.get(alias) : undefined;
+        const record = (peerId && this.peers.get(peerId)) || this.peers.get(id);
+        return record ? this.snapshot(record) : undefined;
+    }
+    list() {
+        return Array.from(this.peers.values())
+            .map((record) => this.snapshot(record))
+            .sort((a, b) => {
+            const aSeen = a.lastSeenAt ?? 0;
+            const bSeen = b.lastSeenAt ?? 0;
+            if (aSeen !== bSeen) {
+                return bSeen - aSeen;
+            }
+            return a.peerId.localeCompare(b.peerId);
+        });
+    }
+    listConnected() {
+        return this.list().filter((peer) => peer.status === 'connected');
+    }
+    addScope(id, scope = 'persistent') {
+        const record = this.resolveRecord(id);
+        if (!record)
+            return undefined;
+        const before = this.snapshot(record);
+        record.scopes.add(scope);
+        const snapshot = this.snapshot(record);
+        if (!samePeerStateIgnoringLastSeen(before, snapshot)) {
+            this.emit();
+        }
+        return snapshot;
+    }
+    releaseScope(id, scope) {
+        const record = this.resolveRecord(id);
+        if (!record)
+            return undefined;
+        const before = this.snapshot(record);
+        if (scope) {
+            record.scopes.delete(scope);
+        }
+        else {
+            record.scopes.clear();
+        }
+        const snapshot = this.snapshot(record);
+        if (!samePeerStateIgnoringLastSeen(before, snapshot)) {
+            this.emit();
+        }
+        return snapshot;
+    }
+    hasScope(id, scope) {
+        const record = this.resolveRecord(id);
+        return record?.scopes.has(scope) ?? false;
+    }
+    hasScopes(id) {
+        const record = this.resolveRecord(id);
+        return (record?.scopes.size ?? 0) > 0;
+    }
+    removeConnection(id) {
+        const record = this.resolveRecord(id);
+        if (!record)
+            return undefined;
+        const before = this.snapshot(record);
+        const connectionAlias = normalizeId(id);
+        if (connectionAlias) {
+            const directConnectionId = Array.from(record.connectionIds).find((candidate) => normalizeId(candidate) === connectionAlias);
+            if (directConnectionId) {
+                record.connectionIds.delete(directConnectionId);
+            }
+        }
+        if (record.connectionId && normalizeId(record.connectionId) === connectionAlias) {
+            record.connectionId = Array.from(record.connectionIds)[0];
+        }
+        if (record.connectionIds.size === 0 && record.status === 'connected') {
+            record.status = 'closed';
+            record.routable = false;
+            record.transportState = 'closed';
+            record.protocolState = 'closed';
+        }
+        const snapshot = this.snapshot(record);
+        if (!samePeerStateIgnoringLastSeen(before, snapshot)) {
+            this.emit();
+        }
+        return snapshot;
+    }
+    updateHealth(id, health, status) {
+        const record = this.resolveRecord(id);
+        if (!record)
+            return undefined;
+        const before = this.snapshot(record);
+        record.health = health;
+        if (status) {
+            record.status = status;
+        }
+        record.lastSeenAt = Date.now();
+        const snapshot = this.snapshot(record);
+        if (!samePeerStateIgnoringLastSeen(before, snapshot)) {
+            this.emit();
+        }
+        return snapshot;
+    }
+    resolveRecord(id) {
+        const alias = normalizeId(id);
+        const peerId = alias ? this.aliases.get(alias) : undefined;
+        return (peerId && this.peers.get(peerId)) || this.peers.get(id);
+    }
+}

package/dist/core/PeerProjectionStore.d.ts

@@ -0,0 +1,43 @@
+import type { Device, PeerHealth, PeerLifecycleStatus, PeerScope, PeerState } from './types';
+export type PeerProjectionUpsert = {
+    peerId?: string;
+    deviceId?: string;
+    deviceIdHint?: string;
+    nodeId?: string;
+    connectionId?: string;
+    ticket?: string;
+    online?: boolean;
+    deviceName?: string;
+    platformType?: string;
+    status?: PeerLifecycleStatus;
+    health?: PeerHealth;
+    transportState?: string;
+    protocolState?: string;
+    routable?: boolean;
+    promotionEligible?: boolean;
+    scopes?: Iterable<PeerScope>;
+    error?: string;
+    lastSeenAt?: number;
+};
+export declare class PeerProjectionStore {
+    private readonly peers;
+    private readonly aliases;
+    private readonly watchers;
+    private resolveCanonicalPeerId;
+    private setAlias;
+    private snapshot;
+    private emit;
+    private rekeyPeer;
+    upsert(input: PeerProjectionUpsert): PeerState;
+    upsertDevice(device: Device): PeerState;
+    watch(callback: (peers: PeerState[]) => void): () => void;
+    get(id: string): PeerState | undefined;
+    list(): PeerState[];
+    listConnected(): PeerState[];
+    addScope(id: string, scope?: PeerScope): PeerState | undefined;
+    releaseScope(id: string, scope?: PeerScope): PeerState | undefined;
+    hasScopes(id: string): boolean;
+    removeConnection(id: string): PeerState | undefined;
+    updateHealth(id: string, health: PeerHealth, status?: PeerLifecycleStatus): PeerState | undefined;
+    private resolveRecord;
+}

package/dist/core/PeerProjectionStore.js

@@ -0,0 +1,327 @@
+function normalizeId(value) {
+    if (!value)
+        return null;
+    const trimmed = value.trim();
+    return trimmed ? trimmed.toLowerCase() : null;
+}
+function choosePeerId(input) {
+    return (input.deviceId ||
+        input.deviceIdHint ||
+        input.nodeId ||
+        input.peerId ||
+        input.connectionId ||
+        null);
+}
+function sortedStrings(values) {
+    return [...values].sort();
+}
+function sameProjectionIgnoringLastSeen(left, right) {
+    if (!left) {
+        return false;
+    }
+    return left.peerId === right.peerId
+        && (left.deviceId ?? null) === (right.deviceId ?? null)
+        && (left.deviceIdHint ?? null) === (right.deviceIdHint ?? null)
+        && (left.nodeId ?? null) === (right.nodeId ?? null)
+        && (left.connectionId ?? null) === (right.connectionId ?? null)
+        && (left.ticket ?? null) === (right.ticket ?? null)
+        && !!left.online === !!right.online
+        && (left.deviceName ?? null) === (right.deviceName ?? null)
+        && (left.platformType ?? null) === (right.platformType ?? null)
+        && left.status === right.status
+        && left.health === right.health
+        && (left.transportState ?? null) === (right.transportState ?? null)
+        && (left.protocolState ?? null) === (right.protocolState ?? null)
+        && !!left.routable === !!right.routable
+        && (left.promotionEligible ?? true) === (right.promotionEligible ?? true)
+        && (left.error ?? null) === (right.error ?? null)
+        && JSON.stringify(sortedStrings(left.connectionIds)) === JSON.stringify(sortedStrings(right.connectionIds))
+        && JSON.stringify(sortedStrings(left.scopes)) === JSON.stringify(sortedStrings(right.scopes));
+}
+export class PeerProjectionStore {
+    constructor() {
+        this.peers = new Map();
+        this.aliases = new Map();
+        this.watchers = new Set();
+    }
+    resolveCanonicalPeerId(input) {
+        const candidates = [
+            input.deviceId,
+            input.deviceIdHint,
+            input.nodeId,
+            input.peerId,
+            input.connectionId,
+        ];
+        for (const candidate of candidates) {
+            const alias = normalizeId(candidate);
+            if (!alias)
+                continue;
+            const existing = this.aliases.get(alias);
+            if (existing)
+                return existing;
+        }
+        return choosePeerId(input);
+    }
+    setAlias(value, peerId) {
+        const alias = normalizeId(value);
+        if (!alias)
+            return;
+        this.aliases.set(alias, peerId);
+    }
+    snapshot(record) {
+        return {
+            peerId: record.peerId,
+            deviceId: record.deviceId,
+            deviceIdHint: record.deviceIdHint,
+            nodeId: record.nodeId,
+            connectionId: record.connectionId,
+            connectionIds: Array.from(record.connectionIds.values()),
+            ticket: record.ticket,
+            online: record.online,
+            deviceName: record.deviceName,
+            platformType: record.platformType,
+            status: record.status,
+            health: record.health,
+            transportState: record.transportState,
+            protocolState: record.protocolState,
+            routable: record.routable,
+            promotionEligible: record.promotionEligible,
+            scopes: Array.from(record.scopes.values()),
+            lastSeenAt: record.lastSeenAt,
+            error: record.error,
+        };
+    }
+    emit() {
+        const peers = this.list();
+        this.watchers.forEach((watcher) => watcher(peers));
+    }
+    rekeyPeer(existingPeerId, nextPeerId) {
+        const existing = this.peers.get(existingPeerId);
+        if (!existing) {
+            throw new Error(`Cannot rekey missing peer ${existingPeerId}`);
+        }
+        if (existingPeerId === nextPeerId) {
+            return existing;
+        }
+        this.peers.delete(existingPeerId);
+        existing.peerId = nextPeerId;
+        this.peers.set(nextPeerId, existing);
+        for (const [alias, peerId] of this.aliases.entries()) {
+            if (peerId === existingPeerId) {
+                this.aliases.set(alias, nextPeerId);
+            }
+        }
+        return existing;
+    }
+    upsert(input) {
+        const canonicalPeerId = this.resolveCanonicalPeerId(input) ?? choosePeerId(input);
+        if (!canonicalPeerId) {
+            throw new Error('Peer projection upsert requires at least one peer identifier.');
+        }
+        const preferredPeerId = choosePeerId(input) ?? canonicalPeerId;
+        let record = this.peers.get(canonicalPeerId);
+        const existed = !!record;
+        if (!record) {
+            record = {
+                peerId: canonicalPeerId,
+                connectionIds: new Set(),
+                status: input.status ?? 'disconnected',
+                health: input.health ?? 'unknown',
+                scopes: new Set(),
+            };
+            this.peers.set(canonicalPeerId, record);
+        }
+        const before = existed ? this.snapshot(record) : undefined;
+        if (preferredPeerId !== record.peerId) {
+            const nextPreferred = input.deviceId ||
+                record.deviceId ||
+                input.deviceIdHint ||
+                record.deviceIdHint ||
+                input.nodeId ||
+                record.nodeId ||
+                record.peerId;
+            if (nextPreferred && nextPreferred !== record.peerId) {
+                record = this.rekeyPeer(record.peerId, nextPreferred);
+            }
+        }
+        if (input.deviceId)
+            record.deviceId = input.deviceId;
+        if (input.deviceIdHint !== undefined)
+            record.deviceIdHint = input.deviceIdHint;
+        if (input.nodeId)
+            record.nodeId = input.nodeId;
+        if (input.connectionId) {
+            record.connectionId = input.connectionId;
+            record.connectionIds.add(input.connectionId);
+        }
+        if (input.ticket !== undefined)
+            record.ticket = input.ticket;
+        if (input.online !== undefined)
+            record.online = input.online;
+        if (input.deviceName !== undefined)
+            record.deviceName = input.deviceName;
+        if (input.platformType !== undefined)
+            record.platformType = input.platformType;
+        if (input.status) {
+            record.status = input.status;
+        }
+        if (input.health)
+            record.health = input.health;
+        if (input.transportState !== undefined)
+            record.transportState = input.transportState;
+        if (input.protocolState !== undefined)
+            record.protocolState = input.protocolState;
+        if (input.routable !== undefined)
+            record.routable = input.routable;
+        if (input.promotionEligible !== undefined)
+            record.promotionEligible = input.promotionEligible;
+        if (input.error !== undefined)
+            record.error = input.error;
+        if (input.lastSeenAt !== undefined)
+            record.lastSeenAt = input.lastSeenAt;
+        if (input.scopes) {
+            for (const scope of input.scopes) {
+                record.scopes.add(scope);
+            }
+        }
+        this.setAlias(record.peerId, record.peerId);
+        this.setAlias(record.deviceId, record.peerId);
+        this.setAlias(record.deviceIdHint, record.peerId);
+        this.setAlias(record.nodeId, record.peerId);
+        this.setAlias(record.connectionId, record.peerId);
+        for (const connectionId of record.connectionIds) {
+            this.setAlias(connectionId, record.peerId);
+        }
+        const snapshot = this.snapshot(record);
+        if (!sameProjectionIgnoringLastSeen(before, snapshot)) {
+            this.emit();
+        }
+        return snapshot;
+    }
+    upsertDevice(device) {
+        return this.upsert({
+            deviceId: device.deviceId,
+            nodeId: device.nodeId,
+            ticket: device.ticket,
+            online: device.online,
+            deviceName: device.deviceName,
+            platformType: device.platformType,
+            status: device.online ? undefined : 'disconnected',
+            health: 'unknown',
+            lastSeenAt: typeof device.updatedAt === 'number'
+                ? device.updatedAt
+                : typeof device.lastSeenAt === 'number'
+                    ? device.lastSeenAt
+                    : Date.now(),
+        });
+    }
+    watch(callback) {
+        this.watchers.add(callback);
+        callback(this.list());
+        return () => {
+            this.watchers.delete(callback);
+        };
+    }
+    get(id) {
+        const alias = normalizeId(id);
+        const peerId = alias ? this.aliases.get(alias) : undefined;
+        const record = (peerId && this.peers.get(peerId)) || this.peers.get(id);
+        return record ? this.snapshot(record) : undefined;
+    }
+    list() {
+        return Array.from(this.peers.values())
+            .map((record) => this.snapshot(record))
+            .sort((a, b) => {
+            const aSeen = a.lastSeenAt ?? 0;
+            const bSeen = b.lastSeenAt ?? 0;
+            if (aSeen !== bSeen) {
+                return bSeen - aSeen;
+            }
+            return a.peerId.localeCompare(b.peerId);
+        });
+    }
+    listConnected() {
+        return this.list().filter((peer) => peer.status === 'connected');
+    }
+    addScope(id, scope = 'persistent') {
+        const record = this.resolveRecord(id);
+        if (!record)
+            return undefined;
+        const before = this.snapshot(record);
+        record.scopes.add(scope);
+        const snapshot = this.snapshot(record);
+        if (!sameProjectionIgnoringLastSeen(before, snapshot)) {
+            this.emit();
+        }
+        return snapshot;
+    }
+    releaseScope(id, scope) {
+        const record = this.resolveRecord(id);
+        if (!record)
+            return undefined;
+        const before = this.snapshot(record);
+        if (scope) {
+            record.scopes.delete(scope);
+        }
+        else {
+            record.scopes.clear();
+        }
+        const snapshot = this.snapshot(record);
+        if (!sameProjectionIgnoringLastSeen(before, snapshot)) {
+            this.emit();
+        }
+        return snapshot;
+    }
+    hasScopes(id) {
+        const record = this.resolveRecord(id);
+        return (record?.scopes.size ?? 0) > 0;
+    }
+    removeConnection(id) {
+        const record = this.resolveRecord(id);
+        if (!record)
+            return undefined;
+        const before = this.snapshot(record);
+        const connectionAlias = normalizeId(id);
+        if (connectionAlias) {
+            const directConnectionId = Array.from(record.connectionIds).find((candidate) => normalizeId(candidate) === connectionAlias);
+            if (directConnectionId) {
+                record.connectionIds.delete(directConnectionId);
+            }
+        }
+        if (record.connectionId && normalizeId(record.connectionId) === connectionAlias) {
+            record.connectionId = Array.from(record.connectionIds)[0];
+        }
+        if (record.connectionIds.size === 0 && record.status === 'connected') {
+            record.status = 'closed';
+            record.routable = false;
+            record.transportState = 'closed';
+            record.protocolState = 'closed';
+        }
+        const snapshot = this.snapshot(record);
+        if (!sameProjectionIgnoringLastSeen(before, snapshot)) {
+            this.emit();
+        }
+        return snapshot;
+    }
+    updateHealth(id, health, status) {
+        const record = this.resolveRecord(id);
+        if (!record)
+            return undefined;
+        const before = this.snapshot(record);
+        record.health = health;
+        if (status) {
+            record.status = status;
+        }
+        record.lastSeenAt = Date.now();
+        const snapshot = this.snapshot(record);
+        if (!sameProjectionIgnoringLastSeen(before, snapshot)) {
+            this.emit();
+        }
+        return snapshot;
+    }
+    resolveRecord(id) {
+        const alias = normalizeId(id);
+        const peerId = alias ? this.aliases.get(alias) : undefined;
+        return (peerId && this.peers.get(peerId)) || this.peers.get(id);
+    }
+}