@reventlessdev/reventless-core 3.0.0-alpha.134

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

@@ -0,0 +1,503 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 SchemaType$ReventlessCore from "./SchemaType.res.mjs";
+import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
+
+let commandResultSdlTypes = [
+  `union CommandResult = CommandAccepted | CommandRejected | CommandPending`,
+  `type CommandAccepted {
+  msgId: ID!
+  entityId: ID
+  eventCount: Int!
+}`,
+  `type CommandRejected {
+  msgId: ID!
+  errorCode: String!
+  errorDetail: String
+}`,
+  `type CommandPending {
+  msgId: ID!
+}`
+];
+
+function fromSchemaType(_required, _asInputOpt, _st, collectedTypes, seenTypes) {
+  while (true) {
+    let asInputOpt = _asInputOpt;
+    let st = _st;
+    let required = _required;
+    let asInput = asInputOpt !== undefined ? asInputOpt : false;
+    let bang = required ? "!" : "";
+    if (typeof st !== "object") {
+      switch (st) {
+        case "ScalarNumber" :
+          return `Float` + bang;
+        case "ScalarBoolean" :
+          return `Boolean` + bang;
+        case "EntityId" :
+          return `ID` + bang;
+        case "ScalarString" :
+        case "ScalarBigInt" :
+        case "Unknown" :
+          return `String` + bang;
+      }
+    } else {
+      switch (st.TAG) {
+        case "Nullable" :
+          _st = st._0;
+          _asInputOpt = asInput;
+          _required = false;
+          continue;
+        case "ArrayOf" :
+          let itemType = fromSchemaType(true, asInput, st._0, collectedTypes, seenTypes);
+          return `[` + itemType + `]` + bang;
+        case "ObjectRef" :
+          let name = st._0;
+          if (!seenTypes.has(name)) {
+            seenTypes.add(name);
+            let typeDef = objectRefToGraphQL(asInput, name, st._1, collectedTypes, seenTypes);
+            collectedTypes.push(typeDef);
+          }
+          return name + bang;
+        case "Enum" :
+          let name$1 = st._0;
+          if (!seenTypes.has(name$1)) {
+            seenTypes.add(name$1);
+            let valuesStr = st._1.join("\n  ");
+            collectedTypes.push(`enum ` + name$1 + ` {\n  ` + valuesStr + `\n}`);
+          }
+          return name$1 + bang;
+      }
+    }
+  };
+}
+
+function objectRefToGraphQL(asInputOpt, typeName, fields, collectedTypes, seenTypes) {
+  let asInput = asInputOpt !== undefined ? asInputOpt : false;
+  let fieldStrs = Object.entries(fields).map(param => {
+    let gqlType = fromSchemaType(true, asInput, param[1], collectedTypes, seenTypes);
+    return `  ` + param[0] + `: ` + gqlType;
+  }).join("\n");
+  let keyword = asInput ? "input" : "type";
+  return keyword + ` ` + typeName + ` {\n` + fieldStrs + `\n}`;
+}
+
+function deriveFieldType(parentTypeName, fieldName, required, fieldSchema, collectedTypes, seenTypes) {
+  let st = SchemaType$ReventlessCore.fromSury(parentTypeName, fieldName, fieldSchema);
+  return fromSchemaType(required, undefined, st, collectedTypes, seenTypes);
+}
+
+function deriveObjectTypeWithNested(typeName, excludeFieldsOpt, includeIdParamOpt, schema) {
+  let excludeFields = excludeFieldsOpt !== undefined ? excludeFieldsOpt : [];
+  let includeIdParam = includeIdParamOpt !== undefined ? includeIdParamOpt : true;
+  let fields = SchemaType$ReventlessCore.fromSuryObject(typeName, schema);
+  if (fields === undefined) {
+    return [];
+  }
+  let filteredFields;
+  if (excludeFields.length !== 0) {
+    let d = {};
+    Object.entries(fields).forEach(param => {
+      let k = param[0];
+      if (!excludeFields.some(ex => ex === k)) {
+        d[k] = param[1];
+        return;
+      }
+    });
+    filteredFields = d;
+  } else {
+    filteredFields = fields;
+  }
+  let collectedTypes = [];
+  let seenTypes = new Set();
+  seenTypes.add(typeName);
+  let mainType = objectRefToGraphQL(undefined, typeName, filteredFields, collectedTypes, seenTypes);
+  let mainTypeWithId = includeIdParam ? mainType.replace(`type ` + typeName + ` {\n`, `type ` + typeName + ` implements Node {\n  id: ID!\n`) : mainType;
+  return collectedTypes.concat([mainTypeWithId]);
+}
+
+function derivePluralWrapperType(pluralTypeName, singularTypeName) {
+  return `type ` + pluralTypeName + ` {\n  nextToken: String\n  scannedCount: Int!\n  items: [` + singularTypeName + `!]!\n}`;
+}
+
+function deriveConnectionTypes(singularTypeName) {
+  return [
+    `type ` + singularTypeName + `Edge {\n  node: ` + singularTypeName + `!\n  cursor: String!\n}`,
+    `type ` + singularTypeName + `Connection {\n  edges: [` + singularTypeName + `Edge!]!\n  pageInfo: PageInfo!\n}`
+  ];
+}
+
+function deriveSubIdFilterType(filterTypeName) {
+  return `input ` + filterTypeName + ` {\n  prefix: String\n  from: String\n  to: String\n  eq: String\n  order: SortOrder\n}`;
+}
+
+let emptyCapability_filterFields = [];
+
+let emptyCapability_sortFields = [];
+
+let emptyCapability = {
+  filterFields: emptyCapability_filterFields,
+  sortFields: emptyCapability_sortFields
+};
+
+function scalarOfSchemaType(st) {
+  if (typeof st === "object") {
+    return "String";
+  }
+  switch (st) {
+    case "ScalarNumber" :
+      return "Float";
+    case "ScalarBoolean" :
+      return "Boolean";
+    case "EntityId" :
+      return "ID";
+    default:
+      return "String";
+  }
+}
+
+function deriveServerCapability(schema) {
+  let spec = StateAnnotations$Reventless.getSpec(schema);
+  if (spec === undefined) {
+    return emptyCapability;
+  }
+  let fieldTypes = Stdlib_Option.getOr(SchemaType$ReventlessCore.fromSuryObject("", schema), {});
+  let scalarOf = fieldName => Stdlib_Option.mapOr(fieldTypes[fieldName], "String", scalarOfSchemaType);
+  let filterFields = [];
+  let sortFields = [];
+  let seenFilter = new Set();
+  let seenSort = new Set();
+  let pushFilter = (name, range) => {
+    if (!seenFilter.has(name)) {
+      seenFilter.add(name);
+      filterFields.push({
+        name: name,
+        gqlType: scalarOf(name),
+        range: range
+      });
+      return;
+    }
+  };
+  let pushSort = name => {
+    if (!seenSort.has(name)) {
+      seenSort.add(name);
+      sortFields.push(name);
+      return;
+    }
+  };
+  spec.ids.forEach(name => {
+    pushFilter(name, false);
+    pushSort(name);
+  });
+  spec.compositeIds.forEach(name => pushFilter(name, false));
+  spec.subIds.forEach(name => {
+    pushFilter(name, true);
+    pushSort(name);
+  });
+  spec.compositeSubIds.forEach(name => {
+    pushFilter(name, true);
+    pushSort(name);
+  });
+  spec.indexes.forEach(param => {
+    let name = param[0];
+    pushFilter(name, false);
+    pushSort(name);
+  });
+  spec.scan.forEach(name => pushFilter(name, false));
+  spec.scanSort.forEach(pushSort);
+  return {
+    filterFields: filterFields,
+    sortFields: sortFields
+  };
+}
+
+function validateScanSortAlignment(schema, readModelName, knownSortFields) {
+  let spec = StateAnnotations$Reventless.getSpec(schema);
+  if (spec !== undefined) {
+    return Stdlib_Array.filterMap(spec.scanSort, field => {
+      if (knownSortFields.includes(field)) {
+        return;
+      } else {
+        return `Read model "` + readModelName + `": @scanSort field "` + field + `" is not the sort key of any table or GSI. Sort requests for this field will be evaluated as a JS-runtime per-page sort over a full Scan — expensive in production. Add it as the sort key of an index, or accept the per-page-sort caveat.`;
+      }
+    });
+  } else {
+    return [];
+  }
+}
+
+function deriveConnectionFilterType(filterTypeName, capabilityOpt) {
+  let capability = capabilityOpt !== undefined ? capabilityOpt : emptyCapability;
+  let baseFields = [
+    "search: String",
+    "searchPrefix: String",
+    "ids: [ID!]"
+  ];
+  let perFieldFilters = capability.filterFields.flatMap(f => {
+    let eq = f.name + `Eq: ` + f.gqlType;
+    if (f.range) {
+      return [
+        eq,
+        f.name + `From: ` + f.gqlType,
+        f.name + `To: ` + f.gqlType
+      ];
+    } else {
+      return [eq];
+    }
+  });
+  let allFields = baseFields.concat(perFieldFilters);
+  let body = allFields.map(f => `  ` + f).join("\n");
+  return `input ` + filterTypeName + ` {\n` + body + `\n}`;
+}
+
+function deriveConnectionOrderByType(singularTypeName, capability) {
+  if (capability.sortFields.length === 0) {
+    return [];
+  }
+  let orderFieldEnumName = singularTypeName + "OrderField";
+  let orderByInputName = singularTypeName + "OrderBy";
+  let valuesStr = capability.sortFields.map(f => `  ` + f).join("\n");
+  return [
+    `enum ` + orderFieldEnumName + ` {\n` + valuesStr + `\n}`,
+    `input ` + orderByInputName + ` {\n  field: ` + orderFieldEnumName + `!\n  direction: SortOrder!\n}`
+  ];
+}
+
+function deriveItemsQueryField(singleFieldName, returnTypeName, filterTypeName) {
+  return `  ` + singleFieldName + `Items(id: ID!, filter: ` + filterTypeName + `, first: Int, after: String, last: Int, before: String): ` + returnTypeName + `Connection!`;
+}
+
+function deriveObjectQueryField(singleFieldName, typeName, includeIdParamOpt, subIdField) {
+  let includeIdParam = includeIdParamOpt !== undefined ? includeIdParamOpt : true;
+  if (includeIdParam) {
+    if (subIdField !== undefined) {
+      return `  ` + singleFieldName + `(id: ID!, ` + subIdField + `: String!): ` + typeName;
+    } else {
+      return `  ` + singleFieldName + `(id: ID!): ` + typeName;
+    }
+  } else {
+    return `  ` + singleFieldName + `: ` + typeName;
+  }
+}
+
+function deriveListQueryField(listFieldName, pluralTypeName) {
+  return `  ` + listFieldName + `(nextToken: String, limit: Int): ` + pluralTypeName + `!`;
+}
+
+function deriveByIdsQueryField(listFieldName, returnTypeName) {
+  return `  ` + listFieldName + `ByIds(ids: [String!]!): [` + returnTypeName + `!]!`;
+}
+
+function deriveConnectionQueryField(listFieldName, singularTypeName, filterTypeName, hasOrderByOpt) {
+  let hasOrderBy = hasOrderByOpt !== undefined ? hasOrderByOpt : false;
+  let orderByArg = hasOrderBy ? `, orderBy: ` + singularTypeName + `OrderBy` : "";
+  return `  ` + listFieldName + `(filter: ` + filterTypeName + orderByArg + `, first: Int, after: String, last: Int, before: String): ` + singularTypeName + `Connection!`;
+}
+
+function deriveMutationFieldFromObject(fieldName, collectedTypes, seenTypes, variantSchema) {
+  let fields = SchemaType$ReventlessCore.fromSuryObject(fieldName, variantSchema);
+  if (fields === undefined) {
+    return;
+  }
+  let args = Object.entries(fields).map(param => {
+    let gqlType = fromSchemaType(true, true, param[1], collectedTypes, seenTypes);
+    return param[0] + `: ` + gqlType;
+  }).join(", ");
+  let argsPart = args.length > 0 ? `(` + args + `)` : "";
+  return `  ` + fieldName + argsPart + `: CommandResult!`;
+}
+
+function generate(mutationEntries, queryEntries) {
+  let types = [];
+  let mutations = [];
+  let queries = [];
+  let seenTypes = new Set();
+  let constructorNameOf = fieldName => Stdlib_Option.getOr(fieldName.split("_")[fieldName.split("_").length - 1 | 0], fieldName);
+  mutationEntries.forEach(entry => {
+    let schema = entry.commandSchema;
+    switch (schema.type) {
+      case "object" :
+        let fieldName = Stdlib_Option.getOr(entry.fieldNames[0], "");
+        if (fieldName.length > 0) {
+          return Stdlib_Option.forEach(deriveMutationFieldFromObject(fieldName, types, seenTypes, schema), field => {
+            mutations.push(field);
+          });
+        } else {
+          return;
+        }
+      case "union" :
+        let anyOf = schema.anyOf;
+        let variantNames = anyOf.map(v => {
+          switch (v.type) {
+            case "string" :
+              let $$const = v.const;
+              if ($$const !== undefined) {
+                return $$const;
+              } else {
+                return "";
+              }
+            case "object" :
+              return Stdlib_Option.getOr(Stdlib_Option.flatMap(v.items.find(item => item.location === "TAG"), item => {
+                let match = item.schema;
+                if (match.type !== "string") {
+                  return;
+                }
+                let $$const = match.const;
+                if ($$const !== undefined) {
+                  return $$const;
+                }
+              }), "");
+            default:
+              return "";
+          }
+        });
+        entry.fieldNames.forEach(fieldName => {
+          let cname = constructorNameOf(fieldName);
+          let variantIndex = variantNames.indexOf(cname);
+          let variantSchema = variantIndex >= 0 ? Stdlib_Option.getOr(anyOf[variantIndex], schema) : schema;
+          let field = deriveMutationFieldFromObject(fieldName, types, seenTypes, variantSchema);
+          if (field !== undefined) {
+            let withId = field.includes("(") ? field.replace(fieldName + `(`, fieldName + `(id: ID!, `) : field.replace(fieldName + `:`, fieldName + `(id: ID!):`);
+            mutations.push(withId);
+            return;
+          }
+          mutations.push(`  ` + fieldName + `(id: ID!): CommandResult!`);
+        });
+        return;
+      default:
+        return;
+    }
+  });
+  queryEntries.forEach(entry => {
+    let includeIdParam = Stdlib_Option.getOr(entry.includeIdParam, true);
+    let connectionSpec = Stdlib_Option.getOr(entry.connectionSpec, true);
+    if (!seenTypes.has(entry.returnTypeName)) {
+      seenTypes.add(entry.returnTypeName);
+      let fields = entry.excludeFields;
+      let excludeFields = fields !== undefined ? fields : [];
+      let nestedTypes = deriveObjectTypeWithNested(entry.returnTypeName, excludeFields, includeIdParam, entry.stateSchema);
+      nestedTypes.forEach(t => {
+        types.push(t);
+      });
+    }
+    let singleField = deriveObjectQueryField(entry.singleFieldName, entry.returnTypeName, includeIdParam, entry.subIdField);
+    queries.push(singleField);
+    if (includeIdParam && entry.subIdField === undefined) {
+      queries.push(deriveByIdsQueryField(entry.listFieldName, entry.returnTypeName));
+    }
+    let listFieldName = entry.listFieldName;
+    let _sf = entry.subIdField;
+    if (_sf !== undefined) {
+      let itemsFilterTypeName = entry.returnTypeName + "ItemsFilter";
+      if (!seenTypes.has(itemsFilterTypeName)) {
+        seenTypes.add(itemsFilterTypeName);
+        types.push(deriveSubIdFilterType(itemsFilterTypeName));
+      }
+      queries.push(deriveItemsQueryField(entry.singleFieldName, entry.returnTypeName, itemsFilterTypeName));
+    }
+    let indexes = entry.indexQueries;
+    if (indexes !== undefined) {
+      let connectionTypeName = entry.returnTypeName + "Connection";
+      indexes.forEach(param => {
+        let index = param.index;
+        let stripped = index.startsWith("by") && index.length > 2 ? index.slice(2, index.length) : index;
+        let fieldName = entry.singleFieldName + "By" + Stdlib_String.capitalize(stripped);
+        queries.push(`  ` + fieldName + `(id: ID!, first: Int, after: String, last: Int, before: String): ` + connectionTypeName + `!`);
+      });
+    }
+    if (connectionSpec) {
+      let connectionTypeName$1 = entry.returnTypeName + "Connection";
+      if (!seenTypes.has(connectionTypeName$1)) {
+        let edgeName = entry.returnTypeName + "Edge";
+        seenTypes.add(edgeName);
+        seenTypes.add(connectionTypeName$1);
+        deriveConnectionTypes(entry.returnTypeName).forEach(t => {
+          types.push(t);
+        });
+      }
+      let capability = deriveServerCapability(entry.stateSchema);
+      let connectionFilterTypeName = entry.returnTypeName + "Filter";
+      if (!seenTypes.has(connectionFilterTypeName)) {
+        seenTypes.add(connectionFilterTypeName);
+        types.push(deriveConnectionFilterType(connectionFilterTypeName, capability));
+      }
+      let orderByTypes = deriveConnectionOrderByType(entry.returnTypeName, capability);
+      let hasOrderBy = orderByTypes.length !== 0;
+      if (hasOrderBy) {
+        let orderFieldEnumName = entry.returnTypeName + "OrderField";
+        let orderByInputName = entry.returnTypeName + "OrderBy";
+        if (!seenTypes.has(orderFieldEnumName)) {
+          seenTypes.add(orderFieldEnumName);
+          seenTypes.add(orderByInputName);
+          orderByTypes.forEach(t => {
+            types.push(t);
+          });
+        }
+      }
+      let listField = deriveConnectionQueryField(listFieldName, entry.returnTypeName, connectionFilterTypeName, hasOrderBy);
+      queries.push(listField);
+      return;
+    }
+    if (!seenTypes.has(listFieldName)) {
+      seenTypes.add(listFieldName);
+      let pluralType = derivePluralWrapperType(listFieldName, entry.returnTypeName);
+      types.push(pluralType);
+    }
+    let listField$1 = deriveListQueryField(listFieldName, listFieldName);
+    queries.push(listField$1);
+  });
+  if (mutations.length !== 0) {
+    commandResultSdlTypes.forEach(t => {
+      types.push(t);
+    });
+  }
+  let encoded = JSON.stringify(Object.fromEntries([
+    [
+      "types",
+      types.map(prim => prim)
+    ],
+    [
+      "mutations",
+      mutations.map(prim => prim)
+    ],
+    [
+      "queries",
+      queries.map(prim => prim)
+    ],
+    [
+      "subscriptions",
+      []
+    ]
+  ]));
+  return {
+    encoded: encoded,
+    protocol: "graphql"
+  };
+}
+
+export {
+  commandResultSdlTypes,
+  fromSchemaType,
+  objectRefToGraphQL,
+  deriveFieldType,
+  deriveObjectTypeWithNested,
+  derivePluralWrapperType,
+  deriveConnectionTypes,
+  deriveSubIdFilterType,
+  emptyCapability,
+  scalarOfSchemaType,
+  deriveServerCapability,
+  validateScanSortAlignment,
+  deriveConnectionFilterType,
+  deriveConnectionOrderByType,
+  deriveItemsQueryField,
+  deriveObjectQueryField,
+  deriveListQueryField,
+  deriveByIdsQueryField,
+  deriveConnectionQueryField,
+  deriveMutationFieldFromObject,
+  generate,
+}
+/* SchemaType-ReventlessCore Not a pure module */

package/src/components/Api/GraphQL_SchemaInspector.res

@@ -0,0 +1,156 @@
+// GraphQL schema inspector — debugging utilities for inspecting generated schemas.
+// All public functions accept polymorphic S.t<'a> and use S.castToUnknown internally.
+
+open ReventlessInfra.Api
+
+// ── Granular Level ──────────────────────────────────────────────────────────
+
+let inspectScalar = (schema: S.t<'a>): string => {
+  let collectedTypes: array<string> = []
+  let seenTypes = Set.make()
+  GraphQL_FragmentGenerator.deriveFieldType(
+    ~parentTypeName="",
+    ~fieldName="",
+    ~required=false,
+    schema->S.castToUnknown,
+    collectedTypes,
+    seenTypes,
+  )
+}
+
+let inspectObjectType = (~typeName: string, schema: S.t<'a>): option<string> => {
+  let types = GraphQL_FragmentGenerator.deriveObjectTypeWithNested(~typeName, schema->S.castToUnknown)
+  types->Array.get(types->Array.length - 1)
+}
+
+let inspectMutationFields = (~fieldPrefix: string, commandSchema: S.t<'a>): array<string> => {
+  let schema = commandSchema->S.castToUnknown
+  let fields: array<string> = []
+  let collectedTypes: array<string> = []
+  let seenTypes = Set.make()
+  switch schema {
+  | Union({anyOf}) =>
+    let constructorNames = Reventless.DcbTag.extractAllVariantNames(commandSchema)
+    anyOf->Array.forEachWithIndex((variantSchema, i) => {
+      let fieldName = switch constructorNames->Array.get(i) {
+      | Some(name) => `${fieldPrefix}_${name}`
+      | None => `${fieldPrefix}_Variant${Int.toString(i)}`
+      }
+      GraphQL_FragmentGenerator.deriveMutationFieldFromObject(
+        ~fieldName,
+        ~collectedTypes,
+        ~seenTypes,
+        variantSchema,
+      )->Option.forEach(field => fields->Array.push(field))
+    })
+  | Object(_) =>
+    GraphQL_FragmentGenerator.deriveMutationFieldFromObject(
+      ~fieldName=fieldPrefix,
+      ~collectedTypes,
+      ~seenTypes,
+      schema,
+    )->Option.forEach(field => fields->Array.push(field))
+  | _ => ()
+  }
+  fields
+}
+
+type queryFieldInspection = {
+  typeDef: option<string>,
+  singleQuery: string,
+  listQuery: option<string>,
+}
+
+let inspectQueryFields = (
+  ~name: string,
+  ~typeName: string,
+  stateSchema: S.t<'a>,
+): queryFieldInspection => {
+  let schema = stateSchema->S.castToUnknown
+  let types = GraphQL_FragmentGenerator.deriveObjectTypeWithNested(~typeName, schema)
+  let typeDef = types->Array.get(types->Array.length - 1)
+  let singleQuery = GraphQL_FragmentGenerator.deriveObjectQueryField(
+    ~singleFieldName=name,
+    ~typeName,
+  )
+  let pluralName = name ++ "s"
+  let listQuery = Some(
+    GraphQL_FragmentGenerator.deriveListQueryField(
+      ~listFieldName=pluralName,
+      ~pluralTypeName=pluralName,
+    ),
+  )
+  {typeDef, singleQuery, listQuery}
+}
+
+// ── Plugin Level — Fragment Inspector ───────────────────────────────────────
+
+type fragmentInspection = {
+  types: array<string>,
+  mutations: array<string>,
+  queries: array<string>,
+  sdlPreview: string,
+}
+
+let inspectFragment = (fragment: Reventless.Plugin.apiSchemaFragment): fragmentInspection => {
+  let parts = GraphQL_Stitcher.decode(fragment)
+  let typesSdl = parts.types->Array.join("\n\n")
+  let queriesSdl = switch parts.queries->Array.length > 0 {
+  | true => `type Query {\n${parts.queries->Array.join("\n")}\n}`
+  | false => ""
+  }
+  let mutationsSdl = switch parts.mutations->Array.length > 0 {
+  | true => `type Mutation {\n${parts.mutations->Array.join("\n")}\n}`
+  | false => ""
+  }
+  let sdlParts =
+    [typesSdl, queriesSdl, mutationsSdl]->Array.filter(p => p->String.length > 0)
+  let sdlPreview = sdlParts->Array.join("\n\n")
+  {types: parts.types, mutations: parts.mutations, queries: parts.queries, sdlPreview}
+}
+
+let printFragment = (fragment: Reventless.Plugin.apiSchemaFragment): unit => {
+  let log = Logger.fromEnv()
+  let {types, mutations, queries, sdlPreview} = inspectFragment(fragment)
+  log.debug(~comp="GraphQL", "[GraphQL Fragment]")
+  log.debug(~comp="GraphQL", `  Types (${types->Array.length->Int.toString}):`)
+  types->Array.forEach(t => {
+    let name = GraphQL_Stitcher.extractLeadingName(t)
+    log.debug(~comp="GraphQL", `    - ${name}`)
+    log.debug(~comp="GraphQL", `      ${t}`)
+  })
+  log.debug(~comp="GraphQL", `  Mutations (${mutations->Array.length->Int.toString}):`)
+  mutations->Array.forEach(m => {
+    let name = GraphQL_Stitcher.extractLeadingName(m)
+    log.debug(~comp="GraphQL", `    - ${name}`)
+    log.debug(~comp="GraphQL", `      ${m}`)
+  })
+  log.debug(~comp="GraphQL", `  Queries (${queries->Array.length->Int.toString}):`)
+  queries->Array.forEach(q => {
+    let name = GraphQL_Stitcher.extractLeadingName(q)
+    log.debug(~comp="GraphQL", `    - ${name}`)
+    log.debug(~comp="GraphQL", `      ${q}`)
+  })
+  log.debug(~comp="GraphQL", "\n--- SDL Preview ---")
+  log.debug(~comp="GraphQL", sdlPreview)
+  log.debug(~comp="GraphQL", "--- End ---")
+}
+
+let inspectPluginEntries = (
+  ~mutationEntries: array<mutationSchemaEntry>,
+  ~queryEntries: array<querySchemaEntry>,
+): string => {
+  let mutationNames =
+    mutationEntries
+    ->Array.flatMap(entry => entry.fieldNames)
+    ->Array.join(", ")
+  let queryNames =
+    queryEntries
+    ->Array.map(entry => {
+      `${entry.singleFieldName}(id) -> ${entry.returnTypeName}, ${entry.listFieldName} -> [${entry.returnTypeName}]`
+    })
+    ->Array.join(", ")
+  let mutCount = mutationEntries->Array.flatMap(e => e.fieldNames)->Array.length->Int.toString
+  let queryCount = queryEntries->Array.length->Int.toString
+  `Mutations (${mutCount}): ${mutationNames}\nQueries (${queryCount}): ${queryNames}`
+}