graphile-build-pg 4.12.3 → 4.14.0

package/node8plus/plugins/PgTypesPlugin.js

@@ -11,6 +11,8 @@ 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  ");
 }
@@ -31,6 +33,7 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
   builder.hook("build", build => {
     const {
       pgIntrospectionResultsByKind: introspectionResultsByKind,
+      getPgFakeEnumIdentifier,
       getTypeByName,
       pgSql: sql,
       inflection,
@@ -324,7 +327,7 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
     const SimpleJSON = stringType(inflection.builtin("JSON"), build.wrapDescription("A JavaScript object encoded in the JSON format as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf).", "type"));
     const SimpleUUID = stringType(inflection.builtin("UUID"), build.wrapDescription("A universally unique identifier as defined by [RFC 4122](https://tools.ietf.org/html/rfc4122).", "type"), string => {
       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 hypens");
+        throw new Error("Invalid UUID, expected 32 hexadecimal characters, optionally with hyphens");
       }
 
       return string;
@@ -398,7 +401,7 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
     addType(RegDictionaryType, "graphile-build-pg built-in");
     const oidLookup = {
       20: stringType(inflection.builtin("BigInt"), build.wrapDescription("A signed eight-byte integer. The upper big integer values are greater than the max value for a JavaScript number. Therefore all big integers will be output as strings and not numbers.", "type")),
-      // bitint - even though this is int8, it's too big for JS int, so cast to string.
+      // bigint - even though this is int8, it's too big for JS int, so cast to string.
       21: GraphQLInt,
       // int2
       23: GraphQLInt,
@@ -569,8 +572,10 @@ var PgTypesPlugin = function PgTypesPlugin(builder, {
         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, {
@@ -729,19 +734,42 @@ end`;
 
 
       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
+        // 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] = Object.assign(Object.create(baseType), {
-          name: inflection.domainType(type),
-          description: type.description
-        });
+          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
 
-        if (baseInputType && baseInputType !== baseType) {
-          gqlInputTypeByTypeIdAndModifier[type.id][typeModifierKey] = Object.assign(Object.create(baseInputType), {
-            name: inflection.inputType(gqlTypeByTypeIdAndModifier[type.id][typeModifierKey]),
+          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
 
@@ -782,9 +810,14 @@ end`;
         if (isInputType(gqlTypeByTypeIdAndModifier[type.id][typeModifierKey])) {
           gqlInputTypeByTypeIdAndModifier[type.id][typeModifierKey] = 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]));
       }
 
-      addType(getNamedType(gqlTypeByTypeIdAndModifier[type.id][typeModifierKey]));
       return gqlTypeByTypeIdAndModifier[type.id][typeModifierKey];
     };
 

package/node8plus/plugins/PgTypesPlugin.js.flow

@@ -5,6 +5,8 @@ import makeGraphQLJSONType from "../GraphQLJSON";
 
 import { parseInterval } from "../postgresInterval";
 
+const ENUM_DOMAIN_SUFFIX = "_enum_domain";
+
 function indent(str) {
   return "  " + str.replace(/\n/g, "\n  ");
 }
@@ -30,6 +32,7 @@ export default (function PgTypesPlugin(
     build => {
       const {
         pgIntrospectionResultsByKind: introspectionResultsByKind,
+        getPgFakeEnumIdentifier,
         getTypeByName,
         pgSql: sql,
         inflection,
@@ -423,7 +426,7 @@ export default (function PgTypesPlugin(
             )
           ) {
             throw new Error(
-              "Invalid UUID, expected 32 hexadecimal characters, optionally with hypens"
+              "Invalid UUID, expected 32 hexadecimal characters, optionally with hyphens"
             );
           }
           return string;
@@ -594,7 +597,7 @@ export default (function PgTypesPlugin(
             "A signed eight-byte integer. The upper big integer values are greater than the max value for a JavaScript number. Therefore all big integers will be output as strings and not numbers.",
             "type"
           )
-        ), // bitint - even though this is int8, it's too big for JS int, so cast to string.
+        ), // bigint - even though this is int8, it's too big for JS int, so cast to string.
         21: GraphQLInt, // int2
         23: GraphQLInt, // int4
         700: GraphQLFloat, // float4
@@ -753,6 +756,10 @@ export default (function PgTypesPlugin(
               gqlInputType;
           }
         }
+
+        // cf https://github.com/graphile/graphile-engine/pull/748#discussion_r650828353
+        let shouldSkipAddType = false;
+
         // Enums
         if (
           !gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] &&
@@ -994,30 +1001,72 @@ end`;
           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,
+          // 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.`
+                );
+              }
             }
-          );
-          if (baseInputType && baseInputType !== baseType) {
+
+            gqlTypeByTypeIdAndModifier[type.id][typeModifierKey] = baseType;
             gqlInputTypeByTypeIdAndModifier[type.id][typeModifierKey] =
-              Object.assign(Object.create(baseInputType), {
-                name: inflection.inputType(
-                  gqlTypeByTypeIdAndModifier[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,
+                });
+            }
           }
         }
 
@@ -1076,9 +1125,13 @@ end`;
               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];
       };