fauna-api 0.0.0-stage → 1.0.676

package/dist/src/integrations.js

@@ -0,0 +1,205 @@
+import { Fauna } from "../index.js";
+export var Platform;
+(function (Platform) {
+    Platform["GOOGLE"] = "GOOGLE";
+    Platform["SLACK"] = "SLACK";
+    Platform["DISCORD"] = "DISCORD";
+    Platform["TWILIO"] = "TWILIO";
+    Platform["MICROSOFT"] = "MICROSOFT";
+    Platform["WHATSAPP"] = "WHATSAPP";
+})(Platform || (Platform = {}));
+// One linked account on a platform. A user can link several accounts per
+// platform (e.g. two gmails). Tokens stay server-side and are never exposed.
+// Subclasses carry the platform specific surface (vars, calls).
+export class Account {
+    constructor(authorization, platform, raw) {
+        Object.defineProperty(this, "authorization", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "platform", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "authorized", {
+            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, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.authorization = authorization;
+        this.platform = platform;
+        this.authorized = raw.authorized;
+        this.createdAt = new Date(raw.createdAt);
+        this.id = raw.id;
+    }
+    async unlink() {
+        const response = await fetch(`${Fauna.getURL()}/integrations/accounts/${encodeURIComponent(this.id)}?platform=${encodeURIComponent(this.platform)}`, {
+            method: "DELETE",
+            headers: {
+                "Authorization": `Token ${this.authorization.token}`
+            }
+        });
+        if (!response.ok)
+            throw new Error(await response.text());
+    }
+}
+export class Google extends Account {
+    constructor(authorization, raw) {
+        super(authorization, Platform.GOOGLE, raw);
+        Object.defineProperty(this, "email", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "scopes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.email = raw.email;
+        this.scopes = raw.scopes;
+    }
+    async getDemographics() {
+        const response = await fetch(`${Fauna.getURL()}/integrations/google/youtube/demographics`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Token ${this.authorization.token}`
+            },
+            body: JSON.stringify({ accountId: this.id })
+        });
+        if (!response.ok)
+            throw new Error(await response.text());
+        return await response.json();
+    }
+}
+export class Slack extends Account {
+    constructor(authorization, raw) {
+        super(authorization, Platform.SLACK, raw);
+        Object.defineProperty(this, "email", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "scopes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.email = raw.email;
+        this.scopes = raw.scopes;
+    }
+}
+export class Discord extends Account {
+    constructor(authorization, raw) {
+        super(authorization, Platform.DISCORD, raw);
+        Object.defineProperty(this, "handle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.handle = raw.handle;
+    }
+}
+export class Twilio extends Account {
+    constructor(authorization, raw) {
+        super(authorization, Platform.TWILIO, raw);
+        Object.defineProperty(this, "phone", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.phone = raw.phone;
+    }
+}
+export class Microsoft extends Account {
+    constructor(authorization, raw) {
+        super(authorization, Platform.MICROSOFT, raw);
+        Object.defineProperty(this, "email", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "scopes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.email = raw.email;
+        this.scopes = raw.scopes;
+    }
+}
+export class WhatsApp extends Account {
+    constructor(authorization, raw) {
+        super(authorization, Platform.WHATSAPP, raw);
+        Object.defineProperty(this, "phone", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.phone = raw.phone;
+    }
+}
+function wrapAccount(authorization, platform, raw) {
+    switch (platform) {
+        case Platform.GOOGLE: return new Google(authorization, raw);
+        case Platform.SLACK: return new Slack(authorization, raw);
+        case Platform.DISCORD: return new Discord(authorization, raw);
+        case Platform.TWILIO: return new Twilio(authorization, raw);
+        case Platform.MICROSOFT: return new Microsoft(authorization, raw);
+        case Platform.WHATSAPP: return new WhatsApp(authorization, raw);
+    }
+}
+export async function linkPlatform(credentials, integration) {
+    const response = await fetch(`${Fauna.getURL()}/integrations/link`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Token ${credentials.token}`
+        },
+        body: JSON.stringify({ integration })
+    });
+    if (!response.ok) {
+        return null;
+    }
+    const { url } = await response.json();
+    return window.open(url, "_blank", "width=500,height=600");
+}
+export async function getAccounts(credentials) {
+    const response = await fetch(`${Fauna.getURL()}/integrations/accounts`, {
+        method: "GET",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    const json = await response.json();
+    return json.map((raw) => wrapAccount(credentials, raw.platform, raw));
+}

package/dist/src/magpie/explorer.d.ts

@@ -0,0 +1,14 @@
+import { Credentials, ApiKey } from "../authentification.js";
+import { Asset } from "./portfolio.js";
+export { ExplorerRoom } from "./room.js";
+export type Trend = [number, number, number, number];
+export type Explorer = {
+    ticker: string;
+    asset: Asset;
+    trends: Trend[];
+    horizontals: number[];
+    notifications: number[];
+};
+export declare function listExplorers(authorization: Credentials | ApiKey): Promise<Explorer[]>;
+export declare function getExplorer(authorization: Credentials | ApiKey, asset: Asset, ticker: string): Promise<Explorer>;
+export declare function setExplorer(authorization: Credentials | ApiKey, explorer: Explorer): Promise<void>;

package/dist/src/magpie/explorer.js

@@ -0,0 +1,36 @@
+import { Magpie } from "./index.js";
+export { ExplorerRoom } from "./room.js";
+export async function listExplorers(authorization) {
+    const response = await fetch(`${Magpie.getURL()}/magpie/explorers`, {
+        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();
+}
+export async function getExplorer(authorization, asset, ticker) {
+    const response = await fetch(`${Magpie.getURL()}/magpie/explorer/${encodeURIComponent(asset)}/${encodeURIComponent(ticker)}`, {
+        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();
+}
+export async function setExplorer(authorization, explorer) {
+    const response = await fetch(`${Magpie.getURL()}/magpie/explorer`, {
+        method: 'PUT',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ explorer })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+}

package/dist/src/magpie/index.d.ts

@@ -0,0 +1,16 @@
+import * as PortfolioAPI from "./portfolio.js";
+import * as QuotesAPI from "./quotes.js";
+import * as ExplorerAPI from "./explorer.js";
+import * as RoomAPI from "./room.js";
+export declare namespace Magpie {
+    function setRoute(route: string): void;
+    function getIP(): string;
+    function getPort(): number;
+    function getRoute(): string;
+    function getURL(): string;
+    function ping(): Promise<number>;
+    export import Portfolio = PortfolioAPI;
+    export import Quotes = QuotesAPI;
+    export import Explorer = ExplorerAPI;
+    export import Room = RoomAPI;
+}

package/dist/src/magpie/index.js

@@ -0,0 +1,61 @@
+import * as PortfolioAPI from "./portfolio.js";
+import * as QuotesAPI from "./quotes.js";
+import * as ExplorerAPI from "./explorer.js";
+import * as RoomAPI from "./room.js";
+export var Magpie;
+(function (Magpie) {
+    var PREFIX = 'https://';
+    var IP = 'api.faunakit.com';
+    var PORT = 443;
+    function setRoute(route) {
+        const parts_0 = route.split('//');
+        if (parts_0.length > 1) {
+            PREFIX = parts_0[0] + '//';
+            const parts_1 = parts_0[1].split(':');
+            if (parts_1.length > 1) {
+                IP = parts_1[0];
+                PORT = Number(parts_1[1]);
+            }
+            else {
+                IP = parts_1[0];
+            }
+        }
+        else {
+            const parts_1 = parts_0[0].split(':');
+            if (parts_1.length > 1) {
+                IP = parts_1[0];
+                PORT = Number(parts_1[1]);
+            }
+            else {
+                IP = parts_1[0];
+            }
+        }
+    }
+    Magpie.setRoute = setRoute;
+    function getIP() {
+        return IP;
+    }
+    Magpie.getIP = getIP;
+    function getPort() {
+        return PORT;
+    }
+    Magpie.getPort = getPort;
+    function getRoute() {
+        return IP + ':' + PORT;
+    }
+    Magpie.getRoute = getRoute;
+    function getURL() {
+        return PREFIX + IP + ':' + PORT;
+    }
+    Magpie.getURL = getURL;
+    async function ping() {
+        const start = Date.now();
+        await fetch(`${getURL()}/`);
+        return Date.now() - start;
+    }
+    Magpie.ping = ping;
+    Magpie.Portfolio = PortfolioAPI;
+    Magpie.Quotes = QuotesAPI;
+    Magpie.Explorer = ExplorerAPI;
+    Magpie.Room = RoomAPI;
+})(Magpie || (Magpie = {}));

package/dist/src/magpie/portfolio.d.ts

@@ -0,0 +1,52 @@
+import { Credentials, ApiKey } from "../authentification.js";
+import { Group } from "../groups.js";
+export { PortfolioRoom } from "./room.js";
+export type { PortfolioEntry } from "./room.js";
+export declare enum Asset {
+    EQUITY = "EQUITY",
+    CRYPTO = "CRYPTO",
+    MONEY_MARKET = "MONEY_MARKET",
+    OTHER = "OTHER"
+}
+export type Position = {
+    id: string;
+    asset: Asset;
+    symbol: string;
+    name: string;
+    quantity: number;
+    costBasis: number;
+    date: Date;
+    /** HTTPS URL Magpie pulls for OTHER quotes. Ignored for other assets. */
+    source?: string;
+};
+export type Holding = {
+    id: string;
+    name: string;
+    estimates: {
+        value: number;
+        date: Date;
+    }[];
+};
+export type Portfolio = {
+    id: string;
+    name: string;
+    profile: (Position | Holding)[];
+    created: Date;
+    lastModified: Date;
+};
+export type GroupOpts = {
+    group?: Group;
+};
+export declare function getPortfolios(authorization: Credentials | ApiKey, opts?: GroupOpts): Promise<Portfolio[]>;
+export declare function getPortfolio(authorization: Credentials | ApiKey, portfolioId: string, opts?: GroupOpts): Promise<Portfolio>;
+export declare function createPortfolio(authorization: Credentials | ApiKey, name: string, opts?: GroupOpts): Promise<string>;
+export declare function removePortfolio(authorization: Credentials | ApiKey, portfolioId: string, opts?: GroupOpts): Promise<void>;
+export declare function addPosition(authorization: Credentials | ApiKey, portfolioId: string, position: Omit<Position, 'id'>, opts?: GroupOpts): Promise<string>;
+export declare function updatePosition(authorization: Credentials | ApiKey, portfolioId: string, positionId: string, updates: Partial<Position>, opts?: GroupOpts): Promise<void>;
+export declare function removePosition(authorization: Credentials | ApiKey, portfolioId: string, positionId: string, opts?: GroupOpts): Promise<void>;
+export declare function addHolding(authorization: Credentials | ApiKey, portfolioId: string, holding: Omit<Holding, 'id'>, opts?: GroupOpts): Promise<string>;
+export declare function addEstimate(authorization: Credentials | ApiKey, portfolioId: string, holdingId: string, estimate: {
+    value: number;
+    date: Date;
+}, opts?: GroupOpts): Promise<void>;
+export declare function removeHolding(authorization: Credentials | ApiKey, portfolioId: string, holdingId: string, opts?: GroupOpts): Promise<void>;

package/dist/src/magpie/portfolio.js

@@ -0,0 +1,179 @@
+import { Magpie } from "./index.js";
+export { PortfolioRoom } from "./room.js";
+export var Asset;
+(function (Asset) {
+    Asset["EQUITY"] = "EQUITY";
+    Asset["CRYPTO"] = "CRYPTO";
+    Asset["MONEY_MARKET"] = "MONEY_MARKET";
+    Asset["OTHER"] = "OTHER";
+})(Asset || (Asset = {}));
+function wrapPosition(raw) {
+    return {
+        ...raw,
+        date: new Date(raw.date),
+        source: typeof raw.source === 'string' && raw.source ? raw.source : undefined,
+    };
+}
+function wrapHolding(raw) {
+    return {
+        ...raw,
+        estimates: (raw.estimates ?? []).map((e) => ({ value: e.value, date: new Date(e.date) }))
+    };
+}
+function wrapEntry(raw) {
+    if ('asset' in raw)
+        return wrapPosition(raw);
+    return wrapHolding(raw);
+}
+function wrapPortfolio(raw) {
+    return {
+        ...raw,
+        profile: (raw.profile ?? []).map(wrapEntry),
+        created: new Date(raw.created),
+        lastModified: new Date(raw.lastModified)
+    };
+}
+export async function getPortfolios(authorization, opts) {
+    const response = await fetch(`${Magpie.getURL()}/magpie/portfolios`, {
+        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 json.map(wrapPortfolio);
+}
+export async function getPortfolio(authorization, portfolioId, opts) {
+    const response = await fetch(`${Magpie.getURL()}/magpie/portfolios/${encodeURIComponent(portfolioId)}`, {
+        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 wrapPortfolio(await response.json());
+}
+export async function createPortfolio(authorization, name, opts) {
+    const response = await fetch(`${Magpie.getURL()}/magpie/portfolios`, {
+        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 })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    const json = await response.json();
+    return json.id;
+}
+export async function removePortfolio(authorization, portfolioId, opts) {
+    const response = await fetch(`${Magpie.getURL()}/magpie/portfolios/${encodeURIComponent(portfolioId)}`, {
+        method: 'DELETE',
+        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());
+}
+export async function addPosition(authorization, portfolioId, position, opts) {
+    const response = await fetch(`${Magpie.getURL()}/magpie/portfolios/${encodeURIComponent(portfolioId)}/positions`, {
+        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({
+            position: {
+                ...position,
+                date: position.date.toISOString()
+            }
+        })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    const json = await response.json();
+    return json.id;
+}
+export async function updatePosition(authorization, portfolioId, positionId, updates, opts) {
+    const serialized = { ...updates };
+    if (updates.date)
+        serialized.date = updates.date.toISOString();
+    const response = await fetch(`${Magpie.getURL()}/magpie/portfolios/${encodeURIComponent(portfolioId)}/positions/${encodeURIComponent(positionId)}`, {
+        method: 'PATCH',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`,
+            ...(opts?.group ? { Group: opts.group.id } : {}),
+        },
+        body: JSON.stringify({ updates: serialized })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+}
+export async function removePosition(authorization, portfolioId, positionId, opts) {
+    const response = await fetch(`${Magpie.getURL()}/magpie/portfolios/${encodeURIComponent(portfolioId)}/positions/${encodeURIComponent(positionId)}`, {
+        method: 'DELETE',
+        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());
+}
+export async function addHolding(authorization, portfolioId, holding, opts) {
+    const response = await fetch(`${Magpie.getURL()}/magpie/portfolios/${encodeURIComponent(portfolioId)}/holdings`, {
+        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({
+            holding: {
+                ...holding,
+                estimates: holding.estimates.map(e => ({ value: e.value, date: e.date.toISOString() }))
+            }
+        })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    const json = await response.json();
+    return json.id;
+}
+export async function addEstimate(authorization, portfolioId, holdingId, estimate, opts) {
+    const response = await fetch(`${Magpie.getURL()}/magpie/portfolios/${encodeURIComponent(portfolioId)}/holdings/${encodeURIComponent(holdingId)}/estimates`, {
+        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({
+            estimate: { value: estimate.value, date: estimate.date.toISOString() }
+        })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+}
+export async function removeHolding(authorization, portfolioId, holdingId, opts) {
+    const response = await fetch(`${Magpie.getURL()}/magpie/portfolios/${encodeURIComponent(portfolioId)}/holdings/${encodeURIComponent(holdingId)}`, {
+        method: 'DELETE',
+        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());
+}

package/dist/src/magpie/quotes.d.ts

@@ -0,0 +1,35 @@
+import { Credentials, ApiKey } from "../authentification.js";
+import { Asset } from "./portfolio.js";
+export type Quote = {
+    symbol: string;
+    asset: Asset;
+    price: number;
+    change: number;
+    changePercent: number;
+    marketCap?: number;
+    volume?: number;
+    timestamp: Date;
+};
+export type Price = {
+    date: Date;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+};
+export type SearchResult = {
+    symbol: string;
+    name: string;
+    asset: Asset;
+    exchange?: string;
+};
+export type Interval = '1d' | '1h' | '1wk' | '1mo';
+export type SourceOpts = {
+    source?: string;
+};
+export declare function quoteAsset(authorization: Credentials | ApiKey, asset: Asset, symbol: string, opts?: SourceOpts): Promise<Quote>;
+export declare function priceAsset(authorization: Credentials | ApiKey, asset: Asset, symbol: string, start: Date, end: Date, interval: Interval, opts?: SourceOpts): Promise<Price[]>;
+export declare function quoteSource(authorization: Credentials | ApiKey, url: string): Promise<Quote>;
+export declare function priceSource(authorization: Credentials | ApiKey, url: string, start: Date, end: Date, interval: Interval): Promise<Price[]>;
+export declare function search(authorization: Credentials | ApiKey, asset: Asset, query: string): Promise<SearchResult[]>;

package/dist/src/magpie/quotes.js

@@ -0,0 +1,47 @@
+import { Magpie } from "./index.js";
+import { Asset } from "./portfolio.js";
+function wrapQuote(raw) {
+    return { ...raw, timestamp: new Date(raw.timestamp) };
+}
+function wrapPrice(raw) {
+    return { ...raw, date: new Date(raw.date) };
+}
+export async function quoteAsset(authorization, asset, symbol, opts) {
+    const params = new URLSearchParams();
+    if (opts?.source)
+        params.set('source', opts.source);
+    const query = params.toString();
+    const response = await fetch(`${Magpie.getURL()}/magpie/quote/${encodeURIComponent(asset)}/${encodeURIComponent(symbol)}${query ? `?${query}` : ''}`, { method: 'GET', headers: { Authorization: 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}` } });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return wrapQuote(await response.json());
+}
+export async function priceAsset(authorization, asset, symbol, start, end, interval, opts) {
+    const params = new URLSearchParams({
+        start: start.toISOString(),
+        end: end.toISOString(),
+        interval,
+    });
+    if (opts?.source)
+        params.set('source', opts.source);
+    const response = await fetch(`${Magpie.getURL()}/magpie/price/${encodeURIComponent(asset)}/${encodeURIComponent(symbol)}?${params}`, { method: 'GET', headers: { Authorization: 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}` } });
+    if (!response.ok)
+        throw new Error(await response.text());
+    const json = await response.json();
+    return json.map(wrapPrice);
+}
+export async function quoteSource(authorization, url) {
+    return quoteAsset(authorization, Asset.OTHER, '_', { source: url });
+}
+export async function priceSource(authorization, url, start, end, interval) {
+    return priceAsset(authorization, Asset.OTHER, '_', start, end, interval, { source: url });
+}
+export async function search(authorization, asset, query) {
+    const response = await fetch(`${Magpie.getURL()}/magpie/search/${encodeURIComponent(asset)}?query=${encodeURIComponent(query)}`, {
+        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();
+}