graphile-build-pg 4.13.0 → 4.14.1

package/node8plus/plugins/PgTypesPlugin.js

@@ -4,21 +4,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _GraphQLJSON = _interopRequireDefault(require("../GraphQLJSON"));
-
 var _postgresInterval = require("../postgresInterval");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+const ENUM_DOMAIN_SUFFIX = "_enum_domain";
 function indent(str) {
   return "  " + str.replace(/\n/g, "\n  ");
 }
-
 function identity(value) {
   return value;
 }
-
 var PgTypesPlugin = function PgTypesPlugin(builder, {
   pgExtendedTypes = true,
   // Adding hstore support is technically a breaking change; this allows people to opt out easily:
@@ -31,11 +26,13 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
   builder.hook("build", build => {
     const {
       pgIntrospectionResultsByKind: introspectionResultsByKind,
+      getPgFakeEnumIdentifier,
       getTypeByName,
       pgSql: sql,
       inflection,
       graphql
     } = build;
+
     /*
      * Note these do not do `foo.bind(build)` because they want to reference
      * the *latest* value of foo (i.e. after all the build hooks run) rather
@@ -46,11 +43,8 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
      *
      * TODO:v5: move this to the 'init' hook.
      */
-
     const newWithHooks = (...args) => build.newWithHooks(...args);
-
     const addType = (...args) => build.addType(...args);
-
     const {
       GraphQLNonNull,
       GraphQLString,
@@ -68,21 +62,18 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
     } = graphql;
     const gqlTypeByTypeIdGenerator = {};
     const gqlInputTypeByTypeIdGenerator = {};
-
     if (build.pgGqlTypeByTypeId || build.pgGqlInputTypeByTypeId) {
       // I don't expect anyone to receive this error, because I don't think anyone uses this interface.
       throw new Error("Sorry! This interface is no longer supported because it is not granular enough. It's not hard to port it to the new system - please contact Benjie and he'll walk you through it.");
     }
-
-    const gqlTypeByTypeIdAndModifier = { ...build.pgGqlTypeByTypeIdAndModifier
+    const gqlTypeByTypeIdAndModifier = {
+      ...build.pgGqlTypeByTypeIdAndModifier
     };
-    const gqlInputTypeByTypeIdAndModifier = { ...build.pgGqlInputTypeByTypeIdAndModifier
+    const gqlInputTypeByTypeIdAndModifier = {
+      ...build.pgGqlInputTypeByTypeIdAndModifier
     };
-
     const isNull = val => val == null || val.__isNull;
-
     const pg2GqlMapper = {};
-
     const pg2gqlForType = type => {
       if (pg2GqlMapper[type.id]) {
         const map = pg2GqlMapper[type.id].map;
@@ -93,40 +84,32 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
         const elementHandler = pg2gqlForType(type.arrayItemType);
         return val => {
           if (isNull(val)) return null;
-
           if (!Array.isArray(val)) {
             throw new Error(`Expected array when converting PostgreSQL data into GraphQL; failing type: '${type.namespaceName}.${type.name}'`);
           }
-
           return val.map(elementHandler);
         };
       } else {
         return identity;
       }
     };
-
     const pg2gql = (val, type) => pg2gqlForType(type)(val);
-
     const gql2pg = (val, type, modifier) => {
       if (modifier === undefined) {
         let stack;
-
         try {
           throw new Error();
         } catch (e) {
           stack = e.stack;
-        } // eslint-disable-next-line no-console
-
-
-        console.warn("gql2pg should be called with three arguments, the third being the type modifier (or `null`); " + (stack || "")); // Hack for backwards compatibility:
-
+        }
+        // eslint-disable-next-line no-console
+        console.warn("gql2pg should be called with three arguments, the third being the type modifier (or `null`); " + (stack || ""));
+        // Hack for backwards compatibility:
         modifier = null;
       }
-
       if (val == null) {
         return sql.null;
       }
-
       if (pg2GqlMapper[type.id]) {
         return pg2GqlMapper[type.id].unmap(val, modifier);
       } else if (type.domainBaseType) {
@@ -135,13 +118,11 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
         if (!Array.isArray(val)) {
           throw new Error(`Expected array when converting GraphQL data into PostgreSQL data; failing type: '${type.namespaceName}.${type.name}' (type: ${type === null ? "null" : typeof type})`);
         }
-
         return sql.fragment`array[${sql.join(val.map(v => gql2pg(v, type.arrayItemType, modifier)), ", ")}]::${type.isFake ? sql.identifier("unknown") : sql.identifier(type.namespaceName, type.name)}`;
       } else {
         return sql.value(val);
       }
     };
-
     const makeIntervalFields = () => {
       return {
         seconds: {
@@ -170,7 +151,6 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
         }
       };
     };
-
     const GQLInterval = newWithHooks(GraphQLObjectType, {
       name: inflection.builtin("Interval"),
       description: build.wrapDescription("An interval of time that has passed where the smallest distinct unit is a second.", "type"),
@@ -187,7 +167,6 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
       isIntervalInputType: true
     });
     addType(GQLIntervalInput, "graphile-build-pg built-in");
-
     const stringType = (name, description, coerce) => new GraphQLScalarType({
       name,
       description,
@@ -197,7 +176,6 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
         if (ast.kind !== Kind.STRING) {
           throw new Error("Can only parse string values");
         }
-
         if (coerce) {
           return coerce(ast.value);
         } else {
@@ -205,34 +183,32 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
         }
       }
     });
-
     const BigFloat = stringType(inflection.builtin("BigFloat"), build.wrapDescription("A floating point number that requires more precision than IEEE 754 binary 64", "type"));
     const BitString = stringType(inflection.builtin("BitString"), build.wrapDescription("A string representing a series of binary bits", "type"));
     addType(BigFloat, "graphile-build-pg built-in");
     addType(BitString, "graphile-build-pg built-in");
-    const rawTypes = [1186, // interval
-    1082, // date
-    1114, // timestamp
-    1184, // timestamptz
-    1083, // time
+    const rawTypes = [1186,
+    // interval
+    1082,
+    // date
+    1114,
+    // timestamp
+    1184,
+    // timestamptz
+    1083,
+    // time
     1266 // timetz
     ];
 
     const tweakToJson = fragment => fragment; // Since everything is to_json'd now, just pass through
-
-
     const tweakToJsonArray = fragment => fragment;
-
     const tweakToText = fragment => sql.fragment`(${fragment})::text`;
-
     const tweakToTextArray = fragment => sql.fragment`(${fragment})::text[]`;
-
     const tweakToNumericText = fragment => sql.fragment`(${fragment})::numeric::text`;
-
     const tweakToNumericTextArray = fragment => sql.fragment`(${fragment})::numeric[]::text[]`;
-
     const pgTweaksByTypeIdAndModifer = {};
-    const pgTweaksByTypeId = { // '::text' rawTypes
+    const pgTweaksByTypeId = {
+      // '::text' rawTypes
       ...rawTypes.reduce((memo, typeId) => {
         memo[typeId] = tweakToText;
         return memo;
@@ -248,11 +224,9 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
       1266: tweakToJson,
       790: tweakToNumericText
     };
-
     const pgTweakFragmentForTypeAndModifier = (fragment, type, typeModifier = null, resolveData) => {
       const typeModifierKey = typeModifier != null ? typeModifier : -1;
       const tweaker = pgTweaksByTypeIdAndModifer[type.id] && pgTweaksByTypeIdAndModifer[type.id][typeModifierKey] || pgTweaksByTypeId[type.id];
-
       if (tweaker) {
         return tweaker(fragment, resolveData);
       } else if (type.domainBaseType) {
@@ -262,26 +236,25 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
           // when taking PostgreSQL's JSON into Node.js.
           const arrayItemType = type.domainBaseType.arrayItemType;
           const domainBaseTypeModifierKey = type.domainBaseTypeModifier != null ? type.domainBaseTypeModifier : -1;
-          const arrayItemTweaker = pgTweaksByTypeIdAndModifer[arrayItemType.id] && pgTweaksByTypeIdAndModifer[arrayItemType.id][domainBaseTypeModifierKey] || pgTweaksByTypeId[arrayItemType.id]; // If it's a domain over a known type array (e.g. `bigint[]`), use
-          // the Array version of the tweaker.
+          const arrayItemTweaker = pgTweaksByTypeIdAndModifer[arrayItemType.id] && pgTweaksByTypeIdAndModifer[arrayItemType.id][domainBaseTypeModifierKey] || pgTweaksByTypeId[arrayItemType.id];
 
+          // If it's a domain over a known type array (e.g. `bigint[]`), use
+          // the Array version of the tweaker.
           switch (arrayItemTweaker) {
             case tweakToText:
               return tweakToTextArray(fragment);
-
             case tweakToNumericText:
               return tweakToNumericTextArray(fragment);
-
             case tweakToJson:
               return tweakToJsonArray(fragment);
-          } // If we get here, it's not a simple type, so use our
+          }
+
+          // If we get here, it's not a simple type, so use our
           // infrastructure to figure out what tweaks to apply to the array
           // item.
 
-
           const sqlVal = sql.fragment`val`;
           const innerFragment = pgTweakFragmentForTypeAndModifier(sqlVal, arrayItemType, type.domainBaseTypeModifier, resolveData);
-
           if (innerFragment === sqlVal) {
             // There was no tweak applied to the fragment, no change
             // necessary.
@@ -298,13 +271,11 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
         }
       } else if (type.isPgArray) {
         const error = new Error(`Internal graphile-build-pg error: should not attempt to tweak an array, please process array before tweaking (type: "${type.namespaceName}.${type.name}")`);
-
         if (process.env.NODE_ENV === "test") {
           // This is to ensure that Graphile core does not introduce these problems
           throw error;
-        } // eslint-disable-next-line no-console
-
-
+        }
+        // eslint-disable-next-line no-console
         console.error(error);
         return fragment;
       } else {
@@ -316,8 +287,6 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
        select oid, typname, typarray, typcategory, typtype from pg_catalog.pg_type where typtype = 'b' order by oid;
      We only need to add oidLookups for types that don't have the correct fallback
     */
-
-
     const SimpleDate = stringType(inflection.builtin("Date"), build.wrapDescription("The day, does not include a time.", "type"));
     const SimpleDatetime = stringType(inflection.builtin("Datetime"), build.wrapDescription("A point in time as described by the [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) standard. May or may not include a timezone.", "type"));
     const SimpleTime = stringType(inflection.builtin("Time"), build.wrapDescription("The exact time of day, does not include the date. May or may not have a timezone offset.", "type"));
@@ -326,7 +295,6 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
       if (!/^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$/i.test(string)) {
         throw new Error("Invalid UUID, expected 32 hexadecimal characters, optionally with hyphens");
       }
-
       return string;
     });
     const InetType = stringType(inflection.builtin("InternetAddress"), build.wrapDescription("An IPv4 or IPv6 host address, and optionally its subnet.", "type"));
@@ -342,18 +310,16 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
     const RegDictionaryType = stringType(inflection.builtin("RegDictionary"), build.wrapDescription("A builtin object identifier type for a text search dictionary", "type"));
     const CidrType = pgUseCustomNetworkScalars ? stringType(inflection.builtin("CidrAddress"), build.wrapDescription("An IPv4 or IPv6 CIDR address.", "type")) : GraphQLString;
     const MacAddrType = pgUseCustomNetworkScalars ? stringType(inflection.builtin("MacAddress"), build.wrapDescription("A 6-byte MAC address.", "type")) : GraphQLString;
-    const MacAddr8Type = pgUseCustomNetworkScalars ? stringType(inflection.builtin("MacAddress8"), build.wrapDescription("An 8-byte MAC address.", "type")) : GraphQLString; // pgExtendedTypes might change what types we use for things
+    const MacAddr8Type = pgUseCustomNetworkScalars ? stringType(inflection.builtin("MacAddress8"), build.wrapDescription("An 8-byte MAC address.", "type")) : GraphQLString;
 
+    // pgExtendedTypes might change what types we use for things
     const JSONType = pgExtendedTypes ? (0, _GraphQLJSON.default)(graphql, inflection.builtin("JSON")) : SimpleJSON;
     const UUIDType = SimpleUUID; // GraphQLUUID
-
     const DateType = SimpleDate; // GraphQLDate
-
     const DateTimeType = SimpleDatetime; // GraphQLDateTime
-
     const TimeType = SimpleTime; // GraphQLTime
-    // 'point' in PostgreSQL is a 16-byte type that's comprised of two 8-byte floats.
 
+    // 'point' in PostgreSQL is a 16-byte type that's comprised of two 8-byte floats.
     const Point = newWithHooks(GraphQLObjectType, {
       name: inflection.builtin("Point"),
       fields: {
@@ -379,8 +345,9 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
       }
     }, {
       isPointInputType: true
-    }); // Other plugins might want to use JSON
+    });
 
+    // Other plugins might want to use JSON
     addType(JSONType, "graphile-build-pg built-in");
     addType(UUIDType, "graphile-build-pg built-in");
     addType(DateType, "graphile-build-pg built-in");
@@ -411,6 +378,7 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
       // numeric
       790: GraphQLFloat,
       // money
+
       1186: GQLInterval,
       // interval
       1082: DateType,
@@ -423,24 +391,29 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
       // time
       1266: TimeType,
       // timetz
+
       114: JSONType,
       // json
       3802: JSONType,
       // jsonb
       2950: UUIDType,
       // uuid
+
       1560: BitString,
       // bit
       1562: BitString,
       // varbit
+
       18: GraphQLString,
       // char
       25: GraphQLString,
       // text
       1043: GraphQLString,
       // varchar
+
       600: Point,
       // point
+
       869: InetType,
       650: CidrType,
       829: MacAddrType,
@@ -460,11 +433,9 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
       1186: GQLIntervalInput,
       // interval
       600: PointInput // point
-
     };
 
     const jsonStringify = o => JSON.stringify(o);
-
     if (pgExtendedTypes) {
       pg2GqlMapper[114] = {
         map: identity,
@@ -476,30 +447,28 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
         unmap: str => sql.value(str)
       };
     }
-
     pg2GqlMapper[3802] = pg2GqlMapper[114]; // jsonb
-    // interval
 
+    // interval
     pg2GqlMapper[1186] = {
       map: str => (0, _postgresInterval.parseInterval)(str),
       unmap: o => {
         const keys = ["seconds", "minutes", "hours", "days", "months", "years"];
         const parts = [];
-
         for (const key of keys) {
           if (o[key]) {
             parts.push(`${o[key]} ${key}`);
           }
         }
-
         return sql.value(parts.join(" ") || "0 seconds");
       }
     };
     pg2GqlMapper[790] = {
       map: _ => _,
       unmap: val => sql.fragment`(${sql.value(val)})::money`
-    }; // point
+    };
 
+    // point
     pg2GqlMapper[600] = {
       map: f => {
         if (f[0] === "(" && f[f.length - 1] === ")") {
@@ -511,67 +480,63 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
         }
       },
       unmap: o => sql.fragment`point(${sql.value(o.x)}, ${sql.value(o.y)})`
-    }; // TODO: add more support for geometric types
+    };
+
+    // TODO: add more support for geometric types
 
     let depth = 0;
+
     /*
      * Enforce: this is the fallback when we can't find a specific GraphQL type
      * for a specific PG type.  Use the generators from
      * `pgRegisterGqlTypeByTypeId` first, this is a last resort.
      */
-
     const enforceGqlTypeByPgTypeId = (typeId, typeModifier) => {
       const type = introspectionResultsByKind.type.find(t => t.id === typeId);
       depth++;
-
       if (depth > 50) {
         throw new Error("Type enforcement went too deep - infinite loop?");
       }
-
       try {
         return reallyEnforceGqlTypeByPgTypeAndModifier(type, typeModifier);
       } catch (e) {
-        const error = new Error(`Error occurred when processing database type '${type.namespaceName}.${type.name}' (type=${type.type}):\n${indent(e.message)}`); // $FlowFixMe
-
+        const error = new Error(`Error occurred when processing database type '${type.namespaceName}.${type.name}' (type=${type.type}):\n${indent(e.message)}`);
+        // $FlowFixMe
         error.originalError = e;
         throw error;
       } finally {
         depth--;
       }
     };
-
     const reallyEnforceGqlTypeByPgTypeAndModifier = (type, typeModifier) => {
       if (!type.id) {
         throw new Error(`Invalid argument to enforceGqlTypeByPgTypeId - expected a full type, received '${type}'`);
       }
-
       if (!gqlTypeByTypeIdAndModifier[type.id]) {
         gqlTypeByTypeIdAndModifier[type.id] = {};
       }
-
       if (!gqlInputTypeByTypeIdAndModifier[type.id]) {
         gqlInputTypeByTypeIdAndModifier[type.id] = {};
       }
-
-      const typeModifierKey = typeModifier != null ? typeModifier : -1; // Explicit overrides
-
+      const typeModifierKey = typeModifier != null ? typeModifier : -1;
+      // Explicit overrides
       if (!gqlTypeByTypeIdAndModifier[type.id][typeModifierKey]) {
         const gqlType = oidLookup[type.id];
-
         if (gqlType) {
           gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] = gqlType;
         }
       }
-
       if (!gqlInputTypeByTypeIdAndModifier[type.id][typeModifierKey]) {
         const gqlInputType = oidInputLookup[type.id];
-
         if (gqlInputType) {
           gqlInputTypeByTypeIdAndModifier[type.id][typeModifierKey] = gqlInputType;
         }
-      } // Enums
+      }
 
+      // cf https://github.com/graphile/graphile-engine/pull/748#discussion_r650828353
+      let shouldSkipAddType = false;
 
+      // Enums
       if (!gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] && type.type === "e") {
         gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] = newWithHooks(GraphQLEnumType, {
           name: inflection.enumType(type),
@@ -587,25 +552,20 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
           pgIntrospection: type,
           isPgEnumType: true
         });
-      } // Ranges
-
-
+      }
+      // Ranges
       if (!gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] && type.type === "r") {
         const subtype = introspectionResultsByKind.typeById[type.rangeSubTypeId];
         const gqlRangeSubType = getGqlTypeByTypeIdAndModifier(subtype.id, typeModifier);
         const gqlRangeInputSubType = getGqlInputTypeByTypeIdAndModifier(subtype.id, typeModifier);
-
         if (!gqlRangeSubType) {
           throw new Error("Range of unsupported");
         }
-
         if (!gqlRangeInputSubType) {
           throw new Error("Range of unsupported input type");
         }
-
         let Range = getTypeByName(inflection.rangeType(gqlRangeSubType.name));
         let RangeInput;
-
         if (!Range) {
           const RangeBound = newWithHooks(GraphQLObjectType, {
             name: inflection.rangeBoundType(gqlRangeSubType.name),
@@ -688,14 +648,11 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
         } else {
           RangeInput = getTypeByName(inflection.inputType(Range.name));
         }
-
         gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] = Range;
         gqlInputTypeByTypeIdAndModifier[type.id][typeModifierKey] = RangeInput;
-
         if (pgTweaksByTypeIdAndModifer[type.id] === undefined) {
           pgTweaksByTypeIdAndModifer[type.id] = {};
         }
-
         pgTweaksByTypeIdAndModifer[type.id][typeModifierKey] = fragment => sql.fragment`\
 case
 when (${fragment}) is null then null
@@ -710,7 +667,6 @@ else json_build_object(
   end
 )
 end`;
-
         pg2GqlMapper[type.id] = {
           map: identity,
           unmap: ({
@@ -725,223 +681,205 @@ end`;
             return sql.fragment`${sql.identifier(type.namespaceName, type.name)}(${lower}, ${upper}, ${sql.literal(lowerInclusive + upperInclusive)})`;
           }
         };
-      } // Domains
-
+      }
 
+      // Domains
       if (!gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] && type.type === "d" && type.domainBaseTypeId) {
-        const baseType = getGqlTypeByTypeIdAndModifier(type.domainBaseTypeId, typeModifier);
-        const baseInputType = getGqlInputTypeByTypeIdAndModifier(type.domainBaseTypeId, typeModifier); // Hack stolen from: https://github.com/graphile/postgraphile/blob/ade728ed8f8e3ecdc5fdad7d770c67aa573578eb/src/graphql/schema/type/aliasGqlType.ts#L16
-
-        gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] = Object.assign(Object.create(baseType), {
-          name: inflection.domainType(type),
-          description: type.description
-        });
-
-        if (baseInputType && baseInputType !== baseType) {
-          gqlInputTypeByTypeIdAndModifier[type.id][typeModifierKey] = Object.assign(Object.create(baseInputType), {
-            name: inflection.inputType(gqlTypeByTypeIdAndModifier[type.id][typeModifierKey]),
+        // might be used as an enum alias: https://github.com/graphile/postgraphile/issues/1500
+        const tagEnumName = type.tags && typeof type.tags.enum === "string" ? type.tags.enum : null;
+        const truncatedTypeName = !tagEnumName && type.name.endsWith(ENUM_DOMAIN_SUFFIX) ? type.name.slice(0, type.name.length - ENUM_DOMAIN_SUFFIX.length) : null;
+        const underlyingEnumTypeName = tagEnumName || truncatedTypeName;
+        if (underlyingEnumTypeName !== null) {
+          const baseTypeId = getPgFakeEnumIdentifier(type.namespaceName, underlyingEnumTypeName);
+          const baseType = getGqlTypeByTypeIdAndModifier(baseTypeId, typeModifierKey);
+          const baseInputType = getGqlInputTypeByTypeIdAndModifier(baseTypeId, typeModifierKey);
+          if (!baseType || !baseInputType) {
+            if (tagEnumName) {
+              throw new Error(`The domain ${type.name} uses '@enum ${tagEnumName}' to references its underlying enum type, but no type named ${tagEnumName} could be found.`);
+            } else {
+              throw new Error(`The domain ${type.name} references the enum type ${underlyingEnumTypeName}, but no such type could be found.`);
+            }
+          }
+          gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] = baseType;
+          gqlInputTypeByTypeIdAndModifier[type.id][typeModifierKey] = baseInputType;
+          shouldSkipAddType = true;
+        } else {
+          const baseType = getGqlTypeByTypeIdAndModifier(type.domainBaseTypeId, typeModifier);
+          const baseInputType = getGqlInputTypeByTypeIdAndModifier(type.domainBaseTypeId, typeModifier);
+          // Hack stolen from: https://github.com/graphile/postgraphile/blob/ade728ed8f8e3ecdc5fdad7d770c67aa573578eb/src/graphql/schema/type/aliasGqlType.ts#L16
+          gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] = Object.assign(Object.create(baseType), {
+            name: inflection.domainType(type),
             description: type.description
           });
+          if (baseInputType && baseInputType !== baseType) {
+            gqlInputTypeByTypeIdAndModifier[type.id][typeModifierKey] = Object.assign(Object.create(baseInputType), {
+              name: inflection.inputType(gqlTypeByTypeIdAndModifier[type.id][typeModifierKey]),
+              description: type.description
+            });
+          }
         }
-      } // Arrays
-
+      }
 
+      // Arrays
       if (!gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] && type.category === "A") {
         const arrayEntryOutputType = getGqlTypeByTypeIdAndModifier(type.arrayItemTypeId, typeModifier);
         gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] = new GraphQLList(arrayEntryOutputType);
-
         if (!disableIssue390Fix) {
           const arrayEntryInputType = getGqlInputTypeByTypeIdAndModifier(type.arrayItemTypeId, typeModifier);
-
           if (arrayEntryInputType) {
             gqlInputTypeByTypeIdAndModifier[type.id][typeModifierKey] = new GraphQLList(arrayEntryInputType);
           }
         }
-      } // Booleans
-
+      }
 
+      // Booleans
       if (!gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] && type.category === "B") {
         gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] = GraphQLBoolean;
-      } // Numbers may be too large for GraphQL/JS to handle, so stringify by
-      // default.
-
+      }
 
+      // Numbers may be too large for GraphQL/JS to handle, so stringify by
+      // default.
       if (!gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] && type.category === "N") {
         pgTweaksByTypeId[type.id] = tweakToText;
         gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] = BigFloat;
-      } // Nothing else worked; pass through as string!
-
+      }
 
+      // Nothing else worked; pass through as string!
       if (!gqlTypeByTypeIdAndModifier[type.id][typeModifierKey]) {
         // XXX: consider using stringType(upperFirst(camelCase(`fallback_${type.name}`)), type.description)?
         gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] = GraphQLString;
-      } // Now for input types, fall back to output types if possible
-
-
+      }
+      // Now for input types, fall back to output types if possible
       if (!gqlInputTypeByTypeIdAndModifier[type.id][typeModifierKey]) {
         if (isInputType(gqlTypeByTypeIdAndModifier[type.id][typeModifierKey])) {
           gqlInputTypeByTypeIdAndModifier[type.id][typeModifierKey] = gqlTypeByTypeIdAndModifier[type.id][typeModifierKey];
         }
       }
-
-      addType(getNamedType(gqlTypeByTypeIdAndModifier[type.id][typeModifierKey]));
+      // if its a domain type substituting for an enum table,
+      // adding it creates a duplicate
+      if (!shouldSkipAddType) {
+        addType(getNamedType(gqlTypeByTypeIdAndModifier[type.id][typeModifierKey]));
+      }
       return gqlTypeByTypeIdAndModifier[type.id][typeModifierKey];
     };
-
     function getGqlTypeByTypeIdAndModifier(typeId, typeModifier = null, useFallback = true) {
       const typeModifierKey = typeModifier != null ? typeModifier : -1;
-
       if (!gqlTypeByTypeIdAndModifier[typeId]) {
         gqlTypeByTypeIdAndModifier[typeId] = {};
       }
-
       if (!gqlInputTypeByTypeIdAndModifier[typeId]) {
         gqlInputTypeByTypeIdAndModifier[typeId] = {};
       }
-
       if (!gqlTypeByTypeIdAndModifier[typeId][typeModifierKey]) {
         const type = introspectionResultsByKind.type.find(t => t.id === typeId);
-
         if (!type) {
           throw new Error(`Type '${typeId}' not present in introspection results`);
         }
-
         const gen = gqlTypeByTypeIdGenerator[type.id];
-
         if (gen) {
           const set = Type => {
             gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] = Type;
           };
-
           const result = gen(set, typeModifier);
-
           if (result) {
             if (gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] && gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] !== result) {
               throw new Error(`Callback and return types differ when defining type for '${type.id}'`);
             }
-
             gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] = result;
           }
         }
       }
-
       if (!gqlTypeByTypeIdAndModifier[typeId][typeModifierKey] && typeModifierKey > -1) {
         // Fall back to `null` modifier, but if that still doesn't work, we
         // still want to pass the modifier to enforceGqlTypeByPgTypeId.
         const fallback = getGqlTypeByTypeIdAndModifier(typeId, null, false);
-
         if (fallback) {
           return fallback;
         }
       }
-
       if (useFallback && !gqlTypeByTypeIdAndModifier[typeId][typeModifierKey]) {
         return enforceGqlTypeByPgTypeId(typeId, typeModifier);
       }
-
       return gqlTypeByTypeIdAndModifier[typeId][typeModifierKey];
     }
-
     function getGqlInputTypeByTypeIdAndModifier(typeId, typeModifier = null) {
       // First, load the OUTPUT type (it might register an input type)
       getGqlTypeByTypeIdAndModifier(typeId, typeModifier);
       const typeModifierKey = typeModifier != null ? typeModifier : -1;
-
       if (!gqlInputTypeByTypeIdAndModifier[typeId]) {
         gqlInputTypeByTypeIdAndModifier[typeId] = {};
       }
-
       if (!gqlInputTypeByTypeIdAndModifier[typeId][typeModifierKey]) {
         const type = introspectionResultsByKind.typeById[typeId];
-
         if (!type) {
           throw new Error(`Type '${typeId}' not present in introspection results`);
         }
-
         const gen = gqlInputTypeByTypeIdGenerator[type.id];
-
         if (gen) {
           const set = Type => {
             gqlInputTypeByTypeIdAndModifier[type.id][typeModifierKey] = Type;
           };
-
           const result = gen(set, typeModifier);
-
           if (result) {
             if (gqlInputTypeByTypeIdAndModifier[type.id][typeModifierKey] && gqlInputTypeByTypeIdAndModifier[type.id][typeModifierKey] !== result) {
               throw new Error(`Callback and return types differ when defining type for '${type.id}'`);
             }
-
             gqlInputTypeByTypeIdAndModifier[type.id][typeModifierKey] = result;
           }
         }
-      } // Use the same type as the output type if it's valid input
-
-
+      }
+      // Use the same type as the output type if it's valid input
       if (!gqlInputTypeByTypeIdAndModifier[typeId][typeModifierKey] && gqlTypeByTypeIdAndModifier[typeId] && gqlTypeByTypeIdAndModifier[typeId][typeModifierKey] && isInputType(gqlTypeByTypeIdAndModifier[typeId][typeModifierKey])) {
         gqlInputTypeByTypeIdAndModifier[typeId][typeModifierKey] = gqlTypeByTypeIdAndModifier[typeId][typeModifierKey];
       }
-
       if (!gqlInputTypeByTypeIdAndModifier[typeId][typeModifierKey] && typeModifierKey > -1) {
         // Fall back to default
         return getGqlInputTypeByTypeIdAndModifier(typeId, null);
       }
-
       return gqlInputTypeByTypeIdAndModifier[typeId][typeModifierKey];
     }
-
     function registerGqlTypeByTypeId(typeId, gen, yieldToExisting = false) {
       if (gqlTypeByTypeIdGenerator[typeId]) {
         if (yieldToExisting) {
           return;
         }
-
         throw new Error(`There's already a type generator registered for '${typeId}'`);
       }
-
       gqlTypeByTypeIdGenerator[typeId] = gen;
     }
-
     function registerGqlInputTypeByTypeId(typeId, gen, yieldToExisting = false) {
       if (gqlInputTypeByTypeIdGenerator[typeId]) {
         if (yieldToExisting) {
           return;
         }
-
         throw new Error(`There's already an input type generator registered for '${typeId}'`);
       }
-
       gqlInputTypeByTypeIdGenerator[typeId] = gen;
-    } // DEPRECATIONS!
-
+    }
 
+    // DEPRECATIONS!
     function getGqlTypeByTypeId(typeId, typeModifier) {
       if (typeModifier === undefined) {
         // eslint-disable-next-line no-console
         console.warn("DEPRECATION WARNING: getGqlTypeByTypeId should not be used - for some columns we also require typeModifier to be specified. Please update your code ASAP to pass `attribute.typeModifier` through as the second parameter (or null if it's not available).");
       }
-
       return getGqlTypeByTypeIdAndModifier(typeId, typeModifier);
     }
-
     function getGqlInputTypeByTypeId(typeId, typeModifier) {
       if (typeModifier === undefined) {
         // eslint-disable-next-line no-console
         console.warn("DEPRECATION WARNING: getGqlInputTypeByTypeId should not be used - for some columns we also require typeModifier to be specified. Please update your code ASAP to pass `attribute.typeModifier` through as the second parameter (or null if it's not available).");
       }
-
       return getGqlInputTypeByTypeIdAndModifier(typeId, typeModifier);
     }
-
     function pgTweakFragmentForType(fragment, type, typeModifier, resolveData) {
       if (typeModifier === undefined) {
         // eslint-disable-next-line no-console
         console.warn("DEPRECATION WARNING: pgTweakFragmentForType should not be used - for some columns we also require typeModifier to be specified. Please update your code ASAP to pass `attribute.typeModifier` through as the third parameter (or null if it's not available).");
       }
-
       return pgTweakFragmentForTypeAndModifier(fragment, type, typeModifier, resolveData);
-    } // END OF DEPRECATIONS!
-
+    }
+    // END OF DEPRECATIONS!
 
     return build.extend(build, {
       pgRegisterGqlTypeByTypeId: registerGqlTypeByTypeId,
@@ -961,11 +899,10 @@ end`;
       pgGetGqlInputTypeByTypeId: getGqlInputTypeByTypeId,
       // DEPRECATED, replaced by getGqlInputTypeByTypeIdAndModifier
       pgTweakFragmentForType // DEPRECATED, replaced by pgTweakFragmentForTypeAndModifier
-
     });
   }, ["PgTypes"], [], ["PgIntrospection", "StandardTypes"]);
-  /* Start of hstore type */
 
+  /* Start of hstore type */
   builder.hook("inflection", (inflection, build) => {
     // This hook allows you to append a plugin which renames the KeyValueHash
     // (hstore) type name.
@@ -974,7 +911,6 @@ end`;
       hstoreType() {
         return "KeyValueHash";
       }
-
     });
   }, ["PgTypesHstore"]);
   builder.hook("build", build => {
@@ -987,30 +923,31 @@ end`;
       pgRegisterGqlInputTypeByTypeId,
       pg2GqlMapper,
       pgSql: sql
-    } = build; // Check we have the hstore extension
+    } = build;
 
+    // Check we have the hstore extension
     const hstoreExtension = introspectionResultsByKind.extension.find(e => e.name === "hstore");
-
     if (!hstoreExtension) {
       return build;
-    } // Get the 'hstore' type itself:
-
+    }
 
+    // Get the 'hstore' type itself:
     const hstoreType = introspectionResultsByKind.type.find(t => t.name === "hstore" && t.namespaceId === hstoreExtension.namespaceId);
-
     if (!hstoreType) {
       return build;
     }
+    const hstoreTypeName = build.inflection.hstoreType();
 
-    const hstoreTypeName = build.inflection.hstoreType(); // We're going to use our own special HStore type for this so that we get
+    // We're going to use our own special HStore type for this so that we get
     // better validation; but you could just as easily use JSON directly if you
     // wanted to.
+    const GraphQLHStoreType = makeGraphQLHstoreType(build, hstoreTypeName);
 
-    const GraphQLHStoreType = makeGraphQLHstoreType(build, hstoreTypeName); // Now register the hstore type with the type system for both output and input.
-
+    // Now register the hstore type with the type system for both output and input.
     pgRegisterGqlTypeByTypeId(hstoreType.id, () => GraphQLHStoreType);
-    pgRegisterGqlInputTypeByTypeId(hstoreType.id, () => GraphQLHStoreType); // Finally we must tell the system how to translate the data between PG-land and JS-land:
+    pgRegisterGqlInputTypeByTypeId(hstoreType.id, () => GraphQLHStoreType);
 
+    // Finally we must tell the system how to translate the data between PG-land and JS-land:
     pg2GqlMapper[hstoreType.id] = {
       // node-postgres parses hstore for us, no action required on map
       map: identity,
@@ -1022,7 +959,6 @@ end`;
   /* End of hstore type */
 
   /* Geometric types */
-
   builder.hook("build", build => {
     // This hook tells graphile-build-pg about the hstore database type so it
     // knows how to express it in input/output.
@@ -1042,8 +978,9 @@ end`;
         GraphQLFloat
       },
       inflection
-    } = build; // Check we have the hstore extension
+    } = build;
 
+    // Check we have the hstore extension
     const LINE = 628;
     const LSEG = 601;
     const BOX = 603;
@@ -1052,11 +989,9 @@ end`;
     const CIRCLE = 718;
     pgRegisterGqlTypeByTypeId(LINE, () => {
       const Point = pgGetGqlTypeByTypeIdAndModifier("600", null);
-
       if (!Point) {
         throw new Error("Need point type");
       }
-
       return new GraphQLObjectType({
         name: inflection.builtin("Line"),
         description: build.wrapDescription("An infinite line that passes through points 'a' and 'b'.", "type"),
@@ -1088,10 +1023,10 @@ end`;
     pg2GqlMapper[LINE] = {
       map: f => {
         if (f[0] === "{" && f[f.length - 1] === "}") {
-          const [A, B, C] = f.slice(1, -1).split(",").map(f => parseFloat(f)); // Lines have the form Ax + By + C = 0.
+          const [A, B, C] = f.slice(1, -1).split(",").map(f => parseFloat(f));
+          // Lines have the form Ax + By + C = 0.
           // So if y = 0, Ax + C = 0; x = -C/A.
           // If x = 0, By + C = 0; y = -C/B.
-
           return {
             a: {
               x: -C / A,
@@ -1237,29 +1172,23 @@ end`;
     pg2GqlMapper[PATH] = {
       map: f => {
         let isOpen = null;
-
         if (f[0] === "(" && f[f.length - 1] === ")") {
           isOpen = false;
         } else if (f[0] === "[" && f[f.length - 1] === "]") {
           isOpen = true;
         }
-
         if (isOpen !== null) {
           const xsAndYs = f.slice(1, -1).replace(/[()]/g, "").split(",").map(f => parseFloat(f));
-
           if (xsAndYs.length % 2 !== 0) {
             throw new Error("Invalid path representation");
           }
-
           const points = [];
-
           for (let i = 0, l = xsAndYs.length; i < l; i += 2) {
             points.push({
               x: xsAndYs[i],
               y: xsAndYs[i + 1]
             });
           }
-
           return {
             isOpen,
             points
@@ -1299,20 +1228,16 @@ end`;
       map: f => {
         if (f[0] === "(" && f[f.length - 1] === ")") {
           const xsAndYs = f.slice(1, -1).replace(/[()]/g, "").split(",").map(f => parseFloat(f));
-
           if (xsAndYs.length % 2 !== 0) {
             throw new Error("Invalid polygon representation");
           }
-
           const points = [];
-
           for (let i = 0, l = xsAndYs.length; i < l; i += 2) {
             points.push({
               x: xsAndYs[i],
               y: xsAndYs[i + 1]
             });
           }
-
           return {
             points
           };
@@ -1365,15 +1290,15 @@ end`;
         }
       },
       unmap: o => sql.fragment`circle(point(${sql.value(o.center.x)}, ${sql.value(o.center.y)}), ${sql.value(o.radius)})`
-    }; // TODO: add the non-nulls!
+    };
+
+    // TODO: add the non-nulls!
 
     return build;
   }, ["PgGeometryTypes"], [], ["PgTypes"]);
   /* End of geometric types */
 };
-
 exports.default = PgTypesPlugin;
-
 function makeGraphQLHstoreType(build, hstoreTypeName) {
   const {
     graphql
@@ -1382,7 +1307,6 @@ function makeGraphQLHstoreType(build, hstoreTypeName) {
     GraphQLScalarType,
     Kind
   } = graphql;
-
   function isValidHstoreObject(obj) {
     if (obj === null) {
       // Null is okay
@@ -1390,67 +1314,56 @@ function makeGraphQLHstoreType(build, hstoreTypeName) {
     } else if (typeof obj === "object") {
       // A hash with string/null values is also okay
       const keys = Object.keys(obj);
-
       for (const key of keys) {
         const val = obj[key];
-
-        if (val === null) {// Null is okay
-        } else if (typeof val === "string") {// String is okay
+        if (val === null) {
+          // Null is okay
+        } else if (typeof val === "string") {
+          // String is okay
         } else {
           // Everything else is invalid.
           return false;
         }
       }
-
       return true;
     } else {
       // Everything else is invalid.
       return false;
     }
   }
-
   function identityWithCheck(obj) {
     if (isValidHstoreObject(obj)) {
       return obj;
     }
-
     throw new TypeError(`This is not a valid ${hstoreTypeName} object, it must be a key/value hash where keys and values are both strings (or null).`);
   }
-
   function parseValueLiteral(ast, variables) {
     switch (ast.kind) {
       case Kind.INT:
       case Kind.FLOAT:
         // Number isn't really okay, but we'll coerce it to a string anyway.
         return String(parseFloat(ast.value));
-
       case Kind.STRING:
         // String is okay.
         return String(ast.value);
-
       case Kind.NULL:
         // Null is okay.
         return null;
-
       case Kind.VARIABLE:
         {
           // Variable is okay if that variable is either a string or null.
           const name = ast.name.value;
           const value = variables ? variables[name] : undefined;
-
           if (value === null || typeof value === "string") {
             return value;
           }
-
           return undefined;
         }
-
       default:
         // Everything else is invalid.
         return undefined;
     }
   }
-
   function parseLiteral(ast, variables) {
     switch (ast.kind) {
       case Kind.OBJECT:
@@ -1459,35 +1372,28 @@ function makeGraphQLHstoreType(build, hstoreTypeName) {
             memo[field.name.value] = parseValueLiteral(field.value, variables);
             return memo;
           }, Object.create(null));
-
           if (!isValidHstoreObject(value)) {
             return undefined;
           }
-
           return value;
         }
-
       case Kind.NULL:
         return null;
-
       case Kind.VARIABLE:
         {
           const name = ast.name.value;
           const value = variables ? variables[name] : undefined;
-
           if (!isValidHstoreObject(value)) {
             return undefined;
           }
-
           return value;
         }
-
       default:
         return undefined;
     }
-  } // TODO: use newWithHooks instead
-
+  }
 
+  // TODO: use newWithHooks instead
   const GraphQLHStore = new GraphQLScalarType({
     name: hstoreTypeName,
     description: build.wrapDescription("A set of key/value pairs, keys are strings, values may be a string or null. Exposed as a JSON object.", "type"),
@@ -1496,36 +1402,30 @@ function makeGraphQLHstoreType(build, hstoreTypeName) {
     parseLiteral
   });
   return GraphQLHStore;
-} // To include a double quote or a backslash in a key or value, escape it
+}
+
+// To include a double quote or a backslash in a key or value, escape it
 // with a backslash.
 // -- https://www.postgresql.org/docs/10/static/hstore.html
-
-
 function toHstoreString(str) {
   return '"' + str.replace(/(["\\])/g, "\\$1") + '"';
 }
-
 function hstoreStringify(o) {
   if (o === null) {
     return null;
   }
-
   if (typeof o !== "object") {
     throw new TypeError("Expected an hstore object");
   }
-
   const keys = Object.keys(o);
-
   const encodeKeyValue = key => {
     const value = o[key];
-
     if (value === null) {
       return `${toHstoreString(key)} => NULL`;
     } else {
       return `${toHstoreString(key)} => ${toHstoreString(String(value))}`;
     }
   };
-
   return keys.map(encodeKeyValue).join(", ");
 }
 //# sourceMappingURL=PgTypesPlugin.js.map