GQLBase

Until such time as the reference implementation of Facebook's GraphQL
SDL AST parser supports comments, or until we take advantage of Apollo's
AST parser, this is how comments will be applied to a built schema.

Several constants are defined on the GQLBase object itself, and thereby
all its subclasses. They pertain to how to define description fields
for various parts of your GQL implementation.

// To define a description on the top level class
[this.DOC_CLASS]: string

// To define a description on a field (getter, function or async function)
[this.DOC_FIELDS]: {
  fieldName: string
}

// To define a description on a query, mutation or subscription field
[this.DOC_QUERIES || this.DOC_MUTATORS || this.DOC_SUBSCRIPTIONS]: {
  fieldName: string
}

To make writing code easier, the joinLines() template function is
available so your source code can look nice and neat and your descriptions
won't get annoying line breaks and spaces as part of that process.

An simple pass-thru method for fetching a types merged root object.

The static version of getProp reads into the prototype to find the field
that is desired. If the field is either a getter or a initializer (see
class properties descriptors), then the option to bind that to either the
prototype object or one of your choosing is available.

Resolvers are created in a number of different ways. OOP design
dictates that instances of a created class will handle field
resolvers, but query, mutation and subscription resolvers are
typically what creates these instances.

Since a resolver can be created using @mutator/@subscriptor/@resolver
or via method on a object returned from RESOLVERS(), MUTATORS() or
SUBSCRIPTIONS(), there should be an easy to use way to fetch a
resolver by name; if for nothing else, code reuse.

Pass the name of the resolver to the function and optionally pass a
requestData object. The getMergedRoot() method will build an object
containing all the root resolvers for the type, bound to the supplied
requestData object. It is from this object that resolverName will
be used to fetch the function in question. If one exists, it will be
returned, ready for use. Otherwise, null will be your answer.

Creates an appropriate Symbol crafted with the right data for use by
the IDLFileHandler class below.

This method should return a promise that resolves to an object of
functions matching the names of the mutation operations. These are to be
injected into the root object when used by GQLExpressMiddleware.

This method should return a promise that resolves to an object of
functions matching the names of the query operations. These are to be
injected into the root object when used by GQLExpressMiddleware.

The internal data model has some custom EventEmitter code wrapped
it here. When the data model is set via setModel or by accessing it
via instance[MODEL_KEY], an event EVENT_MODEL_SET is emitted. Any
listener listening for this event receives an object with two keys

{
  model: The actual model being set; changes are persisted
  instance: The GQLBase instance the model is associated with
}

Subsequently, the events EVENT_MODEL_PROP_CHANGE and
EVENT_MODEL_PROP_DELETE can be listened to if your version of node
supports Proxy objects. They allow you to be notified whenever your
model has a property changed or deleted, respectively.

The callback for change receives an object with four properties

{
  model: The model object the value is being changed on
  old: The old value being replaced; undefined if it is the first time
  key: The property key for the value being changed
  value: The new value being set
}

The callback for delete receives an object with four properties

{
  model: The model object the value is deleted from
  key: The property key for the deleted value
  deleted: The deleted value
}

A file handler for fetching the IDL schema string from the file system
for those GQLBase extended classes that have indicated to do so by
returning a Symbol for their SCHEMA property.

Defined in a base class, this getter should return either a String
detailing the full IDL schema of a GraphQL handler or one of two
types of Symbols.

The first Symbol type is the constant ADJACENT_FILE. If this Symbol is
returned, the system assumes that next to the source file in question is
a file of the same name with a .graphql extension. This file should be
made of the GraphQL IDL schema definitions for the object types being
created.

Example:

  static get SCHEMA(): string | Symbol {
    return GQLBase.ADJACENT_FILE
  }

The primary advantage of this approach is allowing an outside editor that
provides syntax highlighting rather than returning a string from the
SCHEMA getter.

Alternatively, the static method IDLFilePath can be used to point to an
alternate location where the GraphQL IDL file resides. The extension can
also be changed from .graphql to something else if need be using this
method.

Example:

  static get SCHEMA(): string | Symbol {
    return GQLBase.IDLFilePath('/path/to/file', '.idl')
  }

Since reading the Schema for a given GraphQL Lattice type or
interface is simple enough, we should be able to automatically
apply one to one GraphQL:Model properties.

Properties defined for GraphQL types in Lattice can be defined as
a getter, a function or an async function. In the case of standard
functions, if they return a promise they will be handled as though
they were async. In addition to fetching the property, or field
resolver, its resulting function or getter will be invoked.

Given the variety of things a GraphQL type can actually be, obtaining
its value can annoying. This method tends to lessen that boilerplate.
Errors raised will be thrown.

Uses _.merge() to modify the internal backing data store for the
object instance. This is a shortcut for
_.merge()(instance[MODEL_KEY], ...extensions)

Getter for the internally stored model data. The contents of this
object are abstracted away behind a Symbol key to prevent collision
between the underlying model and any GraphQL Object Definition properties.

Properties defined for GraphQL types in Lattice can be defined as
a getter, a function or an async function. In the case of standard
functions, if they return a promise they will be handled as though
they were async

Given the variety of things a GraphQL type can actually be, obtaining
its value can annoying. This method tends to lessen that boilerplate.
Errors raised will be thrown.

A pass-thru method to the static function of the same name. The
difference being that if requestData is not specified, the
requestData object from this instance will be used to build the
resolvers in question.

Setter for the internally stored model data. The contents of this
object are abstracted away behind a Symbol key to prevent collision
between the underlying model and any GraphQL Object Definition properties.

A setter that assigns a value to the inner request data object. When
used with GQLExpressMiddleware, this is an object matching {req, res, gql}.

A getter that retrieves the inner request data object. When used with
GQLExpressMiddleware, this is an object matching {req, res, gql}.

Proxy deleteProperty() handler. This is where the delete property
events are fired from

Proxy set() handler. This is where the change events are fired from