@manta-eu/client 0.8.0 → 0.8.1

package/src/generated/graphql.ts

@@ -860,6 +860,7 @@ export type GQLDatastoreSubscription = {
   inGoodStanding: Scalars["Boolean"]["output"];
   interval?: Maybe<Scalars["String"]["output"]>;
   intervalCount?: Maybe<Scalars["Int"]["output"]>;
+  managed: Scalars["Boolean"]["output"];
   productIds: Array<Scalars["String"]["output"]>;
   status: Scalars["String"]["output"];
 };
@@ -1635,6 +1636,15 @@ export type GQLMetaAdAccount = {
   unavailableReason?: Maybe<GQLSetupAccountUnavailableReason>;
 };
 
+export type GQLMetaInterestSuggestion = {
+  __typename?: "MetaInterestSuggestion";
+  audienceSizeLowerBound?: Maybe<Scalars["Float"]["output"]>;
+  audienceSizeUpperBound?: Maybe<Scalars["Float"]["output"]>;
+  id: Scalars["String"]["output"];
+  name: Scalars["String"]["output"];
+  path: Array<Scalars["String"]["output"]>;
+};
+
 export type GQLMetaPage = {
   __typename?: "MetaPage";
   id: Scalars["String"]["output"];
@@ -1760,6 +1770,7 @@ export type GQLMutation = {
   provisionDatastore: GQLProvisionDatastoreResponse;
   reconfirmMemory: GQLUpdateMemoryResponse;
   recordHotelProfile: GQLRecordHotelProfileResponse;
+  refreshResources: GQLRefreshResourcesResponse;
   registerDatastore: GQLRegisterDatastoreResponse;
   releaseRuleOwnership: GQLReleaseRuleOwnershipResponse;
   removeCustomAppUser: GQLCustomAppUserRemoval;
@@ -2072,6 +2083,10 @@ export type GQLMutationRecordHotelProfileArgs = {
   input: GQLHotelProfileInput;
 };
 
+export type GQLMutationRefreshResourcesArgs = {
+  resources: Array<GQLRefreshResourceInput>;
+};
+
 export type GQLMutationRegisterDatastoreArgs = {
   datastoreId: Scalars["String"]["input"];
 };
@@ -2369,6 +2384,7 @@ export type GQLQuery = {
   memoryRedundancyReview: GQLMemoryRedundancyResult;
   memoryReplaySeries: GQLMemoryReplaySeriesResult;
   memorySchemas: GQLMemorySchemasResponse;
+  metaInterestSuggestions: Array<GQLMetaInterestSuggestion>;
   metaSetupProgress: GQLMetaSetupProgress;
   microsoftAdsSetupProgress: GQLMicrosoftAdsSetupProgress;
   nodeProperties: GQLNodePropertiesResponse;
@@ -2377,6 +2393,8 @@ export type GQLQuery = {
   organizationLinking?: Maybe<GQLOrganizationLinking>;
   organizationNameAvailable: GQLOrganizationNameAvailability;
   pendingInvitations: Array<GQLPendingInvitation>;
+  refreshResourceCapabilities: GQLRefreshResourceCapabilitiesResponse;
+  refreshResourcesStatus: GQLRefreshResourcesStatusResponse;
   rules: GQLRulesResponse;
   sessionContext: GQLSessionContext;
   shaclShapes: GQLShaclShapesResponse;
@@ -2525,6 +2543,13 @@ export type GQLQueryMemoryReplaySeriesArgs = {
   limit?: InputMaybe<Scalars["Int"]["input"]>;
 };
 
+export type GQLQueryMetaInterestSuggestionsArgs = {
+  adAccountIri: Scalars["IRI"]["input"];
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  locale?: InputMaybe<Scalars["String"]["input"]>;
+  term: Scalars["String"]["input"];
+};
+
 export type GQLQueryNodePropertiesArgs = {
   nodeIri: Scalars["String"]["input"];
   planGraphIri?: InputMaybe<Scalars["IRI"]["input"]>;
@@ -2540,6 +2565,14 @@ export type GQLQueryOrganizationNameAvailableArgs = {
   name: Scalars["String"]["input"];
 };
 
+export type GQLQueryRefreshResourceCapabilitiesArgs = {
+  rdfTypes: Array<Scalars["String"]["input"]>;
+};
+
+export type GQLQueryRefreshResourcesStatusArgs = {
+  workflowId: Scalars["String"]["input"];
+};
+
 export type GQLQueryRulesArgs = {
   filterByOwner?: InputMaybe<Scalars["String"]["input"]>;
   includeDependencyGraph?: InputMaybe<Scalars["Boolean"]["input"]>;
@@ -2613,6 +2646,53 @@ export type GQLRecordHotelProfileResponse = {
   error?: Maybe<Scalars["String"]["output"]>;
 };
 
+export type GQLRefreshResourceCapabilitiesResponse = {
+  __typename?: "RefreshResourceCapabilitiesResponse";
+  capabilities: Array<GQLRefreshResourceCapability>;
+};
+
+export type GQLRefreshResourceCapability = {
+  __typename?: "RefreshResourceCapability";
+  rdfType: Scalars["String"]["output"];
+  supportsRefresh: Scalars["Boolean"]["output"];
+};
+
+export type GQLRefreshResourceInput = {
+  iri: Scalars["String"]["input"];
+  type: Scalars["String"]["input"];
+};
+
+export type GQLRefreshResourceResult = {
+  __typename?: "RefreshResourceResult";
+  iri: Scalars["String"]["output"];
+  refreshStatus: GQLRefreshResourceStatus;
+  type: Scalars["String"]["output"];
+};
+
+export enum GQLRefreshResourceStatus {
+  NotReadable = "NOT_READABLE",
+  NotSynced = "NOT_SYNCED",
+  Synced = "SYNCED",
+}
+
+export type GQLRefreshResourcesResponse = {
+  __typename?: "RefreshResourcesResponse";
+  workflowId: Scalars["String"]["output"];
+};
+
+export type GQLRefreshResourcesStatusResponse = {
+  __typename?: "RefreshResourcesStatusResponse";
+  error?: Maybe<Scalars["String"]["output"]>;
+  results?: Maybe<Array<GQLRefreshResourceResult>>;
+  status: GQLRefreshWorkflowStatus;
+};
+
+export enum GQLRefreshWorkflowStatus {
+  Completed = "COMPLETED",
+  Failed = "FAILED",
+  Running = "RUNNING",
+}
+
 export type GQLRegisterDatastoreResponse = {
   __typename?: "RegisterDatastoreResponse";
   error?: Maybe<Scalars["String"]["output"]>;
@@ -4265,6 +4345,15 @@ export type GQLReconfirmMemoryMutation = {
   };
 };
 
+export type GQLRefreshResourcesMutationVariables = Exact<{
+  resources: Array<GQLRefreshResourceInput> | GQLRefreshResourceInput;
+}>;
+
+export type GQLRefreshResourcesMutation = {
+  __typename?: "Mutation";
+  refreshResources: { __typename?: "RefreshResourcesResponse"; workflowId: string };
+};
+
 export type GQLRegisterDatastoreMutationVariables = Exact<{
   datastoreId: Scalars["String"]["input"];
 }>;
@@ -5368,6 +5457,7 @@ export type GQLDatastoreSubscriptionsQuery = {
     datastoreId: string;
     status: string;
     inGoodStanding: boolean;
+    managed: boolean;
     amount?: number | null;
     currency?: string | null;
     interval?: string | null;
@@ -5738,6 +5828,25 @@ export type GQLMemorySchemasQuery = {
   };
 };
 
+export type GQLMetaInterestSuggestionsQueryVariables = Exact<{
+  adAccountIri: Scalars["IRI"]["input"];
+  term: Scalars["String"]["input"];
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  locale?: InputMaybe<Scalars["String"]["input"]>;
+}>;
+
+export type GQLMetaInterestSuggestionsQuery = {
+  __typename?: "Query";
+  metaInterestSuggestions: Array<{
+    __typename?: "MetaInterestSuggestion";
+    id: string;
+    name: string;
+    path: Array<string>;
+    audienceSizeLowerBound?: number | null;
+    audienceSizeUpperBound?: number | null;
+  }>;
+};
+
 export type GQLMetaSetupProgressQueryVariables = Exact<{ [key: string]: never }>;
 
 export type GQLMetaSetupProgressQuery = {
@@ -5866,6 +5975,37 @@ export type GQLProfileQuery = {
   };
 };
 
+export type GQLRefreshResourceCapabilitiesQueryVariables = Exact<{
+  rdfTypes: Array<Scalars["String"]["input"]> | Scalars["String"]["input"];
+}>;
+
+export type GQLRefreshResourceCapabilitiesQuery = {
+  __typename?: "Query";
+  refreshResourceCapabilities: {
+    __typename?: "RefreshResourceCapabilitiesResponse";
+    capabilities: Array<{ __typename?: "RefreshResourceCapability"; rdfType: string; supportsRefresh: boolean }>;
+  };
+};
+
+export type GQLRefreshResourcesStatusQueryVariables = Exact<{
+  workflowId: Scalars["String"]["input"];
+}>;
+
+export type GQLRefreshResourcesStatusQuery = {
+  __typename?: "Query";
+  refreshResourcesStatus: {
+    __typename?: "RefreshResourcesStatusResponse";
+    status: GQLRefreshWorkflowStatus;
+    error?: string | null;
+    results?: Array<{
+      __typename?: "RefreshResourceResult";
+      iri: string;
+      type: string;
+      refreshStatus: GQLRefreshResourceStatus;
+    }> | null;
+  };
+};
+
 export type GQLRulesQueryVariables = Exact<{
   ruleIri?: InputMaybe<Scalars["IRI"]["input"]>;
   filterByOwner?: InputMaybe<Scalars["String"]["input"]>;
@@ -8303,6 +8443,32 @@ export const useReconfirmMemoryMutation = <TError = unknown, TContext = unknown>
   });
 };
 
+export const RefreshResourcesDocument = `
+    mutation RefreshResources($resources: [RefreshResourceInput!]!) {
+  refreshResources(resources: $resources) {
+    workflowId
+  }
+}
+    `;
+
+export const useRefreshResourcesMutation = <TError = unknown, TContext = unknown>(
+  client: GraphQLClient,
+  options?: UseMutationOptions<GQLRefreshResourcesMutation, TError, GQLRefreshResourcesMutationVariables, TContext>,
+  headers?: RequestInit["headers"],
+) => {
+  return useMutation<GQLRefreshResourcesMutation, TError, GQLRefreshResourcesMutationVariables, TContext>({
+    mutationKey: ["RefreshResources"],
+    mutationFn: (variables?: GQLRefreshResourcesMutationVariables) =>
+      fetcher<GQLRefreshResourcesMutation, GQLRefreshResourcesMutationVariables>(
+        client,
+        RefreshResourcesDocument,
+        variables,
+        headers,
+      )(),
+    ...options,
+  });
+};
+
 export const RegisterDatastoreDocument = `
     mutation RegisterDatastore($datastoreId: String!) {
   registerDatastore(datastoreId: $datastoreId) {
@@ -10636,6 +10802,7 @@ export const DatastoreSubscriptionsDocument = `
     datastoreId
     status
     inGoodStanding
+    managed
     amount
     currency
     interval
@@ -11615,6 +11782,73 @@ export const useSuspenseMemorySchemasQuery = <TData = GQLMemorySchemasQuery, TEr
 useSuspenseMemorySchemasQuery.getKey = (variables?: GQLMemorySchemasQueryVariables) =>
   variables === undefined ? ["MemorySchemasSuspense"] : ["MemorySchemasSuspense", variables];
 
+export const MetaInterestSuggestionsDocument = `
+    query MetaInterestSuggestions($adAccountIri: IRI!, $term: String!, $limit: Int, $locale: String) {
+  metaInterestSuggestions(
+    adAccountIri: $adAccountIri
+    term: $term
+    limit: $limit
+    locale: $locale
+  ) {
+    id
+    name
+    path
+    audienceSizeLowerBound
+    audienceSizeUpperBound
+  }
+}
+    `;
+
+export const useMetaInterestSuggestionsQuery = <TData = GQLMetaInterestSuggestionsQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables: GQLMetaInterestSuggestionsQueryVariables,
+  options?: Omit<UseQueryOptions<GQLMetaInterestSuggestionsQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseQueryOptions<GQLMetaInterestSuggestionsQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useQuery<GQLMetaInterestSuggestionsQuery, TError, TData>({
+    queryKey: ["MetaInterestSuggestions", variables],
+    queryFn: fetcher<GQLMetaInterestSuggestionsQuery, GQLMetaInterestSuggestionsQueryVariables>(
+      client,
+      MetaInterestSuggestionsDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useMetaInterestSuggestionsQuery.getKey = (variables: GQLMetaInterestSuggestionsQueryVariables) => [
+  "MetaInterestSuggestions",
+  variables,
+];
+
+export const useSuspenseMetaInterestSuggestionsQuery = <TData = GQLMetaInterestSuggestionsQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables: GQLMetaInterestSuggestionsQueryVariables,
+  options?: Omit<UseSuspenseQueryOptions<GQLMetaInterestSuggestionsQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseSuspenseQueryOptions<GQLMetaInterestSuggestionsQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useSuspenseQuery<GQLMetaInterestSuggestionsQuery, TError, TData>({
+    queryKey: ["MetaInterestSuggestionsSuspense", variables],
+    queryFn: fetcher<GQLMetaInterestSuggestionsQuery, GQLMetaInterestSuggestionsQueryVariables>(
+      client,
+      MetaInterestSuggestionsDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useSuspenseMetaInterestSuggestionsQuery.getKey = (variables: GQLMetaInterestSuggestionsQueryVariables) => [
+  "MetaInterestSuggestionsSuspense",
+  variables,
+];
+
 export const MetaSetupProgressDocument = `
     query MetaSetupProgress {
   metaSetupProgress {
@@ -12044,6 +12278,134 @@ export const useSuspenseProfileQuery = <TData = GQLProfileQuery, TError = unknow
 useSuspenseProfileQuery.getKey = (variables?: GQLProfileQueryVariables) =>
   variables === undefined ? ["ProfileSuspense"] : ["ProfileSuspense", variables];
 
+export const RefreshResourceCapabilitiesDocument = `
+    query RefreshResourceCapabilities($rdfTypes: [String!]!) {
+  refreshResourceCapabilities(rdfTypes: $rdfTypes) {
+    capabilities {
+      rdfType
+      supportsRefresh
+    }
+  }
+}
+    `;
+
+export const useRefreshResourceCapabilitiesQuery = <TData = GQLRefreshResourceCapabilitiesQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables: GQLRefreshResourceCapabilitiesQueryVariables,
+  options?: Omit<UseQueryOptions<GQLRefreshResourceCapabilitiesQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseQueryOptions<GQLRefreshResourceCapabilitiesQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useQuery<GQLRefreshResourceCapabilitiesQuery, TError, TData>({
+    queryKey: ["RefreshResourceCapabilities", variables],
+    queryFn: fetcher<GQLRefreshResourceCapabilitiesQuery, GQLRefreshResourceCapabilitiesQueryVariables>(
+      client,
+      RefreshResourceCapabilitiesDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useRefreshResourceCapabilitiesQuery.getKey = (variables: GQLRefreshResourceCapabilitiesQueryVariables) => [
+  "RefreshResourceCapabilities",
+  variables,
+];
+
+export const useSuspenseRefreshResourceCapabilitiesQuery = <
+  TData = GQLRefreshResourceCapabilitiesQuery,
+  TError = unknown,
+>(
+  client: GraphQLClient,
+  variables: GQLRefreshResourceCapabilitiesQueryVariables,
+  options?: Omit<UseSuspenseQueryOptions<GQLRefreshResourceCapabilitiesQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseSuspenseQueryOptions<GQLRefreshResourceCapabilitiesQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useSuspenseQuery<GQLRefreshResourceCapabilitiesQuery, TError, TData>({
+    queryKey: ["RefreshResourceCapabilitiesSuspense", variables],
+    queryFn: fetcher<GQLRefreshResourceCapabilitiesQuery, GQLRefreshResourceCapabilitiesQueryVariables>(
+      client,
+      RefreshResourceCapabilitiesDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useSuspenseRefreshResourceCapabilitiesQuery.getKey = (variables: GQLRefreshResourceCapabilitiesQueryVariables) => [
+  "RefreshResourceCapabilitiesSuspense",
+  variables,
+];
+
+export const RefreshResourcesStatusDocument = `
+    query RefreshResourcesStatus($workflowId: String!) {
+  refreshResourcesStatus(workflowId: $workflowId) {
+    status
+    results {
+      iri
+      type
+      refreshStatus
+    }
+    error
+  }
+}
+    `;
+
+export const useRefreshResourcesStatusQuery = <TData = GQLRefreshResourcesStatusQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables: GQLRefreshResourcesStatusQueryVariables,
+  options?: Omit<UseQueryOptions<GQLRefreshResourcesStatusQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseQueryOptions<GQLRefreshResourcesStatusQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useQuery<GQLRefreshResourcesStatusQuery, TError, TData>({
+    queryKey: ["RefreshResourcesStatus", variables],
+    queryFn: fetcher<GQLRefreshResourcesStatusQuery, GQLRefreshResourcesStatusQueryVariables>(
+      client,
+      RefreshResourcesStatusDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useRefreshResourcesStatusQuery.getKey = (variables: GQLRefreshResourcesStatusQueryVariables) => [
+  "RefreshResourcesStatus",
+  variables,
+];
+
+export const useSuspenseRefreshResourcesStatusQuery = <TData = GQLRefreshResourcesStatusQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables: GQLRefreshResourcesStatusQueryVariables,
+  options?: Omit<UseSuspenseQueryOptions<GQLRefreshResourcesStatusQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseSuspenseQueryOptions<GQLRefreshResourcesStatusQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useSuspenseQuery<GQLRefreshResourcesStatusQuery, TError, TData>({
+    queryKey: ["RefreshResourcesStatusSuspense", variables],
+    queryFn: fetcher<GQLRefreshResourcesStatusQuery, GQLRefreshResourcesStatusQueryVariables>(
+      client,
+      RefreshResourcesStatusDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useSuspenseRefreshResourcesStatusQuery.getKey = (variables: GQLRefreshResourcesStatusQueryVariables) => [
+  "RefreshResourcesStatusSuspense",
+  variables,
+];
+
 export const RulesDocument = `
     query Rules($ruleIri: IRI, $filterByOwner: String, $namedGraph: IRI, $typeFilter: [IRI!]) {
   rules(

package/src/shared/constants.ts

@@ -8,6 +8,12 @@ export const onboardingCompletedCookieName = "manta-onboarding-completed";
 
 export const errorRoutePath = "/error";
 
+// Keycloak access tokens live 300s. Each login-status poll renews a token with at most
+// accessTokenRotationWindowMs left; window - poll (60s) absorbs background-tab timer throttling,
+// and renewing only past 180s of age keeps Keycloak refreshes to ~one per 3 min however many tabs poll.
+export const loginStatusPollMs = 60_000;
+export const accessTokenRotationWindowMs = 120_000;
+
 export const scheduleToolingFlagKey = "schedule-tooling-enabled";
 export const teamActivationFlagKey = "team-activation-enabled";
 export const memoryExtractionFlagKey = "memory-extraction-enabled";

package/src/shared/datastore-id.ts

@@ -11,7 +11,7 @@ export function deriveDatastoreId(organizationName: string, segments: string[]):
   return (
     [organizationName, ...segments]
       .map(slugify)
-      // eslint-disable-next-line @manta-eu/prefer-is-present -- agents/vite.config.ts loads this file without lib
+      // oxlint-disable-next-line @manta-eu/prefer-is-present -- agents/vite.config.ts loads this file without lib
       .filter((slug) => slug.length > 0)
       .join("-")
   );