backeneko 0.0.0-stage → 0.1.0

package/src/compile.ts

@@ -0,0 +1,263 @@
+import {
+  buildASTSchema,
+  Kind,
+  parse,
+  print,
+  visit,
+  type ASTNode,
+  type DefinitionNode,
+  type DocumentNode,
+  type GraphQLSchema,
+} from "graphql";
+import { validateSDL } from "./graphql-internal.ts";
+import { withMockDirectives } from "./directives.ts";
+import type { SkippedDefinition } from "./merge.ts";
+
+export interface CompileResult {
+  schema: GraphQLSchema;
+  document: DocumentNode;
+  skipped: SkippedDefinition[];
+  warnings: string[];
+}
+
+const BUILT_IN_DIRECTIVES = new Set(["skip", "include", "deprecated", "specifiedBy", "oneOf"]);
+const QUERY_PLACEHOLDER = parse("type Query { _empty: String }").definitions[0]!;
+const MAX_ITERATIONS = 1000;
+
+type MemberArrayKey = "fields" | "values" | "types";
+
+interface MemberRemoval {
+  keys: Set<number>;
+  entries: SkippedDefinition[];
+}
+
+export function compileDocument(input: DocumentNode): CompileResult {
+  const warnings: string[] = [];
+  const warningSet = new Set<string>();
+  const warn = (message: string): void => {
+    if (!warningSet.has(message)) {
+      warningSet.add(message);
+      warnings.push(message);
+    }
+  };
+
+  const { document: stripped, droppedDirectives } = stripUnknownDirectives(
+    withMockDirectives(input),
+  );
+  for (const [name, count] of droppedDirectives) {
+    warn(`dropped unknown directive @${name} (${count} use${count > 1 ? "s" : ""})`);
+  }
+
+  const pruned = pruneInvalidDefinitions(normalize(stripped).definitions.slice(), warn);
+
+  let document: DocumentNode = { kind: Kind.DOCUMENT, definitions: pruned.definitions };
+  let schema = buildTolerant(document, warn);
+
+  if (!schema.getQueryType()) {
+    document = append(document, QUERY_PLACEHOLDER);
+    schema = buildASTSchema(document);
+    warn("no Query type found — added `type Query { _empty: String }`");
+  }
+
+  return { schema, document, skipped: pruned.skipped, warnings };
+}
+
+function pruneInvalidDefinitions(
+  initial: DefinitionNode[],
+  warn: (message: string) => void,
+): { definitions: DefinitionNode[]; skipped: SkippedDefinition[] } {
+  let definitions = initial;
+  const skipped: SkippedDefinition[] = [];
+
+  for (let iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
+    const document: DocumentNode = { kind: Kind.DOCUMENT, definitions };
+    const errors = validateSDL(document);
+    if (errors.length === 0) break;
+
+    const dropDefinitions = new Set<DefinitionNode>();
+    const dropMembers = new Map<DefinitionNode, MemberRemoval>();
+
+    for (const error of errors) {
+      const node = lastLocatedNode(error.nodes ?? []);
+      if (!node?.loc) {
+        warn(`unattributed schema error: ${error.message}`);
+        continue;
+      }
+      const definition = findDefinition(definitions, node.loc.start, node.loc.end);
+      if (!definition) {
+        warn(`unattributed schema error: ${error.message}`);
+        continue;
+      }
+
+      const member = findMember(definition, node.loc.start, node.loc.end);
+      if (member) {
+        const removal = dropMembers.get(definition) ?? { keys: new Set(), entries: [] };
+        removal.keys.add(member.key);
+        removal.entries.push({
+          name: `${definitionName(definition)}.${member.name}`,
+          reason: error.message,
+        });
+        dropMembers.set(definition, removal);
+      } else {
+        dropDefinitions.add(definition);
+        skipped.push({ name: definitionName(definition), reason: error.message });
+      }
+    }
+
+    const next: DefinitionNode[] = [];
+    let changed = false;
+
+    for (const definition of definitions) {
+      if (dropDefinitions.has(definition)) {
+        changed = true;
+        continue;
+      }
+      const removal = dropMembers.get(definition);
+      if (!removal) {
+        next.push(definition);
+        continue;
+      }
+      changed = true;
+      const filtered = removeMembers(definition, removal.keys);
+      if (filtered !== null && membersOf(filtered).length > 0) {
+        next.push(filtered);
+        skipped.push(...removal.entries);
+      } else {
+        // The type lost every field, so the definition cannot stand on its own.
+        for (const entry of removal.entries) {
+          skipped.push({ name: definitionName(definition), reason: entry.reason });
+        }
+      }
+    }
+
+    definitions = next;
+    if (!changed) break;
+  }
+
+  return { definitions, skipped };
+}
+
+function lastLocatedNode(nodes: ReadonlyArray<ASTNode>): ASTNode | null {
+  // Duplicate-field errors report every occurrence; the last node is the
+  // offending duplicate, so pruning it keeps the original definition intact.
+  let found: ASTNode | null = null;
+  for (const node of nodes) {
+    if (node.loc) found = node;
+  }
+  return found;
+}
+
+function findDefinition(
+  definitions: ReadonlyArray<DefinitionNode>,
+  start: number,
+  end: number,
+): DefinitionNode | null {
+  for (const definition of definitions) {
+    const loc = definition.loc;
+    if (loc && start >= loc.start && end <= loc.end) return definition;
+  }
+  return null;
+}
+
+interface MemberInfo {
+  key: number;
+  name: string;
+}
+
+function findMember(definition: DefinitionNode, start: number, end: number): MemberInfo | null {
+  for (const member of membersOf(definition)) {
+    const loc = member.loc;
+    if (loc && start >= loc.start && end <= loc.end) {
+      return { key: loc.start, name: memberName(member) };
+    }
+  }
+  return null;
+}
+
+function memberArrayKey(definition: DefinitionNode): MemberArrayKey | null {
+  switch (definition.kind) {
+    case Kind.OBJECT_TYPE_DEFINITION:
+    case Kind.OBJECT_TYPE_EXTENSION:
+    case Kind.INTERFACE_TYPE_DEFINITION:
+    case Kind.INTERFACE_TYPE_EXTENSION:
+    case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+    case Kind.INPUT_OBJECT_TYPE_EXTENSION:
+      return "fields";
+    case Kind.ENUM_TYPE_DEFINITION:
+    case Kind.ENUM_TYPE_EXTENSION:
+      return "values";
+    case Kind.UNION_TYPE_DEFINITION:
+    case Kind.UNION_TYPE_EXTENSION:
+      return "types";
+    default:
+      return null;
+  }
+}
+
+function membersOf(definition: DefinitionNode): readonly ASTNode[] {
+  const key = memberArrayKey(definition);
+  if (!key) return [];
+  const value = (definition as unknown as Record<string, unknown>)[key];
+  return Array.isArray(value) ? (value as ASTNode[]) : [];
+}
+
+function removeMembers(definition: DefinitionNode, keys: Set<number>): DefinitionNode | null {
+  const key = memberArrayKey(definition);
+  if (!key) return null;
+  const members = membersOf(definition).filter((member) => !member.loc || !keys.has(member.loc.start));
+  return { ...(definition as object), [key]: members } as unknown as DefinitionNode;
+}
+
+function memberName(node: ASTNode): string {
+  const name = (node as { name?: { value?: string } }).name;
+  return name && typeof name.value === "string" ? name.value : "member";
+}
+
+function definitionName(definition: DefinitionNode): string {
+  if ("name" in definition && definition.name && typeof definition.name.value === "string") {
+    return definition.name.value;
+  }
+  if (definition.kind === Kind.SCHEMA_DEFINITION || definition.kind === Kind.SCHEMA_EXTENSION) {
+    return "schema";
+  }
+  return definition.kind.toLowerCase().replace(/_/g, " ");
+}
+
+function buildTolerant(document: DocumentNode, warn: (message: string) => void): GraphQLSchema {
+  try {
+    return buildASTSchema(document);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    warn(`schema could not be built (${message}); falling back to an empty schema`);
+    return buildASTSchema({ kind: Kind.DOCUMENT, definitions: [] });
+  }
+}
+
+function stripUnknownDirectives(document: DocumentNode): {
+  document: DocumentNode;
+  droppedDirectives: Map<string, number>;
+} {
+  const known = new Set(BUILT_IN_DIRECTIVES);
+  for (const def of document.definitions) {
+    if (def.kind === Kind.DIRECTIVE_DEFINITION) known.add(def.name.value);
+  }
+
+  const droppedDirectives = new Map<string, number>();
+  const result = visit(document, {
+    Directive(node) {
+      if (known.has(node.name.value)) return undefined;
+      droppedDirectives.set(node.name.value, (droppedDirectives.get(node.name.value) ?? 0) + 1);
+      return null;
+    },
+  });
+
+  return { document: result, droppedDirectives };
+}
+
+function normalize(document: DocumentNode): DocumentNode {
+  return parse(print(document));
+}
+
+function append(document: DocumentNode, definition: DefinitionNode): DocumentNode {
+  return { kind: Kind.DOCUMENT, definitions: [...document.definitions, definition] };
+}

package/src/directives.ts

@@ -0,0 +1,125 @@
+import {
+  Kind,
+  isEnumType,
+  isScalarType,
+  parse,
+  visit,
+  type ConstDirectiveNode,
+  type DefinitionNode,
+  type DocumentNode,
+  type FieldDefinitionNode,
+  type GraphQLNamedType,
+} from "graphql";
+
+// The two project directives are interchangeable: `@backeneko` and `@mock`.
+export const MOCK_DIRECTIVES: readonly string[] = ["backeneko", "mock"];
+export const MOCK_DIRECTIVE_ARG = "value";
+
+export type MockValueResult =
+  | { ok: true; expression: string }
+  | { ok: false; reason: string };
+
+// backeneko owns these directives, so a schema may use them without declaring
+// them. When a name is used but not defined, its definition is injected before
+// SDL validation (otherwise `stripUnknownDirectives` would drop the usage).
+export function withMockDirectives(document: DocumentNode): DocumentNode {
+  const used = new Set<string>();
+  visit(document, {
+    Directive(node) {
+      if (MOCK_DIRECTIVES.includes(node.name.value)) used.add(node.name.value);
+    },
+  });
+
+  const defined = new Set<string>();
+  for (const def of document.definitions) {
+    if (def.kind === Kind.DIRECTIVE_DEFINITION) defined.add(def.name.value);
+  }
+
+  const additions: DefinitionNode[] = [];
+  for (const name of MOCK_DIRECTIVES) {
+    if (!used.has(name) || defined.has(name)) continue;
+    additions.push(
+      ...parse(`directive @${name}(${MOCK_DIRECTIVE_ARG}: String) on FIELD_DEFINITION`).definitions,
+    );
+  }
+  if (additions.length === 0) return document;
+
+  return { kind: Kind.DOCUMENT, definitions: [...additions, ...document.definitions] };
+}
+
+// Collects `Type.field` -> raw string value for every field annotated with a
+// mock directive. Covers type definitions and extensions.
+export function collectFieldDirectives(document: DocumentNode): Map<string, string> {
+  const values = new Map<string, string>();
+
+  for (const definition of document.definitions) {
+    const name = "name" in definition ? definition.name?.value : undefined;
+    const fields = fieldDefinitions(definition);
+    if (!name || fields.length === 0) continue;
+
+    for (const field of fields) {
+      const key = `${name}.${field.name.value}`;
+      if (values.has(key)) continue;
+      const value = mockDirectiveValue(field.directives);
+      if (value !== undefined) values.set(key, value);
+    }
+  }
+
+  return values;
+}
+
+export function renderMockValue(
+  value: string,
+  named: GraphQLNamedType,
+  list: boolean,
+): MockValueResult {
+  if (list) return { ok: false, reason: "list fields are not supported yet" };
+
+  if (isEnumType(named)) return { ok: true, expression: JSON.stringify(value) };
+
+  if (isScalarType(named)) {
+    switch (named.name) {
+      case "Int": {
+        const parsed = Number(value);
+        if (Number.isSafeInteger(parsed) && String(parsed) === value.trim()) {
+          return { ok: true, expression: String(parsed) };
+        }
+        return { ok: false, reason: `"${value}" is not an Int` };
+      }
+      case "Float": {
+        const parsed = Number(value);
+        if (value.trim() !== "" && Number.isFinite(parsed)) {
+          return { ok: true, expression: String(parsed) };
+        }
+        return { ok: false, reason: `"${value}" is not a Float` };
+      }
+      case "Boolean": {
+        if (value === "true") return { ok: true, expression: "true" };
+        if (value === "false") return { ok: true, expression: "false" };
+        return { ok: false, reason: `"${value}" is not a Boolean` };
+      }
+      default:
+        // String, ID and custom scalars keep the raw string.
+        return { ok: true, expression: JSON.stringify(value) };
+    }
+  }
+
+  return { ok: false, reason: "only scalar and enum fields are supported" };
+}
+
+function mockDirectiveValue(
+  directives: readonly ConstDirectiveNode[] | undefined,
+): string | undefined {
+  for (const directive of directives ?? []) {
+    if (!MOCK_DIRECTIVES.includes(directive.name.value)) continue;
+    const argument = directive.arguments?.find((entry) => entry.name.value === MOCK_DIRECTIVE_ARG);
+    if (argument && argument.value.kind === Kind.STRING) return argument.value.value;
+  }
+  return undefined;
+}
+
+function fieldDefinitions(definition: DefinitionNode): readonly FieldDefinitionNode[] {
+  if (!("fields" in definition)) return [];
+  const fields = (definition as { fields?: unknown }).fields;
+  return Array.isArray(fields) ? (fields as readonly FieldDefinitionNode[]) : [];
+}