@databob/sdk 0.0.0-stage → 0.0.2

package/dist/project.js

@@ -0,0 +1,283 @@
+// Finds, scaffolds, generates, and loads a databob project directory.
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { pathToFileURL } from "node:url";
+import { isMetric, projectProblems, randomToken, schemaToJson, } from "@databob/engine";
+export const SOURCE_DIR = "databob";
+export const STATE_DIR = ".databob";
+export function paths(root) {
+    const state = join(root, STATE_DIR);
+    return {
+        root,
+        source: join(root, SOURCE_DIR),
+        generated: join(root, SOURCE_DIR, "_generated"),
+        state,
+        data: join(state, "data"),
+        build: join(state, "build"),
+    };
+}
+function findEntry(dir, base) {
+    for (const extension of [".ts", ".mts", ".js", ".mjs"]) {
+        const file = join(dir, base + extension);
+        if (existsSync(file))
+            return file;
+    }
+    return null;
+}
+const SCHEMA_TEMPLATE = `import { defineSchema, event, v } from "@databob/sdk";
+
+export default defineSchema({
+  // Every event belongs to one of your customers (a workspace, a store, an org).
+  // Each tenant is stored on its own and can be shown its own analytics.
+  tenants: true,
+  events: {
+    pageview: event({ path: v.string() }),
+    signup: event({ plan: v.enum(["free", "pro"]) }),
+    purchase: event({ amount: v.number({ min: 0 }), plan: v.enum(["free", "pro"]) }),
+  },
+});
+`;
+const METRICS_TEMPLATE = `import { v } from "@databob/sdk";
+import { metric } from "./_generated/server";
+
+export const pageviews = metric({
+  description: "Pageviews and users per day",
+  args: { range: v.optional(v.range()) },
+  query: (q, { range }) => q.events("pageview").range(range ?? "30d").by("$day").count("views").users(),
+});
+
+export const topPages = metric({
+  description: "Most viewed pages",
+  args: { range: v.optional(v.range()) },
+  query: (q, { range }) => q.events("pageview").range(range ?? "7d").by("path").count("views").limit(10),
+});
+
+export const revenue = metric({
+  description: "Revenue by plan",
+  args: { range: v.optional(v.range()) },
+  query: (q, { range }) => q.events("purchase").range(range ?? "30d").by("plan").sum("amount", "revenue").count("orders"),
+});
+
+export const activation = metric({
+  description: "Signed up, then purchased within 7 days",
+  query: (q) => q.funnel("signup", "purchase").within("7d").range("30d"),
+});
+`;
+const README_TEMPLATE = `# databob
+
+This folder defines your analytics. \`npx databob dev\` watches it.
+
+- \`schema.ts\` lists every event and its properties. An event that is not here is refused.
+- \`metrics.ts\` holds named queries. Your server and your users' browsers read them by name.
+- \`_generated/\` is written by databob. Commit it, do not edit it.
+
+Track on the server:
+
+\`\`\`ts
+import { Databob } from "@databob/sdk/server";
+import type { Schema } from "./databob/_generated/server";
+
+const databob = new Databob<Schema>();
+await databob.track("signup", { plan: "pro" }, { tenant: org.id, user: user.id });
+\`\`\`
+
+Show a tenant its own numbers:
+
+\`\`\`ts
+// server: mint a token for one tenant
+const { token } = await databob.createToken({ tenant: org.id });
+\`\`\`
+
+\`\`\`tsx
+// browser
+import { DatabobProvider, useMetric } from "@databob/sdk/react";
+import { api } from "./databob/_generated/api";
+
+const { data } = useMetric(api.topPages, { range: "7d" }, { live: true });
+\`\`\`
+
+Rules databob enforces:
+
+- No personal data. Property names like \`email\` or \`ip\` are refused, and values that look like an email, IP address, phone number, or card number are refused.
+- User ids are stored as a keyed hash. \`databob.deleteUser(id)\` erases that user everywhere.
+- Queries are JSON compiled to SQL with bound values. Your query code never runs on the server.
+
+Agents: add the MCP server (\`claude mcp add databob -- npx databob mcp\`), or run \`npx databob describe\` for the schema and metrics as JSON, \`npx databob check\` to validate,
+and \`npx databob query <metric> --args '{"range":"7d"}' --tenant <id>\` to read data.
+`;
+const SERVER_GENERATED = `/* Generated by databob. Do not edit. */
+import schema from "../schema";
+import { metricFactory, queryRoot } from "@databob/sdk";
+
+export type Schema = typeof schema;
+
+// Define metrics with this so event names, properties, and rows are typed.
+export const metric = metricFactory(schema);
+
+// Build an ad hoc query with the same types.
+export const q = queryRoot(schema);
+`;
+const API_GENERATED = `/* Generated by databob. Do not edit. */
+import { makeApi } from "@databob/sdk";
+import type * as metrics from "../metrics";
+
+// Typed references to your metrics. Safe to import in the browser: it holds
+// names only, not query definitions.
+export const api = makeApi<typeof metrics>();
+`;
+// Ignores line endings, so a CRLF checkout (git autocrlf on Windows) does not
+// get its generated files rewritten on every run.
+function writeIfChanged(file, content) {
+    if (existsSync(file) && readFileSync(file, "utf8").replace(/\r\n/g, "\n") === content)
+        return false;
+    writeFileSync(file, content);
+    return true;
+}
+export function codegen(p) {
+    mkdirSync(p.generated, { recursive: true });
+    const written = [];
+    if (writeIfChanged(join(p.generated, "server.ts"), SERVER_GENERATED))
+        written.push("server.ts");
+    if (writeIfChanged(join(p.generated, "api.ts"), API_GENERATED))
+        written.push("api.ts");
+    return written;
+}
+export function scaffold(p) {
+    mkdirSync(p.source, { recursive: true });
+    const created = [];
+    const files = [
+        ["schema.ts", SCHEMA_TEMPLATE],
+        ["metrics.ts", METRICS_TEMPLATE],
+        ["README.md", README_TEMPLATE],
+    ];
+    for (const [name, content] of files) {
+        const file = join(p.source, name);
+        if (name !== "README.md" && findEntry(p.source, name.replace(/\.ts$/, "")))
+            continue;
+        if (existsSync(file))
+            continue;
+        writeFileSync(file, content);
+        created.push(relative(p.root, file));
+    }
+    codegen(p);
+    ignoreState(p);
+    return created;
+}
+function ignoreState(p) {
+    const file = join(p.root, ".gitignore");
+    const line = `${STATE_DIR}/`;
+    if (existsSync(file)) {
+        const content = readFileSync(file, "utf8");
+        if (content.split(/\r?\n/).some((entry) => entry.trim() === line || entry.trim() === STATE_DIR))
+            return;
+        appendFileSync(file, `${content.endsWith("\n") || content === "" ? "" : "\n"}${line}\n`);
+    }
+    else {
+        writeFileSync(file, `${line}\n`);
+    }
+}
+export class ProjectLoadError extends Error {
+}
+export async function loadProject(p) {
+    const schemaFile = findEntry(p.source, "schema");
+    if (!schemaFile)
+        throw new ProjectLoadError(`No ${SOURCE_DIR}/schema.ts. Run \`npx databob init\`.`);
+    const metricsFile = findEntry(p.source, "metrics");
+    codegen(p);
+    const { build } = await import("esbuild");
+    const entryPoints = { schema: schemaFile };
+    if (metricsFile)
+        entryPoints.metrics = metricsFile;
+    mkdirSync(p.build, { recursive: true });
+    try {
+        await build({
+            entryPoints,
+            outdir: p.build,
+            outExtension: { ".js": ".mjs" },
+            bundle: true,
+            platform: "node",
+            format: "esm",
+            packages: "external",
+            logLevel: "silent",
+            write: true,
+        });
+    }
+    catch (error) {
+        const errors = error.errors ?? [];
+        const details = errors.map((item) => (item.location ? `${item.location.file}:${item.location.line} ${item.text}` : item.text));
+        throw new ProjectLoadError(details.length > 0 ? details.join("\n") : String(error));
+    }
+    const stamp = `?v=${Date.now()}`;
+    let schemaModule;
+    try {
+        schemaModule = (await import(pathToFileURL(join(p.build, "schema.mjs")).href + stamp));
+    }
+    catch (error) {
+        throw new ProjectLoadError(`${SOURCE_DIR}/schema.ts: ${error instanceof Error ? error.message : error}`);
+    }
+    const schema = schemaModule.default;
+    if (!schema || schema.kind !== "schema") {
+        throw new ProjectLoadError(`${SOURCE_DIR}/schema.ts must \`export default defineSchema({ ... })\``);
+    }
+    const metrics = {};
+    if (metricsFile) {
+        let metricsModule;
+        try {
+            metricsModule = (await import(pathToFileURL(join(p.build, "metrics.mjs")).href + stamp));
+        }
+        catch (error) {
+            throw new ProjectLoadError(`${SOURCE_DIR}/metrics.ts: ${error instanceof Error ? error.message : error}`);
+        }
+        for (const [name, value] of Object.entries(metricsModule)) {
+            if (!isMetric(value))
+                continue;
+            const entry = { args: value.args, query: value.query };
+            if (value.description !== undefined)
+                entry.description = value.description;
+            metrics[name] = JSON.parse(JSON.stringify(entry));
+        }
+    }
+    const json = schemaToJson(schema);
+    return { schema: json, metrics, problems: projectProblems(json, metrics) };
+}
+export function devState(p) {
+    const file = join(p.state, "dev.json");
+    if (existsSync(file))
+        return JSON.parse(readFileSync(file, "utf8"));
+    mkdirSync(p.state, { recursive: true });
+    const state = {
+        projectId: "local",
+        secretKey: `dbsk_dev_${randomToken(24)}`,
+        signingKey: randomToken(32),
+        userKey: randomToken(32),
+    };
+    writeFileSync(file, `${JSON.stringify(state, null, 2)}\n`);
+    return state;
+}
+export function projectConfig(state, loaded) {
+    return {
+        id: state.projectId,
+        schema: loaded.schema,
+        metrics: loaded.metrics,
+        signingKey: state.signingKey,
+        userKey: state.userKey,
+    };
+}
+// Adds DATABOB_URL and DATABOB_SECRET_KEY to .env.local when they are missing.
+export function writeEnv(p, url, secretKey) {
+    const file = join(p.root, ".env.local");
+    const existing = existsSync(file) ? readFileSync(file, "utf8") : "";
+    const has = (name) => new RegExp(`^\\s*${name}\\s*=`, "m").test(existing);
+    const lines = [];
+    if (!has("DATABOB_URL"))
+        lines.push(`DATABOB_URL=${url}`);
+    if (!has("DATABOB_SECRET_KEY"))
+        lines.push(`DATABOB_SECRET_KEY=${secretKey}`);
+    if (!has("NEXT_PUBLIC_DATABOB_URL"))
+        lines.push(`NEXT_PUBLIC_DATABOB_URL=${url}`);
+    if (lines.length === 0)
+        return [];
+    const prefix = existing === "" || existing.endsWith("\n") ? "" : "\n";
+    appendFileSync(file, `${prefix}${lines.join("\n")}\n`);
+    return lines.map((line) => line.split("=")[0]);
+}

package/dist/react.d.ts

@@ -0,0 +1,27 @@
+import { type ReactNode } from "react";
+import type { MetricRef, RefArgs, RefResult } from "./api.js";
+type TokenSource = () => Promise<string>;
+export type DatabobProviderProps = {
+    url?: string;
+    token?: string;
+    fetchToken?: TokenSource;
+    children: ReactNode;
+};
+export declare function DatabobProvider({ url, token, fetchToken, children }: DatabobProviderProps): import("react").JSX.Element;
+export type MetricOptions = {
+    live?: boolean;
+    timeZone?: string;
+    compare?: "previous";
+    skip?: boolean;
+};
+export type MetricState<T> = {
+    data: T | undefined;
+    error: Error | undefined;
+    isLoading: boolean;
+};
+export declare class MetricError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare function useMetric<R extends MetricRef>(ref: R, args?: RefArgs<R>, options?: MetricOptions): MetricState<RefResult<R>>;
+export {};

package/dist/react.js

@@ -0,0 +1,133 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+// Read metrics in the browser with an embed token your backend mints.
+//
+//   <DatabobProvider url={process.env.NEXT_PUBLIC_DATABOB_URL} fetchToken={getToken}>
+//     <Dashboard />
+//   </DatabobProvider>
+//
+//   const { data } = useMetric(api.topPages, { range: "7d" }, { live: true });
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+const DatabobContext = createContext(null);
+export function DatabobProvider({ url, token, fetchToken, children }) {
+    const cached = useRef({ token: token ?? "", pending: null });
+    useEffect(() => {
+        if (token)
+            cached.current.token = token;
+    }, [token]);
+    const getToken = useCallback(async (refresh) => {
+        const state = cached.current;
+        if (!refresh && state.token)
+            return state.token;
+        if (!fetchToken) {
+            if (state.token)
+                return state.token;
+            throw new Error("DatabobProvider needs token or fetchToken");
+        }
+        if (!state.pending) {
+            state.pending = fetchToken().finally(() => {
+                state.pending = null;
+            });
+        }
+        state.token = await state.pending;
+        return state.token;
+    }, [fetchToken]);
+    const value = useMemo(() => ({ url: (url ?? "http://127.0.0.1:4100").replace(/\/+$/, ""), getToken }), [url, getToken]);
+    return _jsx(DatabobContext.Provider, { value: value, children: children });
+}
+export class MetricError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "MetricError";
+    }
+}
+function browserTimeZone() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+    }
+    catch {
+        return "UTC";
+    }
+}
+export function useMetric(ref, args, options = {}) {
+    const context = useContext(DatabobContext);
+    if (!context)
+        throw new Error("useMetric needs a <DatabobProvider> above it");
+    const [state, setState] = useState({ data: undefined, error: undefined, isLoading: !options.skip });
+    const timeZone = options.timeZone ?? browserTimeZone();
+    const key = JSON.stringify([ref.name, args ?? {}, timeZone, options.compare ?? null, options.live === true]);
+    useEffect(() => {
+        if (options.skip)
+            return;
+        let cancelled = false;
+        let source = null;
+        let retry = null;
+        const { url, getToken } = context;
+        const body = { args: args ?? {}, timeZone, ...(options.compare ? { compare: options.compare } : {}) };
+        setState((previous) => ({ ...previous, isLoading: previous.data === undefined }));
+        const fail = (error) => {
+            if (cancelled)
+                return;
+            setState((previous) => ({
+                ...previous,
+                error: error instanceof Error ? error : new Error(String(error)),
+                isLoading: false,
+            }));
+        };
+        const once = async (refresh = false) => {
+            const token = await getToken(refresh);
+            const response = await fetch(`${url}/v1/metrics/${ref.name}`, {
+                method: "POST",
+                headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+                body: JSON.stringify(body),
+            });
+            if (response.status === 401 && !refresh)
+                return once(true);
+            const data = (await response.json());
+            if (!response.ok)
+                throw new MetricError(data.error ?? "error", data.message ?? response.statusText);
+            if (!cancelled)
+                setState({ data: data, error: undefined, isLoading: false });
+        };
+        const subscribe = async (refresh = false) => {
+            const token = await getToken(refresh);
+            if (cancelled)
+                return;
+            const params = new URLSearchParams({ token, args: JSON.stringify(body.args), timeZone });
+            if (options.compare)
+                params.set("compare", options.compare);
+            source = new EventSource(`${url}/v1/metrics/${ref.name}/live?${params}`);
+            source.addEventListener("result", (event) => {
+                if (!cancelled)
+                    setState({ data: JSON.parse(event.data), error: undefined, isLoading: false });
+            });
+            source.addEventListener("failure", (event) => {
+                const parsed = JSON.parse(event.data);
+                fail(new MetricError(parsed.error ?? "error", parsed.message ?? "Live metric failed"));
+            });
+            // The browser retries a dropped stream by itself. A refused one (an
+            // expired token, a restart) closes, so reconnect with a fresh token.
+            source.addEventListener("error", () => {
+                if (cancelled || source?.readyState !== EventSource.CLOSED)
+                    return;
+                retry = setTimeout(() => void subscribe(true).catch(fail), 2000);
+            });
+            source.addEventListener("expired", () => {
+                source?.close();
+                void subscribe(true).catch(fail);
+            });
+        };
+        (options.live ? subscribe() : once()).catch(fail);
+        return () => {
+            cancelled = true;
+            if (retry)
+                clearTimeout(retry);
+            source?.close();
+        };
+        // `key` covers ref, args, and options.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [key, context, options.skip]);
+    return state;
+}

package/dist/server.d.ts

@@ -0,0 +1,63 @@
+import { type AnySchema, type Built, type EventNames, type EventProps, type QueryAst, type QueryResult, type QueryRoot, type ResultOf, type TrackResult } from "@databob/engine";
+import type { MetricRef, RefArgs, RefResult } from "./api.js";
+export declare const DEFAULT_URL = "http://127.0.0.1:4100";
+export type TrackContext = {
+    tenant?: string;
+    user?: string | number;
+    ts?: Date | number;
+    key?: string;
+};
+export type ReadOptions = {
+    tenant?: string;
+    timeZone?: string;
+    compare?: "previous";
+};
+export type DatabobOptions = {
+    url?: string;
+    secretKey?: string;
+    fetch?: typeof fetch;
+    strict?: boolean;
+};
+export declare class DatabobError extends Error {
+    readonly code: string;
+    readonly status: number;
+    readonly details?: unknown | undefined;
+    constructor(code: string, message: string, status: number, details?: unknown | undefined);
+}
+type PropsArgs<S extends AnySchema, E extends EventNames<S>> = {} extends EventProps<S, E> ? [props?: EventProps<S, E>, context?: TrackContext] : [props: EventProps<S, E>, context?: TrackContext];
+export type TrackInput<S extends AnySchema> = {
+    [E in EventNames<S>]: {
+        name: E;
+        props?: EventProps<S, E>;
+    } & TrackContext;
+}[EventNames<S>];
+export declare class Databob<S extends AnySchema = AnySchema> {
+    private readonly url;
+    private readonly secretKey;
+    private readonly fetchImpl;
+    private readonly strict;
+    constructor(options?: DatabobOptions);
+    private request;
+    track<E extends EventNames<S>>(name: E, ...[props, context]: PropsArgs<S, E>): Promise<TrackResult>;
+    trackMany(events: TrackInput<S>[]): Promise<TrackResult>;
+    metric<R extends MetricRef>(ref: R, args?: RefArgs<R>, options?: ReadOptions): Promise<RefResult<R>>;
+    query<B extends Built<unknown>>(build: (q: QueryRoot<S>) => B, options?: ReadOptions): Promise<ResultOf<B>>;
+    queryJson(query: QueryAst, options?: ReadOptions): Promise<QueryResult>;
+    createToken(options?: {
+        tenant?: string;
+        expiresIn?: number;
+        metrics?: MetricRef[];
+    }): Promise<{
+        token: string;
+        expiresAt: number;
+        tenant: string;
+    }>;
+    deleteUser(userId: string | number): Promise<{
+        erased: number;
+    }>;
+    deleteTenant(tenant: string): Promise<{
+        dropped: boolean;
+    }>;
+    describe(): Promise<unknown>;
+}
+export {};

package/dist/server.js

@@ -0,0 +1,130 @@
+// Server client. It holds the secret key, so never import it in the browser.
+//
+//   import { Databob } from "@databob/sdk/server";
+//   import type { Schema } from "./databob/_generated/server";
+//   const databob = new Databob<Schema>();
+//   await databob.track("signup", { plan: "pro" }, { tenant: org.id, user: user.id });
+import { queryRoot, } from "@databob/engine";
+export const DEFAULT_URL = "http://127.0.0.1:4100";
+export class DatabobError extends Error {
+    code;
+    status;
+    details;
+    constructor(code, message, status, details) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.details = details;
+        this.name = "DatabobError";
+    }
+}
+function env(name) {
+    const value = globalThis.process?.env?.[name];
+    return value === "" ? undefined : value;
+}
+export class Databob {
+    url;
+    secretKey;
+    fetchImpl;
+    strict;
+    constructor(options = {}) {
+        this.url = (options.url ?? env("DATABOB_URL") ?? DEFAULT_URL).replace(/\/+$/, "");
+        this.secretKey = options.secretKey ?? env("DATABOB_SECRET_KEY");
+        this.fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
+        this.strict = options.strict ?? env("NODE_ENV") !== "production";
+    }
+    async request(method, path, body, allowRejected = false) {
+        if (!this.secretKey) {
+            throw new DatabobError("unauthorized", "Set DATABOB_SECRET_KEY or pass secretKey. `npx databob dev` prints a local one.", 401);
+        }
+        const headers = { authorization: `Bearer ${this.secretKey}` };
+        const init = { method, headers };
+        if (body !== undefined) {
+            init.body = JSON.stringify(body);
+            headers["content-type"] = "application/json";
+        }
+        let response;
+        try {
+            response = await this.fetchImpl(`${this.url}${path}`, init);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            throw new DatabobError("network", `Could not reach databob at ${this.url} (${reason}). Is \`databob dev\` running?`, 0);
+        }
+        const text = await response.text();
+        let data = {};
+        try {
+            data = text ? JSON.parse(text) : {};
+        }
+        catch {
+            throw new DatabobError("bad_response", `databob answered ${response.status} with a body that is not JSON`, response.status);
+        }
+        const rejectedBatch = allowRejected && response.status === 400 && Array.isArray(data.rejected);
+        if (!response.ok && !rejectedBatch) {
+            const failure = data;
+            throw new DatabobError(failure.error ?? "error", failure.message ?? response.statusText, response.status, data);
+        }
+        return data;
+    }
+    async track(name, ...[props, context]) {
+        return this.trackMany([{ name, props, ...context }]);
+    }
+    async trackMany(events) {
+        const body = {
+            events: events.map(({ ts, props, ...rest }) => ({
+                ...rest,
+                ...(props === undefined ? {} : { props }),
+                ...(ts === undefined ? {} : { ts: ts instanceof Date ? ts.getTime() : ts }),
+            })),
+        };
+        try {
+            const result = await this.request("POST", "/v1/track", body, true);
+            if (result.rejected.length > 0) {
+                const first = result.rejected[0];
+                const message = `databob refused ${result.rejected.length} of ${events.length} event(s). First: ${first.message}`;
+                if (this.strict)
+                    throw new DatabobError(first.error, message, 400, result);
+                console.warn(message);
+            }
+            return result;
+        }
+        catch (error) {
+            if (this.strict)
+                throw error;
+            console.warn(error instanceof Error ? error.message : error);
+            return { accepted: 0, duplicates: 0, rejected: [] };
+        }
+    }
+    metric(ref, args, options = {}) {
+        return this.request("POST", `/v1/metrics/${ref.name}`, { args: args ?? {}, ...options });
+    }
+    // An ad hoc query, built with the same typed builder as metrics.
+    query(build, options = {}) {
+        return this.request("POST", "/v1/query", { query: build(queryRoot()).toJSON(), ...options });
+    }
+    // The same, from a JSON query (for example one an agent wrote).
+    queryJson(query, options = {}) {
+        return this.request("POST", "/v1/query", { query, ...options });
+    }
+    // A short-lived token your frontend uses to read one tenant's metrics.
+    createToken(options = {}) {
+        const body = {};
+        if (options.tenant !== undefined)
+            body.tenant = options.tenant;
+        if (options.expiresIn !== undefined)
+            body.expiresIn = options.expiresIn;
+        if (options.metrics)
+            body.metrics = options.metrics.map((metric) => metric.name);
+        return this.request("POST", "/v1/tokens", body);
+    }
+    // Deletes every event for this user id, in every tenant.
+    deleteUser(userId) {
+        return this.request("DELETE", `/v1/users/${encodeURIComponent(String(userId))}`);
+    }
+    deleteTenant(tenant) {
+        return this.request("DELETE", `/v1/tenants/${encodeURIComponent(tenant)}`);
+    }
+    describe() {
+        return this.request("GET", "/v1/describe");
+    }
+}