import { ApolloLink, InMemoryCache, split, from } from "/_nuxt/node_modules/.cache/vite/client/deps/@apollo_client_core.js?v=e4f18c29";
import { setContext } from "/_nuxt/node_modules/.cache/vite/client/deps/@apollo_client_link_context.js?v=e4f18c29";
import __vite__cjsImport2_subscriptionsTransportWs from "/_nuxt/node_modules/.cache/vite/client/deps/subscriptions-transport-ws.js?v=e4f18c29"; const SubscriptionClient = __vite__cjsImport2_subscriptionsTransportWs["SubscriptionClient"];
import createUploadLink from "/_nuxt/node_modules/.cache/vite/client/deps/apollo-upload-client_createUploadLink__mjs.js?v=e4f18c29";
import { WebSocketLink } from "/_nuxt/node_modules/.cache/vite/client/deps/@apollo_client_link_ws.js?v=e4f18c29";
import { getMainDefinition, Observable } from "/_nuxt/node_modules/.cache/vite/client/deps/@apollo_client_utilities.js?v=e4f18c29";
import { Kind } from "/_nuxt/node_modules/graphql/index.mjs?v=e4f18c29";
import { errorToString } from "/_nuxt/@fs/D:/speckle-server/packages/shared/dist/esm/index.js";
import { useAuthManager } from "/_nuxt/lib/auth/composables/auth.ts";
import {
  buildAbstractCollectionMergeFunction,
  buildArrayMergeFunction,
  incomingOverwritesExistingMergeFunction,
  mergeAsObjectsFunction
} from "/_nuxt/lib/core/helpers/apolloSetup.ts";
import { onError } from "/_nuxt/node_modules/.cache/vite/client/deps/@apollo_client_link_error.js?v=e4f18c29";
import { useAppErrorState } from "/_nuxt/lib/core/composables/error.ts";
import { isInvalidAuth } from "/_nuxt/lib/common/helpers/graphql.ts";
import { intersection, isArray, isBoolean, omit } from "/_nuxt/node_modules/.cache/vite/client/deps/lodash-es.js?v=e4f18c29";
import { useRequestId } from "/_nuxt/lib/core/composables/server.ts";

import { useRuntimeConfig, useNuxtApp } from "/_nuxt/node_modules/nuxt/dist/app/nuxt.js?v=e4f18c29";
import { useApiOrigin } from "/_nuxt/composables/env.ts";
import { markRaw } from "/_nuxt/node_modules/vue/dist/vue.runtime.esm-bundler.js?v=e4f18c29";
const appName = "frontend-2";
function createCache() {
  return new InMemoryCache({
    /**
     * This is where you configure how various GQL fields should be read, written to or merged when new data comes in.
     * If you define a merge function here, you don't need to duplicate the merge logic inside an `update()` callback
     * of a fetchMore call, for example.
     *
     * Feel free to re-use utilities in the `apolloSetup` helper for defining merge functions or even use the ones that come from `@apollo/client/utilities`.
     *
     * Read more: https://www.apollographql.com/docs/react/caching/cache-field-behavior
     */
    typePolicies: {
      Query: {
        fields: {
          otherUser: {
            read(original, { args, toReference }) {
              if (args?.id) {
                return toReference({ __typename: "LimitedUser", id: args.id });
              }
              return original;
            }
          },
          activeUser: {
            merge(existing, incoming, { mergeObjects }) {
              return mergeObjects(existing, incoming);
            },
            read(original, { args, toReference }) {
              if (args?.id) {
                return toReference({ __typename: "User", id: args.id });
              }
              return original;
            }
          },
          user: {
            read(original, { args, toReference }) {
              if (args?.id) {
                return toReference({ __typename: "User", id: args.id });
              }
              return original;
            }
          },
          stream: {
            read(original, { args, toReference }) {
              if (args?.id) {
                return toReference({ __typename: "Stream", id: args.id });
              }
              return original;
            }
          },
          userSearch: {
            keyArgs: ["query", "limit", "archived", "emailOnly"],
            merge: buildAbstractCollectionMergeFunction("UserSearchResultCollection")
          },
          streams: {
            keyArgs: ["query"],
            merge: buildAbstractCollectionMergeFunction("UserStreamCollection", {
              checkIdentity: true
            })
          },
          project: {
            read(original, { args, toReference }) {
              if (args?.id) {
                return toReference({ __typename: "Project", id: args.id });
              }
              return original;
            }
          },
          projects: {
            merge: buildArrayMergeFunction()
          },
          admin: {
            merge: mergeAsObjectsFunction
          }
        }
      },
      AdminQueries: {
        fields: {
          inviteList: {
            keyArgs: ["query"],
            merge: buildAbstractCollectionMergeFunction("AdminInviteList")
          },
          projectList: {
            keyArgs: ["query", "visibility"],
            merge: buildAbstractCollectionMergeFunction("ProjectCollection")
          },
          userList: {
            keyArgs: ["query", "role"],
            merge: buildAbstractCollectionMergeFunction("AdminUserList")
          }
        }
      },
      LimitedUser: {
        fields: {
          commits: {
            keyArgs: false,
            merge: buildAbstractCollectionMergeFunction("CommitCollection")
          }
        }
      },
      User: {
        fields: {
          meta: {
            merge: mergeAsObjectsFunction
          },
          timeline: {
            keyArgs: ["after", "before"],
            merge: buildAbstractCollectionMergeFunction("ActivityCollection")
          },
          commits: {
            keyArgs: false,
            merge: buildAbstractCollectionMergeFunction("CommitCollection")
          },
          favoriteStreams: {
            keyArgs: false,
            merge: buildAbstractCollectionMergeFunction("StreamCollection")
          },
          projects: {
            keyArgs: ["filter", "limit"],
            merge: buildAbstractCollectionMergeFunction("ProjectCollection")
          },
          versions: {
            keyArgs: ["authoredOnly", "limit"],
            merge: buildAbstractCollectionMergeFunction("CountOnlyCollection")
          },
          permissions: {
            merge: mergeAsObjectsFunction
          }
        }
      },
      Project: {
        fields: {
          models: {
            keyArgs: ["filter", "limit"],
            merge: buildAbstractCollectionMergeFunction("ModelCollection")
          },
          versions: {
            keyArgs: ["filter", "limit"],
            merge: buildAbstractCollectionMergeFunction("VersionCollection")
          },
          commentThreads: {
            keyArgs: ["filter", "limit"],
            merge: buildAbstractCollectionMergeFunction("CommentCollection")
          },
          modelsTree: {
            keyArgs: ["filter", "limit"],
            merge: buildAbstractCollectionMergeFunction("ModelsTreeItemCollection")
          },
          replyAuthors: {
            keyArgs: false,
            merge: buildAbstractCollectionMergeFunction("CommentReplyAuthorCollection")
          },
          invitableCollaborators: {
            merge: buildAbstractCollectionMergeFunction(
              "InvitableCollaboratorCollection"
            )
          },
          automations: {
            keyArgs: ["filter", "limit"],
            merge: buildAbstractCollectionMergeFunction("AutomationCollection")
          },
          embedTokens: {
            keyArgs: ["limit"],
            merge: buildAbstractCollectionMergeFunction("EmbedTokenCollection")
          },
          viewerResources: {
            merge: (_existing, incoming) => [...incoming]
          },
          viewerResourcesExtended: {
            merge: true
          },
          model: {
            read(original, { args, toReference }) {
              if (args?.id) {
                return toReference({ __typename: "Model", id: args.id });
              }
              return original;
            }
          },
          team: {
            merge: (_existing, incoming) => incoming
          },
          invitedTeam: {
            merge: (_existing, incoming) => incoming
          },
          pendingImportedModels: {
            merge: (_existing, incoming) => incoming
          },
          permissions: {
            merge: mergeAsObjectsFunction
          },
          savedViewGroups: {
            keyArgs: ["input", ["limit", "search", "onlyAuthored", "resourceIdString"]],
            merge: buildAbstractCollectionMergeFunction("SavedViewGroupCollection")
          }
        }
      },
      SavedViewGroup: {
        fields: {
          views: {
            keyArgs: [
              "input",
              ["limit", "search", "sortBy", "sortDirection", "onlyAuthored"]
            ],
            merge: buildAbstractCollectionMergeFunction("SavedViewCollection")
          },
          permissions: {
            merge: mergeAsObjectsFunction
          }
        }
      },
      Model: {
        fields: {
          versions: {
            keyArgs: ["filter", "limit"],
            merge: buildAbstractCollectionMergeFunction("VersionCollection")
          },
          pendingImportedVersions: {
            merge: (_existing, incoming) => incoming
          },
          permissions: {
            merge: mergeAsObjectsFunction
          },
          uploads: {
            keyArgs: ["input", ["limit"]],
            merge: buildAbstractCollectionMergeFunction("FileUploadCollection")
          }
        }
      },
      Version: {
        fields: {
          permissions: {
            merge: mergeAsObjectsFunction
          }
        }
      },
      Comment: {
        fields: {
          replies: {
            keyArgs: ["limit"]
          },
          permissions: {
            merge: mergeAsObjectsFunction
          }
        }
      },
      Stream: {
        fields: {
          activity: {
            keyArgs: ["after", "before", "actionType"],
            merge: buildAbstractCollectionMergeFunction("ActivityCollection")
          },
          commits: {
            keyArgs: false,
            merge: buildAbstractCollectionMergeFunction("CommitCollection", {
              checkIdentity: true
            })
          },
          pendingCollaborators: {
            merge: incomingOverwritesExistingMergeFunction
          },
          pendingAccessRequests: {
            merge: incomingOverwritesExistingMergeFunction
          }
        }
      },
      Branch: {
        fields: {
          commits: {
            keyArgs: false,
            merge: buildAbstractCollectionMergeFunction("CommitCollection", {
              checkIdentity: true
            })
          }
        }
      },
      BranchCollection: {
        merge: true
      },
      ServerStats: {
        merge: true
      },
      WebhookEventCollection: {
        merge: true
      },
      ServerInfo: {
        merge: true
      },
      ServerConfiguration: {
        merge: true
      },
      WorkspaceSubscription: {
        merge: true
      },
      CommentThreadActivityMessage: {
        merge: true
      },
      SavedViewPermissionChecks: {
        merge: true
      },
      ProjectPermissionChecks: {
        merge: true
      },
      ExtendedViewerResources: {
        merge: true
      },
      DashboardPermissionChecks: {
        merge: true
      },
      AutomateFunction: {
        fields: {
          releases: {
            keyArgs: ["filter", "limit"],
            merge: buildAbstractCollectionMergeFunction(
              "AutomateFunctionReleaseCollection"
            )
          }
        }
      },
      Automation: {
        fields: {
          runs: {
            keyArgs: ["limit"],
            merge: buildAbstractCollectionMergeFunction("AutomateRunCollection")
          }
        }
      },
      Workspace: {
        fields: {
          invitedTeam: {
            merge: incomingOverwritesExistingMergeFunction
          },
          team: {
            keyArgs: ["limit", "filter", ["roles", "search", "seatType"]],
            merge: buildAbstractCollectionMergeFunction(
              "WorkspaceCollaboratorCollection"
            )
          },
          plan: {
            merge: mergeAsObjectsFunction
          },
          planPrices: {
            merge: mergeAsObjectsFunction
          },
          projects: {
            keyArgs: ["filter", "limit"],
            merge: buildAbstractCollectionMergeFunction("ProjectCollection")
          },
          subscription: {
            merge: mergeAsObjectsFunction
          },
          creationState: {
            merge: mergeAsObjectsFunction
          },
          permissions: {
            merge: mergeAsObjectsFunction
          }
        }
      }
    }
  });
}
function createWsClient(params) {
  const { wsEndpoint, authToken, reqId } = params;
  return new SubscriptionClient(
    wsEndpoint,
    {
      reconnect: true,
      connectionParams: () => {
        const Authorization = authToken.value ? `Bearer ${authToken.value}` : null;
        return Authorization ? { Authorization, headers: { Authorization, "x-request-id": reqId } } : {};
      }
    }
    // wsImplementation
  );
}
const coreShouldSkipLoggingErrors = (err) => {
  const specialAuthFields = ["invitedTeam", "billing", "domains", "subscription"];
  const specialAuthFieldErrorCodes = [
    "FORBIDDEN",
    "UNAUTHORIZED",
    "UNAUTHORIZED_ACCESS_ERROR"
  ];
  return !!(err.graphQLErrors && err.graphQLErrors.every(
    (e) => intersection(e.path || [], specialAuthFields).length > 0 && specialAuthFieldErrorCodes.includes(e.extensions?.code)
  ));
};
function createLink(params) {
  const { httpEndpoint, wsClient, authToken, nuxtApp, reqId, logout } = params;
  const {
    registerError,
    preventHttpCalls,
    preventWebsocketMessaging,
    isFullRedirectState
  } = useAppErrorState();
  const stopLink = new ApolloLink((operation, forward) => {
    if (preventHttpCalls.value) {
      return new Observable(() => {
        return () => {
        };
      });
    }
    return forward(operation);
  });
  const errorLink = onError((res) => {
    const logger = nuxtApp.$logger;
    const isSubTokenMissingError = (res.networkError?.message || "").includes(
      "need a token to subscribe"
    );
    let shouldSkip = coreShouldSkipLoggingErrors(res);
    const skipLoggingErrorsResolver = res.operation.getContext().skipLoggingErrors;
    if (skipLoggingErrorsResolver) {
      shouldSkip = isBoolean(skipLoggingErrorsResolver) ? skipLoggingErrorsResolver : skipLoggingErrorsResolver?.(res);
    }
    if (!isSubTokenMissingError && !shouldSkip) {
      const gqlErrors = isArray(res.graphQLErrors) ? res.graphQLErrors : [];
      const errMsg = res.networkError?.message || gqlErrors[0]?.message;
      const shouldLogAsWarn = gqlErrors.every(
        (e) => e.extensions && "statusCode" in e.extensions && typeof e.extensions.statusCode === "number" && e.extensions.statusCode < 500
      );
      const logContext = {
        ...omit(res, ["forward", "response"]),
        networkError: res.networkError ? errorToString(res.networkError) : void 0,
        networkErrorMessage: res.networkError?.message,
        gqlErrorMessages: gqlErrors.map((e) => e.message),
        errorMessage: errMsg,
        graphql: true
      };
      if (shouldLogAsWarn) {
        logger.warn(logContext, "Apollo Client error: {errorMessage}");
      } else {
        logger.error(logContext, "Apollo Client error: {errorMessage}");
      }
    }
    const { networkError } = res;
    if (networkError && isInvalidAuth(networkError) && !isFullRedirectState.value) {
      void logout({ skipToast: true, forceFullReload: true });
    }
    registerError();
  });
  const uploadHttpLink = createUploadLink({ uri: httpEndpoint });
  const authLink = setContext((_, ctx) => {
    const { headers } = ctx;
    const authHeader = authToken.value ? { Authorization: `Bearer ${authToken.value}` } : {};
    return {
      headers: {
        ...headers,
        ...authHeader,
        "x-request-id": reqId,
        "apollo-require-preflight": "true"
      }
    };
  });
  let link = authLink.concat(uploadHttpLink);
  if (wsClient) {
    const wsLink = new WebSocketLink(wsClient);
    link = split(
      ({ query }) => {
        const definition = getMainDefinition(query);
        const { kind, operation } = definition;
        return kind === Kind.OPERATION_DEFINITION && operation === "subscription";
      },
      wsLink,
      link
    );
    wsClient.use([
      {
        applyMiddleware: (_opt, next) => {
          if (preventWebsocketMessaging.value) {
            return;
          }
          next();
        }
      }
    ]);
  }
  const loggerLink = new ApolloLink((operation, forward) => {
    const startTime = Date.now();
    const name = operation.operationName;
    nuxtApp.$logger.debug(
      { operation: name, graphql: true },
      `Apollo operation {operation} started...`
    );
    return forward(operation).map((result) => {
      const elapsed = (/* @__PURE__ */ new Date()).getTime() - startTime;
      const success = !!(result.data && !result.errors?.length);
      nuxtApp.$logger.info(
        {
          operation: name,
          elapsed,
          success,
          graphql: true
        },
        `Apollo operation {operation} finished in {elapsed}ms`
      );
      return result;
    });
  });
  return from([stopLink, ...false ? [loggerLink] : [], errorLink, link]);
}
const defaultConfigResolver = () => {
  const {
    public: { speckleServerVersion = "unknown" }
  } = useRuntimeConfig();
  const apiOrigin = useApiOrigin();
  const nuxtApp = useNuxtApp();
  const reqId = useRequestId();
  const { effectiveAuthToken, logout } = useAuthManager({
    deferredApollo: () => nuxtApp.$apollo?.default
  });
  const httpEndpoint = `${apiOrigin}/graphql`;
  const wsEndpoint = httpEndpoint.replace("http", "ws");
  const wsClient = true ? createWsClient({ wsEndpoint, authToken: effectiveAuthToken, reqId }) : void 0;
  const link = createLink({
    httpEndpoint,
    wsClient,
    authToken: effectiveAuthToken,
    nuxtApp,
    reqId,
    logout
  });
  return {
    // If we don't markRaw the cache, sometimes we get cryptic internal Apollo Client errors that essentially
    // result from parts of its internals being made reactive, even tho they shouldn't be
    cache: markRaw(createCache()),
    link,
    name: appName,
    version: speckleServerVersion,
    defaultOptions: {
      // We want to retain all data even if there are errors, cause there's often fields with special auth requirements that we don't want
      // to be able to kill the entire query. Besides - in most cases partial data is better than no data at all.
      query: {
        errorPolicy: "all"
      },
      mutate: {
        errorPolicy: "all"
      },
      watchQuery: {
        errorPolicy: "all"
      }
    }
  };
};
export default defaultConfigResolver;

//# sourceMappingURL=data:application/json;base64,{"version":3,"mappings":"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","names":[],"ignoreList":[],"sources":["apollo.ts"],"sourcesContent":["import { ApolloLink, InMemoryCache, split, from } from '@apollo/client/core'\r\nimport { setContext } from '@apollo/client/link/context'\r\nimport { SubscriptionClient } from 'subscriptions-transport-ws'\r\nimport type { ApolloConfigResolver } from '~~/lib/core/nuxt-modules/apollo/module'\r\nimport createUploadLink from 'apollo-upload-client/createUploadLink.mjs'\r\nimport { WebSocketLink } from '@apollo/client/link/ws'\r\nimport { getMainDefinition, Observable } from '@apollo/client/utilities'\r\nimport { Kind } from 'graphql'\r\nimport type { GraphQLError, OperationDefinitionNode } from 'graphql'\r\nimport type { CookieRef, NuxtApp } from '#app'\r\nimport { errorToString, type Optional } from '@speckle/shared'\r\nimport { useAuthManager } from '~~/lib/auth/composables/auth'\r\nimport {\r\n  buildAbstractCollectionMergeFunction,\r\n  buildArrayMergeFunction,\r\n  incomingOverwritesExistingMergeFunction,\r\n  mergeAsObjectsFunction\r\n} from '~~/lib/core/helpers/apolloSetup'\r\nimport { onError, type ErrorResponse } from '@apollo/client/link/error'\r\nimport { useAppErrorState } from '~~/lib/core/composables/error'\r\nimport { isInvalidAuth } from '~~/lib/common/helpers/graphql'\r\nimport { intersection, isArray, isBoolean, omit } from 'lodash-es'\r\nimport { useRequestId } from '~/lib/core/composables/server'\r\n\r\nconst appName = 'frontend-2'\r\n\r\nfunction createCache(): InMemoryCache {\r\n  return new InMemoryCache({\r\n    /**\r\n     * This is where you configure how various GQL fields should be read, written to or merged when new data comes in.\r\n     * If you define a merge function here, you don't need to duplicate the merge logic inside an `update()` callback\r\n     * of a fetchMore call, for example.\r\n     *\r\n     * Feel free to re-use utilities in the `apolloSetup` helper for defining merge functions or even use the ones that come from `@apollo/client/utilities`.\r\n     *\r\n     * Read more: https://www.apollographql.com/docs/react/caching/cache-field-behavior\r\n     */\r\n    typePolicies: {\r\n      Query: {\r\n        fields: {\r\n          otherUser: {\r\n            read(original, { args, toReference }) {\r\n              if (args?.id) {\r\n                return toReference({ __typename: 'LimitedUser', id: args.id })\r\n              }\r\n\r\n              return original\r\n            }\r\n          },\r\n          activeUser: {\r\n            merge(existing, incoming, { mergeObjects }) {\r\n              return mergeObjects(existing, incoming)\r\n            },\r\n            read(original, { args, toReference }) {\r\n              if (args?.id) {\r\n                return toReference({ __typename: 'User', id: args.id })\r\n              }\r\n\r\n              return original\r\n            }\r\n          },\r\n          user: {\r\n            read(original, { args, toReference }) {\r\n              if (args?.id) {\r\n                return toReference({ __typename: 'User', id: args.id })\r\n              }\r\n\r\n              return original\r\n            }\r\n          },\r\n          stream: {\r\n            read(original, { args, toReference }) {\r\n              if (args?.id) {\r\n                return toReference({ __typename: 'Stream', id: args.id })\r\n              }\r\n\r\n              return original\r\n            }\r\n          },\r\n          userSearch: {\r\n            keyArgs: ['query', 'limit', 'archived', 'emailOnly'],\r\n            merge: buildAbstractCollectionMergeFunction('UserSearchResultCollection')\r\n          },\r\n          streams: {\r\n            keyArgs: ['query'],\r\n            merge: buildAbstractCollectionMergeFunction('UserStreamCollection', {\r\n              checkIdentity: true\r\n            })\r\n          },\r\n          project: {\r\n            read(original, { args, toReference }) {\r\n              if (args?.id) {\r\n                return toReference({ __typename: 'Project', id: args.id })\r\n              }\r\n\r\n              return original\r\n            }\r\n          },\r\n          projects: {\r\n            merge: buildArrayMergeFunction()\r\n          },\r\n          admin: {\r\n            merge: mergeAsObjectsFunction\r\n          }\r\n        }\r\n      },\r\n      AdminQueries: {\r\n        fields: {\r\n          inviteList: {\r\n            keyArgs: ['query'],\r\n            merge: buildAbstractCollectionMergeFunction('AdminInviteList')\r\n          },\r\n          projectList: {\r\n            keyArgs: ['query', 'visibility'],\r\n            merge: buildAbstractCollectionMergeFunction('ProjectCollection')\r\n          },\r\n          userList: {\r\n            keyArgs: ['query', 'role'],\r\n            merge: buildAbstractCollectionMergeFunction('AdminUserList')\r\n          }\r\n        }\r\n      },\r\n      LimitedUser: {\r\n        fields: {\r\n          commits: {\r\n            keyArgs: false,\r\n            merge: buildAbstractCollectionMergeFunction('CommitCollection')\r\n          }\r\n        }\r\n      },\r\n      User: {\r\n        fields: {\r\n          meta: {\r\n            merge: mergeAsObjectsFunction\r\n          },\r\n          timeline: {\r\n            keyArgs: ['after', 'before'],\r\n            merge: buildAbstractCollectionMergeFunction('ActivityCollection')\r\n          },\r\n          commits: {\r\n            keyArgs: false,\r\n            merge: buildAbstractCollectionMergeFunction('CommitCollection')\r\n          },\r\n          favoriteStreams: {\r\n            keyArgs: false,\r\n            merge: buildAbstractCollectionMergeFunction('StreamCollection')\r\n          },\r\n          projects: {\r\n            keyArgs: ['filter', 'limit'],\r\n            merge: buildAbstractCollectionMergeFunction('ProjectCollection')\r\n          },\r\n          versions: {\r\n            keyArgs: ['authoredOnly', 'limit'],\r\n            merge: buildAbstractCollectionMergeFunction('CountOnlyCollection')\r\n          },\r\n          permissions: {\r\n            merge: mergeAsObjectsFunction\r\n          }\r\n        }\r\n      },\r\n      Project: {\r\n        fields: {\r\n          models: {\r\n            keyArgs: ['filter', 'limit'],\r\n            merge: buildAbstractCollectionMergeFunction('ModelCollection')\r\n          },\r\n          versions: {\r\n            keyArgs: ['filter', 'limit'],\r\n            merge: buildAbstractCollectionMergeFunction('VersionCollection')\r\n          },\r\n          commentThreads: {\r\n            keyArgs: ['filter', 'limit'],\r\n            merge: buildAbstractCollectionMergeFunction('CommentCollection')\r\n          },\r\n          modelsTree: {\r\n            keyArgs: ['filter', 'limit'],\r\n            merge: buildAbstractCollectionMergeFunction('ModelsTreeItemCollection')\r\n          },\r\n          replyAuthors: {\r\n            keyArgs: false,\r\n            merge: buildAbstractCollectionMergeFunction('CommentReplyAuthorCollection')\r\n          },\r\n          invitableCollaborators: {\r\n            merge: buildAbstractCollectionMergeFunction(\r\n              'InvitableCollaboratorCollection'\r\n            )\r\n          },\r\n          automations: {\r\n            keyArgs: ['filter', 'limit'],\r\n            merge: buildAbstractCollectionMergeFunction('AutomationCollection')\r\n          },\r\n          embedTokens: {\r\n            keyArgs: ['limit'],\r\n            merge: buildAbstractCollectionMergeFunction('EmbedTokenCollection')\r\n          },\r\n          viewerResources: {\r\n            merge: (_existing, incoming) => [...incoming]\r\n          },\r\n          viewerResourcesExtended: {\r\n            merge: true\r\n          },\r\n          model: {\r\n            read(original, { args, toReference }) {\r\n              if (args?.id) {\r\n                return toReference({ __typename: 'Model', id: args.id })\r\n              }\r\n\r\n              return original\r\n            }\r\n          },\r\n          team: {\r\n            merge: (_existing, incoming) => incoming\r\n          },\r\n          invitedTeam: {\r\n            merge: (_existing, incoming) => incoming\r\n          },\r\n          pendingImportedModels: {\r\n            merge: (_existing, incoming) => incoming\r\n          },\r\n          permissions: {\r\n            merge: mergeAsObjectsFunction\r\n          },\r\n          savedViewGroups: {\r\n            keyArgs: ['input', ['limit', 'search', 'onlyAuthored', 'resourceIdString']],\r\n            merge: buildAbstractCollectionMergeFunction('SavedViewGroupCollection')\r\n          }\r\n        }\r\n      },\r\n      SavedViewGroup: {\r\n        fields: {\r\n          views: {\r\n            keyArgs: [\r\n              'input',\r\n              ['limit', 'search', 'sortBy', 'sortDirection', 'onlyAuthored']\r\n            ],\r\n            merge: buildAbstractCollectionMergeFunction('SavedViewCollection')\r\n          },\r\n          permissions: {\r\n            merge: mergeAsObjectsFunction\r\n          }\r\n        }\r\n      },\r\n      Model: {\r\n        fields: {\r\n          versions: {\r\n            keyArgs: ['filter', 'limit'],\r\n            merge: buildAbstractCollectionMergeFunction('VersionCollection')\r\n          },\r\n          pendingImportedVersions: {\r\n            merge: (_existing, incoming) => incoming\r\n          },\r\n          permissions: {\r\n            merge: mergeAsObjectsFunction\r\n          },\r\n          uploads: {\r\n            keyArgs: ['input', ['limit']],\r\n            merge: buildAbstractCollectionMergeFunction('FileUploadCollection')\r\n          }\r\n        }\r\n      },\r\n      Version: {\r\n        fields: {\r\n          permissions: {\r\n            merge: mergeAsObjectsFunction\r\n          }\r\n        }\r\n      },\r\n      Comment: {\r\n        fields: {\r\n          replies: {\r\n            keyArgs: ['limit']\r\n          },\r\n          permissions: {\r\n            merge: mergeAsObjectsFunction\r\n          }\r\n        }\r\n      },\r\n      Stream: {\r\n        fields: {\r\n          activity: {\r\n            keyArgs: ['after', 'before', 'actionType'],\r\n            merge: buildAbstractCollectionMergeFunction('ActivityCollection')\r\n          },\r\n          commits: {\r\n            keyArgs: false,\r\n            merge: buildAbstractCollectionMergeFunction('CommitCollection', {\r\n              checkIdentity: true\r\n            })\r\n          },\r\n          pendingCollaborators: {\r\n            merge: incomingOverwritesExistingMergeFunction\r\n          },\r\n          pendingAccessRequests: {\r\n            merge: incomingOverwritesExistingMergeFunction\r\n          }\r\n        }\r\n      },\r\n      Branch: {\r\n        fields: {\r\n          commits: {\r\n            keyArgs: false,\r\n            merge: buildAbstractCollectionMergeFunction('CommitCollection', {\r\n              checkIdentity: true\r\n            })\r\n          }\r\n        }\r\n      },\r\n      BranchCollection: {\r\n        merge: true\r\n      },\r\n      ServerStats: {\r\n        merge: true\r\n      },\r\n      WebhookEventCollection: {\r\n        merge: true\r\n      },\r\n      ServerInfo: {\r\n        merge: true\r\n      },\r\n      ServerConfiguration: {\r\n        merge: true\r\n      },\r\n      WorkspaceSubscription: {\r\n        merge: true\r\n      },\r\n      CommentThreadActivityMessage: {\r\n        merge: true\r\n      },\r\n      SavedViewPermissionChecks: {\r\n        merge: true\r\n      },\r\n      ProjectPermissionChecks: {\r\n        merge: true\r\n      },\r\n      ExtendedViewerResources: {\r\n        merge: true\r\n      },\r\n      DashboardPermissionChecks: {\r\n        merge: true\r\n      },\r\n      AutomateFunction: {\r\n        fields: {\r\n          releases: {\r\n            keyArgs: ['filter', 'limit'],\r\n            merge: buildAbstractCollectionMergeFunction(\r\n              'AutomateFunctionReleaseCollection'\r\n            )\r\n          }\r\n        }\r\n      },\r\n      Automation: {\r\n        fields: {\r\n          runs: {\r\n            keyArgs: ['limit'],\r\n            merge: buildAbstractCollectionMergeFunction('AutomateRunCollection')\r\n          }\r\n        }\r\n      },\r\n      Workspace: {\r\n        fields: {\r\n          invitedTeam: {\r\n            merge: incomingOverwritesExistingMergeFunction\r\n          },\r\n          team: {\r\n            keyArgs: ['limit', 'filter', ['roles', 'search', 'seatType']],\r\n            merge: buildAbstractCollectionMergeFunction(\r\n              'WorkspaceCollaboratorCollection'\r\n            )\r\n          },\r\n          plan: {\r\n            merge: mergeAsObjectsFunction\r\n          },\r\n          planPrices: {\r\n            merge: mergeAsObjectsFunction\r\n          },\r\n          projects: {\r\n            keyArgs: ['filter', 'limit'],\r\n            merge: buildAbstractCollectionMergeFunction('ProjectCollection')\r\n          },\r\n          subscription: {\r\n            merge: mergeAsObjectsFunction\r\n          },\r\n          creationState: {\r\n            merge: mergeAsObjectsFunction\r\n          },\r\n          permissions: {\r\n            merge: mergeAsObjectsFunction\r\n          }\r\n        }\r\n      }\r\n    }\r\n  })\r\n}\r\n\r\nfunction createWsClient(params: {\r\n  wsEndpoint: string\r\n  authToken: CookieRef<Optional<string>>\r\n  reqId: string\r\n}): SubscriptionClient {\r\n  const { wsEndpoint, authToken, reqId } = params\r\n\r\n  // WS IN SSR DOESN'T WORK CURRENTLY CAUSE OF SOME NUXT TRANSPILATION WEIRDNESS\r\n  // SO DON'T RUN createWsClient in SSR\r\n\r\n  // const wsImplementation = process.server ? (await import('ws')).default : undefined\r\n  return new SubscriptionClient(\r\n    wsEndpoint,\r\n    {\r\n      reconnect: true,\r\n      connectionParams: () => {\r\n        const Authorization = authToken.value ? `Bearer ${authToken.value}` : null\r\n        return Authorization\r\n          ? { Authorization, headers: { Authorization, 'x-request-id': reqId } }\r\n          : {}\r\n      }\r\n    }\r\n    // wsImplementation\r\n  )\r\n}\r\n\r\nconst coreShouldSkipLoggingErrors = (err: ErrorResponse): boolean => {\r\n  // These fields have special auth requirements and will often throw errors that we don't want to log\r\n  const specialAuthFields = ['invitedTeam', 'billing', 'domains', 'subscription']\r\n  const specialAuthFieldErrorCodes = [\r\n    'FORBIDDEN',\r\n    'UNAUTHORIZED',\r\n    'UNAUTHORIZED_ACCESS_ERROR'\r\n  ]\r\n\r\n  return !!(\r\n    err.graphQLErrors &&\r\n    err.graphQLErrors.every(\r\n      (e) =>\r\n        intersection(e.path || [], specialAuthFields).length > 0 &&\r\n        specialAuthFieldErrorCodes.includes(e.extensions?.code as string)\r\n    )\r\n  )\r\n}\r\n\r\nfunction createLink(params: {\r\n  httpEndpoint: string\r\n  wsClient?: SubscriptionClient\r\n  authToken: CookieRef<Optional<string>>\r\n  nuxtApp: NuxtApp\r\n  reqId: string\r\n  logout: ReturnType<typeof useAuthManager>['logout']\r\n}): ApolloLink {\r\n  const { httpEndpoint, wsClient, authToken, nuxtApp, reqId, logout } = params\r\n  const {\r\n    registerError,\r\n    preventHttpCalls,\r\n    preventWebsocketMessaging,\r\n    isFullRedirectState\r\n  } = useAppErrorState()\r\n\r\n  const stopLink = new ApolloLink((operation, forward) => {\r\n    if (preventHttpCalls.value) {\r\n      // swallow the req, we're blocking them all\r\n      return new Observable(() => {\r\n        return () => {}\r\n      })\r\n    }\r\n\r\n    return forward(operation)\r\n  })\r\n\r\n  const errorLink = onError((res) => {\r\n    const logger = nuxtApp.$logger\r\n    const isSubTokenMissingError = (res.networkError?.message || '').includes(\r\n      'need a token to subscribe'\r\n    )\r\n\r\n    let shouldSkip = coreShouldSkipLoggingErrors(res)\r\n    const skipLoggingErrorsResolver = res.operation.getContext().skipLoggingErrors\r\n    if (skipLoggingErrorsResolver) {\r\n      shouldSkip = isBoolean(skipLoggingErrorsResolver)\r\n        ? skipLoggingErrorsResolver\r\n        : skipLoggingErrorsResolver?.(res)\r\n    }\r\n\r\n    if (!isSubTokenMissingError && !shouldSkip) {\r\n      const gqlErrors: Array<GraphQLError> = isArray(res.graphQLErrors)\r\n        ? res.graphQLErrors\r\n        : []\r\n      const errMsg = res.networkError?.message || gqlErrors[0]?.message\r\n\r\n      // only log as error if at least one error has a status code of 5xx or has no status code\r\n      const shouldLogAsWarn = gqlErrors.every(\r\n        (e) =>\r\n          e.extensions &&\r\n          'statusCode' in e.extensions &&\r\n          typeof e.extensions.statusCode === 'number' &&\r\n          e.extensions.statusCode < 500\r\n      )\r\n      const logContext = {\r\n        ...omit(res, ['forward', 'response']),\r\n        networkError: res.networkError ? errorToString(res.networkError) : undefined,\r\n        networkErrorMessage: res.networkError?.message,\r\n        gqlErrorMessages: gqlErrors.map((e) => e.message),\r\n        errorMessage: errMsg,\r\n        graphql: true\r\n      }\r\n\r\n      if (shouldLogAsWarn) {\r\n        logger.warn(logContext, 'Apollo Client error: {errorMessage}')\r\n      } else {\r\n        logger.error(logContext, 'Apollo Client error: {errorMessage}')\r\n      }\r\n    }\r\n\r\n    const { networkError } = res\r\n    if (networkError && isInvalidAuth(networkError) && !isFullRedirectState.value) {\r\n      // Reset auth\r\n      // since this may happen mid-routing, a standard router.push call may not work - do full reload\r\n      void logout({ skipToast: true, forceFullReload: true })\r\n    }\r\n\r\n    registerError()\r\n  })\r\n\r\n  // TODO: Do we even need upload client?\r\n  // Prepare links\r\n  // Decide between upload link and batch link based on whether variables contain File/Blob/FileList\r\n  // const hasUpload = (val: unknown): boolean => {\r\n  //   if (!val) return false\r\n  //   // Guard for SSR where File/Blob/FileList may be undefined\r\n  //   const isFile =\r\n  //     typeof File !== 'undefined' && typeof val === 'object' && val instanceof File\r\n  //   const isBlob =\r\n  //     typeof Blob !== 'undefined' && typeof val === 'object' && val instanceof Blob\r\n  //   const isFileList =\r\n  //     typeof FileList !== 'undefined' &&\r\n  //     typeof val === 'object' &&\r\n  //     val instanceof FileList\r\n  //   if (isFile || isBlob) return true\r\n  //   if (isFileList) return Array.from(val as FileList).some((v) => hasUpload(v))\r\n  //   if (Array.isArray(val)) return val.some((v) => hasUpload(v))\r\n  //   if (typeof val === 'object') {\r\n  //     for (const k in val as Record<string, unknown>) {\r\n  //       if (hasUpload((val as Record<string, unknown>)[k])) return true\r\n  //     }\r\n  //   }\r\n  //   return false\r\n  // }\r\n\r\n  const uploadHttpLink = createUploadLink({ uri: httpEndpoint })\r\n  // const batchHttpLink = new BatchHttpLink({\r\n  //   uri: httpEndpoint,\r\n  //   batchMax: 10,\r\n  //   batchInterval: 20,\r\n  //   // Keep batches “compatible” (avoid mixing ops with different auth/headers)\r\n  //   batchKey: (op) =>\r\n  //     JSON.stringify({\r\n  //       uri: op.getContext().uri,\r\n  //       headers: op.getContext().headers,\r\n  //       credentials: op.getContext().credentials\r\n  //     })\r\n  // })\r\n  // const httpLink = split(\r\n  //   (operation) => hasUpload(operation.variables),\r\n  //   // If there's an upload in variables -> use upload link, else batch\r\n  //   uploadHttpLink,\r\n  //   batchHttpLink\r\n  // )\r\n\r\n  const authLink = setContext((_, ctx) => {\r\n    const { headers } = ctx\r\n    const authHeader = authToken.value\r\n      ? { Authorization: `Bearer ${authToken.value}` }\r\n      : {}\r\n    return {\r\n      headers: {\r\n        ...headers,\r\n        ...authHeader,\r\n        'x-request-id': reqId,\r\n        'apollo-require-preflight': 'true'\r\n      }\r\n    }\r\n  })\r\n\r\n  let link = authLink.concat(uploadHttpLink)\r\n\r\n  if (wsClient) {\r\n    const wsLink = new WebSocketLink(wsClient)\r\n    link = split(\r\n      ({ query }) => {\r\n        const definition = getMainDefinition(query) as OperationDefinitionNode\r\n        const { kind, operation } = definition\r\n\r\n        return kind === Kind.OPERATION_DEFINITION && operation === 'subscription'\r\n      },\r\n      wsLink,\r\n      link\r\n    )\r\n\r\n    // Stopping WS when in error state\r\n    wsClient.use([\r\n      {\r\n        applyMiddleware: (_opt, next) => {\r\n          if (preventWebsocketMessaging.value) {\r\n            return // never invokes next() - essentially stuck\r\n          }\r\n\r\n          next()\r\n        }\r\n      }\r\n    ])\r\n  }\r\n\r\n  // SSR req logging link\r\n  const loggerLink = new ApolloLink((operation, forward) => {\r\n    const startTime = Date.now()\r\n    const name = operation.operationName\r\n\r\n    nuxtApp.$logger.debug(\r\n      { operation: name, graphql: true },\r\n      `Apollo operation {operation} started...`\r\n    )\r\n    return forward(operation).map((result) => {\r\n      const elapsed = new Date().getTime() - startTime\r\n      const success = !!(result.data && !result.errors?.length)\r\n\r\n      nuxtApp.$logger.info(\r\n        {\r\n          operation: name,\r\n          elapsed,\r\n          success,\r\n          graphql: true\r\n        },\r\n        `Apollo operation {operation} finished in {elapsed}ms`\r\n      )\r\n\r\n      return result\r\n    })\r\n  })\r\n\r\n  return from([stopLink, ...(import.meta.server ? [loggerLink] : []), errorLink, link])\r\n}\r\n\r\nconst defaultConfigResolver: ApolloConfigResolver = () => {\r\n  const {\r\n    public: { speckleServerVersion = 'unknown' }\r\n  } = useRuntimeConfig()\r\n  const apiOrigin = useApiOrigin()\r\n  const nuxtApp = useNuxtApp()\r\n  const reqId = useRequestId()\r\n  const { effectiveAuthToken, logout } = useAuthManager({\r\n    deferredApollo: () => nuxtApp.$apollo?.default\r\n  })\r\n\r\n  const httpEndpoint = `${apiOrigin}/graphql`\r\n  const wsEndpoint = httpEndpoint.replace('http', 'ws')\r\n\r\n  const wsClient = import.meta.client\r\n    ? createWsClient({ wsEndpoint, authToken: effectiveAuthToken, reqId })\r\n    : undefined\r\n  const link = createLink({\r\n    httpEndpoint,\r\n    wsClient,\r\n    authToken: effectiveAuthToken,\r\n    nuxtApp,\r\n    reqId,\r\n    logout\r\n  })\r\n\r\n  return {\r\n    // If we don't markRaw the cache, sometimes we get cryptic internal Apollo Client errors that essentially\r\n    // result from parts of its internals being made reactive, even tho they shouldn't be\r\n    cache: markRaw(createCache()),\r\n    link,\r\n    name: appName,\r\n    version: speckleServerVersion,\r\n    defaultOptions: {\r\n      // We want to retain all data even if there are errors, cause there's often fields with special auth requirements that we don't want\r\n      // to be able to kill the entire query. Besides - in most cases partial data is better than no data at all.\r\n      query: {\r\n        errorPolicy: 'all'\r\n      },\r\n      mutate: {\r\n        errorPolicy: 'all'\r\n      },\r\n      watchQuery: {\r\n        errorPolicy: 'all'\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\nexport default defaultConfigResolver\r\n"],"file":"D:/speckle-server/packages/frontend-2/lib/core/configs/apollo.ts"}