@segmentstream/app 0.0.0-stage → 0.38.0

package/dist/errors.d.ts

@@ -0,0 +1,60 @@
+/** One problem with a request's input, as the ontology service reports it. */
+export interface ApiIssue {
+    readonly path: ReadonlyArray<string | number>;
+    readonly message: string;
+}
+/** Structured platform limits; workspace clients choose their own user-facing wording. */
+export type ApiLimit = {
+    readonly kind: "storage_quota";
+    readonly usedBytes: number;
+    readonly requestedBytes: number;
+    readonly quotaBytes: number;
+} | {
+    readonly kind: "pending_uploads";
+    readonly pending: number;
+    readonly max: number;
+    readonly uploads?: ReadonlyArray<{
+        readonly id: string;
+        readonly filename: string;
+        readonly expiresAt: string;
+    }>;
+} | {
+    readonly kind: "member_attachments";
+    readonly live: number;
+    readonly max: number;
+};
+/**
+ * A failed SegmentStream or ontology request; `code` is the API error code, such as `not_invited`,
+ * `forbidden`, `action_rejected` or `query_timeout`.
+ */
+export declare class SegmentStreamApiError extends Error {
+    readonly code: string;
+    readonly status: number;
+    readonly detail: string;
+    readonly requestId: string | undefined;
+    readonly retryable: boolean;
+    /** The warehouse query this error concerns, when one was started. */
+    readonly queryId: string | undefined;
+    /** What was wrong with the input, for `invalid_request`, `invalid_input` and `action_rejected`. */
+    readonly issues: ReadonlyArray<ApiIssue>;
+    readonly limit: ApiLimit | undefined;
+    constructor(input: {
+        readonly code: string;
+        readonly status: number;
+        readonly detail: string;
+        readonly requestId?: string | undefined;
+        readonly retryable?: boolean;
+        readonly queryId?: string | undefined;
+        readonly issues?: ReadonlyArray<ApiIssue>;
+        readonly limit?: ApiLimit | undefined;
+        /** The underlying failure, kept for server logs. */
+        readonly cause?: unknown;
+    });
+}
+/** The person signed in, but the ontology has no member row for them. */
+export declare const NOT_INVITED = "not_invited";
+/** An emailed sign-in link that Neon Auth rejected: expired, already used or unknown. */
+export declare const SIGN_IN_LINK_INVALID = "sign_in_link_invalid";
+/** The error body of a failed response: `{ error, detail, requestId, issues? }`. */
+export declare function apiErrorFrom(status: number, payload: unknown, fallbackDetail: string): SegmentStreamApiError;
+export declare function readJson(response: Response): Promise<unknown>;

package/dist/errors.js

@@ -0,0 +1,123 @@
+/**
+ * A failed SegmentStream or ontology request; `code` is the API error code, such as `not_invited`,
+ * `forbidden`, `action_rejected` or `query_timeout`.
+ */
+export class SegmentStreamApiError extends Error {
+    code;
+    status;
+    detail;
+    requestId;
+    retryable;
+    /** The warehouse query this error concerns, when one was started. */
+    queryId;
+    /** What was wrong with the input, for `invalid_request`, `invalid_input` and `action_rejected`. */
+    issues;
+    limit;
+    constructor(input) {
+        super(`${input.detail} (${input.code})`, input.cause === undefined ? undefined : { cause: input.cause });
+        this.name = "SegmentStreamApiError";
+        this.code = input.code;
+        this.status = input.status;
+        this.detail = input.detail;
+        this.requestId = input.requestId;
+        this.retryable = input.retryable ?? false;
+        this.queryId = input.queryId;
+        this.issues = input.issues ?? [];
+        this.limit = input.limit;
+    }
+}
+/** The person signed in, but the ontology has no member row for them. */
+export const NOT_INVITED = "not_invited";
+/** An emailed sign-in link that Neon Auth rejected: expired, already used or unknown. */
+export const SIGN_IN_LINK_INVALID = "sign_in_link_invalid";
+/** The error body of a failed response: `{ error, detail, requestId, issues? }`. */
+export function apiErrorFrom(status, payload, fallbackDetail) {
+    const body = typeof payload === "object" && payload !== null ? payload : {};
+    return new SegmentStreamApiError({
+        code: typeof body.error === "string" ? body.error : `http_${status}`,
+        status,
+        detail: typeof body.detail === "string" ? body.detail : fallbackDetail,
+        requestId: typeof body.request_id === "string"
+            ? body.request_id
+            : typeof body.requestId === "string"
+                ? body.requestId
+                : undefined,
+        retryable: typeof body.retryable === "boolean" ? body.retryable : status >= 500 || status === 429,
+        issues: issuesFrom(body.issues),
+        limit: limitFrom(body.limit),
+    });
+}
+function limitFrom(value) {
+    if (typeof value !== "object" || value === null) {
+        return undefined;
+    }
+    const limit = value;
+    const count = (key) => {
+        const candidate = limit[key];
+        return typeof candidate === "number" && Number.isSafeInteger(candidate) && candidate >= 0
+            ? candidate
+            : undefined;
+    };
+    const max = count("max");
+    if (limit.kind === "storage_quota") {
+        const usedBytes = count("used_bytes");
+        const requestedBytes = count("requested_bytes");
+        const quotaBytes = count("quota_bytes");
+        return usedBytes !== undefined && requestedBytes !== undefined && quotaBytes !== undefined
+            ? { kind: "storage_quota", usedBytes, requestedBytes, quotaBytes }
+            : undefined;
+    }
+    if (limit.kind === "member_attachments") {
+        const live = count("live");
+        return live !== undefined && max !== undefined
+            ? { kind: "member_attachments", live, max }
+            : undefined;
+    }
+    if (limit.kind === "pending_uploads") {
+        const pending = count("pending");
+        if (pending === undefined || max === undefined) {
+            return undefined;
+        }
+        const uploads = Array.isArray(limit.uploads)
+            ? limit.uploads.flatMap((item) => {
+                if (typeof item !== "object" || item === null) {
+                    return [];
+                }
+                const upload = item;
+                return typeof upload.id === "string" &&
+                    typeof upload.filename === "string" &&
+                    typeof upload.expires_at === "string"
+                    ? [{ id: upload.id, filename: upload.filename, expiresAt: upload.expires_at }]
+                    : [];
+            })
+            : undefined;
+        return { kind: "pending_uploads", pending, max, ...(uploads ? { uploads } : {}) };
+    }
+    return undefined;
+}
+function issuesFrom(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((candidate) => {
+        if (typeof candidate !== "object" || candidate === null) {
+            return [];
+        }
+        const { path, message } = candidate;
+        if (typeof message !== "string") {
+            return [];
+        }
+        const segments = Array.isArray(path)
+            ? path.filter((segment) => typeof segment === "string" || typeof segment === "number")
+            : [];
+        return [{ path: segments, message }];
+    });
+}
+export async function readJson(response) {
+    try {
+        return await response.json();
+    }
+    catch {
+        return null;
+    }
+}

package/dist/federation.d.ts

@@ -0,0 +1,24 @@
+import { type BrowserRevision } from "./browser-revision.js";
+import type { SegmentStreamApp } from "./app.js";
+import type { BrowserAuthBinding, ResolvedConfig } from "./config.js";
+import { type OntologyTransport } from "./ontology.js";
+import type { Fetch } from "./sessions.js";
+import type { AppUser } from "./tokens.js";
+/** Public-client RP. Only workspace-owned opaque sessions are stored in its session cookie. */
+export declare function withFederation<O>(base: SegmentStreamApp<O>, config: ResolvedConfig, oidc: {
+    issuer: string;
+    clientId: string;
+}, options: {
+    fetch: Fetch;
+    ontologyUrl?: string;
+    neon: boolean;
+    browserAuth?: BrowserAuthBinding;
+    browserRevision?: BrowserRevision;
+    proofTransport?: OntologyTransport;
+    identityToken?: () => Promise<string | null>;
+    channelSession?: {
+        readonly getUser: () => Promise<AppUser | null>;
+        readonly signOut: () => Promise<void>;
+        readonly transport: OntologyTransport;
+    };
+}): SegmentStreamApp<O>;