@dooc-dev/dooc 0.0.0-stage → 0.0.1

package/dist/plugins/actions.js

@@ -0,0 +1,125 @@
+import { PluginError } from "./oauth.js";
+export const validatePluginActions = (input) => {
+    if (new TextEncoder().encode(JSON.stringify(input)).length > 2 * 1024 * 1024 ||
+        !Array.isArray(input) ||
+        input.length > 500)
+        throw new Error("Invalid plugin actions");
+    const ids = new Set();
+    const string = (v) => typeof v === "string" && v.length <= 60_000;
+    const optionalBoolean = (v) => v === undefined || typeof v === "boolean";
+    for (const action of input) {
+        if (!action ||
+            !string(action.id) ||
+            !action.id ||
+            ids.has(action.id) ||
+            !string(action.label) ||
+            !string(action.target) ||
+            !Array.isArray(action.fields) ||
+            action.fields.length > 40 ||
+            !optionalBoolean(action.destructive) ||
+            !optionalBoolean(action.confirm) ||
+            !optionalBoolean(action.partial) ||
+            (action.version !== undefined && !string(action.version)))
+            throw new Error("Invalid plugin actions");
+        ids.add(action.id);
+        const names = new Set();
+        for (const field of action.fields) {
+            if (!field ||
+                !string(field.name) ||
+                !/^[a-zA-Z][\w.:-]{0,199}$/.test(field.name) ||
+                names.has(field.name) ||
+                !string(field.label) ||
+                !["text", "textarea", "select", "multiselect", "date", "number"].includes(field.type) ||
+                !optionalBoolean(field.required) ||
+                (field.value !== undefined && !string(field.value)) ||
+                (field.maxLength !== undefined &&
+                    (!Number.isInteger(field.maxLength) ||
+                        field.maxLength < 1 ||
+                        field.maxLength > 60_000)) ||
+                [field.min, field.max].some((v) => v !== undefined && (typeof v !== "number" || !Number.isFinite(v))) ||
+                (field.min !== undefined && field.max !== undefined && field.min > field.max) ||
+                (["select", "multiselect"].includes(field.type) &&
+                    (!Array.isArray(field.options) ||
+                        field.options.length > 1000 ||
+                        field.options.some((o) => !o || !string(o.value) || !string(o.label)))))
+                throw new Error("Invalid plugin action field");
+            if (field.type === "multiselect" && field.value !== undefined) {
+                let values;
+                try {
+                    values = JSON.parse(field.value);
+                }
+                catch {
+                    throw new Error("Invalid plugin action selection");
+                }
+                if (!Array.isArray(values) || values.some((v) => typeof v !== "string"))
+                    throw new Error("Invalid plugin action selection");
+            }
+            names.add(field.name);
+        }
+    }
+    return input;
+};
+export const validatePluginActionRequest = (input) => {
+    const request = input;
+    if (!request ||
+        typeof request.id !== "string" ||
+        !request.id ||
+        request.id.length > 1000 ||
+        !request.values ||
+        typeof request.values !== "object" ||
+        Array.isArray(request.values) ||
+        Object.keys(request.values).length > 40 ||
+        Object.values(request.values).some((v) => typeof v !== "string" || v.length > 60_000) ||
+        (request.version !== undefined &&
+            (typeof request.version !== "string" || request.version.length > 1000)) ||
+        (request.confirmed !== undefined && typeof request.confirmed !== "boolean"))
+        throw new PluginError(400, "Invalid plugin operation");
+    return request;
+};
+export const validatePluginActionValues = (action, input) => {
+    if ((action.destructive || action.confirm) && input.confirmed !== true)
+        throw new PluginError(400, "Confirm the operation target");
+    if (action.version !== undefined && input.version !== action.version)
+        throw new PluginError(409, "Content changed. Reload before saving.");
+    if (Object.keys(input.values).some((key) => !action.fields.some((field) => field.name === key)) ||
+        (action.partial && !Object.keys(input.values).length))
+        throw new PluginError(400, "Invalid operation fields");
+    for (const field of action.fields) {
+        if (action.partial && !Object.hasOwn(input.values, field.name))
+            continue;
+        const value = input.values[field.name] ?? "";
+        const invalid = () => {
+            throw new PluginError(400, `Invalid value: ${field.label}`);
+        };
+        if (value.length > (field.maxLength ?? 4000) || (field.required && !value.trim()))
+            invalid();
+        if (field.type === "select" && !field.options?.some((o) => o.value === value))
+            invalid();
+        if (field.type === "multiselect") {
+            let selected;
+            try {
+                selected = JSON.parse(value);
+            }
+            catch {
+                invalid();
+            }
+            if (!Array.isArray(selected) ||
+                (field.required && !selected.length) ||
+                new Set(selected).size !== selected.length ||
+                selected.some((v) => !field.options?.some((o) => o.value === v)))
+                invalid();
+        }
+        if (value &&
+            field.type === "date" &&
+            (!/^\d{4}-\d{2}-\d{2}$/.test(value) ||
+                !Number.isFinite(Date.parse(value)) ||
+                new Date(value).toISOString().slice(0, 10) !== value))
+            invalid();
+        if (value &&
+            field.type === "number" &&
+            (!Number.isFinite(Number(value)) ||
+                Number(value) < (field.min ?? -Infinity) ||
+                Number(value) > (field.max ?? Infinity)))
+            invalid();
+    }
+};

package/dist/plugins/blocks.d.ts

@@ -0,0 +1,92 @@
+export type PluginTone = "neutral" | "accent" | "success" | "warning" | "danger";
+export type PluginInline = string | {
+    text: string;
+    url?: string;
+    code?: boolean;
+    strong?: boolean;
+    tone?: PluginTone;
+    copy?: string;
+};
+export interface PluginEdit {
+    action: string;
+    field?: string;
+}
+export interface PluginCell {
+    items: PluginInline[];
+    edit?: PluginEdit;
+}
+export type PluginBlock = {
+    type: "heading" | "text";
+    text: string;
+    markdown?: boolean;
+    edit?: PluginEdit;
+} | {
+    type: "context";
+    items: PluginInline[];
+} | {
+    type: "fields";
+    items: (PluginCell & {
+        label: string;
+    })[];
+} | {
+    type: "section";
+    title: string;
+    blocks: PluginBlock[];
+    collapsed?: boolean;
+    note?: string;
+} | {
+    type: "columns";
+    main: PluginBlock[];
+    aside: PluginBlock[];
+} | {
+    type: "table";
+    headers: string[];
+    rows: {
+        cells: PluginCell[];
+        actions?: string[];
+    }[];
+} | {
+    type: "code";
+    text: string;
+    diff?: boolean;
+    edit?: PluginEdit;
+} | {
+    type: "message";
+    author: string;
+    text: string;
+    time?: string;
+    edit?: PluginEdit;
+    actions?: string[];
+    reactions?: {
+        label: string;
+        count: number;
+        active?: boolean;
+        action?: string;
+        values?: Record<string, string>;
+    }[];
+} | {
+    type: "actions";
+    ids: string[];
+    composer?: boolean;
+} | {
+    type: "progress";
+    label: string;
+    value: number;
+} | {
+    type: "divider";
+};
+export interface PluginBlockContent {
+    format: "blocks";
+    header?: {
+        title: string;
+        context?: string;
+        reference?: string;
+        icon?: {
+            light: string;
+            dark?: string;
+        };
+    };
+    blocks: PluginBlock[];
+}
+export declare const pluginLink: (value: unknown) => value is string;
+export declare const validPluginBlocks: (value: unknown) => value is PluginBlockContent;

package/dist/plugins/blocks.js

@@ -0,0 +1,99 @@
+const record = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const text = (value) => typeof value === "string" && value.length <= 60_000;
+const optional = (value, check) => value === undefined || check(value);
+const flag = (value) => typeof value === "boolean";
+const array = (value, check, limit = 200) => Array.isArray(value) && value.length <= limit && value.every(check);
+export const pluginLink = (value) => {
+    if (typeof value !== "string" || value.length > 4096 || /[\s\\\p{Cc}]/u.test(value))
+        return false;
+    try {
+        const url = new URL(value);
+        return /^https?:$/.test(url.protocol) && !url.username && !url.password;
+    }
+    catch {
+        return false;
+    }
+};
+const icon = (value) => typeof value === "string" &&
+    value.length <= 100_000 &&
+    /^data:image\/(?:svg\+xml|png|webp);base64,[A-Za-z0-9+/]+={0,2}$/.test(value);
+const edit = (value) => record(value) && text(value.action) && optional(value.field, text);
+const inlines = (value) => array(value, (item) => text(item) ||
+    (record(item) &&
+        text(item.text) &&
+        optional(item.url, pluginLink) &&
+        optional(item.code, flag) &&
+        optional(item.strong, flag) &&
+        optional(item.copy, text) &&
+        optional(item.tone, (v) => ["neutral", "accent", "success", "warning", "danger"].includes(String(v)))));
+const cell = (value) => record(value) && inlines(value.items) && optional(value.edit, edit);
+export const validPluginBlocks = (value) => {
+    let count = 0;
+    const blocks = (value, depth) => depth <= 8 &&
+        array(value, (item) => {
+            if (++count > 2000 || !record(item))
+                return false;
+            if (!optional(item.edit, edit))
+                return false;
+            switch (item.type) {
+                case "heading":
+                case "text":
+                    return text(item.text) && optional(item.markdown, flag);
+                case "context":
+                    return inlines(item.items);
+                case "fields":
+                    return array(item.items, (v) => cell(v) && record(v) && text(v.label));
+                case "section":
+                    return (text(item.title) &&
+                        blocks(item.blocks, depth + 1) &&
+                        optional(item.collapsed, flag) &&
+                        optional(item.note, text));
+                case "columns":
+                    return blocks(item.main, depth + 1) && blocks(item.aside, depth + 1);
+                case "table":
+                    return (array(item.headers, text, 40) &&
+                        array(item.rows, (v) => record(v) &&
+                            array(v.cells, cell, 40) &&
+                            v.cells.length ===
+                                item.headers.length &&
+                            optional(v.actions, (v) => array(v, text))));
+                case "code":
+                    return text(item.text) && optional(item.diff, flag);
+                case "message":
+                    return (text(item.author) &&
+                        text(item.text) &&
+                        optional(item.time, text) &&
+                        optional(item.actions, (v) => array(v, text)) &&
+                        optional(item.reactions, (v) => array(v, (r) => record(r) &&
+                            text(r.label) &&
+                            typeof r.count === "number" &&
+                            Number.isInteger(r.count) &&
+                            r.count >= 0 &&
+                            optional(r.active, flag) &&
+                            optional(r.action, text) &&
+                            optional(r.values, (v) => record(v) &&
+                                Object.keys(v).length <= 40 &&
+                                Object.values(v).every(text)))));
+                case "actions":
+                    return array(item.ids, text) && optional(item.composer, flag);
+                case "progress":
+                    return (text(item.label) &&
+                        typeof item.value === "number" &&
+                        Number.isFinite(item.value) &&
+                        item.value >= 0 &&
+                        item.value <= 100);
+                case "divider":
+                    return true;
+                default:
+                    return false;
+            }
+        });
+    return (record(value) &&
+        value.format === "blocks" &&
+        blocks(value.blocks, 0) &&
+        optional(value.header, (h) => record(h) &&
+            text(h.title) &&
+            optional(h.context, text) &&
+            optional(h.reference, text) &&
+            optional(h.icon, (v) => record(v) && icon(v.light) && optional(v.dark, icon))));
+};

package/dist/plugins/index.d.ts

@@ -0,0 +1,4 @@
+export type { PluginAction, PluginActionContext, PluginActionField, PluginActionRequest, PluginActionResult, } from "./actions.js";
+export type { PluginBlock, PluginBlockContent, PluginCell, PluginEdit, PluginInline, PluginTone, } from "./blocks.js";
+export { PluginError, parseOAuthToken } from "./oauth.js";
+export type { DataPlugin, OAuthToken, PluginContent, PluginContext, PluginOAuth, PluginUser, PluginView, } from "./types.js";

package/dist/plugins/index.js

@@ -0,0 +1 @@
+export { PluginError, parseOAuthToken } from "./oauth.js";

package/dist/plugins/oauth.d.ts

@@ -0,0 +1,14 @@
+import type { DataPlugin, OAuthToken } from "./types.js";
+export declare class PluginError extends Error {
+    readonly status: number;
+    readonly name = "DoocPluginError";
+    constructor(status: number, message: string);
+}
+/** A plugin may load a separate installed copy of the SDK. */
+export declare const isPluginError: (error: unknown) => error is PluginError;
+export declare const httpsUrl: (source: string) => URL;
+/** Use after selecting a provider's user-token object in parseToken. */
+export declare const parseOAuthToken: (input: unknown) => OAuthToken;
+/** Bound both transfer time and decoded size; never include remote error bodies in errors. */
+export declare const fetchPluginJson: (url: string, init: RequestInit, tokenExchange?: boolean, transport?: typeof fetch) => Promise<unknown>;
+export declare const validatePlugins: (input: unknown) => DataPlugin[];

package/dist/plugins/oauth.js

@@ -0,0 +1,164 @@
+export class PluginError extends Error {
+    status;
+    name = "DoocPluginError";
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+/** A plugin may load a separate installed copy of the SDK. */
+export const isPluginError = (error) => error instanceof Error &&
+    error.name === "DoocPluginError" &&
+    "status" in error &&
+    typeof error.status === "number" &&
+    Number.isInteger(error.status) &&
+    error.status >= 400 &&
+    error.status <= 599;
+export const httpsUrl = (source) => {
+    const url = new URL(source);
+    if (url.protocol !== "https:" || url.username || url.password || url.hash)
+        throw new Error("Plugin endpoints must use HTTPS without credentials or fragments");
+    return url;
+};
+/** Use after selecting a provider's user-token object in parseToken. */
+export const parseOAuthToken = (input) => {
+    const token = input;
+    if (!token ||
+        typeof token !== "object" ||
+        typeof token.access_token !== "string" ||
+        !token.access_token ||
+        /[\s\p{Cc}]/u.test(token.access_token) ||
+        (token.token_type !== undefined &&
+            token.token_type !== "user" &&
+            (typeof token.token_type !== "string" ||
+                token.token_type.toLowerCase() !== "bearer")) ||
+        (token.refresh_token !== undefined &&
+            (typeof token.refresh_token !== "string" || !token.refresh_token)) ||
+        (token.expires_in !== undefined &&
+            (typeof token.expires_in !== "number" ||
+                !Number.isFinite(token.expires_in) ||
+                token.expires_in <= 0)) ||
+        (token.scope !== undefined &&
+            typeof token.scope !== "string" &&
+            (!Array.isArray(token.scope) || token.scope.some((s) => typeof s !== "string"))))
+        throw new PluginError(502, "Invalid OAuth token response");
+    return {
+        access_token: token.access_token,
+        ...(token.refresh_token === undefined ? {} : { refresh_token: token.refresh_token }),
+        ...(token.expires_in === undefined ? {} : { expires_in: token.expires_in }),
+        ...(token.scope === undefined ? {} : { scope: token.scope }),
+    };
+};
+/** Bound both transfer time and decoded size; never include remote error bodies in errors. */
+export const fetchPluginJson = async (url, init, tokenExchange = false, transport = fetch) => {
+    try {
+        const response = await transport(url, {
+            ...init,
+            redirect: "error",
+            cache: "no-store",
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new PluginError(response.status === 400 && tokenExchange
+                ? 401
+                : [400, 401, 403, 404, 409, 422, 429].includes(response.status)
+                    ? response.status
+                    : 502, response.status === 401 || (response.status === 400 && tokenExchange)
+                ? "Connect this plugin again"
+                : response.status === 403
+                    ? "Access denied by the service"
+                    : "Plugin service request failed");
+        }
+        if (response.status === 204)
+            return null;
+        const reader = response.body?.getReader();
+        if (!reader)
+            return null;
+        const chunks = [];
+        let size = 0;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                size += value.byteLength;
+                if (size > 2 * 1024 * 1024)
+                    throw new Error("Response too large");
+                chunks.push(value);
+            }
+        }
+        finally {
+            await reader.cancel();
+        }
+        return size === 0 ? null : JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    }
+    catch (error) {
+        if (isPluginError(error))
+            throw error;
+        throw new PluginError(502, "Plugin service request failed");
+    }
+};
+export const validatePlugins = (input) => {
+    if (!Array.isArray(input))
+        throw new Error("Viewer plugins: plugins must be an array");
+    const ids = new Set();
+    return input.map((plugin) => {
+        if (!plugin ||
+            typeof plugin.id !== "string" ||
+            !/^[a-z][a-z0-9-]{0,63}$/.test(plugin.id) ||
+            ids.has(plugin.id))
+            throw new Error("Viewer plugins: plugin IDs must be unique lowercase names");
+        ids.add(plugin.id);
+        const oauth = plugin.oauth;
+        if (!oauth ||
+            typeof oauth.clientId !== "string" ||
+            !oauth.clientId.trim() ||
+            (oauth.clientSecret !== undefined && typeof oauth.clientSecret !== "string") ||
+            !Array.isArray(oauth.scopes) ||
+            oauth.scopes.some((s) => typeof s !== "string" || !s.trim()) ||
+            typeof plugin.identifyUser !== "function" ||
+            typeof plugin.matches !== "function" ||
+            typeof plugin.read !== "function" ||
+            (plugin.actions !== undefined && typeof plugin.actions !== "function") ||
+            (plugin.act !== undefined && typeof plugin.act !== "function") ||
+            Boolean(plugin.actions) !== Boolean(plugin.act) ||
+            !Array.isArray(plugin.apiOrigins) ||
+            !plugin.apiOrigins.length ||
+            (oauth.parseToken !== undefined && typeof oauth.parseToken !== "function"))
+            throw new Error(`Viewer plugins: invalid plugin ${plugin.id}`);
+        for (const endpoint of [oauth.authorizationUrl, oauth.tokenUrl]) {
+            if (typeof endpoint !== "string" || httpsUrl(endpoint).search)
+                throw new Error("OAuth endpoints must not contain query parameters");
+        }
+        for (const origin of plugin.apiOrigins)
+            if (typeof origin !== "string" || httpsUrl(origin).origin !== origin)
+                throw new Error("apiOrigins must contain exact HTTPS origins");
+        const reserved = new Set([
+            "client_id",
+            "client_secret",
+            "redirect_uri",
+            "response_type",
+            "state",
+            "code_challenge",
+            "code_challenge_method",
+        ]);
+        if (oauth.scopeParameter !== undefined &&
+            (!/^[a-z_]+$/.test(oauth.scopeParameter) || reserved.has(oauth.scopeParameter)))
+            throw new Error("Invalid OAuth scope parameter");
+        if (oauth.scopeSeparator !== undefined && ![" ", ","].includes(oauth.scopeSeparator))
+            throw new Error("OAuth scope separator must be a space or comma");
+        if (oauth.authorizationParams !== undefined) {
+            if (!oauth.authorizationParams ||
+                typeof oauth.authorizationParams !== "object" ||
+                Array.isArray(oauth.authorizationParams))
+                throw new Error("Invalid OAuth authorization parameters");
+            for (const [key, value] of Object.entries(oauth.authorizationParams))
+                if (reserved.has(key) ||
+                    key === (oauth.scopeParameter ?? "scope") ||
+                    typeof value !== "string")
+                    throw new Error("OAuth authorization parameters cannot override security parameters");
+        }
+        return plugin;
+    });
+};

package/dist/plugins/runtime.d.ts

@@ -0,0 +1,24 @@
+import { type PluginActionResult } from "./actions.js";
+import type { DataPlugin, PluginUser } from "./types.js";
+export declare const createPluginRuntime: (definitions: readonly DataPlugin[], transport?: typeof fetch) => {
+    resolve(source: unknown): string | undefined;
+    register(plugin: DataPlugin): void;
+    unregister: (pluginId: string) => void;
+    createSession(): string;
+    hasSession(id: string): boolean;
+    connect(id: string, pluginId: string, redirectUri: string): string;
+    callback(id: string, pluginId: string, redirectUri: string, params: URLSearchParams): Promise<void>;
+    disconnect(id: string, pluginId: string): void;
+    read(id: string, pluginId: string, source: unknown): Promise<{
+        user: PluginUser;
+        view: import("./view.js").PluginView;
+    }>;
+    actions(id: string, pluginId: string, source: unknown): Promise<{
+        user: PluginUser;
+        actions: import("./actions.js").PluginAction[];
+    }>;
+    act(id: string, pluginId: string, source: unknown, input: unknown, requestId: unknown): Promise<{
+        user: PluginUser;
+        result: PluginActionResult;
+    }>;
+};