feat(pg): use table enums in functions via domain (#832)

Co-authored-by: ben-pr-p <ben.paul.ryan.packer@gmail.com>
Co-authored-by: Benjie <code@benjiegillam.com>

Author: 3 people

packages/graphile-build-pg/src/plugins/PgIntrospectionPlugin.js

@@ -209,6 +209,20 @@ export type PgEntity =
   | PgExtension
   | PgIndex;
 
+const fakeEnumIdentifier = (
+  namespaceName: string,
+  name: string,
+  identifierExtra = "",
+  list = false
+) => {
+  const baseEnumIdentifier = `FAKE_ENUM_${namespaceName}_${name}${identifierExtra}`;
+  if (list) {
+    return `${baseEnumIdentifier}_list`;
+  } else {
+    return baseEnumIdentifier;
+  }
+};
+
 export type PgIntrospectionResultsByKind = {
   __pgVersion: number,
   attribute: PgAttribute[],
@@ -556,7 +570,12 @@ function enumTables(introspectionResults) {
       const enumTypeArray = {
         kind: "type",
         isFake: true,
-        id: `FAKE_ENUM_${klass.namespaceName}_${klass.name}${constraintIdent}_list`,
+        id: fakeEnumIdentifier(
+          klass.namespaceName,
+          klass.name,
+          constraintIdent,
+          true
+        ),
         name: `_${klass.name}${constraintIdent}`,
         description: null,
         tags: {},
@@ -579,7 +598,12 @@ function enumTables(introspectionResults) {
       const enumType = {
         kind: "type",
         isFake: true,
-        id: `FAKE_ENUM_${klass.namespaceName}_${klass.name}${constraintIdent}`,
+        id: fakeEnumIdentifier(
+          klass.namespaceName,
+          klass.name,
+          constraintIdent,
+          false
+        ),
         name: `${klass.name}${constraintIdent}`,
         description: klass.description,
         tags: { ...klass.tags, ...constraint.tags },
@@ -1320,6 +1344,7 @@ Original error: ${e.message}
         rawIntrospectionResultsByKind,
         build.pgAugmentIntrospectionResults
       );
+
       if (introspectionResultsByKind.__pgVersion < 90500) {
         // TODO:v5: remove this workaround
         // This is a bit of a hack, but until we have plugin priorities it's the
@@ -1330,6 +1355,7 @@ Original error: ${e.message}
       }
       return build.extend(build, {
         pgIntrospectionResultsByKind: introspectionResultsByKind,
+        getPgFakeEnumIdentifier: fakeEnumIdentifier,
       });
     },
     ["PgIntrospection"],

packages/graphile-build-pg/src/plugins/PgTypesPlugin.js

@@ -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,
@@ -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];
       };
 

packages/postgraphile-core/__tests__/kitchen-sink-data.sql

@@ -321,3 +321,12 @@ insert into ranges.range_test(
 
 alter sequence c.issue756_id_seq restart with 1;
 alter sequence inheritence.file_id_seq restart with 1;
+
+--------------------------------------------------------------------------------
+
+insert into function_returning_enum.applicants(
+  id, first_name, last_name, stage, favorite_pet, transportation
+) values 
+  (1, 'John', 'Doe', 'round 2', 'CAT', 'BIKE' ),
+  (2, 'David', 'Bowie', 'round 2', 'DOG', 'SUBWAY'),
+  (3, 'John', 'Lennon', 'round 1', 'CAT', 'CAR');

packages/postgraphile-core/__tests__/kitchen-sink-schema.sql

@@ -14,7 +14,8 @@ drop schema if exists
   network_types,
   named_query_builder,
   enum_tables,
-  geometry
+  geometry,
+  function_returning_enum
 cascade;
 drop extension if exists tablefunc;
 drop extension if exists intarray;
@@ -1238,3 +1239,125 @@ create table geometry.geom (
   polygon polygon,
   circle circle
 );
+
+--------------------------------------------------------------------------------
+
+create schema function_returning_enum;
+
+create table function_returning_enum.stage_options (
+  type text primary key
+);
+comment on table function_returning_enum.stage_options is E'@enum';
+insert into function_returning_enum.stage_options (type) values ('pending'), ('round 1'), ('round 2'), ('rejected'), ('hired');
+
+create type function_returning_enum.animal_type as enum (
+  'CAT',
+  'DOG',
+  'FISH'
+);
+
+
+create table function_returning_enum.enum_table (
+  transportation text not null constraint transportation_enum unique
+);
+
+comment on constraint transportation_enum on function_returning_enum.enum_table is E'@enum';
+insert into function_returning_enum.enum_table (transportation) values ('CAR'), ('BIKE'), ('SUBWAY');
+
+create table function_returning_enum.applicants (
+  id int,
+  first_name text,
+  last_name text,
+  favorite_pet function_returning_enum.animal_type,
+  stage text references function_returning_enum.stage_options (type),
+  transportation text references function_returning_enum.enum_table (transportation)
+);
+
+--- follow the convention of [enum_name]_enum_domain
+create domain function_returning_enum.stage_options_enum_domain as text;
+
+create function function_returning_enum.applicants_next_stage(
+  a function_returning_enum.applicants
+) returns function_returning_enum.stage_options_enum_domain
+as $$
+  select (case when a.stage = 'round 2' then 'hired' 
+    else 'rejected' end)::function_returning_enum.stage_options_enum_domain;
+$$ language sql stable;
+comment on function function_returning_enum.applicants_next_stage is E'@filterable';
+
+create table function_returning_enum.length_status (
+  type text primary key
+);
+comment on table function_returning_enum.length_status is E'@enum';
+insert into function_returning_enum.length_status (type) values ('ok'), ('too_short');
+
+--- use an @enum tag this time
+create domain function_returning_enum.length as text;
+comment on domain function_returning_enum.length is E'@enum length_status';
+
+create function function_returning_enum.text_length(
+  text text,
+  min_length int
+) returns function_returning_enum.length
+as $$
+  select (case when length(text) < min_length then 'too_short' 
+    else 'ok' end)::function_returning_enum.length;
+$$ language sql stable;
+
+create function function_returning_enum.applicants_name_length(
+  a function_returning_enum.applicants
+) returns function_returning_enum.length
+as $$
+  select function_returning_enum.text_length(a.last_name, 4)::function_returning_enum.length;
+$$ language sql stable;
+comment on function function_returning_enum.applicants_name_length is E'@filterable';
+
+create function function_returning_enum.applicants_by_stage(
+  wanted_stage function_returning_enum.stage_options_enum_domain
+) returns setof function_returning_enum.applicants
+as $$ 
+  select * from function_returning_enum.applicants a where a.stage = wanted_stage;
+$$ language sql stable;
+
+create function function_returning_enum.applicants_by_favorite_pet(
+  pet function_returning_enum.animal_type
+) returns setof function_returning_enum.applicants
+as $$ 
+  select * from function_returning_enum.applicants a where a.favorite_pet = pet;
+$$ language sql stable;
+
+create function function_returning_enum.applicants_pet_food(
+  a function_returning_enum.applicants
+) returns function_returning_enum.animal_type
+as $$
+  select (case 
+    when a.favorite_pet = 'FISH' then null 
+    when a.favorite_pet = 'CAT' then 'FISH'
+    when a.favorite_pet = 'DOG' then 'CAT'
+    else null
+    end)::function_returning_enum.animal_type;
+$$ language sql stable;
+comment on function function_returning_enum.applicants_pet_food is E'@filterable';
+
+create domain function_returning_enum.transportation as text;
+comment on domain function_returning_enum.transportation is E'@enum enum_table_transportation_enum';
+
+create function function_returning_enum.applicants_by_transportation(
+  transportation function_returning_enum.transportation
+) returns setof function_returning_enum.applicants
+as $$ 
+  select * from function_returning_enum.applicants a where a.transportation = applicants_by_transportation.transportation;
+$$ language sql stable;
+
+create function function_returning_enum.applicants_favorite_pet_transportation(
+  a function_returning_enum.applicants
+) returns function_returning_enum.transportation
+as $$
+  select (case 
+    when a.favorite_pet = 'FISH' then 'SUBWAY' 
+    when a.favorite_pet = 'CAT' then 'CAR'
+    when a.favorite_pet = 'DOG' then 'BIKE'
+    else null
+    end)::function_returning_enum.transportation;
+$$ language sql stable;
+comment on function function_returning_enum.applicants_favorite_pet_transportation is E'@filterable';