graphql 0.0.1-test.1

package/utilities/astFromValue.mjs

@@ -0,0 +1,177 @@
+import { inspect } from '../jsutils/inspect.mjs';
+import { invariant } from '../jsutils/invariant.mjs';
+import { isIterableObject } from '../jsutils/isIterableObject.mjs';
+import { isObjectLike } from '../jsutils/isObjectLike.mjs';
+import { Kind } from '../language/kinds.mjs';
+import {
+  isEnumType,
+  isInputObjectType,
+  isLeafType,
+  isListType,
+  isNonNullType,
+} from '../type/definition.mjs';
+import { GraphQLID } from '../type/scalars.mjs';
+/**
+ * Produces a GraphQL Value AST given a JavaScript object.
+ * Function will match JavaScript/JSON values to GraphQL AST schema format
+ * by using suggested GraphQLInputType. For example:
+ *
+ *     astFromValue("value", GraphQLString)
+ *
+ * A GraphQL type must be provided, which will be used to interpret different
+ * JavaScript values.
+ *
+ * | JSON Value    | GraphQL Value        |
+ * | ------------- | -------------------- |
+ * | Object        | Input Object         |
+ * | Array         | List                 |
+ * | Boolean       | Boolean              |
+ * | String        | String / Enum Value  |
+ * | Number        | Int / Float          |
+ * | Unknown       | Enum Value           |
+ * | null          | NullValue            |
+ *
+ */
+
+export function astFromValue(value, type) {
+  if (isNonNullType(type)) {
+    const astValue = astFromValue(value, type.ofType);
+
+    if (
+      (astValue === null || astValue === void 0 ? void 0 : astValue.kind) ===
+      Kind.NULL
+    ) {
+      return null;
+    }
+
+    return astValue;
+  } // only explicit null, not undefined, NaN
+
+  if (value === null) {
+    return {
+      kind: Kind.NULL,
+    };
+  } // undefined
+
+  if (value === undefined) {
+    return null;
+  } // Convert JavaScript array to GraphQL list. If the GraphQLType is a list, but
+  // the value is not an array, convert the value using the list's item type.
+
+  if (isListType(type)) {
+    const itemType = type.ofType;
+
+    if (isIterableObject(value)) {
+      const valuesNodes = [];
+
+      for (const item of value) {
+        const itemNode = astFromValue(item, itemType);
+
+        if (itemNode != null) {
+          valuesNodes.push(itemNode);
+        }
+      }
+
+      return {
+        kind: Kind.LIST,
+        values: valuesNodes,
+      };
+    }
+
+    return astFromValue(value, itemType);
+  } // Populate the fields of the input object by creating ASTs from each value
+  // in the JavaScript object according to the fields in the input type.
+
+  if (isInputObjectType(type)) {
+    if (!isObjectLike(value)) {
+      return null;
+    }
+
+    const fieldNodes = [];
+
+    for (const field of Object.values(type.getFields())) {
+      const fieldValue = astFromValue(value[field.name], field.type);
+
+      if (fieldValue) {
+        fieldNodes.push({
+          kind: Kind.OBJECT_FIELD,
+          name: {
+            kind: Kind.NAME,
+            value: field.name,
+          },
+          value: fieldValue,
+        });
+      }
+    }
+
+    return {
+      kind: Kind.OBJECT,
+      fields: fieldNodes,
+    };
+  }
+
+  if (isLeafType(type)) {
+    // Since value is an internally represented value, it must be serialized
+    // to an externally represented value before converting into an AST.
+    const serialized = type.serialize(value);
+
+    if (serialized == null) {
+      return null;
+    } // Others serialize based on their corresponding JavaScript scalar types.
+
+    if (typeof serialized === 'boolean') {
+      return {
+        kind: Kind.BOOLEAN,
+        value: serialized,
+      };
+    } // JavaScript numbers can be Int or Float values.
+
+    if (typeof serialized === 'number' && Number.isFinite(serialized)) {
+      const stringNum = String(serialized);
+      return integerStringRegExp.test(stringNum)
+        ? {
+            kind: Kind.INT,
+            value: stringNum,
+          }
+        : {
+            kind: Kind.FLOAT,
+            value: stringNum,
+          };
+    }
+
+    if (typeof serialized === 'string') {
+      // Enum types use Enum literals.
+      if (isEnumType(type)) {
+        return {
+          kind: Kind.ENUM,
+          value: serialized,
+        };
+      } // ID types can use Int literals.
+
+      if (type === GraphQLID && integerStringRegExp.test(serialized)) {
+        return {
+          kind: Kind.INT,
+          value: serialized,
+        };
+      }
+
+      return {
+        kind: Kind.STRING,
+        value: serialized,
+      };
+    }
+
+    throw new TypeError(`Cannot convert value to AST: ${inspect(serialized)}.`);
+  }
+  /* c8 ignore next 3 */
+  // Not reachable, all possible types have been considered.
+
+  false || invariant(false, 'Unexpected input type: ' + inspect(type));
+}
+/**
+ * IntValue:
+ *   - NegativeSign? 0
+ *   - NegativeSign? NonZeroDigit ( Digit+ )?
+ */
+
+const integerStringRegExp = /^-?(?:0|[1-9][0-9]*)$/;

package/utilities/buildASTSchema.d.ts

@@ -0,0 +1,35 @@
+import type { DocumentNode } from '../language/ast';
+import type { ParseOptions } from '../language/parser';
+import type { Source } from '../language/source';
+import type { GraphQLSchemaValidationOptions } from '../type/schema';
+import { GraphQLSchema } from '../type/schema';
+export interface BuildSchemaOptions extends GraphQLSchemaValidationOptions {
+  /**
+   * Set to true to assume the SDL is valid.
+   *
+   * Default: false
+   */
+  assumeValidSDL?: boolean;
+}
+/**
+ * This takes the ast of a schema document produced by the parse function in
+ * src/language/parser.js.
+ *
+ * If no schema definition is provided, then it will look for types named Query,
+ * Mutation and Subscription.
+ *
+ * Given that AST it constructs a GraphQLSchema. The resulting schema
+ * has no resolve methods, so execution will use default resolvers.
+ */
+export declare function buildASTSchema(
+  documentAST: DocumentNode,
+  options?: BuildSchemaOptions,
+): GraphQLSchema;
+/**
+ * A helper function to build a GraphQLSchema directly from a source
+ * document.
+ */
+export declare function buildSchema(
+  source: string | Source,
+  options?: BuildSchemaOptions & ParseOptions,
+): GraphQLSchema;

package/utilities/buildASTSchema.js

@@ -0,0 +1,115 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.buildASTSchema = buildASTSchema;
+exports.buildSchema = buildSchema;
+
+var _devAssert = require('../jsutils/devAssert.js');
+
+var _kinds = require('../language/kinds.js');
+
+var _parser = require('../language/parser.js');
+
+var _directives = require('../type/directives.js');
+
+var _schema = require('../type/schema.js');
+
+var _validate = require('../validation/validate.js');
+
+var _extendSchema = require('./extendSchema.js');
+
+/**
+ * This takes the ast of a schema document produced by the parse function in
+ * src/language/parser.js.
+ *
+ * If no schema definition is provided, then it will look for types named Query,
+ * Mutation and Subscription.
+ *
+ * Given that AST it constructs a GraphQLSchema. The resulting schema
+ * has no resolve methods, so execution will use default resolvers.
+ */
+function buildASTSchema(documentAST, options) {
+  (documentAST != null && documentAST.kind === _kinds.Kind.DOCUMENT) ||
+    (0, _devAssert.devAssert)(false, 'Must provide valid Document AST.');
+
+  if (
+    (options === null || options === void 0 ? void 0 : options.assumeValid) !==
+      true &&
+    (options === null || options === void 0
+      ? void 0
+      : options.assumeValidSDL) !== true
+  ) {
+    (0, _validate.assertValidSDL)(documentAST);
+  }
+
+  const emptySchemaConfig = {
+    description: undefined,
+    types: [],
+    directives: [],
+    extensions: Object.create(null),
+    extensionASTNodes: [],
+    assumeValid: false,
+  };
+  const config = (0, _extendSchema.extendSchemaImpl)(
+    emptySchemaConfig,
+    documentAST,
+    options,
+  );
+
+  if (config.astNode == null) {
+    for (const type of config.types) {
+      switch (type.name) {
+        // Note: While this could make early assertions to get the correctly
+        // typed values below, that would throw immediately while type system
+        // validation with validateSchema() will produce more actionable results.
+        case 'Query':
+          // @ts-expect-error validated in `validateSchema`
+          config.query = type;
+          break;
+
+        case 'Mutation':
+          // @ts-expect-error validated in `validateSchema`
+          config.mutation = type;
+          break;
+
+        case 'Subscription':
+          // @ts-expect-error validated in `validateSchema`
+          config.subscription = type;
+          break;
+      }
+    }
+  }
+
+  const directives = [
+    ...config.directives, // If specified directives were not explicitly declared, add them.
+    ..._directives.specifiedDirectives.filter((stdDirective) =>
+      config.directives.every(
+        (directive) => directive.name !== stdDirective.name,
+      ),
+    ),
+  ];
+  return new _schema.GraphQLSchema({ ...config, directives });
+}
+/**
+ * A helper function to build a GraphQLSchema directly from a source
+ * document.
+ */
+
+function buildSchema(source, options) {
+  const document = (0, _parser.parse)(source, {
+    noLocation:
+      options === null || options === void 0 ? void 0 : options.noLocation,
+    allowLegacyFragmentVariables:
+      options === null || options === void 0
+        ? void 0
+        : options.allowLegacyFragmentVariables,
+  });
+  return buildASTSchema(document, {
+    assumeValidSDL:
+      options === null || options === void 0 ? void 0 : options.assumeValidSDL,
+    assumeValid:
+      options === null || options === void 0 ? void 0 : options.assumeValid,
+  });
+}

package/utilities/buildASTSchema.mjs

@@ -0,0 +1,97 @@
+import { devAssert } from '../jsutils/devAssert.mjs';
+import { Kind } from '../language/kinds.mjs';
+import { parse } from '../language/parser.mjs';
+import { specifiedDirectives } from '../type/directives.mjs';
+import { GraphQLSchema } from '../type/schema.mjs';
+import { assertValidSDL } from '../validation/validate.mjs';
+import { extendSchemaImpl } from './extendSchema.mjs';
+
+/**
+ * This takes the ast of a schema document produced by the parse function in
+ * src/language/parser.js.
+ *
+ * If no schema definition is provided, then it will look for types named Query,
+ * Mutation and Subscription.
+ *
+ * Given that AST it constructs a GraphQLSchema. The resulting schema
+ * has no resolve methods, so execution will use default resolvers.
+ */
+export function buildASTSchema(documentAST, options) {
+  (documentAST != null && documentAST.kind === Kind.DOCUMENT) ||
+    devAssert(false, 'Must provide valid Document AST.');
+
+  if (
+    (options === null || options === void 0 ? void 0 : options.assumeValid) !==
+      true &&
+    (options === null || options === void 0
+      ? void 0
+      : options.assumeValidSDL) !== true
+  ) {
+    assertValidSDL(documentAST);
+  }
+
+  const emptySchemaConfig = {
+    description: undefined,
+    types: [],
+    directives: [],
+    extensions: Object.create(null),
+    extensionASTNodes: [],
+    assumeValid: false,
+  };
+  const config = extendSchemaImpl(emptySchemaConfig, documentAST, options);
+
+  if (config.astNode == null) {
+    for (const type of config.types) {
+      switch (type.name) {
+        // Note: While this could make early assertions to get the correctly
+        // typed values below, that would throw immediately while type system
+        // validation with validateSchema() will produce more actionable results.
+        case 'Query':
+          // @ts-expect-error validated in `validateSchema`
+          config.query = type;
+          break;
+
+        case 'Mutation':
+          // @ts-expect-error validated in `validateSchema`
+          config.mutation = type;
+          break;
+
+        case 'Subscription':
+          // @ts-expect-error validated in `validateSchema`
+          config.subscription = type;
+          break;
+      }
+    }
+  }
+
+  const directives = [
+    ...config.directives, // If specified directives were not explicitly declared, add them.
+    ...specifiedDirectives.filter((stdDirective) =>
+      config.directives.every(
+        (directive) => directive.name !== stdDirective.name,
+      ),
+    ),
+  ];
+  return new GraphQLSchema({ ...config, directives });
+}
+/**
+ * A helper function to build a GraphQLSchema directly from a source
+ * document.
+ */
+
+export function buildSchema(source, options) {
+  const document = parse(source, {
+    noLocation:
+      options === null || options === void 0 ? void 0 : options.noLocation,
+    allowLegacyFragmentVariables:
+      options === null || options === void 0
+        ? void 0
+        : options.allowLegacyFragmentVariables,
+  });
+  return buildASTSchema(document, {
+    assumeValidSDL:
+      options === null || options === void 0 ? void 0 : options.assumeValidSDL,
+    assumeValid:
+      options === null || options === void 0 ? void 0 : options.assumeValid,
+  });
+}

package/utilities/buildClientSchema.d.ts

@@ -0,0 +1,19 @@
+import type { GraphQLSchemaValidationOptions } from '../type/schema';
+import { GraphQLSchema } from '../type/schema';
+import type { IntrospectionQuery } from './getIntrospectionQuery';
+/**
+ * Build a GraphQLSchema for use by client tools.
+ *
+ * Given the result of a client running the introspection query, creates and
+ * returns a GraphQLSchema instance which can be then used with all graphql-js
+ * tools, but cannot be used to execute a query, as introspection does not
+ * represent the "resolver", "parse" or "serialize" functions or any other
+ * server-internal mechanisms.
+ *
+ * This function expects a complete introspection result. Don't forget to check
+ * the "errors" field of a server response before calling this function.
+ */
+export declare function buildClientSchema(
+  introspection: IntrospectionQuery,
+  options?: GraphQLSchemaValidationOptions,
+): GraphQLSchema;