@burdenoff/fluidgrids-fe-sdk 2026.1104.2 → 2026.1105.1

package/dist/chunk-US5QSLPV.js

@@ -0,0 +1,316 @@
+import { getFluidGridsTokenRevision, config, setFluidGridsConfig } from './chunk-UEG2WC3G.js';
+import { CombinedGraphQLErrors, ServerError } from '@apollo/client/errors';
+import { ApolloLink, Observable } from '@apollo/client/core';
+
+// src/graphql/live-tokens.ts
+function createLiveTokenReader(initial) {
+  const createdAt = getFluidGridsTokenRevision();
+  return () => {
+    if (getFluidGridsTokenRevision() === createdAt) return initial;
+    return {
+      authToken: config.authToken ?? initial.authToken,
+      workspaceToken: config.workspaceToken ?? initial.workspaceToken
+    };
+  };
+}
+function describeGraphQLError(error) {
+  const code = typeof error.extensions?.code === "string" ? error.extensions.code : void 0;
+  switch (code) {
+    case "QUOTA_EXHAUSTED": {
+      const quota = /Quota exhausted for (\S+)/.exec(error.message)?.[1];
+      const allowance = quota ? `"${quota}" quota` : "usage quota";
+      return `Quota exhausted \u2014 your workspace has used up its ${allowance}. 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";
+  }
+}
+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;
+    const message = first.message;
+    if (typeof message !== "string") return null;
+    return first;
+  } catch {
+    return null;
+  }
+}
+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;
+}
+function throwIfResultError(result) {
+  if (result.error) {
+    throw new Error(describeOperationError(result.error), {
+      cause: result.error
+    });
+  }
+  return result;
+}
+function hasForbiddenCode(errors) {
+  return (errors ?? []).some((error) => error.extensions?.code === "FORBIDDEN");
+}
+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;
+}
+var REFRESHABLE_AUTH_FAILURES = /* @__PURE__ */ new Set([
+  "CREDENTIAL_EXPIRED",
+  "CREDENTIAL_REVOKED"
+]);
+var EXPIRED_TOKEN_MESSAGE = /\b(?:jwt|token)\b[^.]{0,40}\bexpired\b|\bexpired\b[^.]{0,20}\b(?:jwt|token)\b/i;
+function isUnauthenticatedGraphQLError(error) {
+  const code = error.extensions?.code;
+  if (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);
+}
+function hasUnauthenticatedGraphQLError(errors) {
+  return (errors ?? []).some(isUnauthenticatedGraphQLError);
+}
+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;
+}
+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);
+  }
+  return void 0;
+}
+
+// src/events/eventBus.ts
+var FLUIDGRIDS_EVENTS_VERSION = "1.0.0";
+var FLUIDGRIDS_EVENT_NAMES = [
+  "workflow:saved",
+  "workflow:activated",
+  "run:started",
+  "run:completed",
+  "node:selected",
+  "error",
+  "auth:failed"
+];
+function withoutUndefined(payload) {
+  return Object.fromEntries(
+    Object.entries(payload).filter(([, value]) => value !== void 0)
+  );
+}
+function emitFluidGridsEvent(name, payload) {
+  let handler;
+  try {
+    handler = config.onEvent;
+  } catch {
+    return;
+  }
+  if (typeof handler !== "function") return;
+  try {
+    const args = [name, withoutUndefined(payload)];
+    handler(...args);
+  } catch (error) {
+    console.warn(`[FluidGrids SDK] onEvent handler failed for ${name}`, error);
+  }
+}
+function emitOperationErrorEvent(source, error) {
+  emitFluidGridsEvent("error", {
+    source,
+    message: describeOperationError(error),
+    code: operationErrorCode(error)
+  });
+}
+var MAX_COMPLETED_RUNS = 500;
+var completedRuns = /* @__PURE__ */ new Set();
+function emitRunCompletedOnce(payload) {
+  if (!payload.runId || completedRuns.has(payload.runId)) return;
+  completedRuns.add(payload.runId);
+  if (completedRuns.size > MAX_COMPLETED_RUNS) {
+    const oldest = completedRuns.values().next().value;
+    if (oldest !== void 0) completedRuns.delete(oldest);
+  }
+  emitFluidGridsEvent("run:completed", payload);
+}
+var inFlight = null;
+var refreshGeneration = 0;
+var lastRefreshed = null;
+function normalizeTokens(value) {
+  if (typeof value === "string") {
+    return value.trim() ? { authToken: value } : null;
+  }
+  if (!value || typeof value !== "object") return null;
+  const tokens = {};
+  if (typeof value.authToken === "string" && value.authToken.trim()) {
+    tokens.authToken = value.authToken;
+  }
+  if (typeof value.workspaceToken === "string" && value.workspaceToken.trim()) {
+    tokens.workspaceToken = value.workspaceToken;
+  }
+  return tokens.authToken || tokens.workspaceToken ? tokens : null;
+}
+function storeInConfig(tokens) {
+  setFluidGridsConfig(tokens);
+}
+function refreshTokens(callback, store) {
+  if (inFlight) return inFlight;
+  const run = (async () => {
+    try {
+      const tokens = normalizeTokens(await callback());
+      if (!tokens) {
+        emitFluidGridsEvent("auth:failed", {
+          message: "onTokenExpired returned no token."
+        });
+        return null;
+      }
+      store(tokens);
+      refreshGeneration += 1;
+      lastRefreshed = tokens;
+      return tokens;
+    } catch (error) {
+      emitFluidGridsEvent("auth:failed", {
+        message: describeOperationError(error, "Token refresh failed.")
+      });
+      return null;
+    }
+  })();
+  inFlight = run;
+  void run.finally(() => {
+    if (inFlight === run) inFlight = null;
+  });
+  return run;
+}
+function withTokenHeaders(headers, tokens) {
+  return {
+    ...headers,
+    ...tokens.authToken && { authorization: `Bearer ${tokens.authToken}` },
+    ...tokens.workspaceToken && {
+      "x-workspace-authorization": `Bearer ${tokens.workspaceToken}`
+    }
+  };
+}
+function resultIsUnauthenticated(result) {
+  return hasUnauthenticatedGraphQLError(result.errors);
+}
+function createFluidGridsTokenRefreshLink(options = {}) {
+  return new ApolloLink((operation, forward) => {
+    const store = options.onTokenRefreshed ?? storeInConfig;
+    return new Observable((observer) => {
+      const sentInGeneration = refreshGeneration;
+      let retried = false;
+      let closed = false;
+      let current = null;
+      const retryOrFail = (fail) => {
+        const callback = options.onTokenExpired ?? config.auth?.onTokenExpired;
+        if (!callback) return false;
+        retried = true;
+        current?.unsubscribe();
+        current = null;
+        const refreshed = refreshGeneration !== sentInGeneration && lastRefreshed ? Promise.resolve(lastRefreshed) : refreshTokens(callback, store);
+        void refreshed.then((tokens) => {
+          if (closed) return;
+          if (!tokens) {
+            fail();
+            return;
+          }
+          const context = operation.getContext();
+          const headers = context.headers;
+          operation.setContext({
+            headers: withTokenHeaders(
+              headers && typeof headers === "object" ? (
+                // Apollo keeps request headers as a plain string map.
+                headers
+              ) : void 0,
+              tokens
+            )
+          });
+          subscribe();
+        });
+        return true;
+      };
+      const subscribe = () => {
+        let refreshing = false;
+        current = forward(operation).subscribe({
+          next: (result) => {
+            if (!retried && resultIsUnauthenticated(result) && retryOrFail(() => {
+              observer.next(result);
+              observer.complete();
+            })) {
+              refreshing = true;
+              return;
+            }
+            observer.next(result);
+          },
+          error: (error) => {
+            if (!retried && isUnauthenticatedError(error) && retryOrFail(() => observer.error(error))) {
+              refreshing = true;
+              return;
+            }
+            observer.error(error);
+          },
+          complete: () => {
+            if (!refreshing) observer.complete();
+          }
+        });
+      };
+      subscribe();
+      return () => {
+        closed = true;
+        current?.unsubscribe();
+      };
+    });
+  });
+}
+
+export { FLUIDGRIDS_EVENTS_VERSION, FLUIDGRIDS_EVENT_NAMES, createFluidGridsTokenRefreshLink, createLiveTokenReader, describeOperationError, emitFluidGridsEvent, emitOperationErrorEvent, emitRunCompletedOnce, isForbiddenError, isUnauthenticatedError, throwIfResultError };

package/dist/{chunk-VDJFTZ2H.js → chunk-VFVN7D3A.js}

@@ -1,5 +1,6 @@
-import { useAgentDefinitions, useAgentDefinitionList, useConnections, describeOperationError } from './chunk-AAIZ6S6E.js';
+import { useAgentDefinitions, useAgentDefinitionList, useConnections } from './chunk-C26QAWCT.js';
 import { useTr } from './chunk-UULVIT25.js';
+import { describeOperationError } from './chunk-US5QSLPV.js';
 import { useState, useCallback, useEffect } from 'react';
 import { Icon } from '@iconify/react';
 import { Button } from '@burdenoff/fe-libs/button';

package/dist/{chunk-D4WA2M2N.js → chunk-XLI75E3D.js}

@@ -1,7 +1,8 @@
-import { throwIfResultError, describeOperationError, signalPayloadCard, components_default, payloadFromCardValues, parseRawSignalPayload } from './chunk-AAIZ6S6E.js';
+import { signalPayloadCard, components_default, payloadFromCardValues, parseRawSignalPayload } from './chunk-C26QAWCT.js';
 import { TerminateWorkflowRunDocument, WorkflowRunHistoryDocument, RunEventAppendedDocument, DurableRunFieldsDocument, WorkflowRunDeterminismStatusDocument, WorkflowRunStackTraceDocument, SignalWorkflowRunDocument } from './chunk-AVHBWJRY.js';
 import { useTr } from './chunk-UULVIT25.js';
-import { getFluidGridsClient, getFluidGridsClientSafe } from './chunk-NTWG3CJX.js';
+import { getFluidGridsClient, getFluidGridsClientSafe } from './chunk-3IXU7WUC.js';
+import { throwIfResultError, describeOperationError } from './chunk-US5QSLPV.js';
 import { useState, useMemo, useRef, useCallback, useEffect } from 'react';
 import { Icon } from '@iconify/react';
 import { Button } from '@burdenoff/fe-libs/button';

package/dist/client-YVZMLEQX.js

@@ -0,0 +1,3 @@
+export { createFluidGridsClient, getFluidGridsClient, getFluidGridsClientSafe, isFluidGridsClientReady, resetFluidGridsClient, setFluidGridsClient, waitForFluidGridsClient } from './chunk-3IXU7WUC.js';
+import './chunk-US5QSLPV.js';
+import './chunk-UEG2WC3G.js';

package/dist/config-66FUPSG5.js

@@ -0,0 +1 @@
+export { config, getFluidGridsConfig, getFluidGridsTokenRevision, getGraphQLEndpoint, resetFluidGridsConfig, resetFluidGridsExecutionState, setFluidGridsConfig, validateTrustedOrigin } from './chunk-UEG2WC3G.js';

package/dist/executions.js

@@ -1,28 +1,29 @@
 import './chunk-AD3BXTJS.js';
-export { ExecutionsListPage } from './chunk-NJRCAE6K.js';
-export { ExecutionDetailPage } from './chunk-WTV6SQYK.js';
-import './chunk-D4WA2M2N.js';
-import './chunk-XNU2PLJ2.js';
-import './chunk-5D4XS3WJ.js';
-import './chunk-SS7Y66P5.js';
-import './chunk-NGXJHYV5.js';
+export { ExecutionsListPage } from './chunk-6EZJ5J3B.js';
+export { ExecutionDetailPage } from './chunk-L44BRLW5.js';
+import './chunk-XLI75E3D.js';
+import './chunk-MSQAULLG.js';
+import './chunk-AG3VC7Y2.js';
+import './chunk-CGR3AEZU.js';
+import './chunk-AMXJLVZN.js';
 import './chunk-5ERAJC2I.js';
-import './chunk-BIB7IH26.js';
+import './chunk-6P7DOBVN.js';
 import './chunk-JDLQ6QIB.js';
-import './chunk-F7LQL43U.js';
+import './chunk-EC2AN74G.js';
 import './chunk-Y53CVZVV.js';
 import './chunk-FNZZ5JJL.js';
-import './chunk-AFX3EKFN.js';
+import './chunk-HOTVUVZG.js';
 import './chunk-PJAWNFJV.js';
 import './chunk-H4ERTSMX.js';
 import './chunk-4VJ3MDOV.js';
-import './chunk-AAIZ6S6E.js';
+import './chunk-C26QAWCT.js';
 import './chunk-5375NUIO.js';
 import './chunk-JL7CASN5.js';
 import './chunk-OCJTTHTS.js';
-import './chunk-PXIFUMLA.js';
-import './chunk-6AMNEX2Y.js';
+import './chunk-AU7LACOY.js';
 import './chunk-G77IGC3Y.js';
 import './chunk-AVHBWJRY.js';
 import './chunk-UULVIT25.js';
-import './chunk-NTWG3CJX.js';
+import './chunk-3IXU7WUC.js';
+import './chunk-US5QSLPV.js';
+import './chunk-UEG2WC3G.js';

package/dist/global-client-N5EIFW6T.js

@@ -0,0 +1,3 @@
+export { createGlobalStoreClient, getGlobalStoreClient, resetGlobalStoreClient, setGlobalStoreClient } from './chunk-AU7LACOY.js';
+import './chunk-US5QSLPV.js';
+import './chunk-UEG2WC3G.js';

package/dist/history.js

@@ -1,16 +1,17 @@
-export { HistoryPage } from './chunk-NYBL5WHP.js';
-import './chunk-KHXRYQYP.js';
+export { HistoryPage } from './chunk-D7G5VWSH.js';
+import './chunk-4QB6S7YW.js';
 import './chunk-FNZZ5JJL.js';
-import './chunk-AFX3EKFN.js';
+import './chunk-HOTVUVZG.js';
 import './chunk-PJAWNFJV.js';
 import './chunk-4VJ3MDOV.js';
-import './chunk-AAIZ6S6E.js';
+import './chunk-C26QAWCT.js';
 import './chunk-5375NUIO.js';
 import './chunk-JL7CASN5.js';
 import './chunk-OCJTTHTS.js';
-import './chunk-PXIFUMLA.js';
-import './chunk-6AMNEX2Y.js';
+import './chunk-AU7LACOY.js';
 import './chunk-G77IGC3Y.js';
 import './chunk-AVHBWJRY.js';
 import './chunk-UULVIT25.js';
-import './chunk-NTWG3CJX.js';
+import './chunk-3IXU7WUC.js';
+import './chunk-US5QSLPV.js';
+import './chunk-UEG2WC3G.js';