@ardatan/relay-compiler 12.0.0

package/lib/transforms/query-generators/FetchableQueryGenerator.js

@@ -0,0 +1,157 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var SchemaUtils = require('../../core/SchemaUtils');
+
+var _require = require('../../core/CompilerError'),
+    createUserError = _require.createUserError;
+
+var _require2 = require('./utils'),
+    buildFragmentSpread = _require2.buildFragmentSpread,
+    buildOperationArgumentDefinitions = _require2.buildOperationArgumentDefinitions;
+
+function buildRefetchOperation(schema, fragment, queryName) {
+  var fetchableIdentifierField = null;
+
+  if (schema.isObject(fragment.type)) {
+    var objectType = schema.assertObjectType(fragment.type);
+    fetchableIdentifierField = schema.getFetchableFieldName(objectType);
+  }
+
+  if (fetchableIdentifierField == null) {
+    return null;
+  }
+
+  var identifierField = schema.getFieldConfig(schema.expectField(fragment.type, fetchableIdentifierField));
+
+  if (!schema.isId(schema.getRawType(identifierField.type))) {
+    var typeName = schema.getTypeString(fragment.type);
+    throw createUserError("Invalid use of @refetchable on fragment '".concat(fragment.name, "', the type ") + "'".concat(typeName, "' is @fetchable but the identifying field '").concat(fetchableIdentifierField, "' ") + "does not have type 'ID'.", [fragment.loc]);
+  }
+
+  var queryType = schema.expectQueryType();
+  var fetchFieldName = "fetch__".concat(schema.getTypeString(fragment.type));
+  var fetchField = schema.getFieldConfig(schema.expectField(queryType, fetchFieldName));
+
+  if (!(fetchField != null && schema.isObject(fetchField.type) && schema.areEqualTypes(fetchField.type, fragment.type) && schema.areEqualTypes(schema.getNullableType(fetchField.args[0].type), schema.expectIdType()))) {
+    var _typeName = schema.getTypeString(fragment.type);
+
+    throw createUserError("Invalid use of @refetchable on fragment '".concat(fragment.name, "', the type ") + "'".concat(_typeName, "' is @fetchable but there is no corresponding '").concat(fetchFieldName, "'") + "field or it is invalid (expected '".concat(fetchFieldName, "(id: ID!): ").concat(_typeName, "')."), [fragment.loc]);
+  } // name and type of the node(_: ID) field parameter
+
+
+  var idArgName = fetchField.args[0].name;
+  var idArgType = fetchField.args[0].type; // name and type of the query variable
+
+  var idVariableType = SchemaUtils.getNonNullIdInput(schema);
+  var idVariableName = 'id';
+  var argumentDefinitions = buildOperationArgumentDefinitions(fragment.argumentDefinitions);
+  var idArgument = argumentDefinitions.find(function (argDef) {
+    return argDef.name === idVariableName;
+  });
+
+  if (idArgument != null) {
+    throw createUserError("Invalid use of @refetchable on fragment `".concat(fragment.name, "`, this ") + 'fragment already has an `$id` variable in scope.', [idArgument.loc]);
+  }
+
+  var argumentDefinitionsWithId = [].concat((0, _toConsumableArray2["default"])(argumentDefinitions), [{
+    defaultValue: null,
+    kind: 'LocalArgumentDefinition',
+    loc: {
+      kind: 'Derived',
+      source: fragment.loc
+    },
+    name: idVariableName,
+    type: idVariableType
+  }]);
+  return {
+    identifierField: fetchableIdentifierField,
+    path: [fetchFieldName],
+    node: {
+      argumentDefinitions: argumentDefinitionsWithId,
+      directives: [],
+      kind: 'Root',
+      loc: {
+        kind: 'Derived',
+        source: fragment.loc
+      },
+      metadata: null,
+      name: queryName,
+      operation: 'query',
+      selections: [{
+        alias: fetchFieldName,
+        args: [{
+          kind: 'Argument',
+          loc: {
+            kind: 'Derived',
+            source: fragment.loc
+          },
+          name: idArgName,
+          type: schema.assertInputType(idArgType),
+          value: {
+            kind: 'Variable',
+            loc: {
+              kind: 'Derived',
+              source: fragment.loc
+            },
+            variableName: idVariableName,
+            type: idVariableType
+          }
+        }],
+        connection: false,
+        directives: [],
+        handles: null,
+        kind: 'LinkedField',
+        loc: {
+          kind: 'Derived',
+          source: fragment.loc
+        },
+        metadata: null,
+        name: fetchFieldName,
+        selections: [buildFragmentSpread(fragment)],
+        type: fragment.type
+      }],
+      type: queryType
+    },
+    transformedFragment: enforceIDField(schema, fragment, fetchableIdentifierField)
+  };
+}
+
+function enforceIDField(schema, fragment, fetchableIdentifierField) {
+  var idSelection = fragment.selections.find(function (selection) {
+    return selection.kind === 'ScalarField' && selection.name === fetchableIdentifierField && selection.alias === fetchableIdentifierField && schema.areEqualTypes(schema.getNullableType(selection.type), schema.expectIdType());
+  });
+
+  if (idSelection) {
+    return fragment;
+  }
+
+  var idField = SchemaUtils.generateIDField(schema, fragment.type); // idField is uniquely owned here, safe to mutate
+
+  idField.alias = fetchableIdentifierField; // idField is uniquely owned here, safe to mutate
+
+  idField.name = fetchableIdentifierField;
+  return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, fragment), {}, {
+    selections: [].concat((0, _toConsumableArray2["default"])(fragment.selections), [idField])
+  });
+}
+
+module.exports = {
+  description: '@fetchable types',
+  buildRefetchOperation: buildRefetchOperation
+};

package/lib/transforms/query-generators/NodeQueryGenerator.js

@@ -0,0 +1,166 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var SchemaUtils = require('../../core/SchemaUtils');
+
+var nullthrows = require('nullthrows');
+
+var _require = require('../../core/CompilerError'),
+    createUserError = _require.createUserError;
+
+var _require2 = require('./utils'),
+    buildFragmentSpread = _require2.buildFragmentSpread,
+    buildOperationArgumentDefinitions = _require2.buildOperationArgumentDefinitions;
+
+var NODE_TYPE_NAME = 'Node';
+var NODE_FIELD_NAME = 'node';
+
+function buildRefetchOperation(schema, fragment, queryName) {
+  var eligible = schema.getTypeString(fragment.type) === NODE_TYPE_NAME || schema.isObject(fragment.type) && schema.getInterfaces(schema.assertCompositeType(fragment.type)).some(function (interfaceType) {
+    return schema.areEqualTypes(interfaceType, schema.expectTypeFromString(NODE_TYPE_NAME));
+  }) || schema.isAbstractType(fragment.type) && Array.from(schema.getPossibleTypes(schema.assertAbstractType(fragment.type))).every(function (possibleType) {
+    return schema.implementsInterface(schema.assertCompositeType(possibleType), schema.assertInterfaceType(schema.expectTypeFromString(NODE_TYPE_NAME)));
+  });
+
+  if (!eligible) {
+    return null;
+  }
+
+  var queryType = schema.expectQueryType();
+  var nodeType = schema.getTypeFromString(NODE_TYPE_NAME);
+  var nodeField = schema.getFieldConfig(schema.expectField(queryType, NODE_FIELD_NAME));
+
+  if (!(nodeType && schema.isInterface(nodeType) && schema.isInterface(nodeField.type) && schema.areEqualTypes(nodeField.type, nodeType) && nodeField.args.length === 1 && schema.areEqualTypes(schema.getNullableType(nodeField.args[0].type), schema.expectIdType()) && ( // the fragment must be on Node or on a type that implements Node
+  schema.isObject(fragment.type) && schema.getInterfaces(schema.assertCompositeType(fragment.type)).some(function (interfaceType) {
+    return schema.areEqualTypes(interfaceType, nodeType);
+  }) || schema.isAbstractType(fragment.type) && Array.from(schema.getPossibleTypes(schema.assertAbstractType(fragment.type))).every(function (possibleType) {
+    return schema.getInterfaces(schema.assertCompositeType(possibleType)).some(function (interfaceType) {
+      return schema.areEqualTypes(interfaceType, nodeType);
+    });
+  })))) {
+    throw createUserError("Invalid use of @refetchable on fragment '".concat(fragment.name, "', check ") + 'that your schema defines a `Node { id: ID }` interface and has a ' + '`node(id: ID): Node` field on the query type (the id argument may ' + 'also be non-null).', [fragment.loc]);
+  } // name and type of the node(_: ID) field parameter
+
+
+  var idArgName = nodeField.args[0].name;
+  var idArgType = nodeField.args[0].type; // name and type of the query variable
+
+  var idVariableType = SchemaUtils.getNonNullIdInput(schema);
+  var idVariableName = 'id';
+  var argumentDefinitions = buildOperationArgumentDefinitions(fragment.argumentDefinitions);
+  var idArgument = argumentDefinitions.find(function (argDef) {
+    return argDef.name === idVariableName;
+  });
+
+  if (idArgument != null) {
+    throw createUserError("Invalid use of @refetchable on fragment `".concat(fragment.name, "`, this ") + 'fragment already has an `$id` variable in scope.', [idArgument.loc]);
+  }
+
+  var argumentDefinitionsWithId = [].concat((0, _toConsumableArray2["default"])(argumentDefinitions), [{
+    defaultValue: null,
+    kind: 'LocalArgumentDefinition',
+    loc: {
+      kind: 'Derived',
+      source: fragment.loc
+    },
+    name: idVariableName,
+    type: idVariableType
+  }]);
+  return {
+    identifierField: 'id',
+    path: [NODE_FIELD_NAME],
+    node: {
+      argumentDefinitions: argumentDefinitionsWithId,
+      directives: [],
+      kind: 'Root',
+      loc: {
+        kind: 'Derived',
+        source: fragment.loc
+      },
+      metadata: null,
+      name: queryName,
+      operation: 'query',
+      selections: [{
+        alias: NODE_FIELD_NAME,
+        args: [{
+          kind: 'Argument',
+          loc: {
+            kind: 'Derived',
+            source: fragment.loc
+          },
+          name: idArgName,
+          type: schema.assertInputType(idArgType),
+          value: {
+            kind: 'Variable',
+            loc: {
+              kind: 'Derived',
+              source: fragment.loc
+            },
+            variableName: idVariableName,
+            type: idVariableType
+          }
+        }],
+        connection: false,
+        directives: [],
+        handles: null,
+        kind: 'LinkedField',
+        loc: {
+          kind: 'Derived',
+          source: fragment.loc
+        },
+        metadata: null,
+        name: NODE_FIELD_NAME,
+        selections: [buildFragmentSpread(fragment)],
+        type: schema.assertLinkedFieldType(nodeType)
+      }],
+      type: queryType
+    },
+    transformedFragment: enforceIDField(schema, fragment)
+  };
+}
+
+function enforceIDField(schema, fragment) {
+  var idSelection = fragment.selections.find(function (selection) {
+    return selection.kind === 'ScalarField' && selection.name === 'id' && selection.alias === 'id' && schema.areEqualTypes(schema.getNullableType(selection.type), schema.expectIdType());
+  });
+
+  if (idSelection) {
+    return fragment;
+  }
+
+  var idField = schema.getFieldByName(fragment.type, 'id');
+  var nodeType = schema.assertCompositeType(nullthrows(schema.getTypeFromString(NODE_TYPE_NAME)));
+  var generatedIDSelection = idField ? SchemaUtils.generateIDField(schema, fragment.type) : {
+    kind: 'InlineFragment',
+    directives: [],
+    loc: {
+      kind: 'Generated'
+    },
+    metadata: null,
+    selections: [SchemaUtils.generateIDField(schema, nodeType)],
+    typeCondition: nodeType
+  };
+  return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, fragment), {}, {
+    selections: [].concat((0, _toConsumableArray2["default"])(fragment.selections), [generatedIDSelection])
+  });
+}
+
+module.exports = {
+  description: 'the Node interface or types implementing the Node interface',
+  buildRefetchOperation: buildRefetchOperation
+};

package/lib/transforms/query-generators/QueryQueryGenerator.js

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _require = require('./utils'),
+    buildFragmentSpread = _require.buildFragmentSpread,
+    buildOperationArgumentDefinitions = _require.buildOperationArgumentDefinitions;
+
+function buildRefetchOperation(schema, fragment, queryName) {
+  var queryType = schema.expectQueryType();
+
+  if (!schema.areEqualTypes(fragment.type, queryType)) {
+    return null;
+  }
+
+  return {
+    identifierField: null,
+    path: [],
+    node: {
+      argumentDefinitions: buildOperationArgumentDefinitions(fragment.argumentDefinitions),
+      directives: [],
+      kind: 'Root',
+      loc: {
+        kind: 'Derived',
+        source: fragment.loc
+      },
+      metadata: null,
+      name: queryName,
+      operation: 'query',
+      selections: [buildFragmentSpread(fragment)],
+      type: queryType
+    },
+    transformedFragment: fragment
+  };
+}
+
+module.exports = {
+  description: 'the Query type',
+  buildRefetchOperation: buildRefetchOperation
+};

package/lib/transforms/query-generators/ViewerQueryGenerator.js

@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _require = require('../../core/CompilerError'),
+    createUserError = _require.createUserError;
+
+var _require2 = require('./utils'),
+    buildFragmentSpread = _require2.buildFragmentSpread,
+    buildOperationArgumentDefinitions = _require2.buildOperationArgumentDefinitions;
+
+var VIEWER_TYPE_NAME = 'Viewer';
+var VIEWER_FIELD_NAME = 'viewer';
+
+function buildRefetchOperation(schema, fragment, queryName) {
+  if (schema.getTypeString(fragment.type) !== VIEWER_TYPE_NAME) {
+    return null;
+  } // Handle fragments on viewer
+
+
+  var queryType = schema.expectQueryType();
+  var viewerType = schema.getTypeFromString(VIEWER_TYPE_NAME);
+  var viewerField = schema.getFieldConfig(schema.expectField(queryType, VIEWER_FIELD_NAME));
+  var viewerFieldType = schema.getNullableType(viewerField.type);
+
+  if (!(viewerType && schema.isObject(viewerType) && schema.isObject(viewerFieldType) && schema.areEqualTypes(viewerFieldType, viewerType) && viewerField.args.length === 0 && schema.areEqualTypes(fragment.type, viewerType))) {
+    throw createUserError("Invalid use of @refetchable on fragment '".concat(fragment.name, "', check ") + "that your schema defines a 'Viewer' object type and has a " + "'viewer: Viewer' field on the query type.", [fragment.loc]);
+  }
+
+  return {
+    identifierField: null,
+    path: [VIEWER_FIELD_NAME],
+    node: {
+      argumentDefinitions: buildOperationArgumentDefinitions(fragment.argumentDefinitions),
+      directives: [],
+      kind: 'Root',
+      loc: {
+        kind: 'Derived',
+        source: fragment.loc
+      },
+      metadata: null,
+      name: queryName,
+      operation: 'query',
+      selections: [{
+        alias: VIEWER_FIELD_NAME,
+        args: [],
+        connection: false,
+        directives: [],
+        handles: null,
+        kind: 'LinkedField',
+        loc: {
+          kind: 'Derived',
+          source: fragment.loc
+        },
+        metadata: null,
+        name: VIEWER_FIELD_NAME,
+        selections: [buildFragmentSpread(fragment)],
+        type: schema.assertLinkedFieldType(viewerField.type)
+      }],
+      type: queryType
+    },
+    transformedFragment: fragment
+  };
+}
+
+module.exports = {
+  description: 'the Viewer type',
+  buildRefetchOperation: buildRefetchOperation
+};

package/lib/transforms/query-generators/index.js

@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var FetchableQueryGenerator = require('./FetchableQueryGenerator');
+
+var NodeQueryGenerator = require('./NodeQueryGenerator');
+
+var QueryQueryGenerator = require('./QueryQueryGenerator');
+
+var ViewerQueryGenerator = require('./ViewerQueryGenerator');
+
+var _require = require('../../core/CompilerError'),
+    createUserError = _require.createUserError;
+
+var GENERATORS = [ViewerQueryGenerator, QueryQueryGenerator, NodeQueryGenerator, FetchableQueryGenerator];
+/**
+ * Builds a query to refetch the given fragment or throws if we have not way to
+ * generate one.
+ */
+
+function buildRefetchOperation(schema, fragment, queryName) {
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(GENERATORS),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var generator = _step.value;
+      var refetchRoot = generator.buildRefetchOperation(schema, fragment, queryName);
+
+      if (refetchRoot != null) {
+        return refetchRoot;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  throw createUserError("Invalid use of @refetchable on fragment '".concat(fragment.name, "', only ") + 'supported are fragments on:\n' + GENERATORS.map(function (generator) {
+    return " - ".concat(generator.description);
+  }).join('\n'), [fragment.loc]);
+}
+
+module.exports = {
+  buildRefetchOperation: buildRefetchOperation
+};

package/lib/transforms/query-generators/utils.js

@@ -0,0 +1,92 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+function buildFragmentSpread(fragment) {
+  var args = [];
+
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(fragment.argumentDefinitions),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var argDef = _step.value;
+
+      if (argDef.kind !== 'LocalArgumentDefinition') {
+        continue;
+      }
+
+      args.push({
+        kind: 'Argument',
+        loc: {
+          kind: 'Derived',
+          source: argDef.loc
+        },
+        name: argDef.name,
+        type: argDef.type,
+        value: {
+          kind: 'Variable',
+          loc: {
+            kind: 'Derived',
+            source: argDef.loc
+          },
+          variableName: argDef.name,
+          type: argDef.type
+        }
+      });
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return {
+    args: args,
+    directives: [],
+    kind: 'FragmentSpread',
+    loc: {
+      kind: 'Derived',
+      source: fragment.loc
+    },
+    metadata: null,
+    name: fragment.name
+  };
+}
+
+function buildOperationArgumentDefinitions(argumentDefinitions) {
+  var localArgumentDefinitions = argumentDefinitions.map(function (argDef) {
+    if (argDef.kind === 'LocalArgumentDefinition') {
+      return argDef;
+    } else {
+      return {
+        kind: 'LocalArgumentDefinition',
+        name: argDef.name,
+        type: argDef.type,
+        defaultValue: null,
+        loc: argDef.loc
+      };
+    }
+  });
+  localArgumentDefinitions.sort(function (a, b) {
+    return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+  });
+  return localArgumentDefinitions;
+}
+
+module.exports = {
+  buildFragmentSpread: buildFragmentSpread,
+  buildOperationArgumentDefinitions: buildOperationArgumentDefinitions
+};

package/lib/util/CodeMarker.js

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+/**
+ * Marks a string of code as code to be replaced later.
+ */
+
+function moduleDependency(code) {
+  return "@@MODULE_START@@".concat(code, "@@MODULE_END@@");
+}
+/**
+ * After JSON.stringify'ing some code that contained parts marked with `mark()`,
+ * this post-processes the JSON to convert the marked code strings to raw code.
+ *
+ * Example:
+ *   CodeMarker.postProcess(
+ *     JSON.stringify({code: CodeMarker.mark('alert(1)')})
+ *   )
+ */
+
+
+function postProcess(json, printModule) {
+  return json.replace(/"@@MODULE_START@@(.*?)@@MODULE_END@@"/g, function (_, moduleName) {
+    return printModule(moduleName);
+  });
+}
+/**
+ * Transforms a value such that any transitive CodeMarker strings are replaced
+ * with the value of the named module in the given module map.
+ */
+
+
+function transform(node, moduleMap) {
+  if (node == null) {
+    return node;
+  } else if (Array.isArray(node)) {
+    return node.map(function (item) {
+      return transform(item, moduleMap);
+    });
+  } else if (typeof node === 'object') {
+    var next = {};
+    Object.keys(node).forEach(function (key) {
+      next[key] = transform(node[key], moduleMap);
+    });
+    return next;
+  } else if (typeof node === 'string') {
+    var match = /^@@MODULE_START@@(.*?)@@MODULE_END@@$/.exec(node);
+
+    if (match != null) {
+      var moduleName = match[1];
+
+      if (moduleMap.hasOwnProperty(moduleName)) {
+        return moduleMap[moduleName];
+      } else {
+        throw new Error("Could not find a value for CodeMarker value '".concat(moduleName, "', ") + 'make sure to supply one in the module mapping.');
+      }
+    } else if (node.indexOf('@@MODULE_START') >= 0) {
+      throw new Error("Found unprocessed CodeMarker value '".concat(node, "'."));
+    }
+
+    return node;
+  } else {
+    // mixed
+    return node;
+  }
+}
+
+module.exports = {
+  moduleDependency: moduleDependency,
+  postProcess: postProcess,
+  transform: transform
+};

package/lib/util/DefaultHandleKey.js

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+module.exports = {
+  DEFAULT_HANDLE_KEY: ''
+};