drupal-mcp-connector 0.6.1

package/src/lib/backends/errors.js

@@ -0,0 +1,31 @@
+/**
+ * Typed error classes for the backend abstraction layer.
+ *
+ * Single responsibility: give callers distinct, catchable error types for the
+ * two backend-specific failure modes (unsupported operation vs. no usable
+ * backend), separate from generic transport/HTTP errors.
+ */
+
+/**
+ * Thrown when a resolved backend cannot perform a requested operation
+ * (e.g. attempting a write through the read-only GraphQL backend).
+ */
+export class BackendCapabilityError extends Error {
+  /** @param {string} message Human-readable explanation. */
+  constructor(message) {
+    super(message);
+    this.name = "BackendCapabilityError";
+  }
+}
+
+/**
+ * Thrown when no usable backend can be resolved for a site (misconfigured
+ * `api` setting, or no protocol reachable during the probe).
+ */
+export class BackendResolutionError extends Error {
+  /** @param {string} message Human-readable explanation. */
+  constructor(message) {
+    super(message);
+    this.name = "BackendResolutionError";
+  }
+}

package/src/lib/backends/graphql-filter.js

@@ -0,0 +1,99 @@
+/**
+ * Client-side filter and sort over canonical entities.
+ *
+ * Single responsibility: apply filter predicates and sort orders in JS for the
+ * GraphQL backend, which cannot filter (and can only sort by a fixed enum of
+ * keys) server-side. This runs over the bounded set of records the backend
+ * already paged in (up to its client-record cap), which is why the results it
+ * feeds are flagged `approximate`/`truncated` upstream.
+ */
+
+const BASE_GETTERS = new Map([
+  ["id",      (e) => e.id],
+  ["title",   (e) => e.title],
+  ["status",  (e) => e.status],
+  ["langcode",(e) => e.langcode],
+  ["created", (e) => e.created],
+  ["changed", (e) => e.changed],
+  ["url",     (e) => e.url],
+]);
+
+/**
+ * Build a value accessor for one entity. The entity's custom fields are copied
+ * into a Map ONCE here, so repeated lookups across many filters/sort keys do not
+ * re-build it per access (this runs over up to ~1000 records in the GraphQL path).
+ * The Map(Object.entries()) lookup also keeps field access object-injection-safe.
+ * @param {import("../canonical.js").CanonicalEntity} entity
+ * @returns {(field: string) => *} Resolver returning the value for a field name.
+ */
+function accessorFor(entity) {
+  const custom = entity.fields ? new Map(Object.entries(entity.fields)) : new Map();
+  return (field) => {
+    const base = BASE_GETTERS.get(field);
+    return base ? base(entity) : custom.get(field);
+  };
+}
+
+/**
+ * Evaluate a single filter condition against an entity's value accessor.
+ * @param {(field: string) => *} get Value accessor from {@link accessorFor}.
+ * @param {{field: string, op?: string, value: *}} cond Filter condition.
+ * @returns {boolean} True when the condition holds (unknown ops return false).
+ */
+function matches(get, { field, op = "eq", value }) {
+  const v = get(field);
+  switch (op) {
+    case "eq": return v === value;
+    case "neq": return v !== value;
+    case "gt": return v > value;
+    case "gte": return v >= value;
+    case "lt": return v < value;
+    case "lte": return v <= value;
+    case "contains": return String(v ?? "").toLowerCase().includes(String(value).toLowerCase());
+    case "in": return Array.isArray(value) && value.includes(v);
+    case "isNull": return v === null || v === undefined;
+    default: return false;
+  }
+}
+
+/**
+ * Filter entities by an AND-combined list of conditions.
+ * @param {import("../canonical.js").CanonicalEntity[]} entities
+ * @param {Array<{field: string, op?: string, value: *}>} [filters]
+ * @returns {import("../canonical.js").CanonicalEntity[]} New filtered array
+ *   (or the input array unchanged when there are no filters).
+ */
+export function applyClientFilters(entities, filters = []) {
+  if (!filters.length) return entities;
+  return entities.filter((e) => {
+    const get = accessorFor(e);
+    return filters.every((f) => matches(get, f));
+  });
+}
+
+/**
+ * Sort entities by an ordered list of sort keys (later keys break ties).
+ * @param {import("../canonical.js").CanonicalEntity[]} entities
+ * @param {Array<{field: string, dir?: "asc"|"desc"}>} [sort]
+ * @returns {import("../canonical.js").CanonicalEntity[]} New sorted array
+ *   (or the input array unchanged when there is no sort).
+ */
+export function applyClientSort(entities, sort = []) {
+  if (!sort.length) return entities;
+  // Build one accessor per entity up front (keyed by the entity object) so the
+  // comparator never re-builds the per-entity fields Map.
+  const accessors = new Map(entities.map((e) => [e, accessorFor(e)]));
+  const sorted = [...entities];
+  sorted.sort((a, b) => {
+    const ga = accessors.get(a);
+    const gb = accessors.get(b);
+    for (const { field, dir = "asc" } of sort) {
+      const av = ga(field);
+      const bv = gb(field);
+      if (av < bv) return dir === "desc" ? 1 : -1;
+      if (av > bv) return dir === "desc" ? -1 : 1;
+    }
+    return 0;
+  });
+  return sorted;
+}

package/src/lib/backends/graphql-names.js

@@ -0,0 +1,63 @@
+/**
+ * Pure helpers mapping graphql_compose type names to Drupal entityType/bundle.
+ *
+ * graphql_compose names a type as <Prefix><PascalBundle>, where Prefix encodes
+ * the entity type (Node, Media, Term=taxonomy_term, Paragraph, BlockContent,
+ * Menu, User). Single-type entities (User, Menu) have no bundle suffix.
+ */
+
+// Type-name prefix -> Drupal entity type. Order matters: longer/more-specific
+// prefixes are listed first so a type like "BlockContent..." matches
+// "BlockContent" before a hypothetical shorter "Block" prefix.
+const PREFIXES = [
+  ["BlockContent", "block_content"],
+  ["Paragraph", "paragraph"],
+  ["Media", "media"],
+  ["Term", "taxonomy_term"],
+  ["Menu", "menu"],
+  ["Node", "node"],
+  ["User", "user"],
+];
+
+/**
+ * Convert a PascalCase fragment to snake_case (the Drupal bundle convention).
+ * @param {string} s e.g. "BasicPage".
+ * @returns {string} e.g. "basic_page".
+ */
+export function pascalToSnake(s) {
+  // Two passes: lower/digit->Upper boundaries, then acronym->Word boundaries,
+  // so both "fooBar" and "URLAlias" split correctly before lowercasing.
+  return s
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
+    .toLowerCase();
+}
+
+/**
+ * Convert a snake_case machine name to PascalCase.
+ * @param {string} s e.g. "basic_page".
+ * @returns {string} e.g. "BasicPage".
+ */
+export function snakeToPascal(s) {
+  return s.split("_").map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+
+/**
+ * Map a graphql_compose type name to its Drupal entityType/bundle.
+ * @param {string} typeName e.g. "NodeArticle".
+ * @returns {{entityType: string, bundle: string}|null} Pair, or null when the
+ *   name matches no known prefix.
+ */
+export function graphqlTypeToEntity(typeName) {
+  for (const [prefix, entityType] of PREFIXES) {
+    if (typeName === prefix) {
+      // Single-type entity (User, Menu): bundle == entityType.
+      return { entityType, bundle: entityType };
+    }
+    if (typeName.startsWith(prefix)) {
+      const rest = typeName.slice(prefix.length);
+      return { entityType, bundle: pascalToSnake(rest) };
+    }
+  }
+  return null;
+}

package/src/lib/backends/graphql-normalize.js

@@ -0,0 +1,73 @@
+/**
+ * GraphQL result normalization.
+ *
+ * Single responsibility: convert a graphql_compose node object into the
+ * shared CanonicalEntity shape, promoting base fields, collapsing entity
+ * references into canonical relationship refs, and leaving everything else as
+ * raw field values.
+ */
+
+import { makeCanonicalEntity } from "../canonical.js";
+import { graphqlTypeToEntity } from "./graphql-names.js";
+
+// Node keys that map to canonical base properties, not to `fields`.
+const BASE_KEYS = new Set(["__typename", "id", "title", "status", "langcode", "created", "changed", "path"]);
+
+/**
+ * Detect a single entity reference object (has `__typename` and `id`).
+ * @param {*} v Candidate value.
+ * @returns {boolean}
+ */
+function isEntityRef(v) {
+  return v && typeof v === "object" && typeof v.__typename === "string" && "id" in v;
+}
+
+/**
+ * Collapse an entity-reference object into a canonical relationship ref.
+ * @param {{__typename: string, id: string}} v
+ * @returns {{id: string, entityType: ?string, bundle: ?string}}
+ */
+function refToCanonical(v) {
+  const entity = graphqlTypeToEntity(v.__typename) ?? { entityType: null, bundle: null };
+  return { id: v.id, entityType: entity.entityType, bundle: entity.bundle };
+}
+
+/**
+ * Normalize a graphql_compose node into a CanonicalEntity.
+ * @param {object} node Raw GraphQL node object (includes `__typename`, `id`).
+ * @returns {import("../canonical.js").CanonicalEntity}
+ */
+export function graphqlNodeToCanonical(node) {
+  const entity = graphqlTypeToEntity(node.__typename || "") ?? { entityType: null, bundle: null };
+
+  const fieldsMap = new Map();
+  const relationshipsMap = new Map();
+  for (const [k, v] of Object.entries(node)) {
+    if (BASE_KEYS.has(k)) continue;
+    if (isEntityRef(v)) {
+      relationshipsMap.set(k, refToCanonical(v));
+    } else if (Array.isArray(v) && v.length && v.every(isEntityRef)) {
+      relationshipsMap.set(k, v.map(refToCanonical));
+    } else {
+      // Note: an empty array ([]) lands in `fields`, not `relationships` — we
+      // cannot tell an empty multi-ref from an empty scalar list without schema
+      // context, so empties stay as raw field values.
+      fieldsMap.set(k, v);
+    }
+  }
+
+  return makeCanonicalEntity({
+    id: node.id,
+    entityType: entity.entityType,
+    bundle: entity.bundle,
+    title: node.title ?? null,
+    status: typeof node.status === "boolean" ? node.status : (node.status ?? null),
+    langcode: node.langcode?.id ?? null,
+    created: node.created?.time ?? null,
+    changed: node.changed?.time ?? null,
+    url: node.path ?? null,
+    fields: Object.fromEntries(fieldsMap),
+    relationships: Object.fromEntries(relationshipsMap),
+    backend: "graphql",
+  });
+}

package/src/lib/backends/graphql-query.js

@@ -0,0 +1,129 @@
+/**
+ * GraphQL selection-set and query-document builders for graphql_compose.
+ *
+ * Single responsibility: turn a resolved SchemaEntry into a valid GraphQL
+ * query string. The builders are type-aware so the generated selection only
+ * requests fields the server can actually resolve (scalars are selected bare,
+ * scalar-wrapper objects get a fixed sub-selection, entity references collapse
+ * to `{ __typename id }`, and unknown wrappers are skipped to keep the query
+ * valid).
+ */
+
+import { graphqlTypeToEntity } from "./graphql-names.js";
+
+// graphql_compose wraps some scalars in object types; each needs an explicit
+// sub-selection because GraphQL forbids selecting an object without one.
+const OBJECT_SUBSELECTIONS = new Map([
+  ["DateTime", "{ time }"],
+  ["Language", "{ id }"],
+  ["TextSummary", "{ value summary format }"],
+]);
+
+// Field kinds that are selected as a bare field name (no sub-selection).
+const SCALAR_KINDS = new Set(["SCALAR", "ENUM"]);
+
+/**
+ * Map an entity union type name to its companion `<Entity>Interface`.
+ * An entity union/interface (TermUnion, MediaUnion, ...) exposes a matching
+ * <Entity>Interface with an `id`. Non-entity unions (e.g. MetaTagUnion) do
+ * NOT, so an inline fragment on their "interface" would be invalid — return
+ * null so the caller skips them.
+ * @param {?string} unionTypeName e.g. "MediaUnion".
+ * @returns {?string} e.g. "MediaInterface", or null when not an entity union.
+ */
+function entityInterfaceFor(unionTypeName) {
+  if (!unionTypeName || !graphqlTypeToEntity(unionTypeName)) return null;
+  return unionTypeName.replace(/Union$/, "Interface");
+}
+
+/**
+ * Build the selection text for a single field, or null to skip it.
+ * @param {string} name Field name.
+ * @param {object} desc describeType() result for the field.
+ * @returns {?string} Selection fragment, or null when the field is unselectable.
+ */
+function selectField(name, desc) {
+  if (SCALAR_KINDS.has(desc.kind)) return name;
+
+  if (desc.kind === "OBJECT") {
+    const sub = OBJECT_SUBSELECTIONS.get(desc.typeName);
+    if (sub) return `${name} ${sub}`;
+    // Another entity (User, MediaImage, ...) -> relationship reference.
+    if (graphqlTypeToEntity(desc.typeName)) return `${name} { __typename id }`;
+    return null; // unknown object wrapper -> skip to keep the query valid
+  }
+
+  // Single union/interface field (e.g. heroImage: MediaUnion) -> entity ref.
+  if (desc.kind === "UNION" || desc.kind === "INTERFACE") {
+    const iface = entityInterfaceFor(desc.typeName);
+    return iface ? `${name} { __typename ... on ${iface} { __typename id } }` : null;
+  }
+
+  if (desc.kind === "LIST") {
+    if (desc.ofTypeKind === "UNION" || desc.ofTypeKind === "INTERFACE") {
+      const iface = entityInterfaceFor(desc.ofTypeName);
+      return iface ? `${name} { __typename ... on ${iface} { __typename id } }` : null;
+    }
+    if (desc.ofTypeKind === "OBJECT" && graphqlTypeToEntity(desc.ofTypeName)) {
+      return `${name} { __typename id }`;
+    }
+    if (SCALAR_KINDS.has(desc.ofTypeKind)) return name;
+    return null;
+  }
+
+  return null;
+}
+
+/**
+ * Build the selection set (without surrounding braces) for an entity entry.
+ * Always includes `__typename` and `id` so results can be normalized later.
+ * @param {import("./graphql-schema.js").SchemaEntry} entry
+ * @returns {string} Space-joined selection fragments.
+ */
+export function buildSelection(entry) {
+  const parts = ["__typename"];
+  for (const [name, desc] of entry.fields) {
+    if (name === "__typename") continue;
+    const sel = selectField(name, desc);
+    if (sel && sel !== "__typename") parts.push(sel);
+  }
+  // Ensure id present even if not in fields map.
+  if (!parts.some((p) => p === "id" || p.startsWith("id "))) parts.splice(1, 0, "id");
+  return parts.join(" ");
+}
+
+/**
+ * Render collection arguments into GraphQL argument syntax.
+ * @param {{first?: number, after?: string, sortKey?: string, reverse?: boolean}} args
+ * @returns {string} e.g. "(first: 50, sortKey: CREATED_AT)" or "" when empty.
+ */
+function formatArgs(args) {
+  const out = [];
+  if (args.first !== undefined && args.first !== null) out.push(`first: ${args.first}`);
+  if (args.after) out.push(`after: ${JSON.stringify(args.after)}`);
+  if (args.sortKey) out.push(`sortKey: ${args.sortKey}`);
+  if (args.reverse !== undefined) out.push(`reverse: ${args.reverse}`);
+  return out.length ? `(${out.join(", ")})` : "";
+}
+
+/**
+ * Build a collection (connection) query document.
+ * @param {import("./graphql-schema.js").SchemaEntry} entry
+ * @param {{first?: number, after?: string, sortKey?: string, reverse?: boolean}} [args]
+ * @returns {string} A complete GraphQL query string.
+ */
+export function buildCollectionQuery(entry, args = {}) {
+  const selection = buildSelection(entry);
+  return `{ ${entry.collection}${formatArgs(args)} { pageInfo { hasNextPage endCursor } nodes { ${selection} } } }`;
+}
+
+/**
+ * Build a single-entity query document.
+ * @param {import("./graphql-schema.js").SchemaEntry} entry
+ * @param {string} id Entity id (UUID) to fetch.
+ * @returns {string} A complete GraphQL query string.
+ */
+export function buildSingleQuery(entry, id) {
+  const selection = buildSelection(entry);
+  return `{ ${entry.single}(id: ${JSON.stringify(id)}) { ${selection} } }`;
+}

package/src/lib/backends/graphql-schema.js

@@ -0,0 +1,226 @@
+/**
+ * GraphQL schema introspection and the queryable SchemaMap.
+ *
+ * Single responsibility: introspect a site's GraphQL schema once and build a
+ * lookup from Drupal entityType/bundle to the graphql_compose query fields
+ * (single + collection), field names, and field type kinds. The resolved map
+ * is cached per site so introspection runs at most once per process per site.
+ */
+
+import { drupalGraphqlFetch } from "../drupal-fetch.js";
+import { graphqlTypeToEntity } from "./graphql-names.js";
+
+// Introspection is intentionally nested four `ofType` levels deep: a field type
+// can be wrapped as NON_NULL(LIST(NON_NULL(NamedType))), so four levels are
+// needed to reach the underlying named type through every wrapper combination.
+const INTROSPECTION_QUERY = `
+{
+  __schema {
+    queryType { name }
+    types {
+      name
+      kind
+      enumValues { name }
+      fields {
+        name
+        args { name }
+        type { name kind ofType { name kind ofType { name kind ofType { name kind } } } }
+      }
+    }
+  }
+}`;
+
+const cache = new Map();
+
+/**
+ * Test helper: clear the per-site schema cache.
+ * @returns {void}
+ */
+export function _clearSchemaCache() {
+  cache.clear();
+}
+
+/**
+ * Unwrap NON_NULL/LIST wrappers down to the meaningful kind and type names.
+ * @param {object|null} t An introspection type node.
+ * @returns {{kind: ?string, typeName: ?string, ofTypeKind: ?string, ofTypeName: ?string}}
+ *   For LIST types, `ofType*` describes the element type; otherwise `typeName`
+ *   is the named type.
+ */
+function describeType(t) {
+  // Returns { kind, typeName, ofTypeKind, ofTypeName }
+  if (!t) return { kind: null, typeName: null, ofTypeKind: null, ofTypeName: null };
+  if (t.kind === "NON_NULL") return describeType(t.ofType);
+  if (t.kind === "LIST") {
+    const inner = t.ofType?.kind === "NON_NULL" ? t.ofType.ofType : t.ofType;
+    return { kind: "LIST", typeName: null, ofTypeKind: inner?.kind ?? null, ofTypeName: inner?.name ?? null };
+  }
+  return { kind: t.kind, typeName: t.name, ofTypeKind: null, ofTypeName: null };
+}
+
+/**
+ * @typedef {Object} SchemaEntry
+ * @property {string} typeName    graphql_compose object type, e.g. "NodeArticle".
+ * @property {string} entityType  Drupal entity type, e.g. "node".
+ * @property {string} bundle      Drupal bundle, e.g. "article".
+ * @property {?string} single     Query field returning one entity, or null.
+ * @property {?string} collection Query field returning a connection, or null.
+ * @property {Map<string, object>} fields Field name -> describeType() result.
+ */
+
+/**
+ * Resolved schema lookup: entityType/bundle -> SchemaEntry, plus the set of
+ * server-supported sort-key enum values.
+ */
+class SchemaMap {
+  constructor() {
+    this._byEntity = new Map();   // "node:article" -> SchemaEntry
+    this._typeToEntity = new Map(); // "NodeArticle" -> {entityType, bundle}
+    /** @type {Set<string>} Enum values of ConnectionSortKeys (server-side sort). */
+    this.sortKeys = new Set();
+  }
+
+  /**
+   * Compose the internal map key for an entity/bundle pair.
+   * @param {string} entityType
+   * @param {string} bundle
+   * @returns {string}
+   */
+  static _key(entityType, bundle) { return `${entityType}:${bundle}`; }
+
+  /**
+   * Look up the schema entry for an entity/bundle.
+   * @param {string} entityType
+   * @param {string} bundle
+   * @returns {?SchemaEntry}
+   */
+  forEntity(entityType, bundle) {
+    return this._byEntity.get(SchemaMap._key(entityType, bundle)) ?? null;
+  }
+
+  /**
+   * Reverse lookup: GraphQL type name -> entity/bundle.
+   * @param {string} typeName
+   * @returns {{entityType: string, bundle: string}|null}
+   */
+  entityForType(typeName) {
+    return this._typeToEntity.get(typeName) ?? null;
+  }
+
+  /**
+   * List bundles of the `node` entity type.
+   * @returns {string[]}
+   */
+  nodeBundles() {
+    const out = [];
+    for (const [key, v] of this._byEntity) {
+      if (key.startsWith("node:")) out.push(v.bundle);
+    }
+    return out;
+  }
+
+  /**
+   * List the bundles of a given entity type.
+   * @param {string} entityType
+   * @returns {string[]}
+   */
+  bundlesOf(entityType) {
+    const out = [];
+    const prefix = `${entityType}:`;
+    for (const [key, v] of this._byEntity) {
+      if (key.startsWith(prefix)) out.push(v.bundle);
+    }
+    return out;
+  }
+
+  /**
+   * List every known entity/bundle pair.
+   * @returns {Array<{entityType: string, bundle: string}>}
+   */
+  allEntities() {
+    const out = [];
+    for (const v of this._byEntity.values()) {
+      out.push({ entityType: v.entityType, bundle: v.bundle });
+    }
+    return out;
+  }
+}
+
+/**
+ * Build a SchemaMap from a raw introspection response.
+ * @param {object} introspection The `{ data: { __schema } }` response.
+ * @returns {SchemaMap}
+ */
+function buildSchemaMap(introspection) {
+  const schema = introspection.data.__schema;
+  const typesByName = new Map(schema.types.map((t) => [t.name, t]));
+  const queryType = typesByName.get(schema.queryType.name);
+  const map = new SchemaMap();
+
+  // Sort keys
+  const sortEnum = typesByName.get("ConnectionSortKeys");
+  for (const v of sortEnum?.enumValues ?? []) map.sortKeys.add(v.name);
+
+  // Index single + collection fields by the concrete entity object type they expose.
+  const singles = new Map();      // typeName -> queryField
+  const collections = new Map();  // typeName -> queryField
+  for (const f of queryType.fields ?? []) {
+    const d = describeType(f.type);
+    // graphql_compose names collection types <Entity>Connection; the nodes-type
+    // guard below is sufficient, so we don't also require a pageInfo field here.
+    if (d.kind === "OBJECT" && d.typeName?.endsWith("Connection")) {
+      const conn = typesByName.get(d.typeName);
+      const nodesField = conn?.fields?.find((x) => x.name === "nodes");
+      const nodeType = describeType(nodesField?.type).ofTypeName;
+      if (nodeType) collections.set(nodeType, f.name);
+    } else if (d.kind === "OBJECT" && (f.args ?? []).some((a) => a.name === "id")) {
+      singles.set(d.typeName, f.name);
+    }
+  }
+
+  // For each entity object type with a single OR collection field, build the entry.
+  const typeNames = new Set([...singles.keys(), ...collections.keys()]);
+  for (const typeName of typeNames) {
+    const entity = graphqlTypeToEntity(typeName);
+    if (!entity) continue;
+    const typeDef = typesByName.get(typeName);
+    const fields = new Map();
+    for (const ff of typeDef?.fields ?? []) {
+      fields.set(ff.name, describeType(ff.type));
+    }
+    const entry = {
+      typeName,
+      entityType: entity.entityType,
+      bundle: entity.bundle,
+      single: singles.get(typeName) ?? null,
+      collection: collections.get(typeName) ?? null,
+      fields,
+    };
+    map._byEntity.set(SchemaMap._key(entity.entityType, entity.bundle), entry);
+    map._typeToEntity.set(typeName, { entityType: entity.entityType, bundle: entity.bundle });
+  }
+
+  return map;
+}
+
+/**
+ * Load (or return the cached) SchemaMap for a site.
+ * @param {object} site Site config; must include `_name` (the cache key).
+ * @returns {Promise<SchemaMap>}
+ * @throws {Error} When introspection fails (the cache entry is cleared first).
+ */
+export async function loadSchemaMap(site) {
+  // Cache the in-flight Promise (not the resolved value) so concurrent first
+  // calls share a single introspection. Clear on failure so a transient error
+  // does not poison the cache.
+  if (!cache.has(site._name)) {
+    const pending = drupalGraphqlFetch(site, { query: INTROSPECTION_QUERY })
+      .then(buildSchemaMap)
+      .catch((err) => {
+        cache.delete(site._name);
+        throw err;
+      });
+    cache.set(site._name, pending);
+  }
+  return cache.get(site._name);
+}