resource.ts

import Handlebars from "handlebars";
import groupBy from "lodash.groupby";
import mapValues from "lodash.mapvalues";
import transform from "lodash.transform";
import type { ObjectTypeDefinitionNode } from "graphql";

import Resources from "./resources.ts";
import {
  oneOrMany,
  isListType,
  unwrapCompositeType,
  ensureArray,
} from "./utils.ts";

interface Triple {
  s: string;
  p: string;
  o: string;
}

type CompiledTemplate = (args: object) => string;
export type ResourceEntry = Record<string, any>;

const handlebars = Handlebars.create();

function decodeQleverValue(rawValue: string): string {
  const iriMatch = rawValue.match(/^<(.+)>$/);
  if (iriMatch) {
    return iriMatch[1];
  }

  const literalMatch = rawValue.match(
    /^"((?:[^"\\]|\\.)*)"(?:@[A-Za-z0-9-]+|\^\^<[^>]+>)?$/
  );
  if (literalMatch) {
    return literalMatch[1]
      .replace(/\\t/g, "\t")
      .replace(/\\n/g, "\n")
      .replace(/\\r/g, "\r")
      .replace(/\\"/g, '"')
      .replace(/\\\\/g, "\\");
  }

  return rawValue;
}

function normalizeBindings(data: any, contentType: string | null): Array<Triple> {
  const normalizedContentType = (contentType || "").toLowerCase();

  if (normalizedContentType.includes("application/sparql-results+json")) {
    return data.results.bindings.map((b: Record<string, any>) => {
      const normalizedBinding = {
        s: b.s || b.subject,
        p: b.p || b.predicate,
        o: b.o || b.object,
      };

      return mapValues(normalizedBinding, ({ value }) => value);
    });
  }

  if (normalizedContentType.includes("application/qlever-results+json")) {
    const selected: string[] = data.selected;
    const getIndex = (...names: string[]) =>
      selected.findIndex((name) => names.includes(name));
    const sIdx = getIndex("?s", "?subject");
    const pIdx = getIndex("?p", "?predicate");
    const oIdx = getIndex("?o", "?object");

    if (sIdx < 0 || pIdx < 0 || oIdx < 0) {
      throw new Error(
        `QLever JSON result does not include ?s/?p/?o (selected=${selected.join(
          ", "
        )})`
      );
    }

    return data.res.map((row: string[]) => ({
      s: decodeQleverValue(row[sIdx]),
      p: decodeQleverValue(row[pIdx]),
      o: decodeQleverValue(row[oIdx]),
    }));
  }

  throw new Error(`Unsupported SPARQL content type: ${contentType}`);
}

handlebars.registerHelper(
  "join",
  function (separator: string, strs: string | string[]): string {
    return ensureArray(strs).join(separator);
  }
);

handlebars.registerHelper(
  "as-iriref",
  function (strs: string | string[]): string[] {
    return ensureArray(strs).map((str) => `<${str}>`);
  }
);

handlebars.registerHelper(
  "as-string",
  function (strs: string | string[]): string[] {
    return ensureArray(strs).map((str) => `"${str}"`);
  }
);

function buildEntry(
  bindingsGroupedBySubject: Record<string, Array<Triple>>,
  subject: string,
  resource: Resource,
  resources: Resources
): ResourceEntry {
  const entry: ResourceEntry = {};

  const pValues = transform(
    bindingsGroupedBySubject[subject],
    (acc, { p, o }: Triple) => {
      const k = p.replace(/^https:\/\/github\.com\/dbcls\/grasp\/ns\//, "");

      (acc[k] || (acc[k] = [])).push(o);
    },
    {} as Record<string, string[]>
  );

  (resource.definition.fields || []).forEach((field) => {
    const type = field.type;
    const name = field.name.value;
    const values = pValues[name] || [];

    const targetType = unwrapCompositeType(type);
    const targetResource = resources.lookup(targetType.name.value);

    if (targetResource?.isEmbeddedType) {
      const entries = values.map((nodeId) =>
        buildEntry(bindingsGroupedBySubject, nodeId, targetResource, resources)
      );
      entry[name] = oneOrMany(entries, !isListType(type));
    } else {
      entry[name] = oneOrMany(values, !isListType(type));
    }
  });

  return entry;
}

export default class Resource {
  resources: Resources;
  definition: ObjectTypeDefinitionNode;
  endpoint: string | null;
  queryTemplate: CompiledTemplate | null;

  constructor(
    resources: Resources,
    definition: ObjectTypeDefinitionNode,
    endpoint: string | null,
    sparql: string | null
  ) {
    this.resources = resources;
    this.definition = definition;
    this.endpoint = endpoint;
    this.queryTemplate = sparql
      ? handlebars.compile(sparql, { noEscape: true })
      : null;
  }

  static buildFromTypeDefinition(
    resources: Resources,
    def: ObjectTypeDefinitionNode
  ): Resource {
    if (
      def.directives?.some((directive) => directive.name.value === "embedded")
    ) {
      return new Resource(resources, def, null, null);
    }

    if (!def.description) {
      throw new Error(`description for type ${def.name.value} is not defined`);
    }
    const description = def.description.value;
    const lines = description.split(/\r?\n/);

    let endpoint: string | null = null,
      sparql = "";

    let state: "default" | "endpoint" | "sparql" = "default";

    lines.forEach((line: string) => {
      switch (line) {
        case "--- endpoint ---":
          state = "endpoint";
          return;
        case "--- sparql ---":
          state = "sparql";
          return;
      }

      switch (state) {
        case "endpoint":
          endpoint = line;
          state = "default";
          break;
        case "sparql":
          sparql += line + "\n";
          break;
      }
    });

    if (!endpoint) {
      throw new Error(`endpoint is not defined for type ${def.name.value}`);
    }
    return new Resource(resources, def, endpoint, sparql);
  }

  async fetch(args: object): Promise<ResourceEntry[]> {
    const bindings = await this.query(args);

    const bindingGropuedBySubject = groupBy(bindings, "s");
    const primaryBindings = bindings.filter(
      (binding) => !binding.s.startsWith("_:")
    );

    const entries = Object.entries(groupBy(primaryBindings, "s")).map(
      ([s, _sBindings]) => {
        return buildEntry(bindingGropuedBySubject, s, this, this.resources);
      }
    );

    return entries;
  }

  async fetchByIRIs(
    iris: ReadonlyArray<string>
  ): Promise<Array<ResourceEntry | null>> {
    const entries = await this.fetch({ iri: iris });
    return iris.map(
      (iri) => entries.find((entry) => entry.iri === iri) || null
    );
  }

  async query(args: object): Promise<Array<Triple>> {
    if (!this.queryTemplate || !this.endpoint) {
      throw new Error(
        "query template and endpoint should be specified in order to query"
      );
    }
    const sparqlQuery = this.queryTemplate(args);

    console.log("--- SPARQL QUERY ---", sparqlQuery);

    const sparqlParams = new URLSearchParams();
    sparqlParams.append("query", sparqlQuery);

    const opts = {
      method: "POST",
      body: sparqlParams,
      headers: {
        // Keep this order for compatibility with both QLever and Virtuoso:
        // Virtuoso may fail when `application/qlever-results+json` is listed first,
        // but QLever needs `application/qlever-results+json` to return `CONSTRUCT` results as JSON.
        Accept:
          "application/sparql-results+json, application/qlever-results+json",
      },
    };

    const res = await fetch(this.endpoint, opts);

    if (res.ok) {
      const data = (await res.json()) as any;
      return normalizeBindings(data, res.headers.get("content-type"));
    } else {
      const body = await res.text();

      throw new Error(
        `SPARQL endpoint returns ${res.status} ${res.statusText}: ${body}`
      );
    }
  }

  get isRootType(): boolean {
    return !this.definition.directives?.some(
      (directive) => directive.name.value === "embedded"
    );
  }

  get isEmbeddedType(): boolean {
    return !this.isRootType;
  }
}