fauna-api 0.0.0-stage → 1.0.679

package/dist/src/termite/versioning.js

@@ -0,0 +1,217 @@
+import { File, parseStream } from "../drive.js";
+import { mimeFromFileName } from "../marmot/media.js";
+import { Termite } from "./index.js";
+export const Change = {
+    fromJSON(json) {
+        return {
+            revision: Number(json.revision),
+            ...(json.rollback ? { rollback: Number(json.rollback) } : {}),
+            head: String(json.head ?? ""),
+            lines: Array.isArray(json.lines) ? json.lines : [],
+            date: new Date(json.date),
+        };
+    },
+};
+/**
+ * A saved machine: a numbered, principal owned chain of disk revisions on the
+ * one Termite base image. `/repository` inside it is a git folder whose history
+ * is `changes()`. Start it with `OS.MachineRoom.start`.
+ */
+export class Repository {
+    constructor(authorization, row, group) {
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sizeBytes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "createdAt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "updatedAt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Its machine while one is booting, running, or saving. */
+        Object.defineProperty(this, "machine", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The group that owns it, when it isn't personal. */
+        Object.defineProperty(this, "group", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "authorization", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.authorization = authorization;
+        this.group = group;
+        this.id = row.id;
+        this.name = row.name;
+        this.sizeBytes = row.sizeBytes;
+        this.createdAt = row.createdAt;
+        this.updatedAt = row.updatedAt;
+        this.machine = row.machine;
+    }
+    static fromJSON(json, authorization, group) {
+        return new Repository(authorization, {
+            id: Number(json.id),
+            name: json.name ?? "",
+            sizeBytes: Number(json.sizeBytes ?? 0),
+            createdAt: new Date(json.createdAt),
+            updatedAt: new Date(json.updatedAt),
+            machine: json.machine ? { id: Number(json.machine.id), status: json.machine.status } : null,
+        }, group);
+    }
+    routes() {
+        throw new Error("Termite routes are not implemented.");
+    }
+    /** Revisions newest first. `cursor: 0` is the latest revision. */
+    async changes(query) {
+        const params = new URLSearchParams({ cursor: String(query.cursor), max: String(query.max) });
+        const response = await fetch(`${Termite.getURL()}/termite/repositories/${this.id}/changes?${params}`, {
+            method: "GET",
+            headers: {
+                Authorization: "email" in this.authorization ? `Token ${this.authorization.token}` : `ApiKey ${this.authorization.id}`,
+                ...(this.group ? { Group: this.group.id } : {}),
+            },
+        });
+        if (!response.ok)
+            throw new Error(await response.text());
+        const parsed = await parseStream(response);
+        const decoder = new TextDecoder();
+        return (Array.isArray(parsed) ? parsed : [parsed])
+            .filter((part) => part.length > 0)
+            .map((part) => Change.fromJSON(JSON.parse(decoder.decode(part))));
+    }
+    /** A folder gives one `File` per entry, a file gives its own `File`. Nothing downloads until asked. */
+    async open(path = '/') {
+        const tail = path.split('/').filter(Boolean).map(encodeURIComponent).join('/');
+        const response = await fetch(`${Termite.getURL()}/termite/repositories/${this.id}/files${tail ? `/${tail}` : ''}`, {
+            method: "GET",
+            headers: {
+                Authorization: "email" in this.authorization ? `Token ${this.authorization.token}` : `ApiKey ${this.authorization.id}`,
+                ...(this.group ? { Group: this.group.id } : {}),
+            },
+        });
+        if (!response.ok)
+            throw new Error(await response.text());
+        const json = await response.json();
+        return Array.isArray(json)
+            ? json.map((entry) => File.fromJSON(entry, { authorization: this.authorization, repository: this.id, path: entry.path, group: this.group?.id }))
+            : File.fromJSON(json, { authorization: this.authorization, repository: this.id, path: json.path, group: this.group?.id });
+    }
+    /** Create or overwrite a file under /repository, running or not. */
+    async write(path, data, onProgress) {
+        const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+        const name = path.split('/').filter(Boolean).pop() ?? "";
+        const now = new Date();
+        const file = new File({ authorization: this.authorization, repository: this.id, path, group: this.group?.id }, name, false, mimeFromFileName(name) || "application/octet-stream", bytes.length, now, now, bytes);
+        await file.upload(onProgress);
+        return file;
+    }
+    /** Record a new revision whose disk is exactly `revision`'s. Refused while a machine is live. */
+    async rollback(revision) {
+        const response = await fetch(`${Termite.getURL()}/termite/repositories/${this.id}/rollback`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: "email" in this.authorization ? `Token ${this.authorization.token}` : `ApiKey ${this.authorization.id}`,
+                ...(this.group ? { Group: this.group.id } : {}),
+            },
+            body: JSON.stringify({ revision }),
+        });
+        if (!response.ok)
+            throw new Error(await response.text());
+    }
+    /** Rename it. Returns the repository with its new name. */
+    async rename(name) {
+        const response = await fetch(`${Termite.getURL()}/termite/repositories/${this.id}`, {
+            method: "PATCH",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: "email" in this.authorization ? `Token ${this.authorization.token}` : `ApiKey ${this.authorization.id}`,
+                ...(this.group ? { Group: this.group.id } : {}),
+            },
+            body: JSON.stringify({ name }),
+        });
+        if (!response.ok)
+            throw new Error(await response.text());
+        return Repository.fromJSON(await response.json(), this.authorization, this.group);
+    }
+    async delete() {
+        const response = await fetch(`${Termite.getURL()}/termite/repositories/${this.id}`, {
+            method: "DELETE",
+            headers: {
+                Authorization: "email" in this.authorization ? `Token ${this.authorization.token}` : `ApiKey ${this.authorization.id}`,
+                ...(this.group ? { Group: this.group.id } : {}),
+            },
+        });
+        if (!response.ok)
+            throw new Error(await response.text());
+    }
+}
+export async function create(authorization, opts) {
+    const response = await fetch(`${Termite.getURL()}/termite/repositories`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: "email" in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`,
+            ...(opts?.group ? { Group: opts.group.id } : {}),
+        },
+        body: JSON.stringify({ name: opts?.name }),
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return Repository.fromJSON(await response.json(), authorization, opts?.group);
+}
+export async function get(authorization, id, opts) {
+    const response = await fetch(`${Termite.getURL()}/termite/repositories/${id}`, {
+        method: "GET",
+        headers: {
+            Authorization: "email" in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`,
+            ...(opts?.group ? { Group: opts.group.id } : {}),
+        },
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return Repository.fromJSON(await response.json(), authorization, opts?.group);
+}
+export async function list(authorization, opts) {
+    const response = await fetch(`${Termite.getURL()}/termite/repositories`, {
+        method: "GET",
+        headers: {
+            Authorization: "email" in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`,
+            ...(opts?.group ? { Group: opts.group.id } : {}),
+        },
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    const json = await response.json();
+    return (Array.isArray(json) ? json : []).map((row) => Repository.fromJSON(row, authorization, opts?.group));
+}

package/dist/src/tickets.d.ts

@@ -0,0 +1,43 @@
+import { Fauna } from "../index.js";
+import { ChatRoom, type RoomHooks } from "./parrot/room.js";
+import { LastMessage } from "./parrot/chat.js";
+import { Authorization, Presence, Room, Hooks as ServerHooks } from "./shared/server.js";
+export declare function ticketChatAutoEnabled(emails: Iterable<string>, reporter: string): boolean;
+export type TicketLast = LastMessage;
+export type Ticket = {
+    id: string;
+    title: string;
+    description: string;
+    source?: string;
+    reporter?: string;
+    roomReference?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    last: TicketLast | null;
+    unread: boolean;
+};
+export declare const Ticket: {
+    fromJSON(json: any): Ticket;
+};
+export declare class TicketRoom extends Room {
+    ticket: Ticket;
+    constructor(endpoint: string, ws: WebSocket, authorization: Authorization, id: string);
+    hydrate(state: any): void;
+    handleEvent(packet: any): boolean;
+    getChat(hooks?: RoomHooks): Promise<{
+        room: ChatRoom;
+        self: Presence;
+    }>;
+    static connect(authorization: Fauna.Authentification.Credentials, target: {
+        id: string;
+    }, hooks?: ServerHooks): Promise<{
+        room: TicketRoom;
+        self: Presence;
+    }>;
+}
+export declare function list(credentials: Fauna.Authentification.Credentials): Promise<Ticket[]>;
+export declare function create(credentials: Fauna.Authentification.Credentials, partial: {
+    title?: string;
+    source?: string;
+    description?: string;
+}): Promise<Ticket>;

package/dist/src/tickets.js

@@ -0,0 +1,138 @@
+import { Fauna } from "../index.js";
+import { connectRoom } from "./parrot/room.js";
+import { LastMessage } from "./parrot/chat.js";
+import { Room, connect as connectServer } from "./shared/server.js";
+export function ticketChatAutoEnabled(emails, reporter) {
+    const reporterEmail = reporter.trim().toLowerCase();
+    if (!reporterEmail)
+        return false;
+    let reporterPresent = false;
+    let otherPresent = false;
+    for (const raw of emails) {
+        const email = raw.trim().toLowerCase();
+        if (!email)
+            continue;
+        if (email === reporterEmail)
+            reporterPresent = true;
+        else
+            otherPresent = true;
+    }
+    return reporterPresent && !otherPresent;
+}
+export const Ticket = {
+    fromJSON(json) {
+        return {
+            id: String(json.id),
+            title: json.title ?? "",
+            description: json.description ?? "",
+            source: json.source || undefined,
+            reporter: json.reporter || undefined,
+            roomReference: json.roomReference || json.room_reference || undefined,
+            createdAt: new Date(json.createdAt ?? json.created_at),
+            updatedAt: new Date(json.updatedAt ?? json.updated_at),
+            last: LastMessage.fromJSON(json.last),
+            unread: Boolean(json.unread),
+        };
+    },
+};
+export class TicketRoom extends Room {
+    constructor(endpoint, ws, authorization, id) {
+        super(endpoint, ws, authorization, id);
+        Object.defineProperty(this, "ticket", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.ticket = {
+            id,
+            title: "",
+            description: "",
+            createdAt: new Date(0),
+            updatedAt: new Date(0),
+            last: null,
+            unread: false,
+        };
+    }
+    hydrate(state) {
+        if (state && typeof state === "object" && state.id != null) {
+            this.ticket = Ticket.fromJSON(state);
+        }
+    }
+    handleEvent(packet) {
+        const event = packet?.event;
+        if (event === "update-ticket" || event === "ticket") {
+            const data = packet.ticket ?? packet.data?.ticket ?? packet.data;
+            if (data && data.id != null)
+                this.ticket = Ticket.fromJSON(data);
+            return true;
+        }
+        return false;
+    }
+    async getChat(hooks) {
+        const auth = this.authorization;
+        const token = "email" in auth.authorization ? auth.authorization.token : undefined;
+        if (!token)
+            throw new Error("Ticket chat requires user credentials.");
+        const response = await fetch(`${Fauna.getURL()}/tickets/${encodeURIComponent(this.ticket.id)}/chat`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Token ${token}`,
+            },
+            body: JSON.stringify({}),
+        });
+        if (!response.ok)
+            throw new Error(await response.text());
+        const { chatId, reference } = await response.json();
+        if (!chatId && !reference)
+            throw new Error("Invalid ensure response.");
+        return connectRoom(auth.authorization, { reference: reference || `parrot:chat:${chatId}` }, hooks ?? {});
+    }
+    static async connect(authorization, target, hooks) {
+        let room;
+        const user = hooks ?? {};
+        const self = await connectServer({ authorization, server: `fauna:ticket:${target.id}` }, `${Fauna.getURL()}/tickets`, {
+            ...user,
+            createRoom: (endpoint, ws, a, id, state) => {
+                room = (user.createRoom?.(endpoint, ws, a, id, state)
+                    ?? new TicketRoom(endpoint, ws, a, id));
+                return room;
+            },
+            onConnection: (r, state) => {
+                r.hydrate(state);
+                user.onConnection?.(r, state);
+            },
+            onEvent: (r, packet) => {
+                const handled = r.handleEvent(packet);
+                return user.onEvent?.(r, packet) ?? handled;
+            },
+        });
+        return { room, self };
+    }
+}
+export async function list(credentials) {
+    const response = await fetch(`${Fauna.getURL()}/tickets`, {
+        method: "GET",
+        headers: {
+            Authorization: `Token ${credentials.token}`,
+        },
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    const rows = await response.json();
+    return (Array.isArray(rows) ? rows : []).map((row) => Ticket.fromJSON(row));
+}
+export async function create(credentials, partial) {
+    const response = await fetch(`${Fauna.getURL()}/tickets`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Token ${credentials.token}`,
+        },
+        body: JSON.stringify(partial),
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return Ticket.fromJSON(await response.json());
+}

package/dist/src/travel.d.ts

@@ -0,0 +1,85 @@
+import { Credentials, ApiKey } from "./authentification.js";
+import type { Group } from "./groups.js";
+import type { Coordinates, Money, Waypoint } from "./maps.js";
+export type Cabin = 'economy' | 'premium' | 'business' | 'first';
+/** One way flights between two airports (IATA codes, or several joined with commas) on a local date. */
+export type FlightQuery = {
+    from: string;
+    to: string;
+    /** YYYY-MM-DD. */
+    date: string;
+    adults?: number;
+    cabin?: Cabin;
+    currency?: string;
+    max?: number;
+};
+export type FlightStop = {
+    code: string;
+    name: string;
+};
+/** Times are local to each airport, YYYY-MM-DDTHH:mm. */
+export type FlightLeg = {
+    airline: string;
+    number: string;
+    from: FlightStop;
+    to: FlightStop;
+    departure: string;
+    arrival: string;
+    /** Seconds. */
+    duration: number;
+    aircraft?: string;
+    logo?: string;
+};
+export type Flight = {
+    id: string;
+    price: Money;
+    /** Seconds, layovers included. */
+    duration: number;
+    stops: number;
+    from: string;
+    to: string;
+    departure: string;
+    arrival: string;
+    airlines: string[];
+    logo?: string;
+    legs: FlightLeg[];
+};
+/** Somewhere to book. When `form` is set, POST it to `url` as a url encoded form instead of opening `url`. */
+export type Offer = {
+    seller: string;
+    price?: Money;
+    url: string;
+    form?: string;
+    logo?: string;
+};
+export type HotelSort = 'relevance' | 'price' | 'rating';
+export type HotelQuery = {
+    near: Waypoint;
+    /** YYYY-MM-DD. */
+    checkIn: string;
+    /** YYYY-MM-DD. */
+    checkOut: string;
+    adults?: number;
+    currency?: string;
+    max?: number;
+    sort?: HotelSort;
+};
+export type Hotel = {
+    id: string;
+    name: string;
+    address?: string;
+    coordinates?: Coordinates;
+    /** Out of 5. */
+    rating?: number;
+    reviews?: number;
+    stars?: number;
+    nightly?: Money;
+    total?: Money;
+    image?: string;
+    amenities: string[];
+    offers: Offer[];
+};
+export declare function searchFlights(authorization: Credentials | ApiKey, query: FlightQuery, group?: Group): Promise<Flight[]>;
+/** Where a flight can be booked, and for how much. */
+export declare function getOffers(authorization: Credentials | ApiKey, flight: Flight, group?: Group): Promise<Offer[]>;
+export declare function searchHotels(authorization: Credentials | ApiKey, query: HotelQuery, group?: Group): Promise<Hotel[]>;

package/dist/src/travel.js

@@ -0,0 +1,44 @@
+import { Fauna } from "../index.js";
+export async function searchFlights(authorization, query, group) {
+    const response = await fetch(`${Fauna.getURL()}/travel/flights`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`,
+            ...(group ? { "Group": group.id } : {})
+        },
+        body: JSON.stringify({ query })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return await response.json();
+}
+/** Where a flight can be booked, and for how much. */
+export async function getOffers(authorization, flight, group) {
+    const response = await fetch(`${Fauna.getURL()}/travel/flights/offers`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`,
+            ...(group ? { "Group": group.id } : {})
+        },
+        body: JSON.stringify({ id: flight.id })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return await response.json();
+}
+export async function searchHotels(authorization, query, group) {
+    const response = await fetch(`${Fauna.getURL()}/travel/hotels`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`,
+            ...(group ? { "Group": group.id } : {})
+        },
+        body: JSON.stringify({ query })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return await response.json();
+}

package/dist/src/ui/authentification.d.ts

@@ -0,0 +1,24 @@
+export declare function getToken(): string | undefined;
+export declare function setToken(token: string): void;
+export declare function clearToken(): void;
+/** Whether this tab is a support session opened from Fauna's ticket board. */
+export declare function isSupportView(): boolean;
+/**
+ * Takes `token` and `support` off a page's query. A support token stays in this tab; any other token
+ * becomes the login cookie and ends the tab's support session. Returns whether the query changed.
+ */
+export declare function takeTokenFromURL(params: URLSearchParams): boolean;
+/** The token this tab signs in with: the support session's in a support view, else the login cookie. */
+export declare function sessionToken(): string | undefined;
+export type OAuthProvider = 'google' | 'microsoft';
+export type OAuthButtonsInstance = {
+    getElement: () => HTMLElement;
+    destroy: () => void;
+};
+export declare function createOAuthButtons(container: HTMLElement, options?: Partial<{
+    providers: OAuthProvider[];
+    redirect: string;
+    label: string;
+    divider: boolean | string;
+    onError: (message: string) => void;
+}>): OAuthButtonsInstance;