@manta-eu/client 0.3.0 → 0.5.0

package/src/generated/graphql.ts

@@ -106,6 +106,7 @@ export type GQLAbortUploadResponse = {
 
 export type GQLAccessibleDatastore = {
   __typename?: "AccessibleDatastore";
+  datastoresInSubtree?: Maybe<Scalars["Int"]["output"]>;
   depth: Scalars["Int"]["output"];
   id: Scalars["String"]["output"];
   live?: Maybe<Scalars["Boolean"]["output"]>;
@@ -572,6 +573,13 @@ export type GQLCreateMemoryResponse = {
   memory?: Maybe<GQLMemory>;
 };
 
+export type GQLCreateStripeBillingPortalSessionResponse = {
+  __typename?: "CreateStripeBillingPortalSessionResponse";
+  error?: Maybe<Scalars["String"]["output"]>;
+  success: Scalars["Boolean"]["output"];
+  url?: Maybe<Scalars["String"]["output"]>;
+};
+
 export type GQLCreateStripeCheckoutSessionResponse = {
   __typename?: "CreateStripeCheckoutSessionResponse";
   error?: Maybe<Scalars["String"]["output"]>;
@@ -852,11 +860,13 @@ export type GQLDatastoreSubscription = {
   inGoodStanding: Scalars["Boolean"]["output"];
   interval?: Maybe<Scalars["String"]["output"]>;
   intervalCount?: Maybe<Scalars["Int"]["output"]>;
+  productIds: Array<Scalars["String"]["output"]>;
   status: Scalars["String"]["output"];
 };
 
 export type GQLDatastoreTreeNode = {
   __typename?: "DatastoreTreeNode";
+  accessibleId: Scalars["String"]["output"];
   datastoreId?: Maybe<Scalars["String"]["output"]>;
   depth: Scalars["Int"]["output"];
   id: Scalars["String"]["output"];
@@ -1187,6 +1197,7 @@ export enum GQLInferalIntegrationProvider {
   Linkedin = "LINKEDIN",
   Mailchimp = "MAILCHIMP",
   Meta = "META",
+  Microsoftads = "MICROSOFTADS",
   Pinterest = "PINTEREST",
   Shopify = "SHOPIFY",
   Slack = "SLACK",
@@ -1207,10 +1218,41 @@ export enum GQLInferalLocation {
 }
 
 export type GQLInferalProviderInput =
-  | { klaviyo: GQLKlaviyoProviderInput; shopify?: never; triplewhale?: never; woocommerce?: never }
-  | { klaviyo?: never; shopify: GQLShopifyProviderInput; triplewhale?: never; woocommerce?: never }
-  | { klaviyo?: never; shopify?: never; triplewhale: GQLTriplewhaleProviderInput; woocommerce?: never }
-  | { klaviyo?: never; shopify?: never; triplewhale?: never; woocommerce: GQLWoocommerceProviderInput };
+  | {
+      klaviyo: GQLKlaviyoProviderInput;
+      microsoftAds?: never;
+      shopify?: never;
+      triplewhale?: never;
+      woocommerce?: never;
+    }
+  | {
+      klaviyo?: never;
+      microsoftAds: GQLMicrosoftAdsProviderInput;
+      shopify?: never;
+      triplewhale?: never;
+      woocommerce?: never;
+    }
+  | {
+      klaviyo?: never;
+      microsoftAds?: never;
+      shopify: GQLShopifyProviderInput;
+      triplewhale?: never;
+      woocommerce?: never;
+    }
+  | {
+      klaviyo?: never;
+      microsoftAds?: never;
+      shopify?: never;
+      triplewhale: GQLTriplewhaleProviderInput;
+      woocommerce?: never;
+    }
+  | {
+      klaviyo?: never;
+      microsoftAds?: never;
+      shopify?: never;
+      triplewhale?: never;
+      woocommerce: GQLWoocommerceProviderInput;
+    };
 
 export type GQLInferalStreamInput = {
   location: GQLInferalLocation;
@@ -1238,6 +1280,7 @@ export enum GQLIntegration {
   GoogleAnalytics = "GOOGLE_ANALYTICS",
   Linkedin = "LINKEDIN",
   Meta = "META",
+  MicrosoftAds = "MICROSOFT_ADS",
   Shopify = "SHOPIFY",
   Slack = "SLACK",
   Snapchat = "SNAPCHAT",
@@ -1600,6 +1643,26 @@ export enum GQLMetaSetupStateEnum {
   TimedOut = "TIMED_OUT",
 }
 
+export type GQLMicrosoftAdsAccount = {
+  __typename?: "MicrosoftAdsAccount";
+  connectable: Scalars["Boolean"]["output"];
+  customerId?: Maybe<Scalars["String"]["output"]>;
+  id: Scalars["String"]["output"];
+  name?: Maybe<Scalars["String"]["output"]>;
+  number?: Maybe<Scalars["String"]["output"]>;
+};
+
+export type GQLMicrosoftAdsProviderInput = {
+  accountId: Scalars["String"]["input"];
+};
+
+export type GQLMicrosoftAdsSetupProgress = {
+  __typename?: "MicrosoftAdsSetupProgress";
+  accounts?: Maybe<Array<GQLMicrosoftAdsAccount>>;
+  lastError?: Maybe<GQLGoogleSetupLastError>;
+  state: Array<GQLGoogleSetupStateEnum>;
+};
+
 export type GQLMutation = {
   __typename?: "Mutation";
   abortUpload: GQLAbortUploadResponse;
@@ -1618,6 +1681,7 @@ export type GQLMutation = {
   createDataConnection: GQLDataConnectionTestState;
   createInferalIntegration: GQLCreateInferalIntegrationResponse;
   createMemory: GQLCreateMemoryResponse;
+  createStripeBillingPortalSession: GQLCreateStripeBillingPortalSessionResponse;
   createStripeCheckoutSession: GQLCreateStripeCheckoutSessionResponse;
   dashSetupConnect: GQLDashSetupProgress;
   deleteActionPlan: GQLDeleteActionPlanResponse;
@@ -1653,6 +1717,7 @@ export type GQLMutation = {
   manualActionResolve?: Maybe<GQLManualActionResolvePayload>;
   materializeOntologyCoverage: GQLMaterializeOntologyCoverageResponse;
   metaSetupConnect: GQLMetaSetupProgress;
+  microsoftAdsSetupConnect: GQLMicrosoftAdsSetupProgress;
   pauseLDESStream: GQLLdesStreamResponse;
   provisionDatastore: GQLProvisionDatastoreResponse;
   reconfirmMemory: GQLUpdateMemoryResponse;
@@ -1764,6 +1829,11 @@ export type GQLMutationCreateMemoryArgs = {
   input: GQLCreateMemoryInput;
 };
 
+export type GQLMutationCreateStripeBillingPortalSessionArgs = {
+  datastoreId: Scalars["String"]["input"];
+  returnUrl: Scalars["String"]["input"];
+};
+
 export type GQLMutationCreateStripeCheckoutSessionArgs = {
   cancelUrl: Scalars["String"]["input"];
   datastoreId: Scalars["String"]["input"];
@@ -1926,6 +1996,11 @@ export type GQLMutationMetaSetupConnectArgs = {
   accountIds: Array<Scalars["String"]["input"]>;
 };
 
+export type GQLMutationMicrosoftAdsSetupConnectArgs = {
+  accountIds: Array<Scalars["String"]["input"]>;
+  location: GQLInferalLocation;
+};
+
 export type GQLMutationPauseLdesStreamArgs = {
   url: Scalars["String"]["input"];
 };
@@ -2233,6 +2308,7 @@ export type GQLQuery = {
   memoryReplaySeries: GQLMemoryReplaySeriesResult;
   memorySchemas: GQLMemorySchemasResponse;
   metaSetupProgress: GQLMetaSetupProgress;
+  microsoftAdsSetupProgress: GQLMicrosoftAdsSetupProgress;
   nodeProperties: GQLNodePropertiesResponse;
   nodeRelationships: GQLActionPlanGraphResponse;
   organizationLinking?: Maybe<GQLOrganizationLinking>;
@@ -3469,6 +3545,21 @@ export type GQLCreateMemoryMutation = {
   };
 };
 
+export type GQLCreateStripeBillingPortalSessionMutationVariables = Exact<{
+  datastoreId: Scalars["String"]["input"];
+  returnUrl: Scalars["String"]["input"];
+}>;
+
+export type GQLCreateStripeBillingPortalSessionMutation = {
+  __typename?: "Mutation";
+  createStripeBillingPortalSession: {
+    __typename?: "CreateStripeBillingPortalSessionResponse";
+    success: boolean;
+    url?: string | null;
+    error?: string | null;
+  };
+};
+
 export type GQLCreateStripeCheckoutSessionMutationVariables = Exact<{
   datastoreId: Scalars["String"]["input"];
   priceId: Scalars["String"]["input"];
@@ -3937,6 +4028,33 @@ export type GQLMetaSetupConnectMutation = {
   };
 };
 
+export type GQLMicrosoftAdsSetupConnectMutationVariables = Exact<{
+  accountIds: Array<Scalars["String"]["input"]> | Scalars["String"]["input"];
+  location: GQLInferalLocation;
+}>;
+
+export type GQLMicrosoftAdsSetupConnectMutation = {
+  __typename?: "Mutation";
+  microsoftAdsSetupConnect: {
+    __typename?: "MicrosoftAdsSetupProgress";
+    state: Array<GQLGoogleSetupStateEnum>;
+    accounts?: Array<{
+      __typename?: "MicrosoftAdsAccount";
+      id: string;
+      name?: string | null;
+      number?: string | null;
+      customerId?: string | null;
+      connectable: boolean;
+    }> | null;
+    lastError?: {
+      __typename?: "GoogleSetupLastError";
+      severity: string;
+      message: string;
+      title?: string | null;
+    } | null;
+  };
+};
+
 export type GQLPauseLdesStreamMutationVariables = Exact<{
   url: Scalars["String"]["input"];
 }>;
@@ -5112,6 +5230,7 @@ export type GQLDatastoreSubscriptionsQuery = {
     currency?: string | null;
     interval?: string | null;
     intervalCount?: number | null;
+    productIds: Array<string>;
   }>;
 };
 
@@ -5122,6 +5241,7 @@ export type GQLDatastoreTreeQuery = {
   datastoreTree: Array<{
     __typename?: "DatastoreTreeNode";
     id: string;
+    accessibleId: string;
     name: string;
     depth: number;
     organizationId: string;
@@ -5496,6 +5616,30 @@ export type GQLMetaSetupProgressQuery = {
   };
 };
 
+export type GQLMicrosoftAdsSetupProgressQueryVariables = Exact<{ [key: string]: never }>;
+
+export type GQLMicrosoftAdsSetupProgressQuery = {
+  __typename?: "Query";
+  microsoftAdsSetupProgress: {
+    __typename?: "MicrosoftAdsSetupProgress";
+    state: Array<GQLGoogleSetupStateEnum>;
+    accounts?: Array<{
+      __typename?: "MicrosoftAdsAccount";
+      id: string;
+      name?: string | null;
+      number?: string | null;
+      customerId?: string | null;
+      connectable: boolean;
+    }> | null;
+    lastError?: {
+      __typename?: "GoogleSetupLastError";
+      severity: string;
+      message: string;
+      title?: string | null;
+    } | null;
+  };
+};
+
 export type GQLNodePropertiesQueryVariables = Exact<{
   nodeIri: Scalars["String"]["input"];
   planGraphIri?: InputMaybe<Scalars["IRI"]["input"]>;
@@ -6510,6 +6654,47 @@ export const useCreateMemoryMutation = <TError = unknown, TContext = unknown>(
   });
 };
 
+export const CreateStripeBillingPortalSessionDocument = `
+    mutation CreateStripeBillingPortalSession($datastoreId: String!, $returnUrl: String!) {
+  createStripeBillingPortalSession(
+    datastoreId: $datastoreId
+    returnUrl: $returnUrl
+  ) {
+    success
+    url
+    error
+  }
+}
+    `;
+
+export const useCreateStripeBillingPortalSessionMutation = <TError = unknown, TContext = unknown>(
+  client: GraphQLClient,
+  options?: UseMutationOptions<
+    GQLCreateStripeBillingPortalSessionMutation,
+    TError,
+    GQLCreateStripeBillingPortalSessionMutationVariables,
+    TContext
+  >,
+  headers?: RequestInit["headers"],
+) => {
+  return useMutation<
+    GQLCreateStripeBillingPortalSessionMutation,
+    TError,
+    GQLCreateStripeBillingPortalSessionMutationVariables,
+    TContext
+  >({
+    mutationKey: ["CreateStripeBillingPortalSession"],
+    mutationFn: (variables?: GQLCreateStripeBillingPortalSessionMutationVariables) =>
+      fetcher<GQLCreateStripeBillingPortalSessionMutation, GQLCreateStripeBillingPortalSessionMutationVariables>(
+        client,
+        CreateStripeBillingPortalSessionDocument,
+        variables,
+        headers,
+      )(),
+    ...options,
+  });
+};
+
 export const CreateStripeCheckoutSessionDocument = `
     mutation CreateStripeCheckoutSession($datastoreId: String!, $priceId: String!, $successUrl: String!, $cancelUrl: String!) {
   createStripeCheckoutSession(
@@ -7650,6 +7835,54 @@ export const useMetaSetupConnectMutation = <TError = unknown, TContext = unknown
   });
 };
 
+export const MicrosoftAdsSetupConnectDocument = `
+    mutation MicrosoftAdsSetupConnect($accountIds: [String!]!, $location: InferalLocation!) {
+  microsoftAdsSetupConnect(accountIds: $accountIds, location: $location) {
+    state
+    accounts {
+      id
+      name
+      number
+      customerId
+      connectable
+    }
+    lastError {
+      severity
+      message
+      title
+    }
+  }
+}
+    `;
+
+export const useMicrosoftAdsSetupConnectMutation = <TError = unknown, TContext = unknown>(
+  client: GraphQLClient,
+  options?: UseMutationOptions<
+    GQLMicrosoftAdsSetupConnectMutation,
+    TError,
+    GQLMicrosoftAdsSetupConnectMutationVariables,
+    TContext
+  >,
+  headers?: RequestInit["headers"],
+) => {
+  return useMutation<
+    GQLMicrosoftAdsSetupConnectMutation,
+    TError,
+    GQLMicrosoftAdsSetupConnectMutationVariables,
+    TContext
+  >({
+    mutationKey: ["MicrosoftAdsSetupConnect"],
+    mutationFn: (variables?: GQLMicrosoftAdsSetupConnectMutationVariables) =>
+      fetcher<GQLMicrosoftAdsSetupConnectMutation, GQLMicrosoftAdsSetupConnectMutationVariables>(
+        client,
+        MicrosoftAdsSetupConnectDocument,
+        variables,
+        headers,
+      )(),
+    ...options,
+  });
+};
+
 export const PauseLdesStreamDocument = `
     mutation PauseLdesStream($url: String!) {
   pauseLDESStream(url: $url) {
@@ -10076,6 +10309,7 @@ export const DatastoreSubscriptionsDocument = `
     currency
     interval
     intervalCount
+    productIds
   }
 }
     `;
@@ -10134,6 +10368,7 @@ export const DatastoreTreeDocument = `
     query DatastoreTree {
   datastoreTree {
     id
+    accessibleId
     name
     depth
     organizationId
@@ -11116,6 +11351,75 @@ export const useSuspenseMetaSetupProgressQuery = <TData = GQLMetaSetupProgressQu
 useSuspenseMetaSetupProgressQuery.getKey = (variables?: GQLMetaSetupProgressQueryVariables) =>
   variables === undefined ? ["MetaSetupProgressSuspense"] : ["MetaSetupProgressSuspense", variables];
 
+export const MicrosoftAdsSetupProgressDocument = `
+    query MicrosoftAdsSetupProgress {
+  microsoftAdsSetupProgress {
+    state
+    accounts {
+      id
+      name
+      number
+      customerId
+      connectable
+    }
+    lastError {
+      severity
+      message
+      title
+    }
+  }
+}
+    `;
+
+export const useMicrosoftAdsSetupProgressQuery = <TData = GQLMicrosoftAdsSetupProgressQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables?: GQLMicrosoftAdsSetupProgressQueryVariables,
+  options?: Omit<UseQueryOptions<GQLMicrosoftAdsSetupProgressQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseQueryOptions<GQLMicrosoftAdsSetupProgressQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useQuery<GQLMicrosoftAdsSetupProgressQuery, TError, TData>({
+    queryKey: variables === undefined ? ["MicrosoftAdsSetupProgress"] : ["MicrosoftAdsSetupProgress", variables],
+    queryFn: fetcher<GQLMicrosoftAdsSetupProgressQuery, GQLMicrosoftAdsSetupProgressQueryVariables>(
+      client,
+      MicrosoftAdsSetupProgressDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useMicrosoftAdsSetupProgressQuery.getKey = (variables?: GQLMicrosoftAdsSetupProgressQueryVariables) =>
+  variables === undefined ? ["MicrosoftAdsSetupProgress"] : ["MicrosoftAdsSetupProgress", variables];
+
+export const useSuspenseMicrosoftAdsSetupProgressQuery = <TData = GQLMicrosoftAdsSetupProgressQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables?: GQLMicrosoftAdsSetupProgressQueryVariables,
+  options?: Omit<UseSuspenseQueryOptions<GQLMicrosoftAdsSetupProgressQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseSuspenseQueryOptions<GQLMicrosoftAdsSetupProgressQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useSuspenseQuery<GQLMicrosoftAdsSetupProgressQuery, TError, TData>({
+    queryKey:
+      variables === undefined
+        ? ["MicrosoftAdsSetupProgressSuspense"]
+        : ["MicrosoftAdsSetupProgressSuspense", variables],
+    queryFn: fetcher<GQLMicrosoftAdsSetupProgressQuery, GQLMicrosoftAdsSetupProgressQueryVariables>(
+      client,
+      MicrosoftAdsSetupProgressDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useSuspenseMicrosoftAdsSetupProgressQuery.getKey = (variables?: GQLMicrosoftAdsSetupProgressQueryVariables) =>
+  variables === undefined ? ["MicrosoftAdsSetupProgressSuspense"] : ["MicrosoftAdsSetupProgressSuspense", variables];
+
 export const NodePropertiesDocument = `
     query NodeProperties($nodeIri: String!, $planGraphIri: IRI) {
   nodeProperties(nodeIri: $nodeIri, planGraphIri: $planGraphIri) {

package/src/shared/action-document.ts

@@ -1,6 +1,9 @@
-import jsonld from "jsonld";
-import { encodeEntity, type Lens, type Schema } from "ldkit";
-import { xsd } from "ldkit/namespaces";
+import { isPresent } from "@manta-eu/lib/present";
+import { owlNothingIri } from "@manta-eu/rdf-lib/namespaces";
+import { encodeEntity, type Identity, type Lens, type Property, type Schema, type SchemaInterface } from "ldkit";
+import { rdf, xsd } from "ldkit/namespaces";
+import { groupBy, uniq, uniqBy } from "ramda";
+import type { GQLExecuteActionUpdateInput } from "../generated/graphql";
 
 export type DocumentTerm = { value: string; termType: string };
 
@@ -10,47 +13,97 @@ export type DocumentQuad = {
   object: DocumentTerm & { datatype?: { value: string }; language?: string };
 };
 
-export type InsertEntity<S extends Schema> = Parameters<Lens<S>["insert"]>[number];
+type InsertEntity<S extends Schema> = Parameters<Lens<S>["insert"]>[number];
 
-// jsonld keeps the `_:` prefix in a blank node value
-function jsonldTerm(term: DocumentTerm): DocumentTerm {
-  return { termType: term.termType, value: term.termType === "BlankNode" ? `_:${term.value}` : term.value };
+export type ActionSchema = Schema & { "@type": string };
+
+export type Writable<T> = T extends readonly (infer E)[]
+  ? Writable<E>[]
+  : T extends Record<string, unknown>
+    ? { [K in keyof T]?: Writable<T[K]> }
+    : T;
+
+export type ActionEntity<S extends Schema> = Identity &
+  (string extends keyof S ? Record<string, unknown> : Writable<Omit<SchemaInterface<S>, "$id">>);
+
+export type ActionInput = GQLExecuteActionUpdateInput;
+
+const termKey = (term: DocumentTerm): string => (term.termType === "BlankNode" ? `_:${term.value}` : term.value);
+
+const objectKey = ({ object }: DocumentQuad): string =>
+  `${termKey(object)} ${object.datatype?.value ?? ""} ${object.language ?? ""}`;
+
+const oneOrMany = (values: readonly unknown[]): unknown => (values.length === 1 ? values[0] : values);
+
+function literal(object: DocumentQuad["object"]): unknown {
+  const datatype = object.datatype?.value ?? xsd.string;
+
+  if (isPresent(object.language)) return { "@value": object.value, "@language": object.language };
+  if (datatype === xsd.string) return object.value;
+  return { "@value": object.value, "@type": datatype };
 }
 
-function jsonldQuad(quad: DocumentQuad) {
-  const { subject, predicate, object } = quad;
-
-  return {
-    subject: jsonldTerm(subject),
-    predicate: { termType: "NamedNode", value: predicate.value },
-    object:
-      object.termType === "Literal"
-        ? {
-            termType: "Literal",
-            value: object.value,
-            language: object.language,
-            datatype: { value: object.datatype?.value ?? xsd.string },
-          }
-        : jsonldTerm(object),
-    graph: { termType: "DefaultGraph", value: "" },
+export function documentFromQuads(quads: readonly DocumentQuad[], subjectIri: string): Record<string, unknown> {
+  const described = quads.filter(({ subject }) => subject.value === subjectIri || subject.termType === "BlankNode");
+  const bySubject = groupBy((quad: DocumentQuad) => termKey(quad.subject), described);
+  const blankObjects = described.flatMap(({ object }) => (object.termType === "BlankNode" ? [termKey(object)] : []));
+  const shared = new Set(blankObjects.filter((key, index) => blankObjects.indexOf(key) !== index));
+  const labels = new Map<string, string>();
+
+  const label = (key: string): string => {
+    if (!labels.has(key)) labels.set(key, `_:b${labels.size}`);
+    return labels.get(key) ?? key;
   };
+
+  const value = (object: DocumentQuad["object"], path: readonly string[]): unknown => {
+    const key = termKey(object);
+
+    if (object.termType === "Literal") return literal(object);
+    if (object.termType !== "BlankNode") return { "@id": key };
+    if (path.includes(key)) return { "@id": label(key) };
+    return node(key, [...path, key]);
+  };
+
+  const node = (key: string, path: readonly string[]): Record<string, unknown> => {
+    const own = bySubject[key] ?? [];
+    const types = own.filter(({ predicate }) => predicate.value === rdf.type).map(({ object }) => termKey(object));
+    const others = own.filter(({ predicate }) => predicate.value !== rdf.type);
+    const byPredicate = groupBy((quad: DocumentQuad) => quad.predicate.value, others);
+
+    return {
+      ...(shared.has(key) && { "@id": label(key) }),
+      ...(isPresent(types) && { "@type": oneOrMany(uniq(types)) }),
+      ...Object.fromEntries(
+        Object.entries(byPredicate).map(([predicate, values = []]) => [
+          predicate,
+          oneOrMany(uniqBy(objectKey, values).map(({ object }) => value(object, path))),
+        ]),
+      ),
+    };
+  };
+
+  return { "@id": subjectIri, ...node(subjectIri, [subjectIri]) };
 }
 
-export async function documentFromQuads(
-  quads: readonly DocumentQuad[],
-  subjectIri: string,
-): Promise<Record<string, unknown>> {
-  const described = quads.filter(({ subject }) => subject.value === subjectIri || subject.termType === "BlankNode");
-  const flattened = await jsonld.fromRDF(described.map(jsonldQuad));
+export function entityActionDocument<S extends Schema>(schema: S, entity: ActionEntity<S>): Record<string, unknown> {
+  const quads = encodeEntity(schema, entity as unknown as InsertEntity<S>).filter(
+    (quad) => quad.object.termType !== "Variable",
+  );
 
-  return jsonld.frame(flattened, { "@id": subjectIri, "@embed": "@always" });
+  return documentFromQuads(quads, entity.$id);
 }
 
-export function entityActionDocument<S extends Schema>(
+const propertyIri = (definition: Property | string | readonly string[] | undefined): string =>
+  typeof definition === "object" && "@id" in definition ? definition["@id"] : String(definition);
+
+export function entityActionInput<S extends ActionSchema>(
   schema: S,
-  entity: InsertEntity<S>,
-): Promise<Record<string, unknown>> {
-  const quads = encodeEntity(schema, entity).filter((quad) => quad.object.termType !== "Variable");
+  actionShape: string,
+  entity: ActionEntity<S>,
+  cleared: readonly (Exclude<keyof S, "@type"> & string)[] = [],
+): ActionInput {
+  const document = entityActionDocument(schema, entity);
+  const nothing = Object.fromEntries(cleared.map((key) => [propertyIri(schema[key]), { "@id": owlNothingIri }]));
 
-  return documentFromQuads(quads, entity.$id);
+  return { subjectIri: entity.$id, rdfType: schema["@type"], actionShape, properties: { ...document, ...nothing } };
 }

package/src/shared/chat-manager.ts

@@ -9,6 +9,22 @@ export const thinkChatFacetPath = "think-chat";
 export const defaultConversationName = "New chat";
 export const defaultFolderName = "New folder";
 
+export const conversationModeSchema = z.enum(["datastore", "group"]);
+export type ConversationMode = z.infer<typeof conversationModeSchema>;
+export const chatModeQueryParam = "mode";
+
+export function chatModeQuery(mode: ConversationMode | undefined): Record<string, string> {
+  return mode === "group" ? { [chatModeQueryParam]: mode } : {};
+}
+
+export function withChatModeQueryParam(href: string, mode: ConversationMode | undefined): string {
+  if (mode !== "group") return href;
+
+  const url = new URL(href, "http://placeholder");
+  url.searchParams.set(chatModeQueryParam, mode);
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+
 export const chatManagerScopeSchema = z.strictObject({
   version: z.literal(1),
   realm: z.string().min(1),
@@ -16,6 +32,8 @@ export const chatManagerScopeSchema = z.strictObject({
   userId: z.string().min(1),
   // Present for a custom app's token, so each app keeps its own chats; absent keeps the web app's chats where they are.
   customAppClientId: z.string().min(1).optional(),
+  // Present only for a group view's manager, so every other manager keeps its name.
+  mode: z.literal("group").optional(),
 });
 
 export type ChatManagerScope = z.infer<typeof chatManagerScopeSchema>;