@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/Api/GraphQL_SchemaInspector.res.mjs

@@ -0,0 +1,123 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
+import * as GraphQL_Stitcher$ReventlessCore from "./GraphQL_Stitcher.res.mjs";
+import * as GraphQL_FragmentGenerator$ReventlessCore from "./GraphQL_FragmentGenerator.res.mjs";
+
+function inspectScalar(schema) {
+  let collectedTypes = [];
+  let seenTypes = new Set();
+  return GraphQL_FragmentGenerator$ReventlessCore.deriveFieldType("", "", false, schema, collectedTypes, seenTypes);
+}
+
+function inspectObjectType(typeName, schema) {
+  let types = GraphQL_FragmentGenerator$ReventlessCore.deriveObjectTypeWithNested(typeName, undefined, undefined, schema);
+  return types[types.length - 1 | 0];
+}
+
+function inspectMutationFields(fieldPrefix, commandSchema) {
+  let fields = [];
+  let collectedTypes = [];
+  let seenTypes = new Set();
+  switch (commandSchema.type) {
+    case "object" :
+      Stdlib_Option.forEach(GraphQL_FragmentGenerator$ReventlessCore.deriveMutationFieldFromObject(fieldPrefix, collectedTypes, seenTypes, commandSchema), field => {
+        fields.push(field);
+      });
+      break;
+    case "union" :
+      let constructorNames = DcbTag$Reventless.extractAllVariantNames(commandSchema);
+      commandSchema.anyOf.forEach((variantSchema, i) => {
+        let name = constructorNames[i];
+        let fieldName = name !== undefined ? fieldPrefix + `_` + name : fieldPrefix + `_Variant` + i.toString();
+        Stdlib_Option.forEach(GraphQL_FragmentGenerator$ReventlessCore.deriveMutationFieldFromObject(fieldName, collectedTypes, seenTypes, variantSchema), field => {
+          fields.push(field);
+        });
+      });
+      break;
+  }
+  return fields;
+}
+
+function inspectQueryFields(name, typeName, stateSchema) {
+  let types = GraphQL_FragmentGenerator$ReventlessCore.deriveObjectTypeWithNested(typeName, undefined, undefined, stateSchema);
+  let typeDef = types[types.length - 1 | 0];
+  let singleQuery = GraphQL_FragmentGenerator$ReventlessCore.deriveObjectQueryField(name, typeName, undefined, undefined);
+  let pluralName = name + "s";
+  let listQuery = GraphQL_FragmentGenerator$ReventlessCore.deriveListQueryField(pluralName, pluralName);
+  return {
+    typeDef: typeDef,
+    singleQuery: singleQuery,
+    listQuery: listQuery
+  };
+}
+
+function inspectFragment(fragment) {
+  let parts = GraphQL_Stitcher$ReventlessCore.decode(fragment);
+  let typesSdl = parts.types.join("\n\n");
+  let queriesSdl = parts.queries.length !== 0 ? `type Query {\n` + parts.queries.join("\n") + `\n}` : "";
+  let mutationsSdl = parts.mutations.length !== 0 ? `type Mutation {\n` + parts.mutations.join("\n") + `\n}` : "";
+  let sdlParts = [
+    typesSdl,
+    queriesSdl,
+    mutationsSdl
+  ].filter(p => p.length > 0);
+  let sdlPreview = sdlParts.join("\n\n");
+  return {
+    types: parts.types,
+    mutations: parts.mutations,
+    queries: parts.queries,
+    sdlPreview: sdlPreview
+  };
+}
+
+function printFragment(fragment) {
+  let log = Logger$ReventlessCore.fromEnv();
+  let match = inspectFragment(fragment);
+  let queries = match.queries;
+  let mutations = match.mutations;
+  let types = match.types;
+  log.debug("GraphQL", undefined, "[GraphQL Fragment]");
+  log.debug("GraphQL", undefined, `  Types (` + types.length.toString() + `):`);
+  types.forEach(t => {
+    let name = GraphQL_Stitcher$ReventlessCore.extractLeadingName(t);
+    log.debug("GraphQL", undefined, `    - ` + name);
+    log.debug("GraphQL", undefined, `      ` + t);
+  });
+  log.debug("GraphQL", undefined, `  Mutations (` + mutations.length.toString() + `):`);
+  mutations.forEach(m => {
+    let name = GraphQL_Stitcher$ReventlessCore.extractLeadingName(m);
+    log.debug("GraphQL", undefined, `    - ` + name);
+    log.debug("GraphQL", undefined, `      ` + m);
+  });
+  log.debug("GraphQL", undefined, `  Queries (` + queries.length.toString() + `):`);
+  queries.forEach(q => {
+    let name = GraphQL_Stitcher$ReventlessCore.extractLeadingName(q);
+    log.debug("GraphQL", undefined, `    - ` + name);
+    log.debug("GraphQL", undefined, `      ` + q);
+  });
+  log.debug("GraphQL", undefined, "\n--- SDL Preview ---");
+  log.debug("GraphQL", undefined, match.sdlPreview);
+  log.debug("GraphQL", undefined, "--- End ---");
+}
+
+function inspectPluginEntries(mutationEntries, queryEntries) {
+  let mutationNames = mutationEntries.flatMap(entry => entry.fieldNames).join(", ");
+  let queryNames = queryEntries.map(entry => entry.singleFieldName + `(id) -> ` + entry.returnTypeName + `, ` + entry.listFieldName + ` -> [` + entry.returnTypeName + `]`).join(", ");
+  let mutCount = mutationEntries.flatMap(e => e.fieldNames).length.toString();
+  let queryCount = queryEntries.length.toString();
+  return `Mutations (` + mutCount + `): ` + mutationNames + `\nQueries (` + queryCount + `): ` + queryNames;
+}
+
+export {
+  inspectScalar,
+  inspectObjectType,
+  inspectMutationFields,
+  inspectQueryFields,
+  inspectFragment,
+  printFragment,
+  inspectPluginEntries,
+}
+/* DcbTag-Reventless Not a pure module */

package/src/components/Api/GraphQL_Stitcher.res

@@ -0,0 +1,271 @@
+// GraphQL schema stitcher.
+// Merges a base fragment with plugin fragments into a single SDL string.
+// Detects and logs type/field name collisions.
+
+let log = Logger.fromEnv()
+
+type fragmentParts = {
+  types: array<string>,
+  mutations: array<string>,
+  queries: array<string>,
+  subscriptions: array<string>,
+}
+
+let encode = (parts: fragmentParts): Reventless.Plugin.apiSchemaFragment => {
+  let encoded =
+    JSON.Encode.object(
+      Dict.fromArray([
+        ("types", JSON.Encode.array(parts.types->Array.map(JSON.Encode.string))),
+        ("mutations", JSON.Encode.array(parts.mutations->Array.map(JSON.Encode.string))),
+        ("queries", JSON.Encode.array(parts.queries->Array.map(JSON.Encode.string))),
+        ("subscriptions", JSON.Encode.array(parts.subscriptions->Array.map(JSON.Encode.string))),
+      ]),
+    )->JSON.stringify
+  {Reventless.Plugin.encoded, protocol: "graphql"}
+}
+
+let decode = (fragment: Reventless.Plugin.apiSchemaFragment): fragmentParts => {
+  switch fragment.encoded->JSON.parseOrThrow->JSON.Decode.object {
+  | None => {types: [], mutations: [], queries: [], subscriptions: []}
+  | Some(dict) =>
+    let getString = (key): array<string> =>
+      switch dict->Dict.get(key) {
+      | Some(JSON.Array(arr)) =>
+        arr->Array.filterMap(j =>
+          switch j {
+          | JSON.String(s) => Some(s)
+          | _ => None
+          }
+        )
+      | _ => []
+      }
+    {
+      types: getString("types"),
+      mutations: getString("mutations"),
+      queries: getString("queries"),
+      subscriptions: getString("subscriptions"),
+    }
+  }
+}
+
+// Extract the first identifier from a SDL field/type string.
+// e.g. "  fieldName(args): Type" → "fieldName"
+//      "type TypeName {" → "TypeName"
+let extractLeadingName = (str: string): string => {
+  let trimmed = str->String.trim
+  // Remove "type ", "enum ", or "input " prefix if present
+  let afterType = if trimmed->String.startsWith("type ") {
+    trimmed->String.slice(~start=5, ~end=trimmed->String.length)->String.trim
+  } else if trimmed->String.startsWith("enum ") {
+    trimmed->String.slice(~start=5, ~end=trimmed->String.length)->String.trim
+  } else if trimmed->String.startsWith("input ") {
+    trimmed->String.slice(~start=6, ~end=trimmed->String.length)->String.trim
+  } else {
+    trimmed
+  }
+  // Split on "(" first to remove arg list, then on " " and "{" for the name
+  afterType
+  ->String.split("(")
+  ->Array.get(0)
+  ->Option.getOr("")
+  ->String.trim
+  ->String.split(" ")
+  ->Array.get(0)
+  ->Option.getOr("")
+  ->String.trim
+  ->String.split("{")
+  ->Array.get(0)
+  ->Option.getOr("")
+  ->String.trim
+}
+
+// Relay base types injected into every stitched schema.
+let relayBaseTypes = [
+  `interface Node {\n  id: ID!\n}`,
+  `type PageInfo {\n  hasNextPage: Boolean!\n  hasPreviousPage: Boolean!\n  startCursor: String\n  endCursor: String\n}`,
+  `enum SortOrder {\n  ASC\n  DESC\n}`,
+]
+
+let relayBaseQueries = [
+  `  node(id: ID!): Node`,
+]
+
+/**
+Stitch a base fragment with plugin fragments into a complete GraphQL SDL string.
+
+- Base fragment is always first (defines core types + Plugin mutations/queries).
+- Plugin fragments add their own types, mutations, and queries.
+- Collision detection: duplicate type definitions and field names are logged and skipped.
+- Relay base types (Node interface, PageInfo) and node query are always injected.
+
+Returns the full SDL string ready for use with AppSync or graphql-yoga.
+*/
+let stitch = (
+  ~baseFragment: Reventless.Plugin.apiSchemaFragment,
+  ~pluginFragments: array<Reventless.Plugin.apiSchemaFragment>,
+): string => {
+  let allFragments = Array.concat([baseFragment], pluginFragments)
+  let parts = allFragments->Array.map(decode)
+
+  // Collect all type definitions — detect collisions by type name
+  // Start with Relay base types (Node interface, PageInfo)
+  let seenTypeNames: Set.t<string> = Set.make()
+  let allTypes: array<string> = []
+  relayBaseTypes->Array.forEach(typeDef => {
+    let name = extractLeadingName(typeDef)
+    seenTypeNames->Set.add(name)
+    allTypes->Array.push(typeDef)
+  })
+
+  parts->Array.forEach(({types}) =>
+    types->Array.forEach(typeDef => {
+      let name = extractLeadingName(typeDef)
+      if name->String.length == 0 {
+        allTypes->Array.push(typeDef)
+      } else if seenTypeNames->Set.has(name) {
+        log.warn(~comp="GraphQL_Stitcher", `Duplicate type — skipped: ${name}`)
+      } else {
+        seenTypeNames->Set.add(name)
+        allTypes->Array.push(typeDef)
+      }
+    })
+  )
+
+  // Collect all mutation fields — detect collisions by field name
+  let seenMutationFields: Set.t<string> = Set.make()
+  let allMutations: array<string> = []
+
+  parts->Array.forEach(({mutations}) =>
+    mutations->Array.forEach(field => {
+      let fieldName = extractLeadingName(field)
+      if seenMutationFields->Set.has(fieldName) {
+        log.warn(~comp="GraphQL_Stitcher", `Duplicate mutation field — skipped: ${fieldName}`)
+      } else {
+        seenMutationFields->Set.add(fieldName)
+        allMutations->Array.push(field)
+      }
+    })
+  )
+
+  // Collect all query fields — detect collisions by field name
+  // Start with Relay node query
+  let seenQueryFields: Set.t<string> = Set.make()
+  let allQueries: array<string> = []
+  relayBaseQueries->Array.forEach(field => {
+    let fieldName = extractLeadingName(field)
+    seenQueryFields->Set.add(fieldName)
+    allQueries->Array.push(field)
+  })
+
+  parts->Array.forEach(({queries}) =>
+    queries->Array.forEach(field => {
+      let fieldName = extractLeadingName(field)
+      if seenQueryFields->Set.has(fieldName) {
+        log.warn(~comp="GraphQL_Stitcher", `Duplicate query field — skipped: ${fieldName}`)
+      } else {
+        seenQueryFields->Set.add(fieldName)
+        allQueries->Array.push(field)
+      }
+    })
+  )
+
+  // Collect all subscription fields — detect collisions by field name
+  let seenSubscriptionFields: Set.t<string> = Set.make()
+  let allSubscriptions: array<string> = []
+
+  parts->Array.forEach(({subscriptions}) =>
+    subscriptions->Array.forEach(field => {
+      let fieldName = extractLeadingName(field)
+      if seenSubscriptionFields->Set.has(fieldName) {
+        log.warn(~comp="GraphQL_Stitcher", `Duplicate subscription field — skipped: ${fieldName}`)
+      } else {
+        seenSubscriptionFields->Set.add(fieldName)
+        allSubscriptions->Array.push(field)
+      }
+    })
+  )
+
+  // Build the final SDL
+  let typesSdl = allTypes->Array.join("\n\n")
+
+  let mutationsSdl =
+    allMutations->Array.length > 0
+      ? `type Mutation {\n${allMutations->Array.join("\n")}\n}`
+      : "type Mutation {\n  _noop: String\n}"
+
+  let queriesSdl =
+    allQueries->Array.length > 0
+      ? `type Query {\n${allQueries->Array.join("\n")}\n}`
+      : "type Query {\n  _noop: String\n}"
+
+  let subscriptionsSdl =
+    allSubscriptions->Array.length > 0
+      ? Some(`type Subscription {\n${allSubscriptions->Array.join("\n")}\n}`)
+      : None
+
+  let sdlParts =
+    [Some(typesSdl), Some(queriesSdl), Some(mutationsSdl), subscriptionsSdl]->Array.filterMap(
+      x => x,
+    )
+  sdlParts->Array.join("\n\n")
+}
+
+let isIdentStart = (line: string): bool =>
+  switch line->String.codePointAt(0) {
+  // A-Z (65-90), a-z (97-122), or `_` (95)
+  | Some(c) => (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c == 95
+  | None => false
+  }
+
+/**
+Count the field definitions inside a root object type (`Mutation` / `Query`) of a
+full SDL string.
+
+Used by the runtime schema-update circuit breaker (AdminEventCollectorEntryPoint)
+to detect a catastrophic shrink before pushing a new schema to AppSync. Heuristic
+but adequate for a shrink guard: root operation fields are flat single-line
+declarations (`name(args): T` or `name: T`), so we slice the `type <typeName> {
+… }` block at its first `{`/`}` and count indented lines that begin with an
+identifier character, ignoring directive-only lines (`@…`), comments (`#…`) and
+braces.
+*/
+let countRootTypeFields = (~sdl: string, ~typeName: string): int => {
+  let marker = `type ${typeName}`
+  switch sdl->String.indexOfOpt(marker) {
+  | None => 0
+  | Some(typeStart) =>
+    let rest = sdl->String.slice(~start=typeStart)
+    switch (rest->String.indexOfOpt("{"), rest->String.indexOfOpt("}")) {
+    | (Some(openIdx), Some(closeIdx)) if closeIdx > openIdx =>
+      rest
+      ->String.slice(~start=openIdx + 1, ~end=closeIdx)
+      ->String.split("\n")
+      ->Array.filter(line => {
+        let trimmed = line->String.trim
+        trimmed->String.length > 0 && isIdentStart(trimmed)
+      })
+      ->Array.length
+    | _ => 0
+    }
+  }
+}
+
+/**
+Decide whether replacing the live schema (`currentSdl`) with `newSdl` would drop
+so many root-type (`Mutation` + `Query`) fields that it is almost certainly a
+transient/incomplete stitch rather than an intentional removal.
+
+Returns `true` when the new root-field total is below `threshold` × the current
+total. When the current schema has no countable root fields (e.g. first deploy,
+or introspection was unavailable so `currentSdl` is empty) it returns `false` so
+the initial push always proceeds.
+*/
+let isCatastrophicSchemaShrink = (~currentSdl: string, ~newSdl: string, ~threshold: float): bool => {
+  let current =
+    countRootTypeFields(~sdl=currentSdl, ~typeName="Mutation") +
+    countRootTypeFields(~sdl=currentSdl, ~typeName="Query")
+  let next =
+    countRootTypeFields(~sdl=newSdl, ~typeName="Mutation") +
+    countRootTypeFields(~sdl=newSdl, ~typeName="Query")
+  current > 0 && next->Int.toFloat < current->Int.toFloat *. threshold
+}

package/src/components/Api/GraphQL_Stitcher.res.mjs

@@ -0,0 +1,229 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
+import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function encode(parts) {
+  let encoded = JSON.stringify(Object.fromEntries([
+    [
+      "types",
+      parts.types.map(prim => prim)
+    ],
+    [
+      "mutations",
+      parts.mutations.map(prim => prim)
+    ],
+    [
+      "queries",
+      parts.queries.map(prim => prim)
+    ],
+    [
+      "subscriptions",
+      parts.subscriptions.map(prim => prim)
+    ]
+  ]));
+  return {
+    encoded: encoded,
+    protocol: "graphql"
+  };
+}
+
+function decode(fragment) {
+  let dict = Stdlib_JSON.Decode.object(JSON.parse(fragment.encoded));
+  if (dict === undefined) {
+    return {
+      types: [],
+      mutations: [],
+      queries: [],
+      subscriptions: []
+    };
+  }
+  let getString = key => {
+    let match = dict[key];
+    if (match !== undefined) {
+      if (Array.isArray(match)) {
+        return Stdlib_Array.filterMap(match, j => {
+          if (typeof j === "string") {
+            return j;
+          }
+        });
+      } else {
+        return [];
+      }
+    } else {
+      return [];
+    }
+  };
+  return {
+    types: getString("types"),
+    mutations: getString("mutations"),
+    queries: getString("queries"),
+    subscriptions: getString("subscriptions")
+  };
+}
+
+function extractLeadingName(str) {
+  let trimmed = str.trim();
+  let afterType = trimmed.startsWith("type ") || trimmed.startsWith("enum ") ? trimmed.slice(5, trimmed.length).trim() : (
+      trimmed.startsWith("input ") ? trimmed.slice(6, trimmed.length).trim() : trimmed
+    );
+  return Stdlib_Option.getOr(Stdlib_Option.getOr(Stdlib_Option.getOr(afterType.split("(")[0], "").trim().split(" ")[0], "").trim().split("{")[0], "").trim();
+}
+
+let relayBaseTypes = [
+  `interface Node {\n  id: ID!\n}`,
+  `type PageInfo {\n  hasNextPage: Boolean!\n  hasPreviousPage: Boolean!\n  startCursor: String\n  endCursor: String\n}`,
+  `enum SortOrder {\n  ASC\n  DESC\n}`
+];
+
+let relayBaseQueries = [`  node(id: ID!): Node`];
+
+function stitch(baseFragment, pluginFragments) {
+  let allFragments = [baseFragment].concat(pluginFragments);
+  let parts = allFragments.map(decode);
+  let seenTypeNames = new Set();
+  let allTypes = [];
+  relayBaseTypes.forEach(typeDef => {
+    let name = extractLeadingName(typeDef);
+    seenTypeNames.add(name);
+    allTypes.push(typeDef);
+  });
+  parts.forEach(param => {
+    param.types.forEach(typeDef => {
+      let name = extractLeadingName(typeDef);
+      if (name.length === 0) {
+        allTypes.push(typeDef);
+        return;
+      } else if (seenTypeNames.has(name)) {
+        return log.warn("GraphQL_Stitcher", undefined, `Duplicate type — skipped: ` + name);
+      } else {
+        seenTypeNames.add(name);
+        allTypes.push(typeDef);
+        return;
+      }
+    });
+  });
+  let seenMutationFields = new Set();
+  let allMutations = [];
+  parts.forEach(param => {
+    param.mutations.forEach(field => {
+      let fieldName = extractLeadingName(field);
+      if (seenMutationFields.has(fieldName)) {
+        return log.warn("GraphQL_Stitcher", undefined, `Duplicate mutation field — skipped: ` + fieldName);
+      } else {
+        seenMutationFields.add(fieldName);
+        allMutations.push(field);
+        return;
+      }
+    });
+  });
+  let seenQueryFields = new Set();
+  let allQueries = [];
+  relayBaseQueries.forEach(field => {
+    let fieldName = extractLeadingName(field);
+    seenQueryFields.add(fieldName);
+    allQueries.push(field);
+  });
+  parts.forEach(param => {
+    param.queries.forEach(field => {
+      let fieldName = extractLeadingName(field);
+      if (seenQueryFields.has(fieldName)) {
+        return log.warn("GraphQL_Stitcher", undefined, `Duplicate query field — skipped: ` + fieldName);
+      } else {
+        seenQueryFields.add(fieldName);
+        allQueries.push(field);
+        return;
+      }
+    });
+  });
+  let seenSubscriptionFields = new Set();
+  let allSubscriptions = [];
+  parts.forEach(param => {
+    param.subscriptions.forEach(field => {
+      let fieldName = extractLeadingName(field);
+      if (seenSubscriptionFields.has(fieldName)) {
+        return log.warn("GraphQL_Stitcher", undefined, `Duplicate subscription field — skipped: ` + fieldName);
+      } else {
+        seenSubscriptionFields.add(fieldName);
+        allSubscriptions.push(field);
+        return;
+      }
+    });
+  });
+  let typesSdl = allTypes.join("\n\n");
+  let mutationsSdl = allMutations.length !== 0 ? `type Mutation {\n` + allMutations.join("\n") + `\n}` : "type Mutation {\n  _noop: String\n}";
+  let queriesSdl = allQueries.length !== 0 ? `type Query {\n` + allQueries.join("\n") + `\n}` : "type Query {\n  _noop: String\n}";
+  let subscriptionsSdl = allSubscriptions.length !== 0 ? `type Subscription {\n` + allSubscriptions.join("\n") + `\n}` : undefined;
+  let sdlParts = Stdlib_Array.filterMap([
+    typesSdl,
+    queriesSdl,
+    mutationsSdl,
+    subscriptionsSdl
+  ], x => x);
+  return sdlParts.join("\n\n");
+}
+
+function isIdentStart(line) {
+  let c = line.codePointAt(0);
+  if (c !== undefined) {
+    if (c >= 65 && c <= 90 || c >= 97 && c <= 122) {
+      return true;
+    } else {
+      return c === 95;
+    }
+  } else {
+    return false;
+  }
+}
+
+function countRootTypeFields(sdl, typeName) {
+  let marker = `type ` + typeName;
+  let typeStart = Stdlib_String.indexOfOpt(sdl, marker);
+  if (typeStart === undefined) {
+    return 0;
+  }
+  let rest = sdl.slice(typeStart);
+  let match = Stdlib_String.indexOfOpt(rest, "{");
+  let match$1 = Stdlib_String.indexOfOpt(rest, "}");
+  if (match !== undefined && match$1 !== undefined && match$1 > match) {
+    return rest.slice(match + 1 | 0, match$1).split("\n").filter(line => {
+      let trimmed = line.trim();
+      if (trimmed.length > 0) {
+        return isIdentStart(trimmed);
+      } else {
+        return false;
+      }
+    }).length;
+  } else {
+    return 0;
+  }
+}
+
+function isCatastrophicSchemaShrink(currentSdl, newSdl, threshold) {
+  let current = countRootTypeFields(currentSdl, "Mutation") + countRootTypeFields(currentSdl, "Query") | 0;
+  let next = countRootTypeFields(newSdl, "Mutation") + countRootTypeFields(newSdl, "Query") | 0;
+  if (current > 0) {
+    return next < current * threshold;
+  } else {
+    return false;
+  }
+}
+
+export {
+  log,
+  encode,
+  decode,
+  extractLeadingName,
+  relayBaseTypes,
+  relayBaseQueries,
+  stitch,
+  isIdentStart,
+  countRootTypeFields,
+  isCatastrophicSchemaShrink,
+}
+/* log Not a pure module */