graphile-plugin-connection-filter 2.3.1

package/esm/PgConnectionArgFilterColumnsPlugin.js

@@ -0,0 +1,49 @@
+const PgConnectionArgFilterColumnsPlugin = (builder) => {
+    builder.hook('GraphQLInputObjectType:fields', (fields, build, context) => {
+        const { extend, newWithHooks, pgSql: sql, pgIntrospectionResultsByKind: introspectionResultsByKind, pgColumnFilter, pgOmit: omit, inflection, connectionFilterOperatorsType, connectionFilterRegisterResolver, connectionFilterResolve, connectionFilterTypesByTypeName, } = build;
+        const { fieldWithHooks, scope: { pgIntrospection: table, isPgConnectionFilter }, Self, } = context;
+        if (!isPgConnectionFilter || table.kind !== 'class')
+            return fields;
+        connectionFilterTypesByTypeName[Self.name] = Self;
+        const attrByFieldName = introspectionResultsByKind.attribute
+            .filter((attr) => attr.classId === table.id)
+            .filter((attr) => pgColumnFilter(attr, build, context))
+            .filter((attr) => !omit(attr, 'filter'))
+            .reduce((memo, attr) => {
+            const fieldName = inflection.column(attr);
+            memo[fieldName] = attr;
+            return memo;
+        }, {});
+        const operatorsTypeNameByFieldName = {};
+        const attrFields = Object.entries(attrByFieldName).reduce((memo, [fieldName, attr]) => {
+            const OperatorsType = connectionFilterOperatorsType(newWithHooks, attr.typeId, attr.typeModifier);
+            if (!OperatorsType) {
+                return memo;
+            }
+            operatorsTypeNameByFieldName[fieldName] = OperatorsType.name;
+            return extend(memo, {
+                [fieldName]: fieldWithHooks(fieldName, {
+                    description: `Filter by the object’s \`${fieldName}\` field.`,
+                    type: OperatorsType,
+                }, {
+                    isPgConnectionFilterField: true,
+                }),
+            });
+        }, {});
+        const resolve = ({ sourceAlias, fieldName, fieldValue, queryBuilder, }) => {
+            if (fieldValue == null)
+                return null;
+            const attr = attrByFieldName[fieldName];
+            const sqlIdentifier = sql.query `${sourceAlias}.${sql.identifier(attr.name)}`;
+            const pgType = attr.type;
+            const pgTypeModifier = attr.typeModifier;
+            const filterTypeName = operatorsTypeNameByFieldName[fieldName];
+            return connectionFilterResolve(fieldValue, sqlIdentifier, filterTypeName, queryBuilder, pgType, pgTypeModifier, fieldName);
+        };
+        for (const fieldName of Object.keys(attrFields)) {
+            connectionFilterRegisterResolver(Self.name, fieldName, resolve);
+        }
+        return extend(fields, attrFields);
+    });
+};
+export default PgConnectionArgFilterColumnsPlugin;

package/esm/PgConnectionArgFilterCompositeTypeColumnsPlugin.js

@@ -0,0 +1,65 @@
+const PgConnectionArgFilterCompositeTypeColumnsPlugin = (builder, rawOptions) => {
+    const { connectionFilterAllowedFieldTypes } = rawOptions;
+    builder.hook('GraphQLInputObjectType:fields', (fields, build, context) => {
+        const { extend, newWithHooks, pgSql: sql, pgIntrospectionResultsByKind: introspectionResultsByKind, pgGetGqlTypeByTypeIdAndModifier, pgColumnFilter, pgOmit: omit, inflection, connectionFilterRegisterResolver, connectionFilterResolve, connectionFilterType, connectionFilterTypesByTypeName, } = build;
+        const { fieldWithHooks, scope: { pgIntrospection: table, isPgConnectionFilter }, Self, } = context;
+        if (!isPgConnectionFilter || table.kind !== 'class')
+            return fields;
+        connectionFilterTypesByTypeName[Self.name] = Self;
+        const attrByFieldName = introspectionResultsByKind.attribute
+            .filter((attr) => attr.classId === table.id)
+            .filter((attr) => pgColumnFilter(attr, build, context))
+            .filter((attr) => !omit(attr, 'filter'))
+            .filter((attr) => attr.type &&
+            attr.type.type === 'c' &&
+            attr.type.class &&
+            !attr.type.class.isSelectable) // keep only the composite type columns
+            .reduce((memo, attr) => {
+            const fieldName = inflection.column(attr);
+            memo[fieldName] = attr;
+            return memo;
+        }, {});
+        const filterTypeNameByFieldName = {};
+        const attrFields = Object.entries(attrByFieldName).reduce((memo, [fieldName, attr]) => {
+            const NodeType = pgGetGqlTypeByTypeIdAndModifier(attr.typeId, attr.typeModifier);
+            if (!NodeType) {
+                return memo;
+            }
+            const nodeTypeName = NodeType.name;
+            // Respect `connectionFilterAllowedFieldTypes` config option
+            if (connectionFilterAllowedFieldTypes &&
+                !connectionFilterAllowedFieldTypes.includes(nodeTypeName)) {
+                return memo;
+            }
+            const filterTypeName = inflection.filterType(nodeTypeName);
+            const CompositeFilterType = connectionFilterType(newWithHooks, filterTypeName, attr.type.class, nodeTypeName);
+            if (!CompositeFilterType) {
+                return memo;
+            }
+            filterTypeNameByFieldName[fieldName] = filterTypeName;
+            return extend(memo, {
+                [fieldName]: fieldWithHooks(fieldName, {
+                    description: `Filter by the object’s \`${fieldName}\` field.`,
+                    type: CompositeFilterType,
+                }, {
+                    isPgConnectionFilterField: true,
+                }),
+            });
+        }, {});
+        const resolve = ({ sourceAlias, fieldName, fieldValue, queryBuilder, }) => {
+            if (fieldValue == null)
+                return null;
+            const attr = attrByFieldName[fieldName];
+            const sqlIdentifier = sql.query `(${sourceAlias}.${sql.identifier(attr.name)})`; // parentheses are required to avoid confusing the parser
+            const pgType = attr.type;
+            const pgTypeModifier = attr.typeModifier;
+            const filterTypeName = filterTypeNameByFieldName[fieldName];
+            return connectionFilterResolve(fieldValue, sqlIdentifier, filterTypeName, queryBuilder, pgType, pgTypeModifier, fieldName);
+        };
+        for (const fieldName of Object.keys(attrFields)) {
+            connectionFilterRegisterResolver(Self.name, fieldName, resolve);
+        }
+        return extend(fields, attrFields);
+    });
+};
+export default PgConnectionArgFilterCompositeTypeColumnsPlugin;

package/esm/PgConnectionArgFilterComputedColumnsPlugin.js

@@ -0,0 +1,112 @@
+const PgConnectionArgFilterComputedColumnsPlugin = (builder, rawOptions) => {
+    const { connectionFilterComputedColumns } = rawOptions;
+    builder.hook('GraphQLInputObjectType:fields', (fields, build, context) => {
+        const { extend, newWithHooks, pgIntrospectionResultsByKind: introspectionResultsByKind, pgOmit: omit, pgSql: sql, inflection, connectionFilterOperatorsType, connectionFilterRegisterResolver, connectionFilterResolve, connectionFilterTypesByTypeName, } = build;
+        const { scope: { isPgConnectionFilter, pgIntrospection: table }, fieldWithHooks, Self, } = context;
+        if (!isPgConnectionFilter || !table || table.kind !== 'class') {
+            return fields;
+        }
+        connectionFilterTypesByTypeName[Self.name] = Self;
+        const procByFieldName = introspectionResultsByKind.procedure.reduce((memo, proc) => {
+            // Must be marked @filterable OR enabled via plugin option
+            if (!(proc.tags.filterable || connectionFilterComputedColumns))
+                return memo;
+            // Must not be omitted
+            if (omit(proc, 'execute'))
+                return memo;
+            if (omit(proc, 'filter'))
+                return memo;
+            // Must be a computed column
+            const computedColumnDetails = getComputedColumnDetails(build, table, proc);
+            if (!computedColumnDetails)
+                return memo;
+            const { pseudoColumnName } = computedColumnDetails;
+            // Must have only one required argument
+            const inputArgsCount = proc.argTypeIds.filter((_typeId, idx) => proc.argModes.length === 0 || // all args are `in`
+                proc.argModes[idx] === 'i' || // this arg is `in`
+                proc.argModes[idx] === 'b' // this arg is `inout`
+            ).length;
+            const nonOptionalArgumentsCount = inputArgsCount - proc.argDefaultsNum;
+            if (nonOptionalArgumentsCount > 1) {
+                return memo;
+            }
+            // Must return a scalar or an array
+            if (proc.returnsSet)
+                return memo;
+            const returnType = introspectionResultsByKind.typeById[proc.returnTypeId];
+            const returnTypeTable = introspectionResultsByKind.classById[returnType.classId];
+            if (returnTypeTable)
+                return memo;
+            const isRecordLike = returnType.id === '2249';
+            if (isRecordLike)
+                return memo;
+            const isVoid = String(returnType.id) === '2278';
+            if (isVoid)
+                return memo;
+            // Looks good
+            const fieldName = inflection.computedColumn(pseudoColumnName, proc, table);
+            memo = build.extend(memo, { [fieldName]: proc });
+            return memo;
+        }, {});
+        const operatorsTypeNameByFieldName = {};
+        const procFields = Object.entries(procByFieldName).reduce((memo, [fieldName, proc]) => {
+            const OperatorsType = connectionFilterOperatorsType(newWithHooks, proc.returnTypeId, null);
+            if (!OperatorsType) {
+                return memo;
+            }
+            operatorsTypeNameByFieldName[fieldName] = OperatorsType.name;
+            return extend(memo, {
+                [fieldName]: fieldWithHooks(fieldName, {
+                    description: `Filter by the object’s \`${fieldName}\` field.`,
+                    type: OperatorsType,
+                }, {
+                    isPgConnectionFilterField: true,
+                }),
+            });
+        }, {});
+        const resolve = ({ sourceAlias, fieldName, fieldValue, queryBuilder, }) => {
+            if (fieldValue == null)
+                return null;
+            const proc = procByFieldName[fieldName];
+            const sqlIdentifier = sql.query `${sql.identifier(proc.namespace.name)}.${sql.identifier(proc.name)}(${sourceAlias})`;
+            const pgType = introspectionResultsByKind.typeById[proc.returnTypeId];
+            const pgTypeModifier = null;
+            const filterTypeName = operatorsTypeNameByFieldName[fieldName];
+            return connectionFilterResolve(fieldValue, sqlIdentifier, filterTypeName, queryBuilder, pgType, pgTypeModifier, fieldName);
+        };
+        for (const fieldName of Object.keys(procFields)) {
+            connectionFilterRegisterResolver(Self.name, fieldName, resolve);
+        }
+        return extend(fields, procFields);
+    });
+    function getComputedColumnDetails(build, table, proc) {
+        if (!proc.isStable)
+            return null;
+        if (proc.namespaceId !== table.namespaceId)
+            return null;
+        if (!proc.name.startsWith(`${table.name}_`))
+            return null;
+        if (proc.argTypeIds.length < 1)
+            return null;
+        if (proc.argTypeIds[0] !== table.type.id)
+            return null;
+        const argTypes = proc.argTypeIds.reduce((prev, typeId, idx) => {
+            if (proc.argModes.length === 0 || // all args are `in`
+                proc.argModes[idx] === 'i' || // this arg is `in`
+                proc.argModes[idx] === 'b' // this arg is `inout`
+            ) {
+                prev.push(build.pgIntrospectionResultsByKind.typeById[typeId]);
+            }
+            return prev;
+        }, []);
+        if (argTypes
+            .slice(1)
+            .some((type) => type.type === 'c' && type.class && type.class.isSelectable)) {
+            // Accepts two input tables? Skip.
+            return null;
+        }
+        const pseudoColumnName = proc.name.substr(table.name.length + 1);
+        return { argTypes, pseudoColumnName };
+    }
+};
+export default PgConnectionArgFilterComputedColumnsPlugin;

package/esm/PgConnectionArgFilterForwardRelationsPlugin.js

@@ -0,0 +1,128 @@
+const PgConnectionArgFilterForwardRelationsPlugin = (builder) => {
+    builder.hook('inflection', (inflection) => ({
+        ...inflection,
+        filterForwardRelationExistsFieldName(relationFieldName) {
+            return `${relationFieldName}Exists`;
+        },
+        filterSingleRelationFieldName(fieldName) {
+            return fieldName;
+        },
+    }));
+    builder.hook('GraphQLInputObjectType:fields', (fields, build, context) => {
+        const { describePgEntity, extend, newWithHooks, inflection, graphql: { GraphQLBoolean }, pgOmit: omit, pgSql: sql, pgIntrospectionResultsByKind: introspectionResultsByKind, connectionFilterResolve, connectionFilterRegisterResolver, connectionFilterTypesByTypeName, connectionFilterType, } = build;
+        const { fieldWithHooks, scope: { pgIntrospection: table, isPgConnectionFilter }, Self, } = context;
+        if (!isPgConnectionFilter || table.kind !== 'class')
+            return fields;
+        connectionFilterTypesByTypeName[Self.name] = Self;
+        const forwardRelationSpecs = introspectionResultsByKind.constraint
+            .filter((con) => con.type === 'f')
+            .filter((con) => con.classId === table.id)
+            .reduce((memo, constraint) => {
+            if (omit(constraint, 'read') || omit(constraint, 'filter')) {
+                return memo;
+            }
+            const foreignTable = constraint.foreignClassId
+                ? introspectionResultsByKind.classById[constraint.foreignClassId]
+                : null;
+            if (!foreignTable) {
+                throw new Error(`Could not find the foreign table (constraint: ${constraint.name})`);
+            }
+            if (omit(foreignTable, 'read') || omit(foreignTable, 'filter')) {
+                return memo;
+            }
+            const attributes = introspectionResultsByKind.attribute
+                .filter((attr) => attr.classId === table.id)
+                .sort((a, b) => a.num - b.num);
+            const foreignAttributes = introspectionResultsByKind.attribute
+                .filter((attr) => attr.classId === foreignTable.id)
+                .sort((a, b) => a.num - b.num);
+            const keyAttributes = constraint.keyAttributeNums.map((num) => attributes.filter((attr) => attr.num === num)[0]);
+            const foreignKeyAttributes = constraint.foreignKeyAttributeNums.map((num) => foreignAttributes.filter((attr) => attr.num === num)[0]);
+            if (keyAttributes.some((attr) => omit(attr, 'read'))) {
+                return memo;
+            }
+            if (foreignKeyAttributes.some((attr) => omit(attr, 'read'))) {
+                return memo;
+            }
+            memo.push({
+                table,
+                keyAttributes,
+                foreignTable,
+                foreignKeyAttributes,
+                constraint,
+            });
+            return memo;
+        }, []);
+        let forwardRelationSpecByFieldName = {};
+        const addField = (fieldName, description, type, resolve, spec, hint) => {
+            // Field
+            fields = extend(fields, {
+                [fieldName]: fieldWithHooks(fieldName, {
+                    description,
+                    type,
+                }, {
+                    isPgConnectionFilterField: true,
+                }),
+            }, hint);
+            // Spec for use in resolver
+            forwardRelationSpecByFieldName = extend(forwardRelationSpecByFieldName, {
+                [fieldName]: spec,
+            });
+            // Resolver
+            connectionFilterRegisterResolver(Self.name, fieldName, resolve);
+        };
+        const resolve = ({ sourceAlias, fieldName, fieldValue, queryBuilder, }) => {
+            if (fieldValue == null)
+                return null;
+            const { foreignTable, foreignKeyAttributes, keyAttributes } = forwardRelationSpecByFieldName[fieldName];
+            const foreignTableAlias = sql.identifier(Symbol());
+            const sqlIdentifier = sql.identifier(foreignTable.namespace.name, foreignTable.name);
+            const sqlKeysMatch = sql.query `(${sql.join(keyAttributes.map((key, i) => {
+                return sql.fragment `${sourceAlias}.${sql.identifier(key.name)} = ${foreignTableAlias}.${sql.identifier(foreignKeyAttributes[i].name)}`;
+            }), ') and (')})`;
+            const foreignTableTypeName = inflection.tableType(foreignTable);
+            const foreignTableFilterTypeName = inflection.filterType(foreignTableTypeName);
+            const sqlFragment = connectionFilterResolve(fieldValue, foreignTableAlias, foreignTableFilterTypeName, queryBuilder);
+            return sqlFragment == null
+                ? null
+                : sql.query `\
+      exists(
+        select 1 from ${sqlIdentifier} as ${foreignTableAlias}
+        where ${sqlKeysMatch} and
+          (${sqlFragment})
+      )`;
+        };
+        const resolveExists = ({ sourceAlias, fieldName, fieldValue, }) => {
+            if (fieldValue == null)
+                return null;
+            const { foreignTable, foreignKeyAttributes, keyAttributes } = forwardRelationSpecByFieldName[fieldName];
+            const foreignTableAlias = sql.identifier(Symbol());
+            const sqlIdentifier = sql.identifier(foreignTable.namespace.name, foreignTable.name);
+            const sqlKeysMatch = sql.query `(${sql.join(keyAttributes.map((key, i) => {
+                return sql.fragment `${sourceAlias}.${sql.identifier(key.name)} = ${foreignTableAlias}.${sql.identifier(foreignKeyAttributes[i].name)}`;
+            }), ') and (')})`;
+            const sqlSelectWhereKeysMatch = sql.query `select 1 from ${sqlIdentifier} as ${foreignTableAlias} where ${sqlKeysMatch}`;
+            return fieldValue === true
+                ? sql.query `exists(${sqlSelectWhereKeysMatch})`
+                : sql.query `not exists(${sqlSelectWhereKeysMatch})`;
+        };
+        for (const spec of forwardRelationSpecs) {
+            const { constraint, foreignTable, keyAttributes } = spec;
+            const fieldName = inflection.singleRelationByKeys(keyAttributes, foreignTable, table, constraint);
+            const filterFieldName = inflection.filterSingleRelationFieldName(fieldName);
+            const foreignTableTypeName = inflection.tableType(foreignTable);
+            const foreignTableFilterTypeName = inflection.filterType(foreignTableTypeName);
+            const ForeignTableFilterType = connectionFilterType(newWithHooks, foreignTableFilterTypeName, foreignTable, foreignTableTypeName);
+            if (!ForeignTableFilterType)
+                continue;
+            addField(filterFieldName, `Filter by the object’s \`${fieldName}\` relation.`, ForeignTableFilterType, resolve, spec, `Adding connection filter forward relation field from ${describePgEntity(table)} to ${describePgEntity(foreignTable)}`);
+            const keyIsNullable = !keyAttributes.every((attr) => attr.isNotNull);
+            if (keyIsNullable) {
+                const existsFieldName = inflection.filterForwardRelationExistsFieldName(fieldName);
+                addField(existsFieldName, `A related \`${fieldName}\` exists.`, GraphQLBoolean, resolveExists, spec, `Adding connection filter forward relation exists field from ${describePgEntity(table)} to ${describePgEntity(foreignTable)}`);
+            }
+        }
+        return fields;
+    });
+};
+export default PgConnectionArgFilterForwardRelationsPlugin;

package/esm/PgConnectionArgFilterLogicalOperatorsPlugin.js

@@ -0,0 +1,65 @@
+const PgConnectionArgFilterLogicalOperatorsPlugin = (builder) => {
+    builder.hook('GraphQLInputObjectType:fields', (fields, build, context) => {
+        const { extend, graphql: { GraphQLList, GraphQLNonNull }, pgSql: sql, connectionFilterTypesByTypeName, connectionFilterResolve, connectionFilterRegisterResolver, } = build;
+        const { fieldWithHooks, scope: { isPgConnectionFilter }, Self, } = context;
+        if (!isPgConnectionFilter)
+            return fields;
+        connectionFilterTypesByTypeName[Self.name] = Self;
+        if (Object.keys(fields).length === 0) {
+            // Skip adding these operators if they would be the only fields
+            return fields;
+        }
+        const logicResolversByFieldName = {
+            and: (arr, sourceAlias, queryBuilder) => {
+                const sqlFragments = arr
+                    .map((o) => connectionFilterResolve(o, sourceAlias, Self.name, queryBuilder))
+                    .filter((x) => x != null);
+                return sqlFragments.length === 0
+                    ? null
+                    : sql.query `(${sql.join(sqlFragments, ') and (')})`;
+            },
+            or: (arr, sourceAlias, queryBuilder) => {
+                const sqlFragments = arr
+                    .map((o) => connectionFilterResolve(o, sourceAlias, Self.name, queryBuilder))
+                    .filter((x) => x != null);
+                return sqlFragments.length === 0
+                    ? null
+                    : sql.query `(${sql.join(sqlFragments, ') or (')})`;
+            },
+            not: (obj, sourceAlias, queryBuilder) => {
+                const sqlFragment = connectionFilterResolve(obj, sourceAlias, Self.name, queryBuilder);
+                return sqlFragment == null ? null : sql.query `not (${sqlFragment})`;
+            },
+        };
+        const logicalOperatorFields = {
+            and: fieldWithHooks('and', {
+                description: `Checks for all expressions in this list.`,
+                type: new GraphQLList(new GraphQLNonNull(Self)),
+            }, {
+                isPgConnectionFilterOperatorLogical: true,
+            }),
+            or: fieldWithHooks('or', {
+                description: `Checks for any expressions in this list.`,
+                type: new GraphQLList(new GraphQLNonNull(Self)),
+            }, {
+                isPgConnectionFilterOperatorLogical: true,
+            }),
+            not: fieldWithHooks('not', {
+                description: `Negates the expression.`,
+                type: Self,
+            }, {
+                isPgConnectionFilterOperatorLogical: true,
+            }),
+        };
+        const resolve = ({ sourceAlias, fieldName, fieldValue, queryBuilder, }) => {
+            if (fieldValue == null)
+                return null;
+            return logicResolversByFieldName[fieldName](fieldValue, sourceAlias, queryBuilder);
+        };
+        for (const fieldName of Object.keys(logicResolversByFieldName)) {
+            connectionFilterRegisterResolver(Self.name, fieldName, resolve);
+        }
+        return extend(fields, logicalOperatorFields);
+    });
+};
+export default PgConnectionArgFilterLogicalOperatorsPlugin;