@burdenoff/fluidgrids-fe-sdk 2026.1112.11 → 2026.1113.2

package/dist/durable-nodes-DXCCQYWD.js

@@ -0,0 +1,81 @@
+"use client";
+// src/feature-flags/durable-nodes.ts
+/**
+* Palette gating for the durable-function nodes (BOFF-9905).
+*
+* wspace-workflow-svc only seeds the `internal:code-workflow` and
+* `internal:wait-for-signal` manifests while `DURABLE_NODE_MANIFESTS_ENABLED`
+* is set, and refuses durable work while the `fluidgrids.durable-functions`
+* flag is off for the workspace. Once the manifests are seeded for every
+* workspace, the builder still has to hide the two nodes from the palettes of
+* workspaces where the flag is off. This module is that client-side filter; it
+* mirrors the server-side gate and is never the gate itself.
+*
+* Hiding only affects what can be picked from a palette. A workflow that
+* already contains one of these nodes keeps rendering and running unchanged.
+*/
+/** Node types offered only while durable functions are enabled. */
+const DURABLE_FUNCTION_NODE_TYPES = /* @__PURE__ */ new Set(["internal:code-workflow", "internal:wait-for-signal"]);
+/**
+* The run-control nodes of Phase C (BOFF-9906, DC15). wspace-workflow-svc
+* seeds their manifests only while `RUN_CONTROL_NODE_MANIFESTS_ENABLED` is
+* set, which is turned on after this filter ships; the builder then still
+* hides each one where its flag is off: Signal Run needs run control, Set
+* Search Attributes needs search attributes.
+*/
+const RUN_CONTROL_NODE_TYPES = /* @__PURE__ */ new Set(["internal:signal-run", "internal:set-search-attributes"]);
+/**
+* The Assert node of the workflow test suites (BOFF-9960). wspace-workflow-svc
+* seeds its manifest for every workspace, so the builder hides it wherever the
+* `fluidgrids.workflow-tests` flag is off.
+*/
+const WORKFLOW_TEST_NODE_TYPES = /* @__PURE__ */ new Set(["internal:assert"]);
+/** Whether a workflow node type is one of the Phase C run-control nodes. */
+function isRunControlNodeType(nodeType) {
+	return !!nodeType && RUN_CONTROL_NODE_TYPES.has(nodeType);
+}
+/** Normalises the boolean (Phase B) or object form of the palette gates. */
+function paletteGatesOf(gates) {
+	if (typeof gates === "boolean") return {
+		durableFunctions: gates,
+		runControl: false,
+		searchAttributes: false,
+		workflowTests: false
+	};
+	return {
+		durableFunctions: gates?.durableFunctions === true,
+		runControl: gates?.runControl === true,
+		searchAttributes: gates?.searchAttributes === true,
+		workflowTests: gates?.workflowTests === true
+	};
+}
+function hiddenBy(nodeType, gates) {
+	if (DURABLE_FUNCTION_NODE_TYPES.has(nodeType)) return !gates.durableFunctions;
+	if (nodeType === "internal:signal-run") return !gates.runControl;
+	if (nodeType === "internal:set-search-attributes") return !gates.searchAttributes;
+	if (WORKFLOW_TEST_NODE_TYPES.has(nodeType)) return !gates.workflowTests;
+	return false;
+}
+/** Whether a workflow node type is one of the durable-function nodes. */
+function isDurableFunctionNodeType(nodeType) {
+	return !!nodeType && DURABLE_FUNCTION_NODE_TYPES.has(nodeType);
+}
+/**
+* Whether a node type must be left out of the builder palettes. Fails closed:
+* a family the caller does not say is enabled is not.
+*/
+function isNodeTypeHiddenFromPalette(nodeType, gates = false) {
+	return !!nodeType && hiddenBy(nodeType, paletteGatesOf(gates));
+}
+/**
+* Drops the palette entries that must stay hidden. Returns the input array
+* itself when nothing is hidden, so the canvas palettes keep the exact list
+* (and references) they had before this filter existed.
+*/
+function filterPaletteNodes(nodes, gates = false) {
+	const resolved = paletteGatesOf(gates);
+	if (!nodes.some((node) => hiddenBy(node.type, resolved))) return nodes;
+	return nodes.filter((node) => !hiddenBy(node.type, resolved));
+}
+
+export { isDurableFunctionNodeType as a, filterPaletteNodes as i, RUN_CONTROL_NODE_TYPES as n, isNodeTypeHiddenFromPalette as o, WORKFLOW_TEST_NODE_TYPES as r, isRunControlNodeType as s, DURABLE_FUNCTION_NODE_TYPES as t };

package/dist/errors-xPZ-IbQd.js

@@ -0,0 +1,142 @@
+"use client";
+import { CombinedGraphQLErrors, ServerError } from "@apollo/client/errors";
+
+// src/graphql/errors.ts
+/**
+* Operation-error helpers.
+*
+* The SDK usually runs against a host-injected Apollo client (see
+* `setFluidGridsClient`). App shells configure their shared client with
+* `errorPolicy: 'all'`, so `client.mutate` / `client.query` RESOLVE on
+* GraphQL errors — `result.data` is empty and the real failure sits in
+* `result.error`. Callers that only check `result.data` silently swallow
+* server errors (e.g. QUOTA_EXHAUSTED) and surface generic messages.
+*
+* Use `throwIfResultError(result)` right after a mutate/query so failures
+* flow through the existing catch paths, and `describeOperationError(err)`
+* to turn whatever was thrown into a user-presentable message.
+*/
+/** Well-known gateway error codes mapped to user-friendly messages. */
+function describeGraphQLError(error) {
+	switch (typeof error.extensions?.code === "string" ? error.extensions.code : void 0) {
+		case "QUOTA_EXHAUSTED": {
+			const quota = /Quota exhausted for (\S+)/.exec(error.message)?.[1];
+			return `Quota exhausted — your workspace has used up its ${quota ? `"${quota}" quota` : "usage quota"}. Upgrade your plan or wait for the quota to reset.`;
+		}
+		case "QUOTA_NOT_PROVISIONED": return "This workspace's plan does not include this usage allowance yet. Contact your workspace admin or support to have it provisioned.";
+		case "UNAUTHENTICATED": return "Your session has expired. Please sign in again.";
+		case "FORBIDDEN": return error.message || "You don't have permission to perform this action.";
+		default: return error.message || "Unknown error";
+	}
+}
+/** The first GraphQL error of a raw JSON response body, if it carries one. */
+function firstGraphQLErrorInBody(bodyText) {
+	try {
+		const parsed = JSON.parse(bodyText);
+		if (typeof parsed !== "object" || parsed === null) return null;
+		const errors = parsed.errors;
+		if (!Array.isArray(errors) || errors.length === 0) return null;
+		const first = errors[0];
+		if (typeof first !== "object" || first === null) return null;
+		if (typeof first.message !== "string") return null;
+		return first;
+	} catch {
+		return null;
+	}
+}
+/**
+* Turn anything thrown (or found in `result.error`) into a message fit for
+* a toast / run log. Unwraps Apollo `CombinedGraphQLErrors` so well-known
+* gateway codes (quota, auth) read properly instead of a concatenated dump.
+*/
+function describeOperationError(error, fallback = "Unknown error") {
+	if (CombinedGraphQLErrors.is(error)) {
+		const first = error.errors[0];
+		return first ? describeGraphQLError(first) : error.message || fallback;
+	}
+	if (ServerError.is(error)) {
+		const first = firstGraphQLErrorInBody(error.bodyText);
+		if (first) return describeGraphQLError(first);
+	}
+	if (error instanceof Error) return error.message || fallback;
+	if (typeof error === "string" && error.length > 0) return error;
+	return fallback;
+}
+/**
+* Throw `result.error` when the injected client resolved an errored
+* operation (errorPolicy 'all'). Returns the result unchanged otherwise, so
+* it can be chained inline:
+*
+* ```ts
+* const result = throwIfResultError(await client.mutate({ ... }));
+* ```
+*/
+function throwIfResultError(result) {
+	if (result.error) throw new Error(describeOperationError(result.error), { cause: result.error });
+	return result;
+}
+/** True when a GraphQL error list carries a FORBIDDEN code. */
+function hasForbiddenCode(errors) {
+	return (errors ?? []).some((error) => error.extensions?.code === "FORBIDDEN");
+}
+/**
+* True when an operation failed because the caller lacks the permission
+* (gateway `@rbac` denial). Accepts the raw Apollo error, a `result.error`,
+* or the Error `throwIfResultError` throws (the original sits in `cause`).
+* Pages use it to render a no-access state instead of a load failure.
+*/
+function isForbiddenError(error) {
+	if (CombinedGraphQLErrors.is(error)) return hasForbiddenCode(error.errors);
+	if (ServerError.is(error)) {
+		if (error.statusCode === 403) return true;
+		const first = firstGraphQLErrorInBody(error.bodyText);
+		return first ? hasForbiddenCode([first]) : false;
+	}
+	if (error instanceof Error && error.cause !== void 0) return isForbiddenError(error.cause);
+	return false;
+}
+const REFRESHABLE_AUTH_FAILURES = /* @__PURE__ */ new Set(["CREDENTIAL_EXPIRED", "CREDENTIAL_REVOKED"]);
+const EXPIRED_TOKEN_MESSAGE = /\b(?:jwt|token)\b[^.]{0,40}\bexpired\b|\bexpired\b[^.]{0,20}\b(?:jwt|token)\b/i;
+function isUnauthenticatedGraphQLError(error) {
+	if (error.extensions?.code === "UNAUTHENTICATED") return true;
+	const authFailure = error.extensions?.authFailure;
+	if (typeof authFailure === "string" && REFRESHABLE_AUTH_FAILURES.has(authFailure)) return true;
+	return typeof error.message === "string" && EXPIRED_TOKEN_MESSAGE.test(error.message);
+}
+/**
+* True when a GraphQL error list says the caller's credential expired or is
+* not accepted: an `UNAUTHENTICATED` code, an expired / revoked
+* `authFailure` category, or an expired-token message.
+*/
+function hasUnauthenticatedGraphQLError(errors) {
+	return (errors ?? []).some(isUnauthenticatedGraphQLError);
+}
+/**
+* True when an operation failed because the session expired: HTTP 401, a
+* GraphQL `UNAUTHENTICATED` error, or an expired / revoked credential.
+* Accepts the raw Apollo error, a `result.error`, or the Error
+* `throwIfResultError` throws (the original sits in `cause`). A 503
+* `AUTH_SERVICE_UNAVAILABLE` is not an expired session and returns false.
+*/
+function isUnauthenticatedError(error) {
+	if (CombinedGraphQLErrors.is(error)) return hasUnauthenticatedGraphQLError(error.errors);
+	if (ServerError.is(error)) {
+		if (error.statusCode === 401) return true;
+		const first = firstGraphQLErrorInBody(error.bodyText);
+		return first ? isUnauthenticatedGraphQLError(first) : false;
+	}
+	if (error instanceof Error && error.cause !== void 0) return isUnauthenticatedError(error.cause);
+	return false;
+}
+/** The gateway error code of an operation failure, when it carries one. */
+function operationErrorCode(error) {
+	const codeOf = (graphQLError) => {
+		const code = graphQLError?.extensions?.code;
+		return typeof code === "string" ? code : void 0;
+	};
+	if (CombinedGraphQLErrors.is(error)) return codeOf(error.errors[0]);
+	if (ServerError.is(error)) return codeOf(firstGraphQLErrorInBody(error.bodyText) ?? void 0);
+	if (error instanceof Error && error.cause !== void 0) return operationErrorCode(error.cause);
+}
+
+export { operationErrorCode as a, isUnauthenticatedError as i, hasUnauthenticatedGraphQLError as n, throwIfResultError as o, isForbiddenError as r, describeOperationError as t };

package/dist/executions.js

@@ -1,5 +1,5 @@
 "use client";
-import { t as ExecutionsListPage } from "./ExecutionsListPage-CUJQA0Vk.js";
-import { t as ExecutionDetailPage } from "./ExecutionDetailPage-UyXErYuS.js";
+import { t as ExecutionsListPage } from "./ExecutionsListPage--4BthM8L.js";
+import { t as ExecutionDetailPage } from "./ExecutionDetailPage-BXDF2eoT.js";
 
 export { ExecutionDetailPage, ExecutionsListPage };