graphile-many-to-many 1.0.3

package/createManyToManyConnectionType.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hasNonNullKey = (row) => {
+    if (Array.isArray(row.__identifiers) && row.__identifiers.every((identifier) => identifier != null)) {
+        return true;
+    }
+    for (const key in row) {
+        if (Object.prototype.hasOwnProperty.call(row, key)) {
+            if ((key[0] !== '_' || key[1] !== '_') && row[key] !== null) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+const base64 = (value) => Buffer.from(String(value)).toString('base64');
+const createManyToManyConnectionType = (relationship, build, options, leftTable) => {
+    const { leftKeyAttributes, junctionLeftKeyAttributes, junctionRightKeyAttributes, rightKeyAttributes, junctionTable, rightTable, junctionLeftConstraint, junctionRightConstraint } = relationship;
+    const { newWithHooks, inflection, graphql: { GraphQLObjectType, GraphQLNonNull, GraphQLList }, getTypeByName, pgGetGqlTypeByTypeIdAndModifier, pgField, getSafeAliasFromResolveInfo, describePgEntity } = build;
+    const { pgForbidSetofFunctionsToReturnNull = false } = options;
+    const nullableIf = (condition, Type) => condition ? Type : new GraphQLNonNull(Type);
+    const Cursor = getTypeByName('Cursor');
+    const handleNullRow = pgForbidSetofFunctionsToReturnNull
+        ? (row) => row
+        : (row, identifiers) => {
+            if ((identifiers && hasNonNullKey(identifiers)) || hasNonNullKey(row)) {
+                return row;
+            }
+            return null;
+        };
+    const LeftTableType = pgGetGqlTypeByTypeIdAndModifier(leftTable.type.id, null);
+    if (!LeftTableType) {
+        throw new Error(`Could not determine type for table with id ${leftTable.type.id}`);
+    }
+    const TableType = pgGetGqlTypeByTypeIdAndModifier(rightTable.type.id, null);
+    if (!TableType) {
+        throw new Error(`Could not determine type for table with id ${rightTable.type.id}`);
+    }
+    const rightPrimaryKeyConstraint = rightTable.primaryKeyConstraint;
+    const rightPrimaryKeyAttributes = rightPrimaryKeyConstraint && rightPrimaryKeyConstraint.keyAttributes;
+    const junctionTypeName = inflection.tableType(junctionTable);
+    const EdgeType = newWithHooks(GraphQLObjectType, {
+        description: `A \`${TableType.name}\` edge in the connection, with data from \`${junctionTypeName}\`.`,
+        name: inflection.manyToManyRelationEdge(leftKeyAttributes, junctionLeftKeyAttributes, junctionRightKeyAttributes, rightKeyAttributes, junctionTable, rightTable, junctionLeftConstraint, junctionRightConstraint, LeftTableType.name),
+        fields: ({ fieldWithHooks }) => {
+            return {
+                cursor: fieldWithHooks('cursor', ({ addDataGenerator }) => {
+                    addDataGenerator(() => ({
+                        usesCursor: [true],
+                        pgQuery: (queryBuilder) => {
+                            if (rightPrimaryKeyAttributes) {
+                                queryBuilder.selectIdentifiers(rightTable);
+                            }
+                        }
+                    }));
+                    return {
+                        description: 'A cursor for use in pagination.',
+                        type: Cursor,
+                        resolve(data) {
+                            return data.__cursor && base64(JSON.stringify(data.__cursor));
+                        }
+                    };
+                }, {
+                    isCursorField: true
+                }),
+                node: pgField(build, fieldWithHooks, 'node', {
+                    description: `The \`${TableType.name}\` at the end of the edge.`,
+                    type: nullableIf(!pgForbidSetofFunctionsToReturnNull, TableType),
+                    resolve(data, _args, _context, resolveInfo) {
+                        const safeAlias = getSafeAliasFromResolveInfo(resolveInfo);
+                        const record = handleNullRow(data[safeAlias], data.__identifiers);
+                        return record;
+                    }
+                }, {}, false, {})
+            };
+        }
+    }, {
+        __origin: `Adding many-to-many edge type from ${describePgEntity(leftTable)} to ${describePgEntity(rightTable)} via ${describePgEntity(junctionTable)}.`,
+        isEdgeType: true,
+        isPgRowEdgeType: true,
+        isPgManyToManyEdgeType: true,
+        nodeType: TableType,
+        pgManyToManyRelationship: relationship
+    });
+    const PageInfo = getTypeByName(inflection.builtin('PageInfo'));
+    return newWithHooks(GraphQLObjectType, {
+        description: `A connection to a list of \`${TableType.name}\` values, with data from \`${junctionTypeName}\`.`,
+        name: inflection.manyToManyRelationConnection(leftKeyAttributes, junctionLeftKeyAttributes, junctionRightKeyAttributes, rightKeyAttributes, junctionTable, rightTable, junctionLeftConstraint, junctionRightConstraint, LeftTableType.name),
+        fields: ({ recurseDataGeneratorsForField, fieldWithHooks }) => {
+            recurseDataGeneratorsForField('pageInfo', true);
+            return {
+                nodes: pgField(build, fieldWithHooks, 'nodes', {
+                    description: `A list of \`${TableType.name}\` objects.`,
+                    type: new GraphQLNonNull(new GraphQLList(nullableIf(!pgForbidSetofFunctionsToReturnNull, TableType))),
+                    resolve(data, _args, _context, resolveInfo) {
+                        const safeAlias = getSafeAliasFromResolveInfo(resolveInfo);
+                        return data.data.map((entry) => {
+                            const record = handleNullRow(entry[safeAlias], entry[safeAlias].__identifiers);
+                            return record;
+                        });
+                    }
+                }, {}, false, {}),
+                edges: pgField(build, fieldWithHooks, 'edges', {
+                    description: `A list of edges which contains the \`${TableType.name}\`, info from the \`${junctionTypeName}\`, and the cursor to aid in pagination.`,
+                    type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(EdgeType))),
+                    resolve(data, _args, _context, resolveInfo) {
+                        const safeAlias = getSafeAliasFromResolveInfo(resolveInfo);
+                        return data.data.map((entry) => ({
+                            ...entry,
+                            ...entry[safeAlias]
+                        }));
+                    }
+                }, {}, false, {
+                    hoistCursor: true
+                }),
+                pageInfo: PageInfo && {
+                    description: 'Information to aid in pagination.',
+                    type: new GraphQLNonNull(PageInfo),
+                    resolve(data) {
+                        return data;
+                    }
+                }
+            };
+        }
+    }, {
+        __origin: `Adding many-to-many connection type from ${describePgEntity(leftTable)} to ${describePgEntity(rightTable)} via ${describePgEntity(junctionTable)}.`,
+        isConnectionType: true,
+        isPgRowConnectionType: true,
+        edgeType: EdgeType,
+        nodeType: TableType,
+        pgIntrospection: rightTable
+    });
+};
+exports.default = createManyToManyConnectionType;

package/esm/PgManyToManyRelationEdgeColumnsPlugin.js

@@ -0,0 +1,58 @@
+const PgManyToManyRelationEdgeColumnsPlugin = (builder) => {
+    builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
+        const { extend, pgGetGqlTypeByTypeIdAndModifier, pgSql: sql, pg2gql, graphql: { GraphQLString, GraphQLNonNull }, pgColumnFilter, inflection, pgOmit: omit, pgGetSelectValueForFieldAndTypeAndModifier: getSelectValueForFieldAndTypeAndModifier, describePgEntity } = build;
+        const { scope: { isPgManyToManyEdgeType, pgManyToManyRelationship }, fieldWithHooks } = context;
+        const nullableIf = (condition, Type) => condition ? Type : new GraphQLNonNull(Type);
+        if (!isPgManyToManyEdgeType || !pgManyToManyRelationship) {
+            return fields;
+        }
+        const { leftKeyAttributes, junctionTable, junctionLeftKeyAttributes, junctionRightKeyAttributes, rightKeyAttributes, allowsMultipleEdgesToNode } = pgManyToManyRelationship;
+        if (allowsMultipleEdgesToNode) {
+            return fields;
+        }
+        return extend(fields, junctionTable.attributes.reduce((memo, attr) => {
+            if (!pgColumnFilter(attr, build, context))
+                return memo;
+            if (omit(attr, 'read'))
+                return memo;
+            // Skip left and right key attributes
+            if (junctionLeftKeyAttributes.map((a) => a.name).includes(attr.name))
+                return memo;
+            if (junctionRightKeyAttributes.map((a) => a.name).includes(attr.name))
+                return memo;
+            const fieldName = inflection.column(attr);
+            const ReturnType = pgGetGqlTypeByTypeIdAndModifier(attr.typeId, attr.typeModifier) || GraphQLString;
+            // Since we're ignoring multi-column keys, we can simplify here
+            const leftKeyAttribute = leftKeyAttributes[0];
+            const junctionLeftKeyAttribute = junctionLeftKeyAttributes[0];
+            const junctionRightKeyAttribute = junctionRightKeyAttributes[0];
+            const rightKeyAttribute = rightKeyAttributes[0];
+            const sqlSelectFrom = sql.fragment `select ${sql.identifier(attr.name)} from ${sql.identifier(junctionTable.namespace.name, junctionTable.name)}`;
+            const fieldConfig = fieldWithHooks(fieldName, (fieldContext) => {
+                const { type, typeModifier } = attr;
+                const { addDataGenerator } = fieldContext;
+                addDataGenerator((parsedResolveInfoFragment) => {
+                    return {
+                        pgQuery: (queryBuilder) => {
+                            queryBuilder.select(getSelectValueForFieldAndTypeAndModifier(ReturnType, fieldContext, parsedResolveInfoFragment, sql.fragment `(${sqlSelectFrom} where ${sql.identifier(junctionRightKeyAttribute.name)} = ${queryBuilder.getTableAlias()}.${sql.identifier(rightKeyAttribute.name)} and ${sql.identifier(junctionLeftKeyAttribute.name)} = ${queryBuilder.parentQueryBuilder.parentQueryBuilder.getTableAlias()}.${sql.identifier(leftKeyAttribute.name)})`, type, typeModifier), fieldName);
+                        }
+                    };
+                });
+                return {
+                    description: attr.description,
+                    type: nullableIf(!attr.isNotNull && !attr.type.domainIsNotNull && !attr.tags.notNull, ReturnType),
+                    resolve: (data) => {
+                        return pg2gql(data[fieldName], attr.type);
+                    }
+                };
+            }, {
+                isPgManyToManyRelationEdgeColumnField: true,
+                pgFieldIntrospection: attr
+            });
+            return extend(memo, {
+                [fieldName]: fieldConfig
+            }, `Adding field for ${describePgEntity(attr)}.`);
+        }, {}), `Adding columns to '${describePgEntity(junctionTable)}'`);
+    }, ['PgManyToManyRelationEdgeColumns']);
+};
+export default PgManyToManyRelationEdgeColumnsPlugin;

package/esm/PgManyToManyRelationEdgeTablePlugin.js

@@ -0,0 +1,105 @@
+const PgManyToManyRelationEdgeTablePlugin = (builder, { pgSimpleCollections }) => {
+    builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
+        const { extend, getTypeByName, pgGetGqlTypeByTypeIdAndModifier, graphql: { GraphQLNonNull, GraphQLList }, inflection, getSafeAliasFromResolveInfo, getSafeAliasFromAlias, pgQueryFromResolveData: queryFromResolveData, pgAddStartEndCursor: addStartEndCursor, pgSql: sql, describePgEntity } = build;
+        const { scope: { isPgManyToManyEdgeType, pgManyToManyRelationship }, fieldWithHooks, Self } = context;
+        if (!isPgManyToManyEdgeType || !pgManyToManyRelationship) {
+            return fields;
+        }
+        const { leftKeyAttributes, junctionLeftKeyAttributes, rightTable, rightKeyAttributes, junctionRightKeyAttributes, junctionTable, junctionRightConstraint, allowsMultipleEdgesToNode } = pgManyToManyRelationship;
+        if (!allowsMultipleEdgesToNode) {
+            return fields;
+        }
+        const JunctionTableType = pgGetGqlTypeByTypeIdAndModifier(junctionTable.type.id, null);
+        if (!JunctionTableType) {
+            throw new Error(`Could not determine type for table with id ${junctionTable.type.id}`);
+        }
+        const JunctionTableConnectionType = getTypeByName(inflection.connection(JunctionTableType.name));
+        const buildFields = (isConnection) => {
+            const fieldName = isConnection
+                ? inflection.manyRelationByKeys(junctionRightKeyAttributes, junctionTable, rightTable, junctionRightConstraint)
+                : inflection.manyRelationByKeysSimple(junctionRightKeyAttributes, junctionTable, rightTable, junctionRightConstraint);
+            const Type = isConnection ? JunctionTableConnectionType : JunctionTableType;
+            if (!Type) {
+                return undefined;
+            }
+            return {
+                [fieldName]: fieldWithHooks(fieldName, ({ getDataFromParsedResolveInfoFragment, addDataGenerator }) => {
+                    const sqlFrom = sql.identifier(junctionTable.namespace.name, junctionTable.name);
+                    const queryOptions = {
+                        useAsterisk: junctionTable.canUseAsterisk,
+                        withPagination: isConnection,
+                        withPaginationAsFields: false,
+                        asJsonAggregate: !isConnection
+                    };
+                    addDataGenerator((parsedResolveInfoFragment) => {
+                        return {
+                            pgQuery: (queryBuilder) => {
+                                queryBuilder.select(() => {
+                                    const resolveData = getDataFromParsedResolveInfoFragment(parsedResolveInfoFragment, Type);
+                                    const junctionTableAlias = sql.identifier(Symbol());
+                                    const rightTableAlias = queryBuilder.getTableAlias();
+                                    const leftTableAlias = queryBuilder.parentQueryBuilder.parentQueryBuilder.getTableAlias();
+                                    const query = queryFromResolveData(sqlFrom, junctionTableAlias, resolveData, queryOptions, (innerQueryBuilder) => {
+                                        innerQueryBuilder.parentQueryBuilder = queryBuilder;
+                                        const junctionPrimaryKeyConstraint = junctionTable.primaryKeyConstraint;
+                                        const junctionPrimaryKeyAttributes = junctionPrimaryKeyConstraint && junctionPrimaryKeyConstraint.keyAttributes;
+                                        if (junctionPrimaryKeyAttributes) {
+                                            innerQueryBuilder.beforeLock('orderBy', () => {
+                                                // append order by primary key to the list of orders
+                                                if (!innerQueryBuilder.isOrderUnique(false)) {
+                                                    innerQueryBuilder.data.cursorPrefix = ['primary_key_asc'];
+                                                    junctionPrimaryKeyAttributes.forEach((attr) => {
+                                                        innerQueryBuilder.orderBy(sql.fragment `${innerQueryBuilder.getTableAlias()}.${sql.identifier(attr.name)}`, true);
+                                                    });
+                                                    innerQueryBuilder.setOrderIsUnique();
+                                                }
+                                            });
+                                        }
+                                        junctionRightKeyAttributes.forEach((attr, i) => {
+                                            innerQueryBuilder.where(sql.fragment `${junctionTableAlias}.${sql.identifier(attr.name)} = ${rightTableAlias}.${sql.identifier(rightKeyAttributes[i].name)}`);
+                                        });
+                                        junctionLeftKeyAttributes.forEach((attr, i) => {
+                                            innerQueryBuilder.where(sql.fragment `${junctionTableAlias}.${sql.identifier(attr.name)} = ${leftTableAlias}.${sql.identifier(leftKeyAttributes[i].name)}`);
+                                        });
+                                    }, queryBuilder.context, queryBuilder.rootValue);
+                                    return sql.fragment `(${query})`;
+                                }, getSafeAliasFromAlias(parsedResolveInfoFragment.alias));
+                            }
+                        };
+                    });
+                    return {
+                        description: `Reads and enables pagination through a set of \`${JunctionTableType.name}\`.`,
+                        type: isConnection
+                            ? new GraphQLNonNull(JunctionTableConnectionType)
+                            : new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(JunctionTableType))),
+                        args: {},
+                        resolve: (data, _args, _context, resolveInfo) => {
+                            const safeAlias = getSafeAliasFromResolveInfo(resolveInfo);
+                            if (isConnection) {
+                                return addStartEndCursor(data[safeAlias]);
+                            }
+                            return data[safeAlias];
+                        }
+                    };
+                }, {
+                    isPgFieldConnection: isConnection,
+                    isPgFieldSimpleCollection: !isConnection,
+                    isPgManyToManyRelationEdgeTableField: true,
+                    pgFieldIntrospection: junctionTable
+                })
+            };
+        };
+        const simpleCollections = junctionRightConstraint.tags.simpleCollections ||
+            junctionTable.tags.simpleCollections ||
+            pgSimpleCollections;
+        const hasConnections = simpleCollections !== 'only';
+        const hasSimpleCollections = simpleCollections === 'only' || simpleCollections === 'both';
+        const connectionFields = hasConnections ? buildFields(true) : undefined;
+        const simpleCollectionFields = hasSimpleCollections ? buildFields(false) : undefined;
+        return extend(fields, {
+            ...(connectionFields || {}),
+            ...(simpleCollectionFields || {})
+        }, `Many-to-many relation edge table (${hasConnections ? 'connection' : 'simple collection'}) on ${Self.name} type for ${describePgEntity(junctionRightConstraint)}.`);
+    });
+};
+export default PgManyToManyRelationEdgeTablePlugin;

package/esm/PgManyToManyRelationInflectionPlugin.js

@@ -0,0 +1,39 @@
+const PgManyToManyRelationInflectionPlugin = (builder) => {
+    builder.hook('inflection', (inflection) => {
+        const manyToManyRelationByKeys = function manyToManyRelationByKeys(_leftKeyAttributes, junctionLeftKeyAttributes, junctionRightKeyAttributes, _rightKeyAttributes, junctionTable, rightTable, _junctionLeftConstraint, junctionRightConstraint) {
+            if (junctionRightConstraint.tags.manyToManyFieldName) {
+                return junctionRightConstraint.tags.manyToManyFieldName;
+            }
+            return this.camelCase(`${this.pluralize(this._singularizedTableName(rightTable))}-by-${this._singularizedTableName(junctionTable)}-${[...junctionLeftKeyAttributes, ...junctionRightKeyAttributes]
+                .map((attr) => this.column(attr))
+                .join('-and-')}`);
+        };
+        const manyToManyRelationByKeysSimple = function manyToManyRelationByKeysSimple(_leftKeyAttributes, junctionLeftKeyAttributes, junctionRightKeyAttributes, _rightKeyAttributes, junctionTable, rightTable, _junctionLeftConstraint, junctionRightConstraint) {
+            if (junctionRightConstraint.tags.manyToManySimpleFieldName) {
+                return junctionRightConstraint.tags.manyToManySimpleFieldName;
+            }
+            return this.camelCase(`${this.pluralize(this._singularizedTableName(rightTable))}-by-${this._singularizedTableName(junctionTable)}-${[...junctionLeftKeyAttributes, ...junctionRightKeyAttributes]
+                .map((attr) => this.column(attr))
+                .join('-and-')}-list`);
+        };
+        const manyToManyRelationEdge = function manyToManyRelationEdge(leftKeyAttributes, junctionLeftKeyAttributes, junctionRightKeyAttributes, rightKeyAttributes, junctionTable, rightTable, junctionLeftConstraint, junctionRightConstraint, leftTableTypeName) {
+            const relationName = inflection.manyToManyRelationByKeys(leftKeyAttributes, junctionLeftKeyAttributes, junctionRightKeyAttributes, rightKeyAttributes, junctionTable, rightTable, junctionLeftConstraint, junctionRightConstraint);
+            return this.upperCamelCase(`${leftTableTypeName}-${relationName}-many-to-many-edge`);
+        };
+        const manyToManyRelationConnection = function manyToManyRelationConnection(leftKeyAttributes, junctionLeftKeyAttributes, junctionRightKeyAttributes, rightKeyAttributes, junctionTable, rightTable, junctionLeftConstraint, junctionRightConstraint, leftTableTypeName) {
+            const relationName = inflection.manyToManyRelationByKeys(leftKeyAttributes, junctionLeftKeyAttributes, junctionRightKeyAttributes, rightKeyAttributes, junctionTable, rightTable, junctionLeftConstraint, junctionRightConstraint, leftTableTypeName);
+            return this.upperCamelCase(`${leftTableTypeName}-${relationName}-many-to-many-connection`);
+        };
+        const manyToManyRelationSubqueryName = function manyToManyRelationSubqueryName(_leftKeyAttributes, _junctionLeftKeyAttributes, _junctionRightKeyAttributes, _rightKeyAttributes, junctionTable) {
+            return `many-to-many-subquery-by-${this._singularizedTableName(junctionTable)}`;
+        };
+        return Object.assign(inflection, {
+            manyToManyRelationByKeys,
+            manyToManyRelationByKeysSimple,
+            manyToManyRelationEdge,
+            manyToManyRelationConnection,
+            manyToManyRelationSubqueryName
+        });
+    });
+};
+export default PgManyToManyRelationInflectionPlugin;

package/esm/PgManyToManyRelationPlugin.js

@@ -0,0 +1,109 @@
+import createManyToManyConnectionType from './createManyToManyConnectionType';
+import manyToManyRelationships from './manyToManyRelationships';
+const PgManyToManyRelationPlugin = (builder, options = {}) => {
+    const { pgSimpleCollections } = options;
+    builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
+        const { extend, pgGetGqlTypeByTypeIdAndModifier, pgSql: sql, getSafeAliasFromResolveInfo, getSafeAliasFromAlias, graphql: { GraphQLNonNull, GraphQLList }, inflection, pgQueryFromResolveData: queryFromResolveData, pgAddStartEndCursor: addStartEndCursor, describePgEntity } = build;
+        const { scope: { isPgRowType, pgIntrospection: leftTable }, fieldWithHooks, Self } = context;
+        if (!isPgRowType || !leftTable || leftTable.kind !== 'class') {
+            return fields;
+        }
+        const relationships = manyToManyRelationships(leftTable, build);
+        const relatedFields = relationships.reduce((memo, relationship) => {
+            const { leftKeyAttributes, junctionLeftKeyAttributes, junctionRightKeyAttributes, rightKeyAttributes, junctionTable, rightTable, junctionLeftConstraint, junctionRightConstraint } = relationship;
+            const RightTableType = pgGetGqlTypeByTypeIdAndModifier(rightTable.type.id, null);
+            if (!RightTableType) {
+                throw new Error(`Could not determine type for table with id ${rightTable.type.id}`);
+            }
+            const RightTableConnectionType = createManyToManyConnectionType(relationship, build, options, leftTable);
+            // Since we're ignoring multi-column keys, we can simplify here
+            const leftKeyAttribute = leftKeyAttributes[0];
+            const junctionLeftKeyAttribute = junctionLeftKeyAttributes[0];
+            const junctionRightKeyAttribute = junctionRightKeyAttributes[0];
+            const rightKeyAttribute = rightKeyAttributes[0];
+            let memoWithRelations = memo;
+            const makeFields = (isConnection) => {
+                const manyRelationFieldName = isConnection
+                    ? inflection.manyToManyRelationByKeys(leftKeyAttributes, junctionLeftKeyAttributes, junctionRightKeyAttributes, rightKeyAttributes, junctionTable, rightTable, junctionLeftConstraint, junctionRightConstraint)
+                    : inflection.manyToManyRelationByKeysSimple(leftKeyAttributes, junctionLeftKeyAttributes, junctionRightKeyAttributes, rightKeyAttributes, junctionTable, rightTable, junctionLeftConstraint, junctionRightConstraint);
+                memoWithRelations = extend(memoWithRelations, {
+                    [manyRelationFieldName]: fieldWithHooks(manyRelationFieldName, ({ getDataFromParsedResolveInfoFragment, addDataGenerator }) => {
+                        const sqlFrom = sql.identifier(rightTable.namespace.name, rightTable.name);
+                        const queryOptions = {
+                            useAsterisk: rightTable.canUseAsterisk,
+                            withPagination: isConnection,
+                            withPaginationAsFields: false,
+                            asJsonAggregate: !isConnection
+                        };
+                        addDataGenerator((parsedResolveInfoFragment) => {
+                            return {
+                                pgQuery: (queryBuilder) => {
+                                    queryBuilder.select(() => {
+                                        const resolveData = getDataFromParsedResolveInfoFragment(parsedResolveInfoFragment, isConnection ? RightTableConnectionType : RightTableType);
+                                        const rightTableAlias = sql.identifier(Symbol());
+                                        const leftTableAlias = queryBuilder.getTableAlias();
+                                        const query = queryFromResolveData(sqlFrom, rightTableAlias, resolveData, queryOptions, (innerQueryBuilder) => {
+                                            innerQueryBuilder.parentQueryBuilder = queryBuilder;
+                                            const rightPrimaryKeyConstraint = rightTable.primaryKeyConstraint;
+                                            const rightPrimaryKeyAttributes = rightPrimaryKeyConstraint && rightPrimaryKeyConstraint.keyAttributes;
+                                            if (rightPrimaryKeyAttributes) {
+                                                innerQueryBuilder.beforeLock('orderBy', () => {
+                                                    // append order by primary key to the list of orders
+                                                    if (!innerQueryBuilder.isOrderUnique(false)) {
+                                                        innerQueryBuilder.data.cursorPrefix = ['primary_key_asc'];
+                                                        rightPrimaryKeyAttributes.forEach((attr) => {
+                                                            innerQueryBuilder.orderBy(sql.fragment `${innerQueryBuilder.getTableAlias()}.${sql.identifier(attr.name)}`, true);
+                                                        });
+                                                        innerQueryBuilder.setOrderIsUnique();
+                                                    }
+                                                });
+                                            }
+                                            const subqueryName = inflection.manyToManyRelationSubqueryName(leftKeyAttributes, junctionLeftKeyAttributes, junctionRightKeyAttributes, rightKeyAttributes, junctionTable, rightTable, junctionLeftConstraint, junctionRightConstraint);
+                                            const subqueryBuilder = innerQueryBuilder.buildNamedChildSelecting(subqueryName, sql.identifier(junctionTable.namespace.name, junctionTable.name), sql.identifier(junctionRightKeyAttribute.name));
+                                            subqueryBuilder.where(sql.fragment `${sql.identifier(junctionLeftKeyAttribute.name)} = ${leftTableAlias}.${sql.identifier(leftKeyAttribute.name)}`);
+                                            innerQueryBuilder.where(() => sql.fragment `${rightTableAlias}.${sql.identifier(rightKeyAttribute.name)} in (${subqueryBuilder.build()})`);
+                                        }, queryBuilder.context, queryBuilder.rootValue);
+                                        return sql.fragment `(${query})`;
+                                    }, getSafeAliasFromAlias(parsedResolveInfoFragment.alias));
+                                }
+                            };
+                        });
+                        return {
+                            description: `Reads and enables pagination through a set of \`${RightTableType.name}\`.`,
+                            type: isConnection
+                                ? new GraphQLNonNull(RightTableConnectionType)
+                                : new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(RightTableType))),
+                            args: {},
+                            resolve: (data, _args, _context, resolveInfo) => {
+                                const safeAlias = getSafeAliasFromResolveInfo(resolveInfo);
+                                if (isConnection) {
+                                    return addStartEndCursor(data[safeAlias]);
+                                }
+                                return data[safeAlias];
+                            }
+                        };
+                    }, {
+                        isPgFieldConnection: isConnection,
+                        isPgFieldSimpleCollection: !isConnection,
+                        isPgManyToManyRelationField: true,
+                        pgFieldIntrospection: rightTable
+                    })
+                }, `Many-to-many relation field (${isConnection ? 'connection' : 'simple collection'}) on ${Self.name} type for ${describePgEntity(junctionLeftConstraint)} and ${describePgEntity(junctionRightConstraint)}.`);
+            };
+            const simpleCollections = junctionRightConstraint.tags.simpleCollections ||
+                rightTable.tags.simpleCollections ||
+                pgSimpleCollections;
+            const hasConnections = simpleCollections !== 'only';
+            const hasSimpleCollections = simpleCollections === 'only' || simpleCollections === 'both';
+            if (hasConnections) {
+                makeFields(true);
+            }
+            if (hasSimpleCollections) {
+                makeFields(false);
+            }
+            return memoWithRelations;
+        }, {});
+        return extend(fields, relatedFields, `Adding many-to-many relations for ${Self.name}`);
+    });
+};
+export default PgManyToManyRelationPlugin;

package/esm/createManyToManyConnectionType.js

@@ -0,0 +1,132 @@
+const hasNonNullKey = (row) => {
+    if (Array.isArray(row.__identifiers) && row.__identifiers.every((identifier) => identifier != null)) {
+        return true;
+    }
+    for (const key in row) {
+        if (Object.prototype.hasOwnProperty.call(row, key)) {
+            if ((key[0] !== '_' || key[1] !== '_') && row[key] !== null) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+const base64 = (value) => Buffer.from(String(value)).toString('base64');
+const createManyToManyConnectionType = (relationship, build, options, leftTable) => {
+    const { leftKeyAttributes, junctionLeftKeyAttributes, junctionRightKeyAttributes, rightKeyAttributes, junctionTable, rightTable, junctionLeftConstraint, junctionRightConstraint } = relationship;
+    const { newWithHooks, inflection, graphql: { GraphQLObjectType, GraphQLNonNull, GraphQLList }, getTypeByName, pgGetGqlTypeByTypeIdAndModifier, pgField, getSafeAliasFromResolveInfo, describePgEntity } = build;
+    const { pgForbidSetofFunctionsToReturnNull = false } = options;
+    const nullableIf = (condition, Type) => condition ? Type : new GraphQLNonNull(Type);
+    const Cursor = getTypeByName('Cursor');
+    const handleNullRow = pgForbidSetofFunctionsToReturnNull
+        ? (row) => row
+        : (row, identifiers) => {
+            if ((identifiers && hasNonNullKey(identifiers)) || hasNonNullKey(row)) {
+                return row;
+            }
+            return null;
+        };
+    const LeftTableType = pgGetGqlTypeByTypeIdAndModifier(leftTable.type.id, null);
+    if (!LeftTableType) {
+        throw new Error(`Could not determine type for table with id ${leftTable.type.id}`);
+    }
+    const TableType = pgGetGqlTypeByTypeIdAndModifier(rightTable.type.id, null);
+    if (!TableType) {
+        throw new Error(`Could not determine type for table with id ${rightTable.type.id}`);
+    }
+    const rightPrimaryKeyConstraint = rightTable.primaryKeyConstraint;
+    const rightPrimaryKeyAttributes = rightPrimaryKeyConstraint && rightPrimaryKeyConstraint.keyAttributes;
+    const junctionTypeName = inflection.tableType(junctionTable);
+    const EdgeType = newWithHooks(GraphQLObjectType, {
+        description: `A \`${TableType.name}\` edge in the connection, with data from \`${junctionTypeName}\`.`,
+        name: inflection.manyToManyRelationEdge(leftKeyAttributes, junctionLeftKeyAttributes, junctionRightKeyAttributes, rightKeyAttributes, junctionTable, rightTable, junctionLeftConstraint, junctionRightConstraint, LeftTableType.name),
+        fields: ({ fieldWithHooks }) => {
+            return {
+                cursor: fieldWithHooks('cursor', ({ addDataGenerator }) => {
+                    addDataGenerator(() => ({
+                        usesCursor: [true],
+                        pgQuery: (queryBuilder) => {
+                            if (rightPrimaryKeyAttributes) {
+                                queryBuilder.selectIdentifiers(rightTable);
+                            }
+                        }
+                    }));
+                    return {
+                        description: 'A cursor for use in pagination.',
+                        type: Cursor,
+                        resolve(data) {
+                            return data.__cursor && base64(JSON.stringify(data.__cursor));
+                        }
+                    };
+                }, {
+                    isCursorField: true
+                }),
+                node: pgField(build, fieldWithHooks, 'node', {
+                    description: `The \`${TableType.name}\` at the end of the edge.`,
+                    type: nullableIf(!pgForbidSetofFunctionsToReturnNull, TableType),
+                    resolve(data, _args, _context, resolveInfo) {
+                        const safeAlias = getSafeAliasFromResolveInfo(resolveInfo);
+                        const record = handleNullRow(data[safeAlias], data.__identifiers);
+                        return record;
+                    }
+                }, {}, false, {})
+            };
+        }
+    }, {
+        __origin: `Adding many-to-many edge type from ${describePgEntity(leftTable)} to ${describePgEntity(rightTable)} via ${describePgEntity(junctionTable)}.`,
+        isEdgeType: true,
+        isPgRowEdgeType: true,
+        isPgManyToManyEdgeType: true,
+        nodeType: TableType,
+        pgManyToManyRelationship: relationship
+    });
+    const PageInfo = getTypeByName(inflection.builtin('PageInfo'));
+    return newWithHooks(GraphQLObjectType, {
+        description: `A connection to a list of \`${TableType.name}\` values, with data from \`${junctionTypeName}\`.`,
+        name: inflection.manyToManyRelationConnection(leftKeyAttributes, junctionLeftKeyAttributes, junctionRightKeyAttributes, rightKeyAttributes, junctionTable, rightTable, junctionLeftConstraint, junctionRightConstraint, LeftTableType.name),
+        fields: ({ recurseDataGeneratorsForField, fieldWithHooks }) => {
+            recurseDataGeneratorsForField('pageInfo', true);
+            return {
+                nodes: pgField(build, fieldWithHooks, 'nodes', {
+                    description: `A list of \`${TableType.name}\` objects.`,
+                    type: new GraphQLNonNull(new GraphQLList(nullableIf(!pgForbidSetofFunctionsToReturnNull, TableType))),
+                    resolve(data, _args, _context, resolveInfo) {
+                        const safeAlias = getSafeAliasFromResolveInfo(resolveInfo);
+                        return data.data.map((entry) => {
+                            const record = handleNullRow(entry[safeAlias], entry[safeAlias].__identifiers);
+                            return record;
+                        });
+                    }
+                }, {}, false, {}),
+                edges: pgField(build, fieldWithHooks, 'edges', {
+                    description: `A list of edges which contains the \`${TableType.name}\`, info from the \`${junctionTypeName}\`, and the cursor to aid in pagination.`,
+                    type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(EdgeType))),
+                    resolve(data, _args, _context, resolveInfo) {
+                        const safeAlias = getSafeAliasFromResolveInfo(resolveInfo);
+                        return data.data.map((entry) => ({
+                            ...entry,
+                            ...entry[safeAlias]
+                        }));
+                    }
+                }, {}, false, {
+                    hoistCursor: true
+                }),
+                pageInfo: PageInfo && {
+                    description: 'Information to aid in pagination.',
+                    type: new GraphQLNonNull(PageInfo),
+                    resolve(data) {
+                        return data;
+                    }
+                }
+            };
+        }
+    }, {
+        __origin: `Adding many-to-many connection type from ${describePgEntity(leftTable)} to ${describePgEntity(rightTable)} via ${describePgEntity(junctionTable)}.`,
+        isConnectionType: true,
+        isPgRowConnectionType: true,
+        edgeType: EdgeType,
+        nodeType: TableType,
+        pgIntrospection: rightTable
+    });
+};
+export default createManyToManyConnectionType;

package/esm/index.js

@@ -0,0 +1,28 @@
+import pkg from '../package.json';
+import PgManyToManyRelationEdgeColumnsPlugin from './PgManyToManyRelationEdgeColumnsPlugin';
+import PgManyToManyRelationEdgeTablePlugin from './PgManyToManyRelationEdgeTablePlugin';
+import PgManyToManyRelationInflectionPlugin from './PgManyToManyRelationInflectionPlugin';
+import PgManyToManyRelationPlugin from './PgManyToManyRelationPlugin';
+const PgManyToManyPlugin = (builder, options = {}) => {
+    builder.hook('build', (build) => {
+        // Check dependencies
+        if (!build.versions) {
+            throw new Error(`Plugin ${pkg.name}@${pkg.version} requires graphile-build@^4.1.0 in order to check dependencies (current version: ${build.graphileBuildVersion})`);
+        }
+        const depends = (name, range) => {
+            if (!build.hasVersion(name, range)) {
+                throw new Error(`Plugin ${pkg.name}@${pkg.version} requires ${name}@${range} (${build.versions[name] ? `current version: ${build.versions[name]}` : 'not found'})`);
+            }
+        };
+        depends('graphile-build-pg', '^4.5.0');
+        // Register this plugin
+        build.versions = build.extend(build.versions, { [pkg.name]: pkg.version });
+        return build;
+    });
+    PgManyToManyRelationInflectionPlugin(builder, options);
+    PgManyToManyRelationPlugin(builder, options);
+    PgManyToManyRelationEdgeColumnsPlugin(builder, options);
+    PgManyToManyRelationEdgeTablePlugin(builder, options);
+};
+export { PgManyToManyPlugin };
+export default PgManyToManyPlugin;