@khanacademy/graphql-flow 0.0.1

package/dist/types.js.flow

@@ -0,0 +1,54 @@
+// @flow
+
+import type {
+    FragmentDefinitionNode,
+    IntrospectionEnumType,
+    IntrospectionField,
+    IntrospectionInputObjectType,
+    IntrospectionInterfaceType,
+    IntrospectionObjectType,
+    IntrospectionUnionType,
+    SelectionNode,
+} from 'graphql';
+
+export type Selections = $ReadOnlyArray<SelectionNode>;
+
+export type Options = {|
+    strictNullability?: boolean, // default true
+    readOnlyArray?: boolean, // default true
+    scalars?: Scalars,
+|};
+
+export type Schema = {
+    interfacesByName: {
+        [key: string]: IntrospectionInterfaceType & {
+            fieldsByName: {[key: string]: IntrospectionField},
+            possibleTypesByName: {[key: string]: boolean},
+        },
+    },
+    inputObjectsByName: {
+        [key: string]: IntrospectionInputObjectType,
+    },
+    typesByName: {
+        [key: string]: IntrospectionObjectType & {
+            fieldsByName: {[key: string]: IntrospectionField},
+        },
+    },
+    unionsByName: {
+        [key: string]: IntrospectionUnionType,
+    },
+    enumsByName: {
+        [key: string]: IntrospectionEnumType,
+    },
+};
+
+export type Config = {
+    strictNullability: boolean,
+    readOnlyArray: boolean,
+    fragments: {[key: string]: FragmentDefinitionNode},
+
+    schema: Schema,
+    scalars: Scalars,
+    errors: Array<string>,
+};
+export type Scalars = {[key: string]: 'string' | 'number' | 'boolean'};

package/dist/utils.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addCommentAsLineComments = addCommentAsLineComments;
+exports.transferLeadingComments = exports.maybeAddDescriptionComment = exports.liftLeadingPropertyComments = void 0;
+
+var babelTypes = _interopRequireWildcard(require("@babel/types"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const liftLeadingPropertyComments = property => {
+  return transferLeadingComments(property.value, property);
+};
+
+exports.liftLeadingPropertyComments = liftLeadingPropertyComments;
+
+const maybeAddDescriptionComment = (description, node) => {
+  if (description) {
+    addCommentAsLineComments(description, node);
+  }
+
+  return node;
+};
+
+exports.maybeAddDescriptionComment = maybeAddDescriptionComment;
+
+function addCommentAsLineComments(description, res) {
+  var _res$leadingComments;
+
+  if ((_res$leadingComments = res.leadingComments) !== null && _res$leadingComments !== void 0 && _res$leadingComments.length) {
+    res.leadingComments[0].value += '\n\n---\n\n' + description;
+  } else {
+    babelTypes.addComment(res, 'leading', '* ' + description, false // this specifies that it's a block comment, not a line comment
+    );
+  }
+}
+
+const transferLeadingComments = (source, dest) => {
+  var _source$leadingCommen;
+
+  if ((_source$leadingCommen = source.leadingComments) !== null && _source$leadingCommen !== void 0 && _source$leadingCommen.length) {
+    dest.leadingComments = [...(dest.leadingComments || []), ...source.leadingComments];
+    source.leadingComments = [];
+  }
+
+  return dest;
+};
+
+exports.transferLeadingComments = transferLeadingComments;

package/dist/utils.js.flow

@@ -0,0 +1,50 @@
+// @flow
+
+import * as babelTypes from '@babel/types';
+import {BabelNodeObjectTypeProperty} from '@babel/types';
+
+export const liftLeadingPropertyComments = (
+    property: BabelNodeObjectTypeProperty,
+): BabelNodeObjectTypeProperty => {
+    return transferLeadingComments(property.value, property);
+};
+
+export const maybeAddDescriptionComment = <T: babelTypes.BabelNode>(
+    description: ?string,
+    node: T,
+): T => {
+    if (description) {
+        addCommentAsLineComments(description, node);
+    }
+    return node;
+};
+
+export function addCommentAsLineComments(
+    description: string,
+    res: babelTypes.BabelNode,
+) {
+    if (res.leadingComments?.length) {
+        res.leadingComments[0].value += '\n\n---\n\n' + description;
+    } else {
+        babelTypes.addComment(
+            res,
+            'leading',
+            '* ' + description,
+            false, // this specifies that it's a block comment, not a line comment
+        );
+    }
+}
+
+export const transferLeadingComments = <T: babelTypes.BabelNode>(
+    source: babelTypes.BabelNode,
+    dest: T,
+): T => {
+    if (source.leadingComments?.length) {
+        dest.leadingComments = [
+            ...(dest.leadingComments || []),
+            ...source.leadingComments,
+        ];
+        source.leadingComments = [];
+    }
+    return dest;
+};