@depup/gatsby 5.16.1-depup.0

package/dist/schema/types/type-builders.d.ts

@@ -0,0 +1,36 @@
+import { ObjectTypeComposerAsObjectDefinition as ComposeObjectTypeConfig, InputTypeComposerAsObjectDefinition as ComposeInputObjectTypeConfig, InterfaceTypeComposerAsObjectDefinition as ComposeInterfaceTypeConfig, UnionTypeComposerAsObjectDefinition as ComposeUnionTypeConfig, EnumTypeComposerAsObjectDefinition as ComposeEnumTypeConfig, ScalarTypeComposerAsObjectDefinition as ComposeScalarTypeConfig } from "graphql-compose";
+declare enum GatsbyGraphQLTypeKind {
+    OBJECT = "OBJECT",
+    INPUT_OBJECT = "INPUT_OBJECT",
+    UNION = "UNION",
+    INTERFACE = "INTERFACE",
+    ENUM = "ENUM",
+    SCALAR = "SCALAR"
+}
+export type GatsbyGraphQLType<TSource, TContext> = {
+    kind: GatsbyGraphQLTypeKind.OBJECT;
+    config: ComposeObjectTypeConfig<TSource, TContext>;
+} | {
+    kind: GatsbyGraphQLTypeKind.INPUT_OBJECT;
+    config: ComposeInputObjectTypeConfig;
+} | {
+    kind: GatsbyGraphQLTypeKind.UNION;
+    config: ComposeUnionTypeConfig<TSource, TContext>;
+} | {
+    kind: GatsbyGraphQLTypeKind.INTERFACE;
+    config: ComposeInterfaceTypeConfig<TSource, TContext>;
+} | {
+    kind: GatsbyGraphQLTypeKind.ENUM;
+    config: ComposeEnumTypeConfig;
+} | {
+    kind: GatsbyGraphQLTypeKind.SCALAR;
+    config: ComposeScalarTypeConfig<any, any>;
+};
+declare function buildObjectType<TSource, TContext>(config: ComposeObjectTypeConfig<TSource, TContext>): GatsbyGraphQLType<TSource, TContext>;
+declare function buildUnionType<TSource, TContext>(config: ComposeUnionTypeConfig<TSource, TContext>): GatsbyGraphQLType<TSource, TContext>;
+declare function buildInterfaceType<TSource, TContext>(config: ComposeInterfaceTypeConfig<TSource, TContext>): GatsbyGraphQLType<TSource, TContext>;
+declare function buildInputObjectType<TSource, TContext>(config: ComposeInputObjectTypeConfig): GatsbyGraphQLType<TSource, TContext>;
+declare function buildEnumType<TSource, TContext>(config: ComposeEnumTypeConfig): GatsbyGraphQLType<TSource, TContext>;
+declare function buildScalarType<TSource, TContext>(config: ComposeScalarTypeConfig<any, any>): GatsbyGraphQLType<TSource, TContext>;
+declare function isGatsbyType(something: any): something is GatsbyGraphQLTypeKind;
+export { GatsbyGraphQLTypeKind, buildObjectType, buildUnionType, buildInterfaceType, buildInputObjectType, buildEnumType, buildScalarType, isGatsbyType, };

package/dist/schema/types/type-builders.js

@@ -0,0 +1,61 @@
+"use strict";
+
+exports.__esModule = true;
+exports.GatsbyGraphQLTypeKind = void 0;
+exports.buildEnumType = buildEnumType;
+exports.buildInputObjectType = buildInputObjectType;
+exports.buildInterfaceType = buildInterfaceType;
+exports.buildObjectType = buildObjectType;
+exports.buildScalarType = buildScalarType;
+exports.buildUnionType = buildUnionType;
+exports.isGatsbyType = isGatsbyType;
+var GatsbyGraphQLTypeKind;
+exports.GatsbyGraphQLTypeKind = GatsbyGraphQLTypeKind;
+(function (GatsbyGraphQLTypeKind) {
+  GatsbyGraphQLTypeKind["OBJECT"] = "OBJECT";
+  GatsbyGraphQLTypeKind["INPUT_OBJECT"] = "INPUT_OBJECT";
+  GatsbyGraphQLTypeKind["UNION"] = "UNION";
+  GatsbyGraphQLTypeKind["INTERFACE"] = "INTERFACE";
+  GatsbyGraphQLTypeKind["ENUM"] = "ENUM";
+  GatsbyGraphQLTypeKind["SCALAR"] = "SCALAR";
+})(GatsbyGraphQLTypeKind || (exports.GatsbyGraphQLTypeKind = GatsbyGraphQLTypeKind = {}));
+function buildObjectType(config) {
+  return {
+    kind: GatsbyGraphQLTypeKind.OBJECT,
+    config
+  };
+}
+function buildUnionType(config) {
+  return {
+    kind: GatsbyGraphQLTypeKind.UNION,
+    config
+  };
+}
+function buildInterfaceType(config) {
+  return {
+    kind: GatsbyGraphQLTypeKind.INTERFACE,
+    config
+  };
+}
+function buildInputObjectType(config) {
+  return {
+    kind: GatsbyGraphQLTypeKind.INPUT_OBJECT,
+    config
+  };
+}
+function buildEnumType(config) {
+  return {
+    kind: GatsbyGraphQLTypeKind.ENUM,
+    config
+  };
+}
+function buildScalarType(config) {
+  return {
+    kind: GatsbyGraphQLTypeKind.SCALAR,
+    config
+  };
+}
+function isGatsbyType(something) {
+  return typeof something === `object` && something.kind && GatsbyGraphQLTypeKind[something.kind];
+}
+//# sourceMappingURL=type-builders.js.map

package/dist/schema/types/type-builders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-builders.js","names":["GatsbyGraphQLTypeKind","buildObjectType","config","kind","OBJECT","buildUnionType","UNION","buildInterfaceType","INTERFACE","buildInputObjectType","INPUT_OBJECT","buildEnumType","ENUM","buildScalarType","SCALAR","isGatsbyType","something"],"sources":["../../../src/schema/types/type-builders.ts"],"sourcesContent":["import {\n  ObjectTypeComposerAsObjectDefinition as ComposeObjectTypeConfig,\n  InputTypeComposerAsObjectDefinition as ComposeInputObjectTypeConfig,\n  InterfaceTypeComposerAsObjectDefinition as ComposeInterfaceTypeConfig,\n  UnionTypeComposerAsObjectDefinition as ComposeUnionTypeConfig,\n  EnumTypeComposerAsObjectDefinition as ComposeEnumTypeConfig,\n  ScalarTypeComposerAsObjectDefinition as ComposeScalarTypeConfig,\n} from \"graphql-compose\"\n\nenum GatsbyGraphQLTypeKind {\n  OBJECT = `OBJECT`,\n  INPUT_OBJECT = `INPUT_OBJECT`,\n  UNION = `UNION`,\n  INTERFACE = `INTERFACE`,\n  ENUM = `ENUM`,\n  SCALAR = `SCALAR`,\n}\n\nexport type GatsbyGraphQLType<TSource, TContext> =\n  | {\n      kind: GatsbyGraphQLTypeKind.OBJECT\n      config: ComposeObjectTypeConfig<TSource, TContext>\n    }\n  | {\n      kind: GatsbyGraphQLTypeKind.INPUT_OBJECT\n      config: ComposeInputObjectTypeConfig\n    }\n  | {\n      kind: GatsbyGraphQLTypeKind.UNION\n      config: ComposeUnionTypeConfig<TSource, TContext>\n    }\n  | {\n      kind: GatsbyGraphQLTypeKind.INTERFACE\n      config: ComposeInterfaceTypeConfig<TSource, TContext>\n    }\n  | {\n      kind: GatsbyGraphQLTypeKind.ENUM\n      config: ComposeEnumTypeConfig\n    }\n  | {\n      kind: GatsbyGraphQLTypeKind.SCALAR\n      config: ComposeScalarTypeConfig<any, any>\n    }\n\nfunction buildObjectType<TSource, TContext>(\n  config: ComposeObjectTypeConfig<TSource, TContext>\n): GatsbyGraphQLType<TSource, TContext> {\n  return {\n    kind: GatsbyGraphQLTypeKind.OBJECT,\n    config,\n  }\n}\n\nfunction buildUnionType<TSource, TContext>(\n  config: ComposeUnionTypeConfig<TSource, TContext>\n): GatsbyGraphQLType<TSource, TContext> {\n  return {\n    kind: GatsbyGraphQLTypeKind.UNION,\n    config,\n  }\n}\n\nfunction buildInterfaceType<TSource, TContext>(\n  config: ComposeInterfaceTypeConfig<TSource, TContext>\n): GatsbyGraphQLType<TSource, TContext> {\n  return {\n    kind: GatsbyGraphQLTypeKind.INTERFACE,\n    config,\n  }\n}\n\nfunction buildInputObjectType<TSource, TContext>(\n  config: ComposeInputObjectTypeConfig\n): GatsbyGraphQLType<TSource, TContext> {\n  return {\n    kind: GatsbyGraphQLTypeKind.INPUT_OBJECT,\n    config,\n  }\n}\n\nfunction buildEnumType<TSource, TContext>(\n  config: ComposeEnumTypeConfig\n): GatsbyGraphQLType<TSource, TContext> {\n  return {\n    kind: GatsbyGraphQLTypeKind.ENUM,\n    config,\n  }\n}\n\nfunction buildScalarType<TSource, TContext>(\n  config: ComposeScalarTypeConfig<any, any>\n): GatsbyGraphQLType<TSource, TContext> {\n  return {\n    kind: GatsbyGraphQLTypeKind.SCALAR,\n    config,\n  }\n}\n\nfunction isGatsbyType(something: any): something is GatsbyGraphQLTypeKind {\n  return (\n    typeof something === `object` &&\n    something.kind &&\n    GatsbyGraphQLTypeKind[something.kind]\n  )\n}\n\nexport {\n  GatsbyGraphQLTypeKind,\n  buildObjectType,\n  buildUnionType,\n  buildInterfaceType,\n  buildInputObjectType,\n  buildEnumType,\n  buildScalarType,\n  isGatsbyType,\n}\n"],"mappings":";;;;;;;;;;;IASKA,qBAAqB;AAAA;AAAA,WAArBA,qBAAqB;EAArBA,qBAAqB;EAArBA,qBAAqB;EAArBA,qBAAqB;EAArBA,qBAAqB;EAArBA,qBAAqB;EAArBA,qBAAqB;AAAA,GAArBA,qBAAqB,qCAArBA,qBAAqB;AAmC1B,SAASC,eAAe,CACtBC,MAAkD,EACZ;EACtC,OAAO;IACLC,IAAI,EAAEH,qBAAqB,CAACI,MAAM;IAClCF;EACF,CAAC;AACH;AAEA,SAASG,cAAc,CACrBH,MAAiD,EACX;EACtC,OAAO;IACLC,IAAI,EAAEH,qBAAqB,CAACM,KAAK;IACjCJ;EACF,CAAC;AACH;AAEA,SAASK,kBAAkB,CACzBL,MAAqD,EACf;EACtC,OAAO;IACLC,IAAI,EAAEH,qBAAqB,CAACQ,SAAS;IACrCN;EACF,CAAC;AACH;AAEA,SAASO,oBAAoB,CAC3BP,MAAoC,EACE;EACtC,OAAO;IACLC,IAAI,EAAEH,qBAAqB,CAACU,YAAY;IACxCR;EACF,CAAC;AACH;AAEA,SAASS,aAAa,CACpBT,MAA6B,EACS;EACtC,OAAO;IACLC,IAAI,EAAEH,qBAAqB,CAACY,IAAI;IAChCV;EACF,CAAC;AACH;AAEA,SAASW,eAAe,CACtBX,MAAyC,EACH;EACtC,OAAO;IACLC,IAAI,EAAEH,qBAAqB,CAACc,MAAM;IAClCZ;EACF,CAAC;AACH;AAEA,SAASa,YAAY,CAACC,SAAc,EAAsC;EACxE,OACE,OAAOA,SAAS,KAAM,QAAO,IAC7BA,SAAS,CAACb,IAAI,IACdH,qBAAqB,CAACgB,SAAS,CAACb,IAAI,CAAC;AAEzC"}

package/dist/schema/types/type-defs.js

@@ -0,0 +1,86 @@
+"use strict";
+
+var _typeBuilders = require("./type-builders");
+const {
+  parse,
+  Kind: GraphQLASTNodeKind
+} = require(`graphql`);
+const {
+  inferExtensionName,
+  dontInferExtensionName
+} = require(`../extensions`);
+const report = require(`gatsby-cli/lib/reporter`);
+const isASTDocument = typeOrTypeDef => typeof typeOrTypeDef === `object` && typeOrTypeDef.kind && GraphQLASTNodeKind.DOCUMENT === typeOrTypeDef.kind;
+
+/**
+ * Parses type definition represented as an SDL string into an AST Document.
+ * Type definitions of other formats (other than SDL) are returned as is
+ */
+const parseTypeDef = typeOrTypeDef => {
+  if (typeof typeOrTypeDef === `string`) {
+    try {
+      return parse(typeOrTypeDef);
+    } catch (error) {
+      reportParsingError(error);
+    }
+  }
+  return typeOrTypeDef;
+};
+const reportParsingError = error => {
+  const {
+    message,
+    source,
+    locations
+  } = error;
+  if (source && locations && locations.length) {
+    const {
+      codeFrameColumns
+    } = require(`@babel/code-frame`);
+    const frame = codeFrameColumns(source.body, {
+      start: locations[0]
+    }, {
+      linesAbove: 5,
+      linesBelow: 5
+    });
+    report.panic(`Encountered an error parsing the provided GraphQL type definitions:\n` + message + `\n\n` + frame + `\n`);
+  } else {
+    throw error;
+  }
+};
+
+/**
+ * Given a type definition, collects type names that should skip the inference process
+ */
+const typesWithoutInference = (typeNames = [], typeOrTypeDef) => {
+  if (typeof typeOrTypeDef === `string`) {
+    typeOrTypeDef = parseTypeDef(typeOrTypeDef);
+  }
+  if (isASTDocument(typeOrTypeDef)) {
+    typeOrTypeDef.definitions.forEach(def => {
+      if (!def.directives) return;
+      def.directives.forEach(directive => {
+        if (directive.name.value === dontInferExtensionName && def.name.value) {
+          typeNames.push(def.name.value);
+        }
+      });
+    });
+    return typeNames;
+  }
+  if ((0, _typeBuilders.isGatsbyType)(typeOrTypeDef) && typeOrTypeDef.config) {
+    const {
+      extensions = {},
+      name
+    } = typeOrTypeDef.config;
+    if (name && (extensions[dontInferExtensionName] || extensions[inferExtensionName] === false)) {
+      typeNames.push(name);
+    }
+  }
+  return typeNames;
+};
+module.exports = {
+  parseTypeDef,
+  reportParsingError,
+  typesWithoutInference,
+  isASTDocument
+};
+//# sourceMappingURL=type-defs.js.map

package/dist/schema/types/type-defs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-defs.js","names":["parse","Kind","GraphQLASTNodeKind","require","inferExtensionName","dontInferExtensionName","report","isASTDocument","typeOrTypeDef","kind","DOCUMENT","parseTypeDef","error","reportParsingError","message","source","locations","length","codeFrameColumns","frame","body","start","linesAbove","linesBelow","panic","typesWithoutInference","typeNames","definitions","forEach","def","directives","directive","name","value","push","isGatsbyType","config","extensions","module","exports"],"sources":["../../../src/schema/types/type-defs.js"],"sourcesContent":["const { parse, Kind: GraphQLASTNodeKind } = require(`graphql`)\nimport { isGatsbyType } from \"./type-builders\"\nconst { inferExtensionName, dontInferExtensionName } = require(`../extensions`)\nconst report = require(`gatsby-cli/lib/reporter`)\n\nconst isASTDocument = typeOrTypeDef =>\n  typeof typeOrTypeDef === `object` &&\n  typeOrTypeDef.kind &&\n  GraphQLASTNodeKind.DOCUMENT === typeOrTypeDef.kind\n\n/**\n * Parses type definition represented as an SDL string into an AST Document.\n * Type definitions of other formats (other than SDL) are returned as is\n */\nconst parseTypeDef = typeOrTypeDef => {\n  if (typeof typeOrTypeDef === `string`) {\n    try {\n      return parse(typeOrTypeDef)\n    } catch (error) {\n      reportParsingError(error)\n    }\n  }\n  return typeOrTypeDef\n}\n\nconst reportParsingError = error => {\n  const { message, source, locations } = error\n\n  if (source && locations && locations.length) {\n    const { codeFrameColumns } = require(`@babel/code-frame`)\n\n    const frame = codeFrameColumns(\n      source.body,\n      { start: locations[0] },\n      { linesAbove: 5, linesBelow: 5 }\n    )\n    report.panic(\n      `Encountered an error parsing the provided GraphQL type definitions:\\n` +\n        message +\n        `\\n\\n` +\n        frame +\n        `\\n`\n    )\n  } else {\n    throw error\n  }\n}\n\n/**\n * Given a type definition, collects type names that should skip the inference process\n */\nconst typesWithoutInference = (typeNames = [], typeOrTypeDef) => {\n  if (typeof typeOrTypeDef === `string`) {\n    typeOrTypeDef = parseTypeDef(typeOrTypeDef)\n  }\n  if (isASTDocument(typeOrTypeDef)) {\n    typeOrTypeDef.definitions.forEach(def => {\n      if (!def.directives) return\n\n      def.directives.forEach(directive => {\n        if (directive.name.value === dontInferExtensionName && def.name.value) {\n          typeNames.push(def.name.value)\n        }\n      })\n    })\n    return typeNames\n  }\n  if (isGatsbyType(typeOrTypeDef) && typeOrTypeDef.config) {\n    const { extensions = {}, name } = typeOrTypeDef.config\n    if (\n      name &&\n      (extensions[dontInferExtensionName] ||\n        extensions[inferExtensionName] === false)\n    ) {\n      typeNames.push(name)\n    }\n  }\n  return typeNames\n}\n\nmodule.exports = {\n  parseTypeDef,\n  reportParsingError,\n  typesWithoutInference,\n  isASTDocument,\n}\n"],"mappings":";;AACA;AADA,MAAM;EAAEA,KAAK;EAAEC,IAAI,EAAEC;AAAmB,CAAC,GAAGC,OAAO,CAAE,SAAQ,CAAC;AAE9D,MAAM;EAAEC,kBAAkB;EAAEC;AAAuB,CAAC,GAAGF,OAAO,CAAE,eAAc,CAAC;AAC/E,MAAMG,MAAM,GAAGH,OAAO,CAAE,yBAAwB,CAAC;AAEjD,MAAMI,aAAa,GAAGC,aAAa,IACjC,OAAOA,aAAa,KAAM,QAAO,IACjCA,aAAa,CAACC,IAAI,IAClBP,kBAAkB,CAACQ,QAAQ,KAAKF,aAAa,CAACC,IAAI;;AAEpD;AACA;AACA;AACA;AACA,MAAME,YAAY,GAAGH,aAAa,IAAI;EACpC,IAAI,OAAOA,aAAa,KAAM,QAAO,EAAE;IACrC,IAAI;MACF,OAAOR,KAAK,CAACQ,aAAa,CAAC;IAC7B,CAAC,CAAC,OAAOI,KAAK,EAAE;MACdC,kBAAkB,CAACD,KAAK,CAAC;IAC3B;EACF;EACA,OAAOJ,aAAa;AACtB,CAAC;AAED,MAAMK,kBAAkB,GAAGD,KAAK,IAAI;EAClC,MAAM;IAAEE,OAAO;IAAEC,MAAM;IAAEC;EAAU,CAAC,GAAGJ,KAAK;EAE5C,IAAIG,MAAM,IAAIC,SAAS,IAAIA,SAAS,CAACC,MAAM,EAAE;IAC3C,MAAM;MAAEC;IAAiB,CAAC,GAAGf,OAAO,CAAE,mBAAkB,CAAC;IAEzD,MAAMgB,KAAK,GAAGD,gBAAgB,CAC5BH,MAAM,CAACK,IAAI,EACX;MAAEC,KAAK,EAAEL,SAAS,CAAC,CAAC;IAAE,CAAC,EACvB;MAAEM,UAAU,EAAE,CAAC;MAAEC,UAAU,EAAE;IAAE,CAAC,CACjC;IACDjB,MAAM,CAACkB,KAAK,CACT,uEAAsE,GACrEV,OAAO,GACN,MAAK,GACNK,KAAK,GACJ,IAAG,CACP;EACH,CAAC,MAAM;IACL,MAAMP,KAAK;EACb;AACF,CAAC;;AAED;AACA;AACA;AACA,MAAMa,qBAAqB,GAAG,CAACC,SAAS,GAAG,EAAE,EAAElB,aAAa,KAAK;EAC/D,IAAI,OAAOA,aAAa,KAAM,QAAO,EAAE;IACrCA,aAAa,GAAGG,YAAY,CAACH,aAAa,CAAC;EAC7C;EACA,IAAID,aAAa,CAACC,aAAa,CAAC,EAAE;IAChCA,aAAa,CAACmB,WAAW,CAACC,OAAO,CAACC,GAAG,IAAI;MACvC,IAAI,CAACA,GAAG,CAACC,UAAU,EAAE;MAErBD,GAAG,CAACC,UAAU,CAACF,OAAO,CAACG,SAAS,IAAI;QAClC,IAAIA,SAAS,CAACC,IAAI,CAACC,KAAK,KAAK5B,sBAAsB,IAAIwB,GAAG,CAACG,IAAI,CAACC,KAAK,EAAE;UACrEP,SAAS,CAACQ,IAAI,CAACL,GAAG,CAACG,IAAI,CAACC,KAAK,CAAC;QAChC;MACF,CAAC,CAAC;IACJ,CAAC,CAAC;IACF,OAAOP,SAAS;EAClB;EACA,IAAI,IAAAS,0BAAY,EAAC3B,aAAa,CAAC,IAAIA,aAAa,CAAC4B,MAAM,EAAE;IACvD,MAAM;MAAEC,UAAU,GAAG,CAAC,CAAC;MAAEL;IAAK,CAAC,GAAGxB,aAAa,CAAC4B,MAAM;IACtD,IACEJ,IAAI,KACHK,UAAU,CAAChC,sBAAsB,CAAC,IACjCgC,UAAU,CAACjC,kBAAkB,CAAC,KAAK,KAAK,CAAC,EAC3C;MACAsB,SAAS,CAACQ,IAAI,CAACF,IAAI,CAAC;IACtB;EACF;EACA,OAAON,SAAS;AAClB,CAAC;AAEDY,MAAM,CAACC,OAAO,GAAG;EACf5B,YAAY;EACZE,kBAAkB;EAClBY,qBAAqB;EACrBlB;AACF,CAAC"}

package/dist/schema/types/utils.d.ts

@@ -0,0 +1,33 @@
+import { GraphQLEnumType, GraphQLScalarType } from "graphql";
+import { InputTypeComposer, SchemaComposer, ObjectTypeComposer, EnumTypeComposer, InterfaceTypeComposer, UnionTypeComposer, ScalarTypeComposer, NonNullComposer } from "graphql-compose";
+type Context = any;
+type AnyComposeType<TContext> = ObjectTypeComposer<any, TContext> | InputTypeComposer<TContext> | EnumTypeComposer<TContext> | InterfaceTypeComposer<any, TContext> | UnionTypeComposer<any, TContext> | ScalarTypeComposer<TContext>;
+export declare const SEARCHABLE_ENUM: {
+    readonly SEARCHABLE: "SEARCHABLE";
+    readonly NOT_SEARCHABLE: "NON_SEARCHABLE";
+    readonly DEPRECATED_SEARCHABLE: "DERPECATED_SEARCHABLE";
+};
+export type IVisitContext = {
+    deprecationReason?: string;
+} | undefined | null;
+export type OnEnter = (visitorContext: {
+    fieldName: string;
+    typeComposer: AnyComposeType<Context>;
+}) => IVisitContext;
+export type LeafInput = InputTypeComposer<Context> | NonNullComposer<InputTypeComposer<Context>> | ((arg: {
+    type: GraphQLScalarType | GraphQLEnumType;
+    schemaComposer: SchemaComposer<Context>;
+}) => InputTypeComposer<Context>) | EnumTypeComposer<Context> | NonNullComposer<EnumTypeComposer<Context>>;
+export type ListInput = (arg: {
+    inputTypeComposer: InputTypeComposer;
+    schemaComposer: SchemaComposer<Context>;
+}) => InputTypeComposer<Context>;
+export declare const convertToNestedInputType: ({ schemaComposer, typeComposer, postfix, onEnter, leafInputComposer, listInputComposer, }: {
+    schemaComposer: SchemaComposer<Context>;
+    typeComposer: ObjectTypeComposer<Context> | InterfaceTypeComposer<Context>;
+    postfix: string;
+    onEnter: OnEnter;
+    leafInputComposer: LeafInput;
+    listInputComposer?: ListInput | undefined;
+}) => InputTypeComposer;
+export {};

package/dist/schema/types/utils.js

@@ -0,0 +1,153 @@
+"use strict";
+
+exports.__esModule = true;
+exports.convertToNestedInputType = exports.SEARCHABLE_ENUM = void 0;
+var _graphql = require("graphql");
+var _derivedTypes = require("./derived-types");
+var _graphqlCompose = require("graphql-compose");
+const SEARCHABLE_ENUM = {
+  SEARCHABLE: `SEARCHABLE`,
+  NOT_SEARCHABLE: `NON_SEARCHABLE`,
+  DEPRECATED_SEARCHABLE: `DERPECATED_SEARCHABLE`
+};
+exports.SEARCHABLE_ENUM = SEARCHABLE_ENUM;
+const removeEmptyFields = ({
+  inputTypeComposer
+}, cache = new Set()) => {
+  const convert = itc => {
+    if (cache.has(itc)) {
+      return itc;
+    }
+    cache.add(itc);
+    const fields = itc.getFields();
+    const nonEmptyFields = {};
+    Object.keys(fields).forEach(fieldName => {
+      const fieldITC = fields[fieldName].type;
+      if (fieldITC instanceof _graphqlCompose.InputTypeComposer) {
+        const convertedITC = convert(fieldITC);
+        if (convertedITC.getFieldNames().length) {
+          nonEmptyFields[fieldName] = convertedITC;
+        }
+      } else {
+        nonEmptyFields[fieldName] = fieldITC;
+      }
+    });
+    itc.setFields(nonEmptyFields);
+    return itc;
+  };
+  return convert(inputTypeComposer);
+};
+const convert = ({
+  schemaComposer,
+  typeComposer,
+  inputTypeComposer,
+  preCreatedInputComposer,
+  deprecationReason,
+  postfix,
+  onEnter,
+  leafInputComposer,
+  listInputComposer
+}) => {
+  const inputTypeName = inputTypeComposer.getTypeName().replace(/Input$/, postfix);
+  (0, _derivedTypes.addDerivedType)({
+    typeComposer,
+    derivedTypeName: inputTypeName
+  });
+  let convertedITC;
+  if (preCreatedInputComposer) {
+    convertedITC = preCreatedInputComposer;
+  } else if (schemaComposer.has(inputTypeName)) {
+    return schemaComposer.getITC(inputTypeName);
+  } else {
+    convertedITC = new _graphqlCompose.InputTypeComposer(new _graphql.GraphQLInputObjectType({
+      name: inputTypeName,
+      fields: {}
+    }), schemaComposer);
+  }
+  schemaComposer.add(convertedITC);
+  const fieldNames = inputTypeComposer.getFieldNames();
+  const convertedFields = {};
+  fieldNames.forEach(fieldName => {
+    const maybeContext = onEnter({
+      fieldName,
+      typeComposer
+    });
+    if (maybeContext === null) {
+      return;
+    }
+    const fieldConfig = inputTypeComposer.getFieldConfig(fieldName);
+    const type = (0, _graphql.getNamedType)(fieldConfig.type);
+    if (type instanceof _graphql.GraphQLInputObjectType) {
+      var _maybeContext$depreca;
+      // Input type composers has names `FooInput`, get the type associated
+      // with it
+      const typeComposer = schemaComposer.getAnyTC(type.name.replace(/Input$/, ``));
+      const itc = new _graphqlCompose.InputTypeComposer(type, schemaComposer);
+      const operatorsInputTC = convert({
+        schemaComposer,
+        typeComposer,
+        inputTypeComposer: itc,
+        deprecationReason: (_maybeContext$depreca = maybeContext === null || maybeContext === void 0 ? void 0 : maybeContext.deprecationReason) !== null && _maybeContext$depreca !== void 0 ? _maybeContext$depreca : deprecationReason,
+        postfix,
+        onEnter,
+        leafInputComposer,
+        listInputComposer
+      });
+
+      // TODO: array of arrays?
+      const isListType = (0, _graphql.getNullableType)(fieldConfig.type) instanceof _graphql.GraphQLList;
+      convertedFields[fieldName] = isListType ? typeof listInputComposer === `function` ? listInputComposer({
+        schemaComposer,
+        inputTypeComposer: operatorsInputTC
+      }) : operatorsInputTC : operatorsInputTC;
+    } else {
+      // GraphQLScalarType || GraphQLEnumType
+      const operatorFields = typeof leafInputComposer === `function` ? leafInputComposer({
+        schemaComposer,
+        type
+      }) : leafInputComposer;
+      if (operatorFields) {
+        convertedFields[fieldName] = operatorFields;
+      }
+    }
+    if (convertedFields[fieldName]) {
+      convertedFields[fieldName].deprecationReason = deprecationReason;
+    }
+  });
+  convertedITC.addFields(convertedFields);
+  return convertedITC;
+};
+const convertToNestedInputType = ({
+  schemaComposer,
+  typeComposer,
+  postfix,
+  onEnter,
+  leafInputComposer,
+  listInputComposer
+}) => {
+  const typeName = typeComposer.getTypeName();
+  const preCreatedInputComposer = schemaComposer.getOrCreateITC(`${typeName}${postfix}`);
+  const inputTypeComposer = typeComposer.getInputTypeComposer({
+    fallbackType: null
+  });
+  if (inputTypeComposer !== null && inputTypeComposer !== void 0 && inputTypeComposer.hasField(`id`) && (0, _graphql.getNamedType)(inputTypeComposer.getFieldType(`id`)).name === `ID`) {
+    inputTypeComposer.extendField(`id`, {
+      type: `String`
+    });
+  }
+  const filterInputTC = convert({
+    schemaComposer,
+    typeComposer,
+    inputTypeComposer,
+    preCreatedInputComposer,
+    postfix,
+    onEnter,
+    leafInputComposer,
+    listInputComposer
+  });
+  return removeEmptyFields({
+    inputTypeComposer: filterInputTC
+  });
+};
+exports.convertToNestedInputType = convertToNestedInputType;
+//# sourceMappingURL=utils.js.map

package/dist/schema/types/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["SEARCHABLE_ENUM","SEARCHABLE","NOT_SEARCHABLE","DEPRECATED_SEARCHABLE","removeEmptyFields","inputTypeComposer","cache","Set","convert","itc","has","add","fields","getFields","nonEmptyFields","Object","keys","forEach","fieldName","fieldITC","type","InputTypeComposer","convertedITC","getFieldNames","length","setFields","schemaComposer","typeComposer","preCreatedInputComposer","deprecationReason","postfix","onEnter","leafInputComposer","listInputComposer","inputTypeName","getTypeName","replace","addDerivedType","derivedTypeName","getITC","GraphQLInputObjectType","name","fieldNames","convertedFields","maybeContext","fieldConfig","getFieldConfig","getNamedType","getAnyTC","operatorsInputTC","isListType","getNullableType","GraphQLList","operatorFields","addFields","convertToNestedInputType","typeName","getOrCreateITC","getInputTypeComposer","fallbackType","hasField","getFieldType","extendField","filterInputTC"],"sources":["../../../src/schema/types/utils.ts"],"sourcesContent":["import {\n  getNamedType,\n  getNullableType,\n  GraphQLInputObjectType,\n  GraphQLEnumType,\n  GraphQLList,\n  GraphQLScalarType,\n} from \"graphql\"\nimport { addDerivedType } from \"./derived-types\"\nimport {\n  InputTypeComposer,\n  SchemaComposer,\n  ObjectTypeComposer,\n  EnumTypeComposer,\n  InterfaceTypeComposer,\n  UnionTypeComposer,\n  ScalarTypeComposer,\n  NonNullComposer,\n} from \"graphql-compose\"\n\ntype Context = any\n\ntype AnyComposeType<TContext> =\n  | ObjectTypeComposer<any, TContext>\n  | InputTypeComposer<TContext>\n  | EnumTypeComposer<TContext>\n  | InterfaceTypeComposer<any, TContext>\n  | UnionTypeComposer<any, TContext>\n  | ScalarTypeComposer<TContext>\n\nexport const SEARCHABLE_ENUM = {\n  SEARCHABLE: `SEARCHABLE`,\n  NOT_SEARCHABLE: `NON_SEARCHABLE`,\n  DEPRECATED_SEARCHABLE: `DERPECATED_SEARCHABLE`,\n} as const\n\nconst removeEmptyFields = (\n  { inputTypeComposer }: { inputTypeComposer: InputTypeComposer },\n  cache = new Set()\n): InputTypeComposer => {\n  const convert = (itc: InputTypeComposer): InputTypeComposer => {\n    if (cache.has(itc)) {\n      return itc\n    }\n    cache.add(itc)\n    const fields = itc.getFields()\n    const nonEmptyFields = {}\n    Object.keys(fields).forEach(fieldName => {\n      const fieldITC = fields[fieldName].type\n      if (fieldITC instanceof InputTypeComposer) {\n        const convertedITC = convert(fieldITC)\n        if (convertedITC.getFieldNames().length) {\n          nonEmptyFields[fieldName] = convertedITC\n        }\n      } else {\n        nonEmptyFields[fieldName] = fieldITC\n      }\n    })\n    itc.setFields(nonEmptyFields)\n    return itc\n  }\n  return convert(inputTypeComposer)\n}\n\nexport type IVisitContext =\n  | {\n      deprecationReason?: string\n    }\n  | undefined\n  | null\n\nexport type OnEnter = (visitorContext: {\n  fieldName: string\n  typeComposer: AnyComposeType<Context>\n}) => IVisitContext\n\nexport type LeafInput =\n  | InputTypeComposer<Context>\n  | NonNullComposer<InputTypeComposer<Context>>\n  | ((arg: {\n      type: GraphQLScalarType | GraphQLEnumType\n      schemaComposer: SchemaComposer<Context>\n    }) => InputTypeComposer<Context>)\n  | EnumTypeComposer<Context>\n  | NonNullComposer<EnumTypeComposer<Context>>\n\nexport type ListInput = (arg: {\n  inputTypeComposer: InputTypeComposer\n  schemaComposer: SchemaComposer<Context>\n}) => InputTypeComposer<Context>\n\nconst convert = ({\n  schemaComposer,\n  typeComposer,\n  inputTypeComposer,\n  preCreatedInputComposer,\n  deprecationReason,\n  postfix,\n  onEnter,\n  leafInputComposer,\n  listInputComposer,\n}: {\n  schemaComposer: SchemaComposer<Context>\n  typeComposer: AnyComposeType<Context>\n  inputTypeComposer: InputTypeComposer<Context>\n  preCreatedInputComposer?: InputTypeComposer<Context>\n  deprecationReason?: any\n  postfix: string\n  onEnter: OnEnter\n  leafInputComposer: LeafInput\n  listInputComposer?: ListInput\n}): InputTypeComposer<Context> => {\n  const inputTypeName = inputTypeComposer\n    .getTypeName()\n    .replace(/Input$/, postfix)\n\n  addDerivedType({ typeComposer, derivedTypeName: inputTypeName })\n\n  let convertedITC\n  if (preCreatedInputComposer) {\n    convertedITC = preCreatedInputComposer\n  } else if (schemaComposer.has(inputTypeName)) {\n    return schemaComposer.getITC(inputTypeName)\n  } else {\n    convertedITC = new InputTypeComposer(\n      new GraphQLInputObjectType({\n        name: inputTypeName,\n        fields: {},\n      }),\n      schemaComposer\n    )\n  }\n\n  schemaComposer.add(convertedITC)\n\n  const fieldNames = inputTypeComposer.getFieldNames()\n  const convertedFields = {}\n  fieldNames.forEach(fieldName => {\n    const maybeContext = onEnter({\n      fieldName,\n      typeComposer,\n    })\n\n    if (maybeContext === null) {\n      return\n    }\n\n    const fieldConfig = inputTypeComposer.getFieldConfig(fieldName)\n    const type = getNamedType(fieldConfig.type)\n\n    if (type instanceof GraphQLInputObjectType) {\n      // Input type composers has names `FooInput`, get the type associated\n      // with it\n      const typeComposer = schemaComposer.getAnyTC(\n        type.name.replace(/Input$/, ``)\n      )\n      const itc = new InputTypeComposer(type, schemaComposer)\n\n      const operatorsInputTC = convert({\n        schemaComposer,\n        typeComposer,\n        inputTypeComposer: itc,\n        deprecationReason: maybeContext?.deprecationReason ?? deprecationReason,\n        postfix,\n        onEnter,\n        leafInputComposer,\n        listInputComposer,\n      })\n\n      // TODO: array of arrays?\n      const isListType =\n        getNullableType(fieldConfig.type) instanceof GraphQLList\n\n      convertedFields[fieldName] = isListType\n        ? typeof listInputComposer === `function`\n          ? listInputComposer({\n              schemaComposer,\n              inputTypeComposer: operatorsInputTC,\n            })\n          : operatorsInputTC\n        : operatorsInputTC\n    } else {\n      // GraphQLScalarType || GraphQLEnumType\n      const operatorFields =\n        typeof leafInputComposer === `function`\n          ? leafInputComposer({ schemaComposer, type })\n          : leafInputComposer\n      if (operatorFields) {\n        convertedFields[fieldName] = operatorFields\n      }\n    }\n\n    if (convertedFields[fieldName]) {\n      convertedFields[fieldName].deprecationReason = deprecationReason\n    }\n  })\n\n  convertedITC.addFields(convertedFields)\n  return convertedITC\n}\n\nexport const convertToNestedInputType = ({\n  schemaComposer,\n  typeComposer,\n  postfix,\n  onEnter,\n  leafInputComposer,\n  listInputComposer,\n}: {\n  schemaComposer: SchemaComposer<Context>\n  typeComposer: ObjectTypeComposer<Context> | InterfaceTypeComposer<Context>\n  postfix: string\n  onEnter: OnEnter\n  leafInputComposer: LeafInput\n  listInputComposer?: ListInput\n}): InputTypeComposer => {\n  const typeName = typeComposer.getTypeName()\n  const preCreatedInputComposer = schemaComposer.getOrCreateITC(\n    `${typeName}${postfix}`\n  )\n  const inputTypeComposer = typeComposer.getInputTypeComposer({\n    fallbackType: null,\n  })\n\n  if (\n    inputTypeComposer?.hasField(`id`) &&\n    getNamedType(inputTypeComposer.getFieldType(`id`)).name === `ID`\n  ) {\n    inputTypeComposer.extendField(`id`, { type: `String` })\n  }\n\n  const filterInputTC = convert({\n    schemaComposer,\n    typeComposer,\n    inputTypeComposer,\n    preCreatedInputComposer,\n    postfix,\n    onEnter,\n    leafInputComposer,\n    listInputComposer,\n  })\n\n  return removeEmptyFields({ inputTypeComposer: filterInputTC })\n}\n"],"mappings":"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"}

package/dist/schema/utils.d.ts

@@ -0,0 +1,28 @@
+import { GraphQLSchema, GraphQLObjectType, GraphQLInterfaceType, GraphQLUnionType } from "graphql";
+import { InterfaceTypeComposer, NamedTypeComposer, ObjectTypeComposer, SchemaComposer } from "graphql-compose";
+import type { IGatsbyNodePartial } from "../datastore/in-memory/indexing";
+import { IGatsbyNode } from "../internal";
+export declare const toNodeTypeNames: (schema: GraphQLSchema, gqlTypeName: string | GraphQLObjectType | GraphQLInterfaceType | GraphQLUnionType) => Array<string>;
+export declare function isObjectOrInterfaceTypeComposer(type: NamedTypeComposer<any>): type is ObjectTypeComposer | InterfaceTypeComposer;
+export declare const fieldNeedToResolve: ({ schema, gqlType, typeComposer, schemaComposer, fieldName, }: {
+    schema: GraphQLSchema;
+    gqlType: GraphQLObjectType | GraphQLInterfaceType;
+    typeComposer: ObjectTypeComposer<any> | InterfaceTypeComposer<any>;
+    schemaComposer: SchemaComposer<any>;
+    fieldName: string;
+}) => boolean;
+export declare const fieldPathNeedToResolve: ({ selector, type, }: {
+    selector: string;
+    type: string | GraphQLObjectType | GraphQLInterfaceType;
+}) => boolean;
+export declare function getResolvedFields(node: IGatsbyNode | IGatsbyNodePartial): undefined | Record<string, any>;
+type NestedPathStructure = INestedPathStructureNode | true | "ASC" | "DESC";
+export interface INestedPathStructureNode {
+    [key: string]: NestedPathStructure;
+}
+export declare function pathObjectToPathString(input: INestedPathStructureNode): {
+    path: string;
+    leaf: any;
+};
+export declare function maybeConvertSortInputObjectToSortPath(args: any): any;
+export {};

package/dist/schema/utils.js

@@ -0,0 +1,149 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.fieldPathNeedToResolve = exports.fieldNeedToResolve = void 0;
+exports.getResolvedFields = getResolvedFields;
+exports.isObjectOrInterfaceTypeComposer = isObjectOrInterfaceTypeComposer;
+exports.maybeConvertSortInputObjectToSortPath = maybeConvertSortInputObjectToSortPath;
+exports.pathObjectToPathString = pathObjectToPathString;
+exports.toNodeTypeNames = void 0;
+var _graphql = require("graphql");
+var _graphqlCompose = require("graphql-compose");
+var _isPlainObject = _interopRequireDefault(require("lodash/isPlainObject"));
+var _redux = require("../redux");
+const toNodeTypeNames = (schema, gqlTypeName) => {
+  const gqlType = typeof gqlTypeName === `string` ? schema.getType(gqlTypeName) : gqlTypeName;
+  if (!gqlType || !((0, _graphql.isObjectType)(gqlType) || (0, _graphql.isAbstractType)(gqlType))) {
+    return [];
+  }
+  const possibleTypes = (0, _graphql.isAbstractType)(gqlType) ? schema.getPossibleTypes(gqlType) : [gqlType];
+  return possibleTypes.filter(type => type.getInterfaces().some(iface => iface.name === `Node`)).map(type => type.name);
+};
+exports.toNodeTypeNames = toNodeTypeNames;
+function isObjectOrInterfaceTypeComposer(type) {
+  return type instanceof _graphqlCompose.ObjectTypeComposer || type instanceof _graphqlCompose.InterfaceTypeComposer;
+}
+const fieldNeedToResolve = ({
+  schema,
+  gqlType,
+  typeComposer,
+  schemaComposer,
+  fieldName
+}) => {
+  const nodeTypeNames = toNodeTypeNames(schema, gqlType);
+  const possibleTCs = [typeComposer, ...nodeTypeNames.map(name => schemaComposer.getAnyTC(name)).filter(isObjectOrInterfaceTypeComposer)];
+  for (const tc of possibleTCs) {
+    if (tc.getFieldExtension(fieldName, `needsResolve`) || false) {
+      return true;
+    }
+  }
+  return false;
+};
+exports.fieldNeedToResolve = fieldNeedToResolve;
+const fieldPathNeedToResolve = ({
+  selector,
+  type
+}) => {
+  const {
+    schema,
+    schemaCustomization: {
+      composer: schemaComposer
+    }
+  } = _redux.store.getState();
+  if (!schemaComposer) {
+    throw new Error(`Schema composer isn't set yet`);
+  }
+  const selectors = typeof selector === `string` ? selector.split(`.`) : selector;
+  let gqlType = typeof type === `string` ? schema.getType(type) : type;
+  if (!gqlType || !((0, _graphql.isObjectType)(gqlType) || (0, _graphql.isInterfaceType)(gqlType))) {
+    return false;
+  }
+  for (let i = 0; i < selectors.length; i++) {
+    const fieldName = selectors[i];
+    const typeComposer = schemaComposer.getAnyTC(gqlType.name);
+    if (!isObjectOrInterfaceTypeComposer(typeComposer)) {
+      return false;
+    }
+    if (fieldNeedToResolve({
+      schema,
+      gqlType,
+      typeComposer,
+      schemaComposer,
+      fieldName
+    })) {
+      return true;
+    }
+    const nextType = (0, _graphql.getNamedType)(gqlType.getFields()[fieldName].type);
+    if (!nextType || !((0, _graphql.isObjectType)(nextType) || (0, _graphql.isInterfaceType)(nextType))) {
+      return false;
+    } else {
+      gqlType = nextType;
+    }
+  }
+  return false;
+};
+exports.fieldPathNeedToResolve = fieldPathNeedToResolve;
+function getResolvedFields(node) {
+  const typeName = node.internal.type;
+  const resolvedNodes = _redux.store.getState().resolvedNodesCache.get(typeName);
+  return resolvedNodes === null || resolvedNodes === void 0 ? void 0 : resolvedNodes.get(node.id);
+}
+function pathObjectToPathString(input) {
+  const path = [];
+  let currentValue = input;
+  let leaf = undefined;
+  while (currentValue) {
+    if ((0, _isPlainObject.default)(currentValue)) {
+      const entries = Object.entries(currentValue);
+      if (entries.length !== 1) {
+        throw new Error(`Invalid field arg`);
+      }
+      for (const [key, value] of entries) {
+        path.push(key);
+        currentValue = value;
+      }
+    } else {
+      leaf = currentValue;
+      currentValue = undefined;
+    }
+  }
+  return {
+    path: path.join(`.`),
+    leaf
+  };
+}
+function maybeConvertSortInputObjectToSortPath(args) {
+  if (!args.sort) {
+    return args;
+  }
+  if ("5" === `5`) {
+    var _args$sort, _args$sort2;
+    // check if it's already in expected format
+    if (Array.isArray((_args$sort = args.sort) === null || _args$sort === void 0 ? void 0 : _args$sort.fields) && Array.isArray((_args$sort2 = args.sort) === null || _args$sort2 === void 0 ? void 0 : _args$sort2.order) && args.sort.order.every(item => typeof item === `string` && (item.toLowerCase() === `asc` || item.toLowerCase() === `desc`))) {
+      return args;
+    }
+    let sorts = args.sort;
+    if (!Array.isArray(sorts)) {
+      sorts = [sorts];
+    }
+    const modifiedSort = {
+      fields: [],
+      order: []
+    };
+    for (const sort of sorts) {
+      const {
+        path,
+        leaf
+      } = pathObjectToPathString(sort);
+      modifiedSort.fields.push(path);
+      modifiedSort.order.push(leaf);
+    }
+    return {
+      ...args,
+      sort: modifiedSort
+    };
+  }
+  return args;
+}
+//# sourceMappingURL=utils.js.map

package/dist/schema/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["toNodeTypeNames","schema","gqlTypeName","gqlType","getType","isObjectType","isAbstractType","possibleTypes","getPossibleTypes","filter","type","getInterfaces","some","iface","name","map","isObjectOrInterfaceTypeComposer","ObjectTypeComposer","InterfaceTypeComposer","fieldNeedToResolve","typeComposer","schemaComposer","fieldName","nodeTypeNames","possibleTCs","getAnyTC","tc","getFieldExtension","fieldPathNeedToResolve","selector","schemaCustomization","composer","store","getState","Error","selectors","split","isInterfaceType","i","length","nextType","getNamedType","getFields","getResolvedFields","node","typeName","internal","resolvedNodes","resolvedNodesCache","get","id","pathObjectToPathString","input","path","currentValue","leaf","undefined","isPlainObject","entries","Object","key","value","push","join","maybeConvertSortInputObjectToSortPath","args","sort","Array","isArray","fields","order","every","item","toLowerCase","sorts","modifiedSort"],"sources":["../../src/schema/utils.ts"],"sourcesContent":["import {\n  isAbstractType,\n  getNamedType,\n  GraphQLSchema,\n  isObjectType,\n  isInterfaceType,\n  GraphQLObjectType,\n  GraphQLInterfaceType,\n  GraphQLUnionType,\n} from \"graphql\"\nimport {\n  InterfaceTypeComposer,\n  NamedTypeComposer,\n  ObjectTypeComposer,\n  SchemaComposer,\n} from \"graphql-compose\"\nimport isPlainObject from \"lodash/isPlainObject\"\n\nimport type { IGatsbyNodePartial } from \"../datastore/in-memory/indexing\"\nimport { IGatsbyNode } from \"../internal\"\nimport { store } from \"../redux\"\n\nexport const toNodeTypeNames = (\n  schema: GraphQLSchema,\n  gqlTypeName:\n    | string\n    | GraphQLObjectType\n    | GraphQLInterfaceType\n    | GraphQLUnionType\n): Array<string> => {\n  const gqlType =\n    typeof gqlTypeName === `string` ? schema.getType(gqlTypeName) : gqlTypeName\n\n  if (!gqlType || !(isObjectType(gqlType) || isAbstractType(gqlType))) {\n    return []\n  }\n\n  const possibleTypes = isAbstractType(gqlType)\n    ? schema.getPossibleTypes(gqlType)\n    : [gqlType]\n\n  return possibleTypes\n    .filter(type => type.getInterfaces().some(iface => iface.name === `Node`))\n    .map(type => type.name)\n}\n\nexport function isObjectOrInterfaceTypeComposer(\n  type: NamedTypeComposer<any>\n): type is ObjectTypeComposer | InterfaceTypeComposer {\n  return (\n    type instanceof ObjectTypeComposer || type instanceof InterfaceTypeComposer\n  )\n}\n\nexport const fieldNeedToResolve = ({\n  schema,\n  gqlType,\n  typeComposer,\n  schemaComposer,\n  fieldName,\n}: {\n  schema: GraphQLSchema\n  gqlType: GraphQLObjectType | GraphQLInterfaceType\n  typeComposer: ObjectTypeComposer<any> | InterfaceTypeComposer<any>\n  schemaComposer: SchemaComposer<any>\n  fieldName: string\n}): boolean => {\n  const nodeTypeNames = toNodeTypeNames(schema, gqlType)\n\n  const possibleTCs: Array<ObjectTypeComposer | InterfaceTypeComposer> = [\n    typeComposer,\n    ...nodeTypeNames\n      .map(name => schemaComposer.getAnyTC(name))\n      .filter(isObjectOrInterfaceTypeComposer),\n  ]\n\n  for (const tc of possibleTCs) {\n    if (tc.getFieldExtension(fieldName, `needsResolve`) || false) {\n      return true\n    }\n  }\n\n  return false\n}\n\nexport const fieldPathNeedToResolve = ({\n  selector,\n  type,\n}: {\n  selector: string\n  type: string | GraphQLObjectType | GraphQLInterfaceType\n}): boolean => {\n  const {\n    schema,\n    schemaCustomization: { composer: schemaComposer },\n  } = store.getState()\n\n  if (!schemaComposer) {\n    throw new Error(`Schema composer isn't set yet`)\n  }\n\n  const selectors =\n    typeof selector === `string` ? selector.split(`.`) : selector\n\n  let gqlType = typeof type === `string` ? schema.getType(type) : type\n\n  if (!gqlType || !(isObjectType(gqlType) || isInterfaceType(gqlType))) {\n    return false\n  }\n\n  for (let i = 0; i < selectors.length; i++) {\n    const fieldName = selectors[i]\n    const typeComposer = schemaComposer.getAnyTC(gqlType.name)\n\n    if (!isObjectOrInterfaceTypeComposer(typeComposer)) {\n      return false\n    }\n\n    if (\n      fieldNeedToResolve({\n        schema,\n        gqlType,\n        typeComposer,\n        schemaComposer,\n        fieldName,\n      })\n    ) {\n      return true\n    }\n\n    const nextType = getNamedType(gqlType.getFields()[fieldName].type)\n    if (!nextType || !(isObjectType(nextType) || isInterfaceType(nextType))) {\n      return false\n    } else {\n      gqlType = nextType\n    }\n  }\n\n  return false\n}\n\nexport function getResolvedFields(\n  node: IGatsbyNode | IGatsbyNodePartial\n): undefined | Record<string, any> {\n  const typeName = node.internal.type\n  const resolvedNodes = store.getState().resolvedNodesCache.get(typeName)\n  return resolvedNodes?.get(node.id)\n}\n\ntype NestedPathStructure = INestedPathStructureNode | true | \"ASC\" | \"DESC\"\n\nexport interface INestedPathStructureNode {\n  [key: string]: NestedPathStructure\n}\n\nexport function pathObjectToPathString(input: INestedPathStructureNode): {\n  path: string\n  leaf: any\n} {\n  const path: Array<string> = []\n  let currentValue: NestedPathStructure | undefined = input\n  let leaf: any = undefined\n  while (currentValue) {\n    if (isPlainObject(currentValue)) {\n      const entries = Object.entries(currentValue)\n      if (entries.length !== 1) {\n        throw new Error(`Invalid field arg`)\n      }\n      for (const [key, value] of entries) {\n        path.push(key)\n        currentValue = value\n      }\n    } else {\n      leaf = currentValue\n      currentValue = undefined\n    }\n  }\n\n  return {\n    path: path.join(`.`),\n    leaf,\n  }\n}\n\nexport function maybeConvertSortInputObjectToSortPath(args: any): any {\n  if (!args.sort) {\n    return args\n  }\n\n  if (_CFLAGS_.GATSBY_MAJOR === `5`) {\n    // check if it's already in expected format\n    if (\n      Array.isArray(args.sort?.fields) &&\n      Array.isArray(args.sort?.order) &&\n      args.sort.order.every(\n        item =>\n          typeof item === `string` &&\n          (item.toLowerCase() === `asc` || item.toLowerCase() === `desc`)\n      )\n    ) {\n      return args\n    }\n\n    let sorts = args.sort\n\n    if (!Array.isArray(sorts)) {\n      sorts = [sorts]\n    }\n\n    const modifiedSort: any = {\n      fields: [],\n      order: [],\n    }\n\n    for (const sort of sorts) {\n      const { path, leaf } = pathObjectToPathString(sort)\n      modifiedSort.fields.push(path)\n      modifiedSort.order.push(leaf)\n    }\n\n    return {\n      ...args,\n      sort: modifiedSort,\n    }\n  }\n\n  return args\n}\n"],"mappings":"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"}

package/dist/services/build-schema.d.ts

@@ -0,0 +1,2 @@
+import { IDataLayerContext } from "../state-machines/data-layer/types";
+export declare function buildSchema({ parentSpan, refresh, }: Partial<IDataLayerContext>): Promise<void>;

package/dist/services/build-schema.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.buildSchema = buildSchema;
+var _schema = require("../schema");
+var _reporter = _interopRequireDefault(require("gatsby-cli/lib/reporter"));
+async function buildSchema({
+  parentSpan,
+  refresh
+}) {
+  if (refresh && Boolean(process.env.GATSBY_EXPERIMENTAL_DISABLE_SCHEMA_REBUILD)) {
+    return;
+  }
+  const activity = _reporter.default.activityTimer(`building schema`, {
+    parentSpan
+  });
+  activity.start();
+  await (0, _schema.build)({
+    parentSpan: activity.span
+  });
+  activity.end();
+}
+//# sourceMappingURL=build-schema.js.map