graphile-plugin-connection-filter 2.3.1

package/PgConnectionArgFilterForwardRelationsPlugin.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+    });
+};
+exports.default = PgConnectionArgFilterForwardRelationsPlugin;

package/PgConnectionArgFilterLogicalOperatorsPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'graphile-build';
+declare const PgConnectionArgFilterLogicalOperatorsPlugin: Plugin;
+export default PgConnectionArgFilterLogicalOperatorsPlugin;

package/PgConnectionArgFilterLogicalOperatorsPlugin.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+    });
+};
+exports.default = PgConnectionArgFilterLogicalOperatorsPlugin;

package/PgConnectionArgFilterOperatorsPlugin.d.ts

@@ -0,0 +1,15 @@
+import type { Plugin } from 'graphile-build';
+import type { PgType, QueryBuilder, SQL } from 'graphile-build-pg';
+import type { GraphQLInputType, GraphQLType } from 'graphql';
+declare const PgConnectionArgFilterOperatorsPlugin: Plugin;
+export interface OperatorSpec {
+    name?: string;
+    description: string;
+    resolveInput?: (input: unknown) => unknown;
+    resolveSql?: any;
+    resolveSqlIdentifier?: (sqlIdentifier: SQL, pgType: PgType, pgTypeModifier: number | null) => SQL;
+    resolveSqlValue?: (input: unknown, pgType: PgType, pgTypeModifier: number | null, resolveListItemSqlValue?: any) => SQL | null;
+    resolveType?: (fieldInputType: GraphQLInputType, rangeElementInputType: GraphQLInputType) => GraphQLType;
+    resolve: (sqlIdentifier: SQL, sqlValue: SQL, input: unknown, parentFieldName: string, queryBuilder: QueryBuilder) => SQL | null;
+}
+export default PgConnectionArgFilterOperatorsPlugin;