@xyd-js/gql 0.1.0-build.170

package/dist/index.js

@@ -0,0 +1,1503 @@
+// src/schema.ts
+import fs from "fs";
+import {
+  buildSchema,
+  print as print2,
+  visit,
+  parse
+} from "graphql";
+import { mergeTypeDefs } from "@graphql-tools/merge";
+
+// src/types.ts
+var DEFAULT_SORT_ORDER = [
+  { node: "query" },
+  { node: "mutation" },
+  { node: "subscription" },
+  { node: "object" },
+  { node: "interface" },
+  { node: "union" },
+  { node: "input" },
+  { node: "enum" },
+  { node: "scalar" }
+];
+var GQLOperation = class {
+  constructor(field) {
+    this.field = field;
+  }
+  get name() {
+    return this.field.name;
+  }
+  get description() {
+    return this.field.description;
+  }
+  get type() {
+    return this.field.type;
+  }
+  get args() {
+    return this.field.args;
+  }
+  get deprecationReason() {
+    return this.field.deprecationReason;
+  }
+  get extensions() {
+    return this.field.extensions;
+  }
+  get astNode() {
+    return this.field.astNode;
+  }
+  set __operationType(operationType) {
+    this._operationType = operationType;
+  }
+};
+
+// src/converters/gql-types.ts
+import {
+  isIntrospectionType as isIntrospectionType2,
+  isSpecifiedScalarType as isSpecifiedScalarType2
+} from "graphql";
+
+// src/converters/gql-field.ts
+import {
+  GraphQLInputObjectType as GraphQLInputObjectType3,
+  GraphQLUnionType as GraphQLUnionType3,
+  GraphQLObjectType as GraphQLObjectType3,
+  GraphQLInterfaceType as GraphQLInterfaceType3,
+  GraphQLScalarType as GraphQLScalarType3,
+  GraphQLNonNull as GraphQLNonNull2
+} from "graphql";
+
+// src/gql-core.ts
+import {
+  GraphQLEnumType as GraphQLEnumType2,
+  GraphQLInputObjectType as GraphQLInputObjectType2,
+  GraphQLInterfaceType as GraphQLInterfaceType2,
+  GraphQLObjectType as GraphQLObjectType2,
+  GraphQLScalarType as GraphQLScalarType2,
+  GraphQLUnionType as GraphQLUnionType2,
+  isIntrospectionType,
+  isSpecifiedScalarType,
+  GraphQLNonNull,
+  GraphQLList
+} from "graphql";
+import GithubSlugger from "github-slugger";
+import {
+  ReferenceCategory,
+  ReferenceType
+} from "@xyd-js/uniform";
+
+// src/opendocs.ts
+import {
+  GraphQLEnumType,
+  GraphQLInputObjectType,
+  GraphQLInterfaceType,
+  GraphQLObjectType,
+  GraphQLScalarType,
+  GraphQLUnionType
+} from "graphql";
+var OPEN_DOCS_SCHEMA_DIRECTIVE_NAME = "docs";
+var OPEN_DOCS_DIRECTIVE_NAME = "doc";
+function openDocsExtensionsToOptions(schema) {
+  const options = {};
+  for (const extension of schema.extensionASTNodes || []) {
+    if (extension.kind === "SchemaExtension") {
+      for (const directive of extension.directives || []) {
+        if (directive.name.value === OPEN_DOCS_SCHEMA_DIRECTIVE_NAME) {
+          for (const arg of directive.arguments || []) {
+            if (arg.name.value === "flattenTypes" && arg.value.kind === "BooleanValue") {
+              if (arg.value.value === true) {
+                options.flat = true;
+              } else if (arg.value.value === false) {
+                options.flat = false;
+              }
+            } else if (arg.name.value === "sort" && arg.value.kind === "ListValue") {
+              const sortItems = [];
+              for (const item of arg.value.values) {
+                if (item.kind === "ObjectValue") {
+                  const sortItem = {};
+                  for (const field of item.fields) {
+                    if (field.name.value === "node" && field.value.kind === "StringValue") {
+                      sortItem.node = field.value.value;
+                    } else if (field.name.value === "group" && field.value.kind === "ListValue") {
+                      sortItem.group = field.value.values.filter((v) => v.kind === "StringValue").map((v) => v.value);
+                    } else if (field.name.value === "stack" && field.value.kind === "IntValue") {
+                      sortItem.stack = parseInt(field.value.value);
+                    }
+                  }
+                  sortItems.push(sortItem);
+                }
+              }
+              if (!options.sort) {
+                options.sort = {};
+              }
+              options.sort.sort = sortItems;
+            } else if (arg.name.value === "sortStack" && arg.value.kind === "ListValue") {
+              const sortStacks = [];
+              for (const item of arg.value.values) {
+                if (item.kind === "ListValue") {
+                  const stack = item.values.filter((v) => v.kind === "StringValue").map((v) => v.value);
+                  sortStacks.push(stack);
+                }
+              }
+              if (!options.sort) {
+                options.sort = {};
+              }
+              options.sort.sortStack = sortStacks;
+            } else if (arg.name.value === "route" && arg.value.kind === "StringValue") {
+              options.route = arg.value.value;
+            }
+          }
+        }
+      }
+    }
+  }
+  return options;
+}
+function openDocsToGroup(ctx, odGqlNode) {
+  var _a, _b;
+  let groups = [];
+  const metadata = (ctx == null ? void 0 : ctx.schema).__metadata;
+  if (metadata == null ? void 0 : metadata.rootGroups) {
+    groups = [...metadata.rootGroups];
+  }
+  let directiveGroups = false;
+  if ((ctx == null ? void 0 : ctx.schema) && "name" in odGqlNode) {
+    const metadata2 = ctx.schema.__metadata;
+    if (metadata2 == null ? void 0 : metadata2.fields) {
+      if ("_operationType" in odGqlNode) {
+        let fieldKey = "";
+        switch (odGqlNode._operationType) {
+          case "query": {
+            fieldKey = `Query.${odGqlNode.name}`;
+            break;
+          }
+          case "mutation": {
+            fieldKey = `Mutation.${odGqlNode.name}`;
+            break;
+          }
+          case "subscription": {
+            fieldKey = `Subscription.${odGqlNode.name}`;
+            break;
+          }
+        }
+        const fieldMetadata = metadata2.fields.get(fieldKey);
+        if (fieldMetadata == null ? void 0 : fieldMetadata.groups) {
+          directiveGroups = true;
+          groups.push(...fieldMetadata.groups);
+        }
+      }
+    }
+  }
+  if (!directiveGroups && ((_a = odGqlNode.astNode) == null ? void 0 : _a.directives)) {
+    for (const directive of odGqlNode.astNode.directives) {
+      switch (directive.name.value) {
+        case OPEN_DOCS_DIRECTIVE_NAME: {
+          const groupArg = (_b = directive.arguments) == null ? void 0 : _b.find((arg) => arg.name.value === "group");
+          if ((groupArg == null ? void 0 : groupArg.value.kind) === "ListValue") {
+            directiveGroups = true;
+            groups.push(
+              ...groupArg.value.values.filter((v) => v.kind === "StringValue").map((v) => v.value)
+            );
+          }
+          break;
+        }
+      }
+    }
+  }
+  if (!directiveGroups) {
+    if (odGqlNode instanceof GraphQLObjectType) {
+      groups.push("Objects");
+    } else if (odGqlNode instanceof GraphQLInterfaceType) {
+      groups.push("Interfaces");
+    } else if (odGqlNode instanceof GraphQLUnionType) {
+      groups.push("Unions");
+    } else if (odGqlNode instanceof GraphQLEnumType) {
+      groups.push("Enums");
+    } else if (odGqlNode instanceof GraphQLInputObjectType) {
+      groups.push("Inputs");
+    } else if (odGqlNode instanceof GraphQLScalarType) {
+      groups.push("Scalars");
+    } else if (odGqlNode instanceof GQLOperation) {
+      switch (odGqlNode._operationType) {
+        case "query": {
+          groups.push("Queries");
+          break;
+        }
+        case "mutation": {
+          groups.push("Mutations");
+          break;
+        }
+        case "subscription": {
+          groups.push("Subscriptions");
+          break;
+        }
+      }
+    }
+  }
+  return groups;
+}
+function openDocsCanonical(ctx, gqlType) {
+  var _a, _b, _c;
+  let path = "";
+  if ("astNode" in gqlType && ((_a = gqlType.astNode) == null ? void 0 : _a.kind) === "FieldDefinition" && (ctx == null ? void 0 : ctx.schema)) {
+    const metadata = ctx.schema.__metadata;
+    if ((metadata == null ? void 0 : metadata.fields) && "name" in gqlType) {
+      if ("_operationType" in gqlType) {
+        let fieldKey = "";
+        switch (gqlType._operationType) {
+          case "query": {
+            fieldKey = `Query.${gqlType.name}`;
+            break;
+          }
+          case "mutation": {
+            fieldKey = `Mutation.${gqlType.name}`;
+            break;
+          }
+          case "subscription": {
+            fieldKey = `Subscription.${gqlType.name}`;
+            break;
+          }
+        }
+        const fieldMetadata = metadata.fields.get(fieldKey);
+        if (fieldMetadata == null ? void 0 : fieldMetadata.path) {
+          path = fieldMetadata.path;
+        }
+      }
+    }
+  }
+  if (!path && ((_b = gqlType.astNode) == null ? void 0 : _b.directives)) {
+    for (const directive of gqlType.astNode.directives) {
+      if (directive.name.value === OPEN_DOCS_DIRECTIVE_NAME) {
+        const pathArg = (_c = directive.arguments) == null ? void 0 : _c.find((arg) => arg.name.value === "path");
+        if ((pathArg == null ? void 0 : pathArg.value.kind) === "StringValue") {
+          path = pathArg.value.value;
+        }
+      }
+    }
+  }
+  return path;
+}
+
+// src/gql-core.ts
+function extractScopesFromDocDirective(ctx, gqlType) {
+  var _a, _b, _c, _d;
+  const scopes = [];
+  const schema = ctx == null ? void 0 : ctx.schema;
+  if ((_a = gqlType.astNode) == null ? void 0 : _a.directives) {
+    for (const directive of gqlType.astNode.directives) {
+      if (directive.name.value === "doc") {
+        const scopesArg = (_b = directive.arguments) == null ? void 0 : _b.find((arg) => arg.name.value === "scopes");
+        if ((scopesArg == null ? void 0 : scopesArg.value.kind) === "ListValue") {
+          for (const scopeValue of scopesArg.value.values) {
+            if (scopeValue.kind === "EnumValue") {
+              let enumType;
+              if (gqlType instanceof GraphQLEnumType2) {
+                enumType = gqlType;
+              } else if (schema) {
+                const type = schema.getType("OpenDocsScope");
+                if (type instanceof GraphQLEnumType2) {
+                  enumType = type;
+                }
+              }
+              if (enumType) {
+                const enumValue = enumType.getValue(scopeValue.value);
+                if ((_c = enumValue == null ? void 0 : enumValue.astNode) == null ? void 0 : _c.directives) {
+                  for (const enumDirective of enumValue.astNode.directives) {
+                    if (enumDirective.name.value === "scope") {
+                      const valueArg = (_d = enumDirective.arguments) == null ? void 0 : _d.find((arg) => arg.name.value === "value");
+                      if ((valueArg == null ? void 0 : valueArg.value.kind) === "StringValue") {
+                        scopes.push(valueArg.value.value);
+                      }
+                    }
+                  }
+                }
+              }
+            } else if (scopeValue.kind === "StringValue") {
+              scopes.push(scopeValue.value);
+            }
+          }
+        }
+      }
+    }
+  }
+  return scopes;
+}
+function uniformify(ctx, gqlType, definitions, examples) {
+  let canonicalPrefix = "";
+  let graphqlTypeShort = "";
+  let refType = void 0;
+  if (gqlType instanceof GraphQLScalarType2) {
+    canonicalPrefix = "scalars";
+    graphqlTypeShort = "scalar";
+    refType = ReferenceType.GRAPHQL_SCALAR;
+  } else if (gqlType instanceof GraphQLObjectType2) {
+    canonicalPrefix = "objects";
+    graphqlTypeShort = "object";
+    refType = ReferenceType.GRAPHQL_OBJECT;
+  } else if (gqlType instanceof GraphQLInterfaceType2) {
+    canonicalPrefix = "interfaces";
+    graphqlTypeShort = "interface";
+    refType = ReferenceType.GRAPHQL_INTERFACE;
+  } else if (gqlType instanceof GraphQLUnionType2) {
+    canonicalPrefix = "unions";
+    graphqlTypeShort = "union";
+    refType = ReferenceType.GRAPHQL_UNION;
+  } else if (gqlType instanceof GraphQLEnumType2) {
+    canonicalPrefix = "enums";
+    graphqlTypeShort = "enum";
+    refType = ReferenceType.GRAPHQL_ENUM;
+  } else if (gqlType instanceof GraphQLInputObjectType2) {
+    canonicalPrefix = "inputs";
+    graphqlTypeShort = "input";
+    refType = ReferenceType.GRAPHQL_INPUT;
+  } else if (gqlType instanceof GQLOperation) {
+    switch (gqlType._operationType) {
+      case "query": {
+        canonicalPrefix = "queries";
+        graphqlTypeShort = "query";
+        refType = ReferenceType.GRAPHQL_QUERY;
+        break;
+      }
+      case "mutation": {
+        canonicalPrefix = "mutations";
+        graphqlTypeShort = "mutation";
+        refType = ReferenceType.GRAPHQL_MUTATION;
+        break;
+      }
+      case "subscription": {
+        canonicalPrefix = "subscriptions";
+        graphqlTypeShort = "subscription";
+        refType = ReferenceType.GRAPHQL_SUBSCRIPTION;
+        break;
+      }
+    }
+  } else {
+    const info = gqlFieldTypeInfo(gqlType);
+    if ((info == null ? void 0 : info.typeFlat) && !isBuiltInType(info == null ? void 0 : info.typeFlat)) {
+      if (info == null ? void 0 : info.typeFlat) {
+        return uniformify(ctx, info.typeFlat, definitions, examples);
+      }
+    }
+  }
+  const slugger = new GithubSlugger();
+  const slug = gqlType.name;
+  const odCanonical = openDocsCanonical(ctx, gqlType);
+  let canonical = "";
+  if (odCanonical) {
+    canonical = odCanonical;
+  } else if (canonicalPrefix) {
+    canonical = [canonicalPrefix, slug].join("/");
+  }
+  const scopes = extractScopesFromDocDirective(ctx, gqlType) || [];
+  return {
+    title: gqlType.name,
+    description: gqlType.description || "",
+    canonical,
+    category: ReferenceCategory.GRAPHQL,
+    type: refType,
+    context: {
+      graphqlTypeShort,
+      graphqlName: gqlType.name,
+      group: openDocsToGroup(ctx, gqlType),
+      scopes
+    },
+    examples: {
+      groups: examples || []
+    },
+    definitions
+  };
+}
+function propsUniformify(ctx, field, properties, meta) {
+  var _a;
+  const fieldInfo = gqlFieldTypeInfo(field);
+  const objRef = uniformify(ctx, field, [], []);
+  const builtInType = (fieldInfo == null ? void 0 : fieldInfo.typeFlat) ? isBuiltInType(fieldInfo == null ? void 0 : fieldInfo.typeFlat) : void 0;
+  return {
+    name: field.name,
+    type: field.type.toJSON(),
+    description: field.description || "",
+    context: {
+      graphqlName: field.name,
+      graphqlTypeFlat: ((_a = fieldInfo.typeFlat) == null ? void 0 : _a.toJSON()) || "",
+      graphqlBuiltInType: builtInType
+    },
+    properties: properties || [],
+    meta: [
+      ...gqlFieldToUniformMeta(field),
+      ...meta || []
+    ],
+    symbolDef: {
+      canonical: objRef == null ? void 0 : objRef.canonical
+    }
+  };
+}
+function gqlObjectPropsUniformify(ctx, obj, meta) {
+  var _a, _b;
+  const objRef = uniformify(ctx, obj, [], []);
+  const inputFields = (_a = obj.getFields) == null ? void 0 : _a.call(obj);
+  const nestedProps = [];
+  const nestedDefinitionProperty = {
+    name: obj.name,
+    type: obj.toJSON(),
+    description: obj.description || "",
+    context: objRef.context,
+    properties: nestedProps,
+    meta: [
+      ...meta || []
+    ],
+    symbolDef: {
+      canonical: objRef.canonical
+    }
+  };
+  if (!((_b = ctx == null ? void 0 : ctx.config) == null ? void 0 : _b.flatArg)) {
+    for (const [name, inputField] of Object.entries(inputFields)) {
+      const prop = gqlFieldToUniformDefinitionProperty(
+        ctx,
+        inputField
+      );
+      if (prop) {
+        nestedProps.push(prop);
+      }
+    }
+  }
+  return nestedDefinitionProperty;
+}
+function gqlFieldToUniformMeta(field) {
+  var _a;
+  const meta = [];
+  if (isNonNullField(field.type) || isListOfNonNullItems(field.type)) {
+    meta.push({
+      name: "required",
+      value: "true"
+    });
+  }
+  if ((_a = field.astNode) == null ? void 0 : _a.directives) {
+    for (const directive of field.astNode.directives) {
+      if (directive.name.value === "deprecated") {
+        let foundDeprecatedReason = false;
+        for (const arg of directive.arguments || []) {
+          if (arg.name.value === "reason") {
+            foundDeprecatedReason = true;
+            meta.push({
+              name: "deprecated",
+              value: arg.value.kind === "StringValue" ? arg.value.value : "true"
+            });
+          }
+        }
+        if (!foundDeprecatedReason) {
+          meta.push({
+            name: "deprecated",
+            value: "true"
+          });
+        }
+      }
+    }
+  }
+  if ("defaultValue" in field && field.defaultValue !== void 0) {
+    meta.push({
+      name: "defaults",
+      value: field.defaultValue
+    });
+  }
+  return meta;
+}
+function gqlFieldTypeInfo(field) {
+  const getTypeInfo = (type) => {
+    if (!type) return void 0;
+    if (type instanceof GraphQLNonNull) {
+      return getTypeInfo(type.ofType);
+    }
+    if (type instanceof GraphQLList) {
+      return getTypeInfo(type.ofType);
+    }
+    return type;
+  };
+  const graphqlTypeFlat = getTypeInfo(field.type);
+  return {
+    typeFlat: graphqlTypeFlat
+  };
+}
+function isBuiltInType(gqlType) {
+  return isSpecifiedScalarType(gqlType) || isIntrospectionType(gqlType);
+}
+function isNonNullField(type) {
+  return type.constructor.name === "GraphQLNonNull";
+}
+function isListOfNonNullItems(type) {
+  return "ofType" in type && type.constructor.name === "GraphQLList" && type.ofType.constructor.name === "GraphQLNonNull";
+}
+
+// src/converters/gql-union.ts
+function gqlUnionToUniformRef(ctx, unionType) {
+  const properties = gqlUnionToUniformDefinitionProperties(ctx, unionType);
+  const definitions = [
+    {
+      title: "Possible types",
+      properties
+    }
+  ];
+  return uniformify(
+    ctx,
+    unionType,
+    definitions,
+    []
+  );
+}
+function gqlUnionToUniformDefinitionProperties(ctx, unionType) {
+  return unionType.getTypes().map((type) => {
+    if (type.constructor.name === "GraphQLObjectType") {
+      return gqlObjectToUniformDefinitionProperty(
+        ctx,
+        type
+      );
+    }
+    return [];
+  }).flat();
+}
+
+// src/converters/gql-field.ts
+function gqlFieldToUniformDefinitionProperty(ctx, field) {
+  return GQLFieldConverter.convert(ctx, field);
+}
+var GQLFieldConverter = class _GQLFieldConverter {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  static convert(ctx, field) {
+    return new _GQLFieldConverter(ctx).convert(field);
+  }
+  convert(field, parent) {
+    var _a, _b, _c, _d, _e;
+    if (((_a = this.ctx.globalOptions) == null ? void 0 : _a.flat) && (((_b = this.ctx.config) == null ? void 0 : _b.flatReturn) || ((_c = this.ctx.config) == null ? void 0 : _c.flat))) {
+      const info = gqlFieldTypeInfo(field);
+      const meta = [];
+      const props = propsUniformify(this.ctx, field, [], meta);
+      if ((_d = this.ctx.config) == null ? void 0 : _d.flatReturn) {
+        return {
+          ...props,
+          name: ""
+        };
+      }
+      if ((_e = this.ctx.config) == null ? void 0 : _e.flat) {
+        return props;
+      }
+    }
+    const fieldInfo = gqlFieldTypeInfo(field);
+    const graphqlTypeFlat = fieldInfo == null ? void 0 : fieldInfo.typeFlat;
+    let properties;
+    switch (graphqlTypeFlat == null ? void 0 : graphqlTypeFlat.constructor) {
+      case GraphQLObjectType3:
+      case GraphQLInputObjectType3:
+      case GraphQLInterfaceType3: {
+        properties = this.nestedProperties(graphqlTypeFlat);
+        break;
+      }
+      case GraphQLScalarType3:
+      case GraphQLNonNull2: {
+        properties = this.definitionPropsFromNestedObj(field) || [];
+        break;
+      }
+      case GraphQLUnionType3: {
+        properties = gqlUnionToUniformDefinitionProperties(this.ctx, graphqlTypeFlat);
+        break;
+      }
+    }
+    const resp = propsUniformify(
+      this.ctx,
+      field,
+      properties
+    );
+    if (graphqlTypeFlat) {
+      const nestedType = graphqlTypeFlat;
+      nestedType.__definitionProperties = resp.properties;
+    }
+    if (parent) {
+      parent.__definitionProperties = resp.properties;
+    }
+    return resp;
+  }
+  // TODO: fix any + another more safety solution?
+  // definitionPropsFromNestedObj converts graphql nested obj into xyd 'uniform' definition properties
+  definitionPropsFromNestedObj(obj) {
+    if (!obj) {
+      return null;
+    }
+    if (obj.getFields) {
+      return this.nestedProperties(obj);
+    }
+    if (obj.ofType) {
+      return this.definitionPropsFromNestedObj(obj.ofType);
+    }
+    if (obj.type) {
+      return this.definitionPropsFromNestedObj(obj.type);
+    }
+    return null;
+  }
+  // deepFieldMap iterates over GraphQL field (field or input fields) maps
+  deepFieldMap(fieldsMap, parent) {
+    const properties = [];
+    for (const [name, field] of Object.entries(fieldsMap)) {
+      const prop = this.convert(
+        field,
+        parent
+      );
+      if (prop) {
+        properties.push(prop);
+      }
+    }
+    return properties;
+  }
+  // nestedProperties get fields from object or input object types and iterates over them
+  nestedProperties(objectType) {
+    var _a;
+    if (this.ctx.processedTypes.has(objectType)) {
+      if (objectType == null ? void 0 : objectType.__definitionProperties) {
+        return objectType.__definitionProperties || [];
+      }
+      return [];
+    }
+    this.ctx.processedTypes.add(objectType);
+    const nestedFields = (_a = objectType == null ? void 0 : objectType.getFields) == null ? void 0 : _a.call(objectType);
+    const result = this.deepFieldMap(nestedFields, objectType);
+    return result;
+  }
+};
+
+// src/converters/gql-arg.ts
+import { GraphQLInputObjectType as GraphQLInputObjectType4 } from "graphql";
+
+// src/converters/gql-input.ts
+function gqlInputToUniformRef(ctx, gqlType) {
+  const prop = gqlInputToUniformDefinitionProperty(
+    ctx,
+    gqlType
+  );
+  return uniformify(
+    ctx,
+    gqlType,
+    [
+      {
+        title: "Fields",
+        properties: prop.properties || []
+      }
+    ],
+    []
+  );
+}
+function gqlInputToUniformDefinitionProperty(ctx, obj) {
+  return gqlObjectPropsUniformify(ctx, obj);
+}
+
+// src/converters/gql-arg.ts
+function gqlArgToUniformDefinitionProperty(ctx, args) {
+  const resp = [];
+  args.forEach((arg) => {
+    const fieldInfo = gqlFieldTypeInfo(arg);
+    if (!fieldInfo.typeFlat) {
+      console.error("gqlArgToUniformDefinitionProperty: no typeFlat for", arg.name);
+      return;
+    }
+    const flatType = fieldInfo.typeFlat;
+    if (flatType instanceof GraphQLInputObjectType4) {
+      const inputObj = flatType;
+      const meta = gqlFieldToUniformMeta(arg);
+      const defProperty = gqlInputToUniformDefinitionProperty(
+        ctx,
+        inputObj
+      );
+      resp.push({
+        ...defProperty,
+        type: arg.type.toJSON(),
+        name: arg.name,
+        description: arg.description || "",
+        meta: [
+          ...defProperty.meta || [],
+          ...meta || []
+        ]
+      });
+    } else {
+      const defProperty = propsUniformify(ctx, arg);
+      resp.push(defProperty);
+    }
+  });
+  return resp;
+}
+
+// src/converters/gql-object.ts
+function gqlObjectToUniformRef(ctx, gqlType) {
+  var _a;
+  const definitions = [];
+  const graphqlFields = [];
+  const variants = [];
+  const argumentDefinition = {
+    title: "Arguments",
+    properties: [],
+    variants,
+    meta: [
+      {
+        name: "type",
+        value: "arguments"
+      }
+    ]
+  };
+  for (const [name, field] of Object.entries(gqlType.getFields())) {
+    if (!((_a = field == null ? void 0 : field.args) == null ? void 0 : _a.length)) {
+      continue;
+    }
+    const args = gqlArgToUniformDefinitionProperty(ctx, field.args);
+    variants.push({
+      title: "",
+      properties: args,
+      meta: [
+        {
+          name: "symbolName",
+          value: name
+        }
+      ]
+    });
+  }
+  definitions.push(argumentDefinition);
+  for (const [name, field] of Object.entries(gqlType.getFields())) {
+    const prop = gqlFieldToUniformDefinitionProperty(ctx, field);
+    graphqlFields.push(prop);
+  }
+  definitions.push({
+    title: "Fields",
+    properties: graphqlFields,
+    meta: [
+      {
+        name: "type",
+        value: "fields"
+      }
+    ]
+  });
+  return uniformify(
+    ctx,
+    gqlType,
+    definitions,
+    []
+  );
+}
+function gqlObjectToUniformDefinitionProperty(ctx, obj) {
+  return gqlObjectPropsUniformify(ctx, obj);
+}
+
+// src/converters/gql-enum.ts
+function gqlEnumToUniformRef(ctx, gqlType) {
+  const props = gqlType.getValues().map((value) => ({
+    name: value.name,
+    type: "string",
+    // TODO: other types?
+    description: value.description || ""
+  }));
+  return uniformify(
+    ctx,
+    gqlType,
+    [
+      {
+        title: "Valid values",
+        properties: props
+      }
+    ],
+    []
+  );
+}
+
+// src/converters/gql-scalar.ts
+function gqlScalarToUniformRef(ctx, gqlType) {
+  return uniformify(
+    ctx,
+    gqlType,
+    [],
+    []
+  );
+}
+
+// src/converters/gql-interface.ts
+function gqlInterfaceToUniformRef(ctx, interfaceType) {
+  const properties = gqlInterfaceToUniformDefinitionProperties(ctx, interfaceType);
+  const definitions = [
+    {
+      title: "Fields",
+      properties
+    }
+  ];
+  return uniformify(
+    ctx,
+    interfaceType,
+    definitions,
+    []
+  );
+}
+function gqlInterfaceToUniformDefinitionProperties(ctx, interfaceType) {
+  return Object.values(interfaceType.getFields()).map((field) => {
+    return gqlFieldToUniformDefinitionProperty(
+      ctx,
+      field
+    );
+  });
+}
+
+// src/context.ts
+var Context = class {
+  constructor(processedTypes = /* @__PURE__ */ new Set(), globalOptions, config, schema) {
+    this.processedTypes = processedTypes;
+    this.globalOptions = globalOptions;
+    this.config = config;
+    this.schema = schema;
+  }
+};
+
+// src/converters/gql-types.ts
+function graphqlTypesToUniformReferences(schema, options) {
+  var _a, _b, _c, _d, _e, _f;
+  const references = [];
+  const typeMap = schema.getTypeMap();
+  const sharedProcessedTypes = /* @__PURE__ */ new Set();
+  for (const gqlType of Object.values(typeMap)) {
+    const builtInType = isSpecifiedScalarType2(gqlType) || isIntrospectionType2(gqlType) || gqlType.name === "Mutation" || gqlType.name === "Query" || gqlType.name === "Subscription" || isInternalOpenDocsType(gqlType);
+    if (builtInType) {
+      continue;
+    }
+    let ref = null;
+    let flat = false;
+    if (options == null ? void 0 : options.flat) {
+      flat = true;
+    }
+    switch (gqlType.constructor.name) {
+      case "GraphQLObjectType": {
+        const type = gqlType;
+        const regionKey = `object.${type.name}`;
+        if (!(options == null ? void 0 : options.regions) || !((_a = options == null ? void 0 : options.regions) == null ? void 0 : _a.length) || options.regions.includes(regionKey)) {
+          ref = gqlObjectToUniformRef(
+            new Context(
+              sharedProcessedTypes,
+              options,
+              {
+                flat
+              },
+              schema
+            ),
+            type
+          );
+        }
+        break;
+      }
+      case "GraphQLInputObjectType": {
+        const type = gqlType;
+        const regionKey = `input.${type.name}`;
+        if (!(options == null ? void 0 : options.regions) || !((_b = options == null ? void 0 : options.regions) == null ? void 0 : _b.length) || options.regions.includes(regionKey)) {
+          ref = gqlInputToUniformRef(
+            new Context(
+              sharedProcessedTypes,
+              options,
+              {
+                flat
+              },
+              schema
+            ),
+            type
+          );
+        }
+        break;
+      }
+      case "GraphQLEnumType": {
+        const type = gqlType;
+        const regionKey = `enum.${type.name}`;
+        if (!(options == null ? void 0 : options.regions) || !((_c = options == null ? void 0 : options.regions) == null ? void 0 : _c.length) || options.regions.includes(regionKey)) {
+          ref = gqlEnumToUniformRef(
+            new Context(
+              /* @__PURE__ */ new Set(),
+              options,
+              {},
+              schema
+            ),
+            type
+          );
+        }
+        break;
+      }
+      case "GraphQLScalarType": {
+        const type = gqlType;
+        const regionKey = `scalar.${type.name}`;
+        if (!(options == null ? void 0 : options.regions) || !((_d = options == null ? void 0 : options.regions) == null ? void 0 : _d.length) || options.regions.includes(regionKey)) {
+          ref = gqlScalarToUniformRef(
+            new Context(
+              /* @__PURE__ */ new Set(),
+              options,
+              {},
+              schema
+            ),
+            type
+          );
+        }
+        break;
+      }
+      case "GraphQLUnionType": {
+        const type = gqlType;
+        const regionKey = `union.${type.name}`;
+        if (!(options == null ? void 0 : options.regions) || !((_e = options == null ? void 0 : options.regions) == null ? void 0 : _e.length) || options.regions.includes(regionKey)) {
+          ref = gqlUnionToUniformRef(
+            new Context(
+              sharedProcessedTypes,
+              options,
+              {
+                flat,
+                flatArg: flat || false
+              },
+              schema
+            ),
+            type
+          );
+        }
+        break;
+      }
+      case "GraphQLInterfaceType": {
+        const type = gqlType;
+        const regionKey = `interface.${type.name}`;
+        if (!(options == null ? void 0 : options.regions) || !((_f = options == null ? void 0 : options.regions) == null ? void 0 : _f.length) || options.regions.includes(regionKey)) {
+          ref = gqlInterfaceToUniformRef(
+            new Context(
+              /* @__PURE__ */ new Set(),
+              options,
+              {
+                flat
+              },
+              schema
+            ),
+            type
+          );
+        }
+        break;
+      }
+      default: {
+        console.debug(`Unsupported type: ${gqlType.constructor.name}`);
+      }
+    }
+    if (ref) {
+      references.push(ref);
+    }
+  }
+  return references;
+}
+function isInternalOpenDocsType(type) {
+  const internalTypes = [
+    "OpenDocsScope",
+    "OpenDocsSidebarItemType",
+    "OpenDocsPage",
+    "OpenDocsExampleInput",
+    "OpenDocsSortInput",
+    "OpenDocsSortStackInput"
+  ];
+  return internalTypes.includes(type.name);
+}
+
+// src/converters/gql-query.ts
+import { OperationTypeNode as OperationTypeNode3 } from "graphql";
+import { ReferenceType as ReferenceType4 } from "@xyd-js/uniform";
+
+// src/utils.ts
+function filterFieldsByRegions(fields, prefix, regions) {
+  if (!regions || regions.length === 0) {
+    return fields;
+  }
+  const filteredFields = {};
+  for (const [fieldName, field] of Object.entries(fields)) {
+    const regionKey = `${prefix}.${fieldName}`;
+    if (regions.some((region) => region === regionKey)) {
+      filteredFields[fieldName] = field;
+    }
+  }
+  return filteredFields;
+}
+
+// src/converters/gql-operation.ts
+import { OperationTypeNode as OperationTypeNode2 } from "graphql";
+import { ReferenceType as ReferenceType3 } from "@xyd-js/uniform";
+
+// src/converters/gql-sample.ts
+import {
+  Kind,
+  print,
+  OperationTypeNode
+} from "graphql";
+import {
+  ReferenceType as ReferenceType2
+} from "@xyd-js/uniform";
+var operationTypeToTypeNode = {
+  [ReferenceType2.GRAPHQL_QUERY]: OperationTypeNode.QUERY,
+  [ReferenceType2.GRAPHQL_MUTATION]: OperationTypeNode.MUTATION,
+  [ReferenceType2.GRAPHQL_SUBSCRIPTION]: OperationTypeNode.SUBSCRIPTION
+};
+function simpleGraphqlExample(operationType, operationName, args, returns) {
+  const requiredArgs = args.filter((arg) => {
+    var _a;
+    return (_a = arg.meta) == null ? void 0 : _a.some((m) => m.name === "required" && m.value === "true");
+  });
+  const selectedArgs = requiredArgs.length > 0 ? requiredArgs : args.slice(0, 1);
+  let hasArgVars = false;
+  const argDefaults = selectedArgs.reduce((acc, arg) => {
+    var _a, _b, _c;
+    if (operationType != ReferenceType2.GRAPHQL_QUERY) {
+      return acc;
+    }
+    let defaultValue = "";
+    const getDefaultValue = (_b = (_a = arg.meta) == null ? void 0 : _a.find((m) => m.name === "defaults")) == null ? void 0 : _b.value;
+    if (getDefaultValue && typeof getDefaultValue !== "string") {
+      defaultValue = JSON.stringify(getDefaultValue);
+    }
+    let sampleValue = void 0;
+    switch ((_c = arg.context) == null ? void 0 : _c.graphqlTypeFlat) {
+      case "String":
+        sampleValue = { kind: Kind.STRING, value: defaultValue || `example-${arg.name}` };
+        break;
+      case "Int":
+      case "Float":
+        sampleValue = { kind: Kind.INT, value: defaultValue || "0" };
+        break;
+      case "Boolean":
+        sampleValue = { kind: Kind.BOOLEAN, value: defaultValue === "true" };
+        break;
+    }
+    if (sampleValue) {
+      return {
+        ...acc,
+        [arg.name]: {
+          kind: Kind.ARGUMENT,
+          name: { kind: Kind.NAME, value: arg.name },
+          value: sampleValue
+        }
+      };
+    }
+    return acc;
+  }, {});
+  const allDefaultArgs = Object.keys(argDefaults).length === selectedArgs.length;
+  const argumentsList = selectedArgs.map((arg) => {
+    if (allDefaultArgs) {
+      return argDefaults[arg.name];
+    }
+    hasArgVars = true;
+    return {
+      kind: Kind.ARGUMENT,
+      name: { kind: Kind.NAME, value: arg.name },
+      value: {
+        kind: Kind.VARIABLE,
+        name: { kind: Kind.NAME, value: arg.name }
+      }
+    };
+  });
+  const queryAST = {
+    kind: Kind.DOCUMENT,
+    definitions: [
+      {
+        kind: Kind.OPERATION_DEFINITION,
+        operation: operationTypeToTypeNode[operationType],
+        name: hasArgVars ? {
+          kind: Kind.NAME,
+          value: operationName
+        } : void 0,
+        variableDefinitions: hasArgVars ? selectedArgs.map(variableDefinitions) : [],
+        selectionSet: {
+          kind: Kind.SELECTION_SET,
+          selections: [
+            {
+              kind: Kind.FIELD,
+              name: { kind: Kind.NAME, value: operationName },
+              arguments: argumentsList,
+              selectionSet: {
+                kind: Kind.SELECTION_SET,
+                selections: [
+                  { kind: Kind.FIELD, name: { kind: Kind.NAME, value: `# ${operationName} fields` } }
+                ]
+              }
+            }
+          ]
+        }
+      }
+    ]
+  };
+  const sampleText = print(queryAST);
+  return sampleText;
+}
+function variableDefinitions(arg) {
+  var _a, _b, _c;
+  const hasDefault = (_a = arg.meta) == null ? void 0 : _a.some((m) => m.name === "defaults");
+  let defaultValue = "";
+  const getDefaultValue = (_c = (_b = arg.meta) == null ? void 0 : _b.find((m) => m.name === "defaults")) == null ? void 0 : _c.value;
+  if (getDefaultValue && typeof getDefaultValue !== "string") {
+    defaultValue = JSON.stringify(getDefaultValue);
+  }
+  return {
+    kind: Kind.VARIABLE_DEFINITION,
+    variable: {
+      kind: Kind.VARIABLE,
+      name: { kind: Kind.NAME, value: arg.name }
+    },
+    type: {
+      kind: Kind.NAMED_TYPE,
+      name: { kind: Kind.NAME, value: arg.type }
+    },
+    ...hasDefault && defaultValue ? {
+      defaultValue: {
+        kind: Kind.STRING,
+        value: defaultValue
+      }
+    } : {}
+  };
+}
+
+// src/converters/gql-operation.ts
+function gqlOperationToUniformRef(operationType, fieldsMap, schema, options) {
+  const references = [];
+  for (const [operationName, operationField] of Object.entries(fieldsMap)) {
+    const definitions = [];
+    let flatReturn = false;
+    let flat = false;
+    let argFlat = false;
+    if (options == null ? void 0 : options.flat) {
+      flatReturn = true;
+      flat = true;
+      argFlat = true;
+    }
+    const args = gqlArgToUniformDefinitionProperty(new Context(
+      /* @__PURE__ */ new Set(),
+      options,
+      {
+        flat,
+        flatArg: argFlat
+      },
+      schema
+    ), operationField.args);
+    const returns = gqlFieldToUniformDefinitionProperty(new Context(
+      /* @__PURE__ */ new Set(),
+      options,
+      {
+        flatReturn
+      },
+      schema
+    ), operationField);
+    let returnProperties = returns.properties || [];
+    if (options == null ? void 0 : options.flat) {
+      returnProperties = [returns];
+    }
+    definitions.push({
+      title: "Arguments",
+      properties: args
+    });
+    definitions.push({
+      title: "Returns",
+      properties: returnProperties
+    });
+    const exampleQuery = simpleGraphqlExample(
+      operationType,
+      operationName,
+      args,
+      returnProperties
+    );
+    const examples = [
+      {
+        codeblock: {
+          tabs: [
+            {
+              title: "",
+              language: "graphql",
+              code: exampleQuery
+            }
+          ]
+        }
+      }
+    ];
+    const exampleGroup = {
+      description: "",
+      examples
+    };
+    const operation = new GQLOperation(operationField);
+    switch (operationType) {
+      case ReferenceType3.GRAPHQL_QUERY: {
+        operation.__operationType = OperationTypeNode2.QUERY;
+        break;
+      }
+      case ReferenceType3.GRAPHQL_MUTATION: {
+        operation.__operationType = OperationTypeNode2.MUTATION;
+        break;
+      }
+      case ReferenceType3.GRAPHQL_SUBSCRIPTION: {
+        operation.__operationType = OperationTypeNode2.SUBSCRIPTION;
+        break;
+      }
+      default: {
+        console.error(`Invalid operation type: ${operationType}`);
+      }
+    }
+    const ref = uniformify(
+      new Context(
+        /* @__PURE__ */ new Set(),
+        options,
+        {},
+        schema
+      ),
+      operation,
+      definitions,
+      [exampleGroup]
+    );
+    if (ref) {
+      references.push(ref);
+    }
+  }
+  return references;
+}
+
+// src/converters/gql-query.ts
+function graphqlQueriesToUniformReferences(schema, options) {
+  var _a;
+  const references = [];
+  const queries = schema.getRootType(OperationTypeNode3.QUERY);
+  const queryFields = (_a = queries == null ? void 0 : queries.getFields) == null ? void 0 : _a.call(queries);
+  if (queryFields) {
+    const filteredQueryFields = filterFieldsByRegions(
+      queryFields,
+      "query",
+      options == null ? void 0 : options.regions
+    );
+    references.push(...gqlOperationToUniformRef(
+      ReferenceType4.GRAPHQL_QUERY,
+      filteredQueryFields,
+      schema,
+      options
+    ));
+  }
+  return references;
+}
+
+// src/converters/gql-mutation.ts
+import { OperationTypeNode as OperationTypeNode4 } from "graphql";
+import { ReferenceType as ReferenceType5 } from "@xyd-js/uniform";
+function graphqlMutationsToUniformReferences(schema, options) {
+  var _a;
+  const references = [];
+  const mutations = schema.getRootType(OperationTypeNode4.MUTATION);
+  const mutationFields = (_a = mutations == null ? void 0 : mutations.getFields) == null ? void 0 : _a.call(mutations);
+  if (mutationFields) {
+    const filteredMutationFields = filterFieldsByRegions(
+      mutationFields,
+      "mutation",
+      options == null ? void 0 : options.regions
+    );
+    references.push(...gqlOperationToUniformRef(
+      ReferenceType5.GRAPHQL_MUTATION,
+      filteredMutationFields,
+      schema,
+      options
+    ));
+  }
+  return references;
+}
+
+// src/converters/gql-subscription.ts
+import { OperationTypeNode as OperationTypeNode5 } from "graphql";
+import { ReferenceType as ReferenceType6 } from "@xyd-js/uniform";
+function graphqlSubscriptionsToUniformReferences(schema, options) {
+  var _a;
+  const references = [];
+  const mutations = schema.getRootType(OperationTypeNode5.SUBSCRIPTION);
+  const mutationFields = (_a = mutations == null ? void 0 : mutations.getFields) == null ? void 0 : _a.call(mutations);
+  if (mutationFields) {
+    const filteredMutationFields = filterFieldsByRegions(
+      mutationFields,
+      "mutation",
+      options == null ? void 0 : options.regions
+    );
+    references.push(...gqlOperationToUniformRef(
+      ReferenceType6.GRAPHQL_SUBSCRIPTION,
+      filteredMutationFields,
+      schema,
+      options
+    ));
+  }
+  return references;
+}
+
+// src/opendocs.graphql
+var opendocs_default = 'directive @scope(value: String!) on ENUM_VALUE\n\nenum OpenDocsScope {\n    _PLACEHOLDER_\n}\n\ndirective @docs(\n    route: String\n    sort: [OpenDocsSortInput!]\n    sortStack: [[String!]!]\n    flattenTypes: Boolean\n    sidebar: [OpenDocsPage]\n    group: [String]\n) repeatable on SCHEMA\n\ninput OpenDocsPage {\n    type: OpenDocsSidebarItemType!\n    key: String!\n    group: String\n    path: String\n    pages: [OpenDocsPage]\n}\n\nenum OpenDocsSidebarItemType {\n    OPERATION\n    TYPE\n}\n\ndirective @doc(\n    group: [String!],\n    path: String,\n    example: OpenDocsExampleInput,\n    scopes: [OpenDocsScope],\n) on QUERY |\n    FIELD_DEFINITION |\n    MUTATION |\n    SUBSCRIPTION |\n    OBJECT |\n    INPUT_OBJECT |\n    ENUM |\n    SCALAR |\n    UNION\n\n# TODO: finish\ninput OpenDocsExampleInput {\n    """\n    The name of the code\n    """\n    code: String!\n}\n\ninput OpenDocsSortInput {\n    node: String\n    group: [String!]\n    stack: Int\n}';
+
+// src/schema.ts
+async function gqlSchemaToReferences(schemaLocation, options) {
+  const schemaLocations = Array.isArray(schemaLocation) ? schemaLocation : [schemaLocation];
+  schemaLocations.unshift(opendocs_default);
+  const schemaContents = await Promise.all(schemaLocations.map(async (location) => {
+    if (location.startsWith("http://") || location.startsWith("https://")) {
+      const response = await fetch(location);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch schema from URL: ${location}`);
+      }
+      return response.text();
+    }
+    if (fs.existsSync(location)) {
+      return fs.readFileSync(location, "utf-8");
+    }
+    return location;
+  }));
+  const mergedTypeDefs = mergeTypeDefs(schemaContents);
+  const schemaString = print2(mergedTypeDefs);
+  const schema = buildSchema(schemaString, {
+    assumeValid: true
+  });
+  if (schemaContents.length > 2) {
+    console.warn(`Warning: More than 2 schema files provided - no all featues will be supported!`);
+  }
+  docDirectiveChain(schemaContents[1], schema);
+  if (!options) {
+    options = {};
+  }
+  if (!options.hasOwnProperty("flat")) {
+    options.flat = true;
+  }
+  options = {
+    ...options,
+    ...openDocsExtensionsToOptions(schema)
+  };
+  const references = [
+    // types
+    ...graphqlTypesToUniformReferences(schema, options),
+    // queries
+    ...graphqlQueriesToUniformReferences(schema, options),
+    // mutations
+    ...graphqlMutationsToUniformReferences(schema, options),
+    // subscriptions
+    ...graphqlSubscriptionsToUniformReferences(schema, options)
+  ];
+  const sortConfig = options.sort ?? { sort: DEFAULT_SORT_ORDER };
+  references.sort((a, b) => {
+    const aOrder = getSortOrder(a, sortConfig);
+    const bOrder = getSortOrder(b, sortConfig);
+    return aOrder - bOrder;
+  });
+  if (options.route) {
+    references.__UNSAFE_route = () => options.route;
+  }
+  return references;
+}
+function getSortOrder(reference, sortConfig) {
+  const sortItems = sortConfig.sort ?? DEFAULT_SORT_ORDER;
+  const sortStacks = sortConfig.sortStack ?? [];
+  const referenceGroups = getReferenceGroups(reference);
+  for (let groupIndex = 0; groupIndex < sortItems.length; groupIndex++) {
+    const sortItem = sortItems[groupIndex];
+    if (matchesPrimaryGroup(reference, sortItem)) {
+      const stackIndex = sortItem.stack !== void 0 ? sortItem.stack : 0;
+      const positionInGroup = calculatePositionInGroup(reference, stackIndex, sortStacks);
+      const result = groupIndex * 1e3 + positionInGroup;
+      return result;
+    }
+  }
+  return Number.MAX_SAFE_INTEGER;
+}
+function matchesPrimaryGroup(reference, sortItem) {
+  if (sortItem.node) {
+    const context = reference.context;
+    if ((context == null ? void 0 : context.graphqlTypeShort) === sortItem.node) {
+      return true;
+    }
+    return false;
+  }
+  if (sortItem.group && sortItem.group.length > 0) {
+    const referenceGroups = getReferenceGroups(reference);
+    const match = sortItem.group.some((group) => referenceGroups.includes(group));
+    return match;
+  }
+  return true;
+}
+function calculatePositionInGroup(reference, stackIndex, sortStacks) {
+  if (stackIndex < 0 || stackIndex >= sortStacks.length) {
+    return 0;
+  }
+  const stackGroups = sortStacks[stackIndex];
+  const referenceGroups = getReferenceGroups(reference);
+  for (let i = 0; i < stackGroups.length; i++) {
+    const stackGroup = stackGroups[i];
+    if (referenceGroups.includes(stackGroup)) {
+      return i;
+    }
+  }
+  return 999;
+}
+function getReferenceGroups(reference) {
+  const context = reference.context;
+  if ((context == null ? void 0 : context.group) && Array.isArray(context.group)) {
+    return context.group;
+  }
+  if (reference.__UNSAFE_selector) {
+    try {
+      const selector = reference.__UNSAFE_selector;
+      const metadata = selector("[metadata]");
+      if (metadata == null ? void 0 : metadata.groups) {
+        return metadata.groups;
+      }
+    } catch (e) {
+    }
+  }
+  return [];
+}
+function docDirectiveChain(rawSDL, schema) {
+  const ast = parse(rawSDL);
+  const metadata = {
+    fields: /* @__PURE__ */ new Map()
+  };
+  visit(ast, {
+    SchemaExtension(node) {
+      var _a;
+      for (const directive of node.directives || []) {
+        if (directive.name.value === OPEN_DOCS_SCHEMA_DIRECTIVE_NAME) {
+          const groupArg = (_a = directive.arguments) == null ? void 0 : _a.find((arg) => arg.name.value === "group");
+          if ((groupArg == null ? void 0 : groupArg.value.kind) === "ListValue") {
+            metadata.rootGroups = groupArg.value.values.filter((v) => v.kind === "StringValue").map((v) => v.value);
+          }
+        }
+      }
+    }
+  });
+  visit(ast, {
+    ObjectTypeExtension(node) {
+      var _a, _b;
+      const validNodeTypes = ["Query", "Mutation", "Subscription"];
+      if (!validNodeTypes.includes(node.name.value)) return;
+      const typeLevelDoc = (_a = node.directives) == null ? void 0 : _a.find((d) => d.name.value === OPEN_DOCS_DIRECTIVE_NAME);
+      const typeLevelDocArgs = typeLevelDoc ? extractDocArgs(typeLevelDoc) : {};
+      for (const field of node.fields ?? []) {
+        const fieldName = field.name.value;
+        const fieldDoc = (_b = field.directives) == null ? void 0 : _b.find((d) => d.name.value === OPEN_DOCS_DIRECTIVE_NAME);
+        const fieldDocArgs = fieldDoc ? extractDocArgs(fieldDoc) : {};
+        let path = fieldDocArgs.path;
+        if (typeLevelDocArgs.path && fieldDocArgs.path) {
+          path = `${typeLevelDocArgs.path}/${fieldDocArgs.path}`;
+        } else if (typeLevelDocArgs.path) {
+          path = typeLevelDocArgs.path;
+        }
+        if (!fieldDocArgs.path && path) {
+          path += "/" + fieldName;
+        }
+        const groups = fieldDocArgs.groups ?? typeLevelDocArgs.groups ?? [];
+        const effectiveDoc = {
+          groups,
+          path
+        };
+        metadata.fields.set(`${node.name.value}.${fieldName}`, effectiveDoc);
+      }
+    }
+  });
+  schema.__metadata = metadata;
+}
+function extractDocArgs(directive) {
+  const info = {};
+  for (const arg of directive.arguments ?? []) {
+    if (arg.name.value === "group" && arg.value.kind === "ListValue") {
+      info.groups = arg.value.values.filter((v) => v.kind === "StringValue").map((v) => v.value);
+    } else if (arg.name.value === "path" && arg.value.kind === "StringValue") {
+      info.path = arg.value.value;
+    }
+  }
+  return info;
+}
+export {
+  gqlSchemaToReferences
+};
+//# sourceMappingURL=index.js.map