@manta-eu/client 0.3.0 → 0.4.0

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/email.ts

@@ -1,6 +1,9 @@
-import { nco, nmo } from "@manta-eu/ldo/namespaces";
+import { NcoEmailAddressSchema } from "@manta-eu/ldo/schemas/nco";
+import { NmoEmailSchema } from "@manta-eu/ldo/schemas/nmo";
 import { isPresent } from "@manta-eu/lib/present";
+import type { Schema } from "ldkit";
 import { ExecuteAgentActionAdditionDocument, type GQLExecuteAgentActionAdditionMutation } from "../generated/graphql";
+import { entityActionInput } from "./action-document";
 
 export type EmailGraphql = (document: string, variables: Record<string, unknown>) => Promise<unknown>;
 
@@ -16,22 +19,25 @@ export type RenderedEmail = {
 
 export type EmailStart = { ok: true; plan: string } | { ok: false; error: string };
 
-function renderedEmailAddition(terms: RealmEmailTerms, email: RenderedEmail) {
-  return {
-    subjectIri: email.subjectIri,
-    rdfType: nmo.Email,
-    actionShape: terms.emailMessageShape,
-    properties: {
-      "@id": email.subjectIri,
-      "@type": nmo.Email,
-      [nmo.messageFrom]: { "@type": nco.EmailAddress, [nco.emailAddress]: email.from },
-      [nmo.emailTo]: { "@type": nco.EmailAddress, [nco.emailAddress]: email.to },
-      [nmo.messageSubject]: email.subject,
-      [nmo.contentMimeType]: "text/html",
-      [terms.renderedFrom]: { "@id": email.renderedFrom },
-    },
-  };
-}
+const renderedEmailSchema = (terms: RealmEmailTerms) =>
+  ({
+    "@type": NmoEmailSchema["@type"],
+    from: { "@id": NmoEmailSchema.messageFrom["@id"], "@schema": NcoEmailAddressSchema },
+    to: { "@id": NmoEmailSchema.emailTo["@id"], "@schema": NcoEmailAddressSchema },
+    subject: NmoEmailSchema.messageSubject,
+    contentMimeType: NmoEmailSchema.contentMimeType,
+    renderedFrom: { ...NmoEmailSchema.renderedFrom, "@id": terms.renderedFrom },
+  }) as const satisfies Schema;
+
+const renderedEmailAddition = (terms: RealmEmailTerms, email: RenderedEmail) =>
+  entityActionInput(renderedEmailSchema(terms), terms.emailMessageShape, {
+    $id: email.subjectIri,
+    from: { emailAddress: email.from },
+    to: { emailAddress: email.to },
+    subject: email.subject,
+    contentMimeType: "text/html",
+    renderedFrom: email.renderedFrom,
+  });
 
 export async function startRenderedEmail(
   graphql: EmailGraphql,