@manta-eu/client 0.12.0 → 0.13.0

package/src/shared/memory-schema-values.ts

@@ -0,0 +1,174 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { match, P } from "ts-pattern";
+import { isValidFullIri } from "./rdf-namespaces";
+
+export const memorySchemaValueTypes = [
+  "text",
+  "longText",
+  "integer",
+  "decimal",
+  "boolean",
+  "date",
+  "dateTime",
+  "url",
+  "entity",
+] as const;
+
+export type MemorySchemaValueType = (typeof memorySchemaValueTypes)[number];
+
+export type MemoryValueConstraints = {
+  valueType: MemorySchemaValueType;
+  allowedValues: readonly string[];
+  minValue: string | null;
+  maxValue: string | null;
+  maxLength: number | null;
+  pattern: string | null;
+};
+
+const integerPattern = /^[+-]?\d+$/;
+const decimalPattern = /^[+-]?(\d+(\.\d*)?|\.\d+)$/;
+const datePattern = /^(\d{4})-(\d{2})-(\d{2})$/;
+const dateTimePattern = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(:(\d{2})(\.\d+)?)?(Z|[+-]\d{2}:\d{2})?$/;
+
+function isCalendarDate(year: string, month: string, day: string): boolean {
+  const date = new Date(0);
+  date.setUTCFullYear(Number(year), Number(month) - 1, Number(day));
+  return (
+    date.getUTCFullYear() === Number(year) &&
+    date.getUTCMonth() === Number(month) - 1 &&
+    date.getUTCDate() === Number(day)
+  );
+}
+
+function canonicalInteger(value: string): string {
+  return BigInt(value).toString();
+}
+
+function canonicalDecimal(value: string): string {
+  const negative = value.startsWith("-");
+  const unsigned = value.replace(/^[+-]/, "");
+  const [whole = "", fraction = ""] = unsigned.split(".");
+  const wholeDigits = whole.replace(/^0+(?=\d)/, "") || "0";
+  const fractionDigits = fraction.replace(/0+$/, "");
+  const magnitude = isPresent(fractionDigits) ? `${wholeDigits}.${fractionDigits}` : wholeDigits;
+  return negative && magnitude !== "0" ? `-${magnitude}` : magnitude;
+}
+
+export function parseMemoryValue(valueType: MemorySchemaValueType, raw: string): string | null {
+  const value = raw.trim();
+  if (!isPresent(value)) return null;
+
+  return match(valueType)
+    .with("text", "longText", () => value)
+    .with("integer", () => (integerPattern.test(value) ? canonicalInteger(value) : null))
+    .with("decimal", () => (decimalPattern.test(value) ? canonicalDecimal(value) : null))
+    .with("boolean", () => {
+      const lowered = value.toLowerCase();
+      return lowered === "true" || lowered === "false" ? lowered : null;
+    })
+    .with("date", () => {
+      const parts = datePattern.exec(value);
+      return parts !== null && isCalendarDate(parts[1]!, parts[2]!, parts[3]!) ? value : null;
+    })
+    .with("dateTime", () => {
+      const parts = dateTimePattern.exec(value);
+      if (parts === null || !isCalendarDate(parts[1]!, parts[2]!, parts[3]!)) return null;
+      if (Number(parts[4]) >= 24 || Number(parts[5]) >= 60 || Number(parts[7] ?? 0) >= 60) return null;
+      return parts[6] === undefined ? withSeconds(value, parts[9]) : value;
+    })
+    .with("url", () => (isAbsoluteHttpUrl(value) ? value : null))
+    .with("entity", () => (isValidFullIri(value) ? value : null))
+    .exhaustive();
+}
+
+// xsd:dateTime requires seconds, and a datetime-local input leaves them out.
+function withSeconds(value: string, zone: string | undefined): string {
+  const local = zone === undefined ? value : value.slice(0, -zone.length);
+  return `${local}:00${zone ?? ""}`;
+}
+
+function isAbsoluteHttpUrl(value: string): boolean {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+export function convertMemoryValue(
+  from: MemorySchemaValueType,
+  to: MemorySchemaValueType,
+  lexical: string,
+): string | null {
+  return match([from, to])
+    .with(["decimal", "integer"], () => {
+      const integral = /^([+-]?\d+)(\.0*)?$/.exec(lexical.trim());
+      return integral !== null ? canonicalInteger(integral[1]!) : null;
+    })
+    .with(["date", "dateTime"], () => {
+      const date = parseMemoryValue("date", lexical);
+      return date !== null ? `${date}T00:00:00` : null;
+    })
+    .with(["dateTime", "date"], () => {
+      const dateTime = parseMemoryValue("dateTime", lexical);
+      return dateTime !== null ? dateTime.slice(0, 10) : null;
+    })
+    .otherwise(() => parseMemoryValue(to, lexical));
+}
+
+function scaledDecimal(value: string, scale: number): bigint {
+  const [whole = "", fraction = ""] = value.replace(/^[+-]/, "").split(".");
+  const magnitude = BigInt(`${whole || "0"}${fraction.padEnd(scale, "0")}`);
+  return value.startsWith("-") ? -magnitude : magnitude;
+}
+
+// Exact on any number of digits, where a double would round a large integer or a long decimal.
+function compareNumbers(a: string, b: string): number {
+  const [left, right] = [a.trim(), b.trim()];
+  if (!decimalPattern.test(left) || !decimalPattern.test(right)) return Number(left) - Number(right);
+  const scale = Math.max(left.split(".")[1]?.length ?? 0, right.split(".")[1]?.length ?? 0);
+  const difference = scaledDecimal(left, scale) - scaledDecimal(right, scale);
+  return difference === 0n ? 0 : difference < 0n ? -1 : 1;
+}
+
+function compareDateTimes(a: string, b: string): number {
+  return Date.parse(a) - Date.parse(b);
+}
+
+export function compareMemoryValues(valueType: MemorySchemaValueType, a: string, b: string): number {
+  return match(valueType)
+    .with(P.union("integer", "decimal"), () => compareNumbers(a, b))
+    .with("dateTime", () => compareDateTimes(a, b))
+    .otherwise(() => a.localeCompare(b));
+}
+
+export const memoryValueBoundTypes: readonly MemorySchemaValueType[] = ["integer", "decimal", "date", "dateTime"];
+
+export const memoryValueTextTypes: readonly MemorySchemaValueType[] = ["text", "longText"];
+
+// `compileMemoryValuePattern` from ./memory-schema-pattern; null skips patterns, for a browser that has not loaded it.
+export type CompileMemoryValuePattern = (pattern: string) => { test: (value: string) => boolean };
+
+export function memoryValueConstraintViolation(
+  property: MemoryValueConstraints,
+  value: string,
+  compilePattern: CompileMemoryValuePattern | null,
+): string | null {
+  if (isPresent(property.allowedValues) && !property.allowedValues.includes(value)) {
+    return `must be one of ${property.allowedValues.map((option) => `"${option}"`).join(", ")}`;
+  }
+  if (property.minValue !== null && compareMemoryValues(property.valueType, value, property.minValue) < 0) {
+    return `must be at least ${property.minValue}`;
+  }
+  if (property.maxValue !== null && compareMemoryValues(property.valueType, value, property.maxValue) > 0) {
+    return `must be at most ${property.maxValue}`;
+  }
+  if (property.maxLength !== null && [...value].length > property.maxLength) {
+    return `must be at most ${property.maxLength} characters`;
+  }
+  if (property.pattern !== null && compilePattern !== null && !compilePattern(property.pattern).test(value)) {
+    return `must match the pattern ${property.pattern}`;
+  }
+  return null;
+}

package/src/shared/operation-root-fields.ts

@@ -0,0 +1,56 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { Kind, type DocumentNode, type FragmentDefinitionNode, type SelectionSetNode } from "graphql";
+import { match } from "ts-pattern";
+
+export type OperationRootFields = { name: string | undefined; fields: string[] };
+
+type RootFieldsArgs = {
+  selectionSet: SelectionSetNode;
+  fragments: Map<string, FragmentDefinitionNode>;
+  visiting: ReadonlySet<string>;
+};
+
+function rootFields(args: RootFieldsArgs): string[] {
+  const { selectionSet, fragments, visiting } = args;
+
+  return selectionSet.selections.flatMap((selection) =>
+    match(selection)
+      .with({ kind: Kind.FIELD }, (field) => [field.name.value])
+      .with({ kind: Kind.INLINE_FRAGMENT }, (inline) =>
+        rootFields({ selectionSet: inline.selectionSet, fragments, visiting }),
+      )
+      .with({ kind: Kind.FRAGMENT_SPREAD }, (spread) => {
+        const fragment = fragments.get(spread.name.value);
+
+        if (!isPresent(fragment) || visiting.has(spread.name.value)) {
+          throw new Error(`Unresolvable fragment ${spread.name.value}`);
+        }
+
+        return rootFields({
+          selectionSet: fragment.selectionSet,
+          fragments,
+          visiting: new Set([...visiting, spread.name.value]),
+        });
+      })
+      .exhaustive(),
+  );
+}
+
+export function operationRootFieldsOf(document: DocumentNode): OperationRootFields[] {
+  const fragments = new Map(
+    document.definitions.flatMap((definition) =>
+      definition.kind === Kind.FRAGMENT_DEFINITION ? [[definition.name.value, definition] as const] : [],
+    ),
+  );
+
+  return document.definitions.flatMap((definition) =>
+    definition.kind === Kind.OPERATION_DEFINITION
+      ? [
+          {
+            name: definition.name?.value,
+            fields: [...new Set(rootFields({ selectionSet: definition.selectionSet, fragments, visiting: new Set() }))],
+          },
+        ]
+      : [],
+  );
+}

package/src/shared/rdf-namespaces.ts

@@ -8,6 +8,9 @@ import {
 // KGC uploads the realm ontology here (kgc/kgc/realms/lib/ontology.py: realm_base + "ontology").
 export const ontologyGraphIri = expandPrefixIri(":ontology");
 
+// Each datastore's editable memory schemas; KGC never writes it (kgc ontology.py: memory_schemas_graph_iri).
+export const memorySchemasGraphIri = expandPrefixIri(":memorySchemas");
+
 // Field mutability Inferal publishes on its property shapes (DAT-577).
 export const writeLifecycle = {
   predicate: expandPrefixIri("relay:writeLifecycle"),

package/src/testing/manta-mock.ts

@@ -0,0 +1,208 @@
+import { QueryEngine } from "@comunica/query-sparql-rdfjs-lite";
+import { isReadOnlySparqlQuery, validateDataManipulationUpdate } from "@manta-eu/datalog-parser";
+import { isPresent } from "@manta-eu/lib/present";
+import type { Term, Variable } from "@rdfjs/types";
+import { Parser, Store, Writer } from "n3";
+import { match, P } from "ts-pattern";
+import { parseDatastorePath, sparqlRoutePath } from "../shared/datastore-path";
+import { prependMissingSparqlPrefixes, toTurtlePrefixes } from "../shared/rdf-namespaces";
+
+export type MantaMockOptions = { turtle?: string };
+
+export type MantaMockRoute = {
+  request(): { url(): string; method(): string; headers(): Record<string, string>; postData(): string | null };
+  fulfill(response: { status: number; headers: Record<string, string>; body: string }): Promise<void>;
+  fallback(): Promise<void>;
+};
+
+export type MantaMock = {
+  fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+  route: (route: MantaMockRoute) => Promise<void>;
+  updates: readonly string[];
+};
+
+export const mantaMockRoutePattern = /\/sparql(-update)?(\?|$)/;
+
+const updatePath = "/sparql-update";
+type SparqlPath = typeof sparqlRoutePath | typeof updatePath;
+
+const sparqlUpdateMediaType = "application/sparql-update";
+const sparqlResultsMediaType = "application/sparql-results+json";
+const nTriplesMediaType = "application/n-triples";
+const turtleMediaType = "text/turtle";
+const xsdString = "http://www.w3.org/2001/XMLSchema#string";
+
+// Manta passes on the datastore's status, and the datastore answers 400 for a query or an update that it cannot run.
+const datastoreRefusalStatus = 400;
+
+type Datastore = { engine: QueryEngine; store: Store };
+
+type SparqlCall = { request: Request; body: string };
+
+export function createMantaMock({ turtle }: MantaMockOptions = {}): MantaMock {
+  const datastore = { engine: new QueryEngine(), store: new Store(seedQuads(turtle)) };
+  const updates: string[] = [];
+  let pending: Promise<unknown> = Promise.resolve();
+
+  function oneAtATime(task: () => Promise<Response>): Promise<Response> {
+    const run = pending.then(task);
+    pending = run.catch(() => undefined);
+    return run;
+  }
+
+  async function respond(path: SparqlPath, call: SparqlCall): Promise<Response> {
+    try {
+      if (path === sparqlRoutePath) return await answerQuery(datastore, call);
+      const response = await applyUpdate(datastore, call);
+      if (response.ok) updates.push(call.body);
+      return response;
+    } catch (error) {
+      const failed = path === sparqlRoutePath ? "SPARQL query failed" : "SPARQL update failed";
+      const details = error instanceof Error ? error.message : String(error);
+      return errorResponse(datastoreRefusalStatus, { error: `${failed}: ${datastoreRefusalStatus}`, details });
+    }
+  }
+
+  async function handle(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
+    const request = new Request(input, init);
+    const path = sparqlPath(request.url);
+    if (request.method !== "POST" || path === undefined) return errorResponse(404, { error: "Not found" });
+
+    const body = await request.text();
+    return oneAtATime(() => respond(path, { request, body }));
+  }
+
+  return { fetch: handle, route: routeTo(handle), updates };
+}
+
+function routeTo(handle: MantaMock["fetch"]): MantaMock["route"] {
+  return async (route) => {
+    const request = route.request();
+    if (sparqlPath(request.url()) === undefined) {
+      await route.fallback();
+      return;
+    }
+    if (request.method() === "OPTIONS") {
+      await route.fulfill({ status: 204, headers: preflightHeaders(request.headers()), body: "" });
+      return;
+    }
+    const response = await handle(request.url(), {
+      method: request.method(),
+      headers: request.headers(),
+      body: request.postData() ?? undefined,
+    });
+    await route.fulfill({
+      status: response.status,
+      headers: { ...Object.fromEntries(response.headers), ...corsHeaders(request.headers()) },
+      body: await response.text(),
+    });
+  };
+}
+
+function seedQuads(turtle: string | undefined) {
+  return turtle === undefined ? [] : new Parser().parse(`${toTurtlePrefixes()}\n${turtle}`);
+}
+
+function sparqlPath(url: string): SparqlPath | undefined {
+  const { path } = parseDatastorePath(new URL(url).pathname);
+  return path === sparqlRoutePath || path === updatePath ? path : undefined;
+}
+
+async function answerQuery({ engine, store }: Datastore, { request, body }: SparqlCall): Promise<Response> {
+  const sparql = prependMissingSparqlPrefixes(body);
+  const validation = isReadOnlySparqlQuery(sparql);
+  if (!validation.allowed) return errorResponse(403, { error: validation.error });
+
+  const result = await engine.query(sparql, { sources: [store] });
+  return match(result)
+    .with({ resultType: "boolean" }, async (booleans) => booleanResponse(await booleans.execute()))
+    .with({ resultType: "quads" }, async (quads) => quadsResponse(await (await quads.execute()).toArray(), request))
+    .with({ resultType: "bindings" }, async (bindings) => {
+      const { variables } = await bindings.metadata();
+      const rows = await (await bindings.execute()).toArray();
+      return bindingsResponse({ variables: variables.map((variable) => variable.value), rows });
+    })
+    .run();
+}
+
+async function applyUpdate({ engine, store }: Datastore, { request, body }: SparqlCall): Promise<Response> {
+  const mediaType = request.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase();
+  if (mediaType !== sparqlUpdateMediaType) {
+    return errorResponse(415, { error: "A write must be sent as application/sparql-update" });
+  }
+  if (!body.trim()) return errorResponse(400, { error: "Empty update body" });
+
+  const sparql = prependMissingSparqlPrefixes(body);
+  const validation = validateDataManipulationUpdate(sparql, { defaultGraphOnly: true });
+  if (!validation.allowed) {
+    const status = isPresent(validation.blockedOperations) ? 403 : 400;
+    return errorResponse(status, { error: validation.error, blockedOperations: validation.blockedOperations });
+  }
+
+  await engine.queryVoid(sparql, { sources: [store] });
+  return new Response(null, { status: 204 });
+}
+
+function booleanResponse(answer: boolean): Response {
+  return sparqlResultsResponse({ head: {}, boolean: answer });
+}
+
+function quadsResponse(quads: Parameters<Writer["quadsToString"]>[0], request: Request): Response {
+  const { mediaType, format } = quadsFormat(request.headers.get("accept"));
+  return new Response(new Writer({ format }).quadsToString(quads), { headers: { "content-type": mediaType } });
+}
+
+type BindingsResult = { variables: string[]; rows: Iterable<[Variable, Term]>[] };
+
+function bindingsResponse({ variables, rows }: BindingsResult): Response {
+  const bindings = rows.map((row) =>
+    Object.fromEntries([...row].map(([variable, term]) => [variable.value, bindingTerm(term)])),
+  );
+  return sparqlResultsResponse({ head: { vars: variables }, results: { bindings } });
+}
+
+function sparqlResultsResponse(body: unknown): Response {
+  return Response.json(body, { headers: { "content-type": sparqlResultsMediaType } });
+}
+
+function errorResponse(status: number, body: unknown): Response {
+  return Response.json(body, { status });
+}
+
+function quadsFormat(accept: string | null): { mediaType: string; format: string } {
+  return accept?.includes(nTriplesMediaType)
+    ? { mediaType: nTriplesMediaType, format: "N-Triples" }
+    : { mediaType: turtleMediaType, format: "Turtle" };
+}
+
+function bindingTerm(term: Term): Record<string, string> {
+  return match(term)
+    .with({ termType: "NamedNode" }, ({ value }) => ({ type: "uri", value }))
+    .with({ termType: "BlankNode" }, ({ value }) => ({ type: "bnode", value }))
+    .with({ termType: "Literal", language: P.string.minLength(1) }, ({ value, language }) => ({
+      type: "literal",
+      value,
+      "xml:lang": language,
+    }))
+    .with({ termType: "Literal", datatype: { value: xsdString } }, ({ value }) => ({ type: "literal", value }))
+    .with({ termType: "Literal" }, ({ value, datatype }) => ({ type: "literal", value, datatype: datatype.value }))
+    .otherwise(({ termType }) => {
+      throw new Error(`Cannot serialize a ${termType} in a result`);
+    });
+}
+
+function corsHeaders(requestHeaders: Record<string, string>): Record<string, string> {
+  const origin = requestHeaders.origin;
+  if (origin === undefined) return {};
+  return { "access-control-allow-origin": origin, "access-control-allow-credentials": "true", vary: "Origin" };
+}
+
+function preflightHeaders(requestHeaders: Record<string, string>): Record<string, string> {
+  const requested = requestHeaders["access-control-request-headers"];
+  return {
+    ...corsHeaders(requestHeaders),
+    "access-control-allow-methods": "POST",
+    ...(requested === undefined ? {} : { "access-control-allow-headers": requested }),
+    "access-control-max-age": "600",
+  };
+}