fauna-api 0.0.0-stage → 1.0.676

package/dist/src/private/cards.css

@@ -0,0 +1,75 @@
+/* The card for links to another Fauna product. Sites theme it through --product-card-*. */
+.product-card {
+    position: fixed;
+    top: 0;
+    left: 0;
+    z-index: 1000;
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    width: max-content;
+    max-width: min(330px, calc(100vw - 24px));
+    padding: 12px 16px 12px 12px;
+    border: 1px solid var(--product-card-border, rgba(255, 255, 255, 0.1));
+    border-radius: var(--product-card-radius, 14px);
+    background: var(--product-card-background, #151515);
+    box-shadow: 0 20px 50px -20px rgba(0, 0, 0, 0.65);
+    color: var(--product-card-color, #f5f3ea);
+    font-family: var(--product-card-font, inherit);
+    font-size: 14px;
+    line-height: 1.35;
+    text-align: left;
+    pointer-events: none;
+    visibility: hidden;
+    opacity: 0;
+    transition: opacity 0.15s ease, visibility 0.15s;
+}
+.product-card.is-open {
+    visibility: visible;
+    opacity: 1;
+}
+.product-card-icon {
+    flex: none;
+    display: block;
+    width: 40px;
+    height: 40px;
+    border-radius: 26%;
+}
+.product-card-icon[hidden] {
+    display: none;
+}
+.product-card-crown {
+    background: #151515;
+    box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.08);
+}
+.product-card-text {
+    display: flex;
+    flex-direction: column;
+    min-width: 0;
+}
+.product-card-name {
+    font-size: 15px;
+    font-weight: 600;
+}
+.product-card-tagline {
+    color: var(--product-card-muted, rgba(245, 243, 234, 0.72));
+}
+.product-card-domain {
+    margin-top: 3px;
+    font-size: 12px;
+    color: var(--product-card-muted, rgba(245, 243, 234, 0.72));
+    opacity: 0.8;
+}
+
+/* Links to another product inside copy. */
+a.product-ref {
+    color: inherit;
+    text-decoration: underline;
+    text-decoration-thickness: 1px;
+    text-underline-offset: 0.18em;
+    text-decoration-color: color-mix(in srgb, currentColor 45%, transparent);
+    transition: text-decoration-color 0.2s;
+}
+a.product-ref:hover {
+    text-decoration-color: currentColor;
+}

package/dist/src/rooms.d.ts

@@ -0,0 +1,76 @@
+import { ApiKey, Credentials, Profile } from "./authentification.js";
+import { Presence, Room, Hooks as ServerHooks } from "./shared/server.js";
+/** What a member may do: `read` sees the state, `write` can also set it. */
+export type Role = 'read' | 'write';
+/** Who is in a room: every member of a group, or one person by email. */
+export type Member = ({
+    group: string;
+} | {
+    email: string;
+}) & {
+    role: Role;
+};
+/** A live room an app (or a person) owns. Everyone in it sees `state` change live. */
+export type LiveRoom = {
+    id: string;
+    name: string;
+    members: Member[];
+    /** Any JSON, up to 256 KB, always set whole. Fauna never reads it. */
+    state: unknown;
+    /** Goes up by one with every state change. */
+    version: number;
+    created: Date;
+    updated: Date;
+};
+/** What `create` takes. Every field is optional. */
+export type Draft = {
+    name?: string;
+    members?: Member[];
+    state?: unknown;
+};
+/** Someone in a room: their profile, and which of the room's groups they're in. */
+export type Person = {
+    profile: Profile;
+    groups: string[];
+};
+/** Room hooks, plus `onState` whenever someone changes the state. */
+export type Hooks = ServerHooks & Partial<{
+    onState(room: StateRoom, state: unknown, version: number): void;
+}>;
+/**
+ * Make a live room. Signed in with an API key, the key owns it; otherwise you do.
+ * Only the owner changes who is in it or deletes it.
+ */
+export declare function create(authorization: Credentials | ApiKey, draft?: Draft): Promise<LiveRoom>;
+/** A room you own or are a member of, with its state. */
+export declare function get(authorization: Credentials | ApiKey, id: string): Promise<LiveRoom>;
+/** Everyone in a room, each group's members listed. Anyone who can read the room. */
+export declare function people(authorization: Credentials | ApiKey, id: string): Promise<Person[]>;
+/** Replace who is in a room. Owner only. */
+export declare function setMembers(authorization: Credentials | ApiKey, id: string, members: Member[]): Promise<LiveRoom>;
+/**
+ * Replace a room's state; everyone in it sees the change. The owner and writers
+ * only. With `ifVersion`, it writes only while the room is still at that version.
+ * Resolves to the new version.
+ */
+export declare function setState(authorization: Credentials | ApiKey, id: string, state: unknown, ifVersion?: number): Promise<number>;
+/** Delete a room; everyone in it is disconnected. Owner only. */
+export declare function remove(authorization: Credentials | ApiKey, id: string): Promise<void>;
+/** A live room you are in: its state, kept current, and who else is here. */
+export declare class StateRoom extends Room {
+    name: string;
+    state: unknown;
+    version: number;
+    /** What you may do here. The owner writes. */
+    role: Role;
+    hydrate(snapshot: any): void;
+    handleEvent(packet: any): boolean;
+    /** Replace the state for everyone here. Writers only; with `ifVersion`, only while the room is at that version. */
+    setState(state: unknown, ifVersion?: number): void;
+    static connect(authorization: Credentials | ApiKey, target: {
+        id: string;
+    }, hooks?: Hooks): Promise<{
+        room: StateRoom;
+        self: Presence;
+    }>;
+}

package/dist/src/rooms.js

@@ -0,0 +1,168 @@
+import { Fauna } from "../index.js";
+import { Room, connect as connectServer } from "./shared/server.js";
+function hydrate(raw) {
+    return { ...raw, created: new Date(raw.created), updated: new Date(raw.updated) };
+}
+/**
+ * Make a live room. Signed in with an API key, the key owns it; otherwise you do.
+ * Only the owner changes who is in it or deletes it.
+ */
+export async function create(authorization, draft = {}) {
+    const response = await fetch(`${Fauna.getURL()}/rooms`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify(draft)
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return hydrate(await response.json());
+}
+/** A room you own or are a member of, with its state. */
+export async function get(authorization, id) {
+    const response = await fetch(`${Fauna.getURL()}/rooms/${encodeURIComponent(id)}`, {
+        method: "GET",
+        headers: {
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return hydrate(await response.json());
+}
+/** Everyone in a room, each group's members listed. Anyone who can read the room. */
+export async function people(authorization, id) {
+    const response = await fetch(`${Fauna.getURL()}/rooms/${encodeURIComponent(id)}/people`, {
+        method: "GET",
+        headers: {
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return await response.json();
+}
+/** Replace who is in a room. Owner only. */
+export async function setMembers(authorization, id, members) {
+    const response = await fetch(`${Fauna.getURL()}/rooms/${encodeURIComponent(id)}/members`, {
+        method: "PUT",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ members })
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return hydrate(await response.json());
+}
+/**
+ * Replace a room's state; everyone in it sees the change. The owner and writers
+ * only. With `ifVersion`, it writes only while the room is still at that version.
+ * Resolves to the new version.
+ */
+export async function setState(authorization, id, state, ifVersion) {
+    const response = await fetch(`${Fauna.getURL()}/rooms/${encodeURIComponent(id)}/state`, {
+        method: "PUT",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ state, ifVersion })
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return (await response.json()).version;
+}
+/** Delete a room; everyone in it is disconnected. Owner only. */
+export async function remove(authorization, id) {
+    const response = await fetch(`${Fauna.getURL()}/rooms/${encodeURIComponent(id)}`, {
+        method: "DELETE",
+        headers: {
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+}
+/** A live room you are in: its state, kept current, and who else is here. */
+export class StateRoom extends Room {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /** What you may do here. The owner writes. */
+        Object.defineProperty(this, "role", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'read'
+        });
+    }
+    hydrate(snapshot) {
+        if (!snapshot || typeof snapshot !== "object")
+            return;
+        this.name = snapshot.name ?? '';
+        this.state = snapshot.state ?? null;
+        this.version = Number(snapshot.version ?? 0);
+        this.role = snapshot.role === 'write' ? 'write' : 'read';
+    }
+    handleEvent(packet) {
+        if (packet?.event !== 'state')
+            return false;
+        this.state = packet.data?.state ?? null;
+        this.version = Number(packet.data?.version ?? this.version);
+        return true;
+    }
+    /** Replace the state for everyone here. Writers only; with `ifVersion`, only while the room is at that version. */
+    setState(state, ifVersion) {
+        this.post({ event: 'set-state', data: { state, ifVersion } });
+    }
+    static async connect(authorization, target, hooks) {
+        let room;
+        const user = hooks ?? {};
+        const self = await connectServer({ authorization, server: `fauna:live:${target.id}` }, `${Fauna.getURL()}/rooms/live`, {
+            ...user,
+            createRoom: (endpoint, ws, a, id, state) => {
+                room = (user.createRoom?.(endpoint, ws, a, id, state)
+                    ?? new StateRoom(endpoint, ws, a, id));
+                return room;
+            },
+            onConnection: (r, state) => {
+                r.hydrate(state);
+                user.onConnection?.(r, state);
+            },
+            onEvent: (r, packet) => {
+                const handled = r.handleEvent(packet);
+                if (handled)
+                    user.onState?.(r, r.state, r.version);
+                return user.onEvent?.(r, packet) ?? handled;
+            },
+        });
+        return { room, self };
+    }
+}

package/dist/src/shared/schema.d.ts

@@ -0,0 +1,24 @@
+export type Schema = ObjectSchema | ArraySchema | PrimitiveSchema;
+export type ObjectSchema = {
+    type: 'OBJECT';
+    description?: string;
+    anyOf?: Schema[];
+    properties?: Record<string, Schema>;
+    required?: string[];
+};
+export type ArraySchema = {
+    type: 'ARRAY';
+    description?: string;
+    anyOf?: Schema[];
+    items?: Schema;
+    maximum?: number;
+    minimum?: number;
+};
+export type PrimitiveSchema = {
+    type: 'STRING' | 'NUMBER' | 'INTEGER' | 'BOOLEAN';
+    description?: string;
+    minimum?: number;
+    maximum?: number;
+    pattern?: string;
+    enum?: string[];
+};

package/dist/src/shared/schema.js

@@ -0,0 +1 @@
+export {};

package/dist/src/shared/server.d.ts

@@ -0,0 +1,65 @@
+import { ApiKey, Credentials, Profile } from "../authentification.js";
+export type Authorization = {
+    authorization: Credentials | ApiKey;
+    server: string;
+    group?: string;
+} | {
+    authorization: Credentials | ApiKey;
+    accessCode: string;
+};
+export type Hooks = Partial<{
+    createRoom(endpoint: string, ws: WebSocket, authorization: Authorization, id: string, state: any): Room;
+    createPresence(room: Room, data: {
+        id: string;
+        profile: Profile;
+    } & Partial<{
+        position: [number, number, number];
+        status: string;
+    }>): Presence;
+    removePresence(room: Room, presence: Presence): void;
+    onConnection(room: Room, state: any): void;
+    onEvent(room: Room, packet: any): boolean;
+    /** Fired after the presence list changes (join / leave / update). */
+    onPresence(room: Room): void;
+    /** Room was destroyed (host left, empty reap, or TTL). Socket is closing. */
+    onClosed(room: Room, info?: {
+        reason?: string;
+    }): void;
+}>;
+export declare class Presence {
+    readonly room: Room;
+    readonly id: string;
+    readonly profile: Profile;
+    private _position;
+    private _status?;
+    constructor(room: Room, id: string, profile: Profile);
+    get position(): [number, number, number];
+    get status(): string;
+    move(position: [number, number, number]): void;
+    setStatus(status: string): void;
+    update(patch: Partial<{
+        position: [number, number, number];
+        status: string;
+    }>): void;
+    toJSON(): {
+        id: string;
+        profile: Profile;
+        position: [number, number, number];
+        status: string;
+    };
+}
+export declare class Room {
+    readonly endpoint: string;
+    readonly ws: WebSocket;
+    readonly authorization: Authorization;
+    readonly id: string;
+    protected presences: Presence[];
+    constructor(endpoint: string, ws: WebSocket, authorization: Authorization, id: string);
+    getPresences(): Presence[];
+    /** The caller's Credentials or ApiKey from the live authorization pack. */
+    getAuthorization(): Credentials | ApiKey;
+    post(packet: any): void;
+    disconnect(): void;
+    generateAccessCode(): Promise<string>;
+}
+export declare function connect(authorization: Authorization, endpoint: string, hooks?: Hooks): Promise<Presence>;