fauna-api 0.0.0-stage → 1.0.679

package/dist/src/friends.js

@@ -0,0 +1,119 @@
+import { Fauna } from "../index.js";
+import { LastMessage } from "./parrot/chat.js";
+function hydrateChats(raw) {
+    return (raw ?? []).map((row) => ({ ...row, human: row.human === true, locked: row.locked === true, last: LastMessage.fromJSON(row.last), unread: typeof row.unread === 'number' ? row.unread : 0 }));
+}
+function hydrate(raw) {
+    return { ...raw, chats: hydrateChats(raw.chats), created: new Date(raw.created) };
+}
+/** Your friends, each with your chats together and what you haven't read. An API key reads them too. */
+export async function list(authorization) {
+    const response = await fetch(`${Fauna.getURL()}/friends`, {
+        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()).map(hydrate);
+}
+/** Start a chat with someone by their Fauna email. The first chat makes you friends. */
+export async function startChat(credentials, email, name) {
+    const response = await fetch(`${Fauna.getURL()}/friends/chats`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Token ${credentials.token}`
+        },
+        body: JSON.stringify({ email, name })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    const raw = await response.json();
+    return { friend: hydrate(raw.friend), chat: raw.chat };
+}
+/** Another chat with a friend. Resolves to its id. */
+export async function createChat(credentials, friend, name) {
+    const response = await fetch(`${Fauna.getURL()}/friends/${encodeURIComponent(friend)}/chats`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Token ${credentials.token}`
+        },
+        body: JSON.stringify({ name })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return (await response.json()).id;
+}
+/** Delete a chat with a friend, for both of you. */
+export async function deleteChat(credentials, friend, chat) {
+    const response = await fetch(`${Fauna.getURL()}/friends/${encodeURIComponent(friend)}/chats/${encodeURIComponent(chat)}`, {
+        method: "DELETE",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+}
+/** Bring a hidden friend out of Hidden. */
+export async function show(credentials, friend) {
+    const response = await fetch(`${Fauna.getURL()}/friends/${encodeURIComponent(friend)}/show`, {
+        method: "POST",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return hydrate(await response.json());
+}
+/** End a friendship. Its chats and their files go with it, for both of you. */
+export async function end(credentials, friend) {
+    const response = await fetch(`${Fauna.getURL()}/friends/${encodeURIComponent(friend)}`, {
+        method: "DELETE",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+}
+export async function settings(credentials) {
+    const response = await fetch(`${Fauna.getURL()}/friends/settings`, {
+        method: "GET",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return await response.json();
+}
+export async function updateSettings(credentials, update) {
+    const response = await fetch(`${Fauna.getURL()}/friends/settings`, {
+        method: "PUT",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Token ${credentials.token}`
+        },
+        body: JSON.stringify(update)
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return await response.json();
+}
+/** Your own trust edges, strongest first. Nobody else can read them; your API keys can. */
+export async function trust(authorization) {
+    const response = await fetch(`${Fauna.getURL()}/friends/trust`, {
+        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();
+}

package/dist/src/groups.d.ts

@@ -0,0 +1,82 @@
+import { ApiKey, Credentials, Profile } from "./authentification.js";
+import { ChatSummary } from "./parrot/chat.js";
+export type Group = {
+    id: string;
+    name: string;
+    icon?: string;
+    balance: number;
+    members: Profile[];
+    createdAt: Date;
+};
+/** A group as someone outside it sees it: no balance, no member list. */
+export type GroupSummary = {
+    id: string;
+    name: string;
+    icon?: string;
+    memberCount: number;
+};
+/** A person found by `query`, with the groups they belong to. */
+export type GroupMatch = {
+    profile: Profile;
+    groups: GroupSummary[];
+};
+export declare function create(credentials: Credentials, name: string): Promise<Group>;
+export declare function list(authorization: Credentials | ApiKey): Promise<Group[]>;
+/** People matching a partial email or name, best first, each with their groups.
+ *  Only people in at least one group come back. */
+export declare function query(authorization: Credentials | ApiKey, profile: Partial<Profile>): Promise<GroupMatch[]>;
+/** Name, icon and member count of groups by id, including groups you are not in.
+ *  Unknown ids are left out. */
+export declare function summaries(authorization: Credentials | ApiKey, ids: string[]): Promise<GroupSummary[]>;
+export declare function get(authorization: Credentials | ApiKey, id: string): Promise<Group>;
+export declare function edit(credentials: Credentials, id: string, update: Partial<Group>): Promise<Group>;
+/** Add a user to a group by email. Resolves `{ status: 'added' }` if they were
+ *  added directly (they have a Fauna account), or `{ status: 'invited', token }`
+ *  if a pending invite was stored instead (no Fauna account for that email yet).
+ *  Fauna emails the invite unless `notify` is false, so an app can send its own
+ *  email carrying the token. */
+export declare function invite(credentials: Credentials, id: string, email: string, options?: {
+    notify?: boolean;
+}): Promise<{
+    status: 'added';
+} | {
+    status: 'invited';
+    token: string;
+}>;
+/** Join the group an email invite points at, using the token from the invite. */
+export declare function acceptInvite(credentials: Credentials, token: string): Promise<{
+    group: Group;
+    alreadyMember: boolean;
+}>;
+export declare function generateLink(credentials: Credentials, id: string): Promise<string>;
+export declare function join(credentials: Credentials, code: string): Promise<{
+    group: Group;
+    alreadyMember: boolean;
+}>;
+export declare function leave(credentials: Credentials, id: string): Promise<void>;
+export declare function kick(credentials: Credentials, id: string, email: string): Promise<void>;
+/** Two groups with people only chats between them. `group` is the one of yours it was listed for. */
+export type Partnership = {
+    id: string;
+    group: string;
+    partner: GroupSummary;
+    /** Under Hidden: the partner started at no trust while you hide strangers, and your group hasn't engaged. */
+    hidden: boolean;
+    chats: ChatSummary[];
+    created: Date;
+};
+/** A group's partnerships, each with their chats and what you haven't read. An API key reads them too. */
+export declare function listPartnerships(authorization: Credentials | ApiKey, id: string): Promise<Partnership[]>;
+/** Start a chat between your group `id` and `partner`. The first chat partners the groups. */
+export declare function startPartnershipChat(credentials: Credentials, id: string, partner: string, name?: string): Promise<{
+    partnership: Partnership;
+    chat: string;
+}>;
+/** Another chat in a partnership. Resolves to its id. */
+export declare function createPartnershipChat(credentials: Credentials, partnership: string, name?: string): Promise<string>;
+/** Delete a partnership chat, for both groups. */
+export declare function deletePartnershipChat(credentials: Credentials, partnership: string, chat: string): Promise<void>;
+/** Bring a hidden partnership out of Hidden for your group. */
+export declare function showPartnership(credentials: Credentials, partnership: string): Promise<Partnership>;
+/** End a partnership. Its chats and their files go with it, for both groups. */
+export declare function endPartnership(credentials: Credentials, partnership: string): Promise<void>;

package/dist/src/groups.js

@@ -0,0 +1,269 @@
+import { Fauna } from "../index.js";
+import { LastMessage } from "./parrot/chat.js";
+export async function create(credentials, name) {
+    const response = await fetch(`${Fauna.getURL()}/groups`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Token ${credentials.token}`
+        },
+        body: JSON.stringify({ name })
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    const raw = await response.json();
+    return { ...raw, createdAt: new Date(raw.createdAt) };
+}
+export async function list(authorization) {
+    const response = await fetch(`${Fauna.getURL()}/groups`, {
+        method: "GET",
+        headers: {
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    const raw = await response.json();
+    return raw.map((group) => ({ ...group, createdAt: new Date(group.createdAt) }));
+}
+/** People matching a partial email or name, best first, each with their groups.
+ *  Only people in at least one group come back. */
+export async function query(authorization, profile) {
+    const response = await fetch(`${Fauna.getURL()}/groups/query`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ email: profile.email, displayName: profile.displayName })
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return await response.json();
+}
+/** Name, icon and member count of groups by id, including groups you are not in.
+ *  Unknown ids are left out. */
+export async function summaries(authorization, ids) {
+    const response = await fetch(`${Fauna.getURL()}/groups/summaries`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ ids })
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return await response.json();
+}
+export async function get(authorization, id) {
+    const response = await fetch(`${Fauna.getURL()}/groups/${encodeURIComponent(id)}`, {
+        method: "GET",
+        headers: {
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    const raw = await response.json();
+    return { ...raw, createdAt: new Date(raw.createdAt) };
+}
+export async function edit(credentials, id, update) {
+    const response = await fetch(`${Fauna.getURL()}/groups/${encodeURIComponent(id)}`, {
+        method: "PATCH",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Token ${credentials.token}`
+        },
+        body: JSON.stringify({ update })
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    const raw = await response.json();
+    return { ...raw, createdAt: new Date(raw.createdAt) };
+}
+/** Add a user to a group by email. Resolves `{ status: 'added' }` if they were
+ *  added directly (they have a Fauna account), or `{ status: 'invited', token }`
+ *  if a pending invite was stored instead (no Fauna account for that email yet).
+ *  Fauna emails the invite unless `notify` is false, so an app can send its own
+ *  email carrying the token. */
+export async function invite(credentials, id, email, options = {}) {
+    const response = await fetch(`${Fauna.getURL()}/groups/${encodeURIComponent(id)}/invite`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Token ${credentials.token}`
+        },
+        body: JSON.stringify({ email, notify: options.notify })
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return await response.json();
+}
+/** Join the group an email invite points at, using the token from the invite. */
+export async function acceptInvite(credentials, token) {
+    const response = await fetch(`${Fauna.getURL()}/groups/invites/accept`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Token ${credentials.token}`
+        },
+        body: JSON.stringify({ token })
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    const raw = await response.json();
+    return {
+        group: { ...raw.group, createdAt: new Date(raw.group.createdAt) },
+        alreadyMember: raw.alreadyMember
+    };
+}
+export async function generateLink(credentials, id) {
+    const response = await fetch(`${Fauna.getURL()}/groups/${encodeURIComponent(id)}/link`, {
+        method: "POST",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    const json = await response.json();
+    return json.code;
+}
+export async function join(credentials, code) {
+    const response = await fetch(`${Fauna.getURL()}/groups/join`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Token ${credentials.token}`
+        },
+        body: JSON.stringify({ code })
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    const raw = await response.json();
+    return {
+        group: { ...raw.group, createdAt: new Date(raw.group.createdAt) },
+        alreadyMember: raw.alreadyMember
+    };
+}
+export async function leave(credentials, id) {
+    const response = await fetch(`${Fauna.getURL()}/groups/${encodeURIComponent(id)}/membership`, {
+        method: "DELETE",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+}
+export async function kick(credentials, id, email) {
+    const response = await fetch(`${Fauna.getURL()}/groups/${encodeURIComponent(id)}/members/${encodeURIComponent(email)}`, {
+        method: "DELETE",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+}
+function hydratePartnership(raw) {
+    return {
+        ...raw,
+        chats: (raw.chats ?? []).map((row) => ({ ...row, human: row.human === true, locked: row.locked === true, last: LastMessage.fromJSON(row.last), unread: typeof row.unread === 'number' ? row.unread : 0 })),
+        created: new Date(raw.created),
+    };
+}
+/** A group's partnerships, each with their chats and what you haven't read. An API key reads them too. */
+export async function listPartnerships(authorization, id) {
+    const response = await fetch(`${Fauna.getURL()}/groups/${encodeURIComponent(id)}/partnerships`, {
+        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()).map(hydratePartnership);
+}
+/** Start a chat between your group `id` and `partner`. The first chat partners the groups. */
+export async function startPartnershipChat(credentials, id, partner, name) {
+    const response = await fetch(`${Fauna.getURL()}/groups/${encodeURIComponent(id)}/partnerships`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Token ${credentials.token}`
+        },
+        body: JSON.stringify({ partner, name })
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    const raw = await response.json();
+    return { partnership: hydratePartnership(raw.partnership), chat: raw.chat };
+}
+/** Another chat in a partnership. Resolves to its id. */
+export async function createPartnershipChat(credentials, partnership, name) {
+    const response = await fetch(`${Fauna.getURL()}/partnerships/${encodeURIComponent(partnership)}/chats`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Token ${credentials.token}`
+        },
+        body: JSON.stringify({ name })
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return (await response.json()).id;
+}
+/** Delete a partnership chat, for both groups. */
+export async function deletePartnershipChat(credentials, partnership, chat) {
+    const response = await fetch(`${Fauna.getURL()}/partnerships/${encodeURIComponent(partnership)}/chats/${encodeURIComponent(chat)}`, {
+        method: "DELETE",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+}
+/** Bring a hidden partnership out of Hidden for your group. */
+export async function showPartnership(credentials, partnership) {
+    const response = await fetch(`${Fauna.getURL()}/partnerships/${encodeURIComponent(partnership)}/show`, {
+        method: "POST",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return hydratePartnership(await response.json());
+}
+/** End a partnership. Its chats and their files go with it, for both groups. */
+export async function endPartnership(credentials, partnership) {
+    const response = await fetch(`${Fauna.getURL()}/partnerships/${encodeURIComponent(partnership)}`, {
+        method: "DELETE",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+}

package/dist/src/inbox.d.ts

@@ -0,0 +1,11 @@
+import { Credentials } from "./authentification.js";
+export type Message = {
+    id: string;
+    icon: string;
+    header: string;
+    content: string;
+    href?: string;
+};
+export declare function read(credentials: Credentials): Promise<Message[]>;
+export declare function remove(credentials: Credentials, id: string): Promise<void>;
+export declare function clear(credentials: Credentials): Promise<void>;

package/dist/src/inbox.js

@@ -0,0 +1,35 @@
+import { Fauna } from "../index.js";
+export async function read(credentials) {
+    const response = await fetch(`${Fauna.getURL()}/inbox`, {
+        method: "GET",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return await response.json();
+}
+export async function remove(credentials, id) {
+    const response = await fetch(`${Fauna.getURL()}/inbox/${encodeURIComponent(id)}`, {
+        method: "DELETE",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+}
+export async function clear(credentials) {
+    const response = await fetch(`${Fauna.getURL()}/inbox`, {
+        method: "DELETE",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+}

package/dist/src/integrations.d.ts

@@ -0,0 +1,52 @@
+import { Credentials } from "./authentification.js";
+export declare enum Platform {
+    GOOGLE = "GOOGLE",
+    SLACK = "SLACK",
+    DISCORD = "DISCORD",
+    TWILIO = "TWILIO",
+    MICROSOFT = "MICROSOFT",
+    WHATSAPP = "WHATSAPP"
+}
+export declare abstract class Account {
+    readonly authorization: Credentials;
+    readonly platform: Platform;
+    readonly authorized: boolean;
+    readonly createdAt: Date;
+    readonly id: string;
+    constructor(authorization: Credentials, platform: Platform, raw: any);
+    unlink(): Promise<void>;
+}
+export declare class Google extends Account {
+    readonly email: string;
+    readonly scopes: string[];
+    constructor(authorization: Credentials, raw: any);
+    getDemographics(): Promise<{
+        ageRange: [number, number];
+        gender: string;
+        percentage: number;
+    }[]>;
+}
+export declare class Slack extends Account {
+    readonly email: string;
+    readonly scopes: string[];
+    constructor(authorization: Credentials, raw: any);
+}
+export declare class Discord extends Account {
+    readonly handle: string;
+    constructor(authorization: Credentials, raw: any);
+}
+export declare class Twilio extends Account {
+    readonly phone: string;
+    constructor(authorization: Credentials, raw: any);
+}
+export declare class Microsoft extends Account {
+    readonly email: string;
+    readonly scopes: string[];
+    constructor(authorization: Credentials, raw: any);
+}
+export declare class WhatsApp extends Account {
+    readonly phone: string;
+    constructor(authorization: Credentials, raw: any);
+}
+export declare function linkPlatform(credentials: Credentials, integration: Platform): Promise<WindowProxy | null>;
+export declare function getAccounts(credentials: Credentials): Promise<Account[]>;