graphile-many-to-many 1.0.3

package/esm/manyToManyRelationships.js

@@ -0,0 +1,84 @@
+const arraysAreEqual = (array1, array2) => array1.length === array2.length && array1.every((el, i) => array2[i] === el);
+const isUniqueConstraint = (constraint, attributes) => ['p', 'u'].includes(constraint.type) &&
+    arraysAreEqual(constraint.keyAttributeNums, attributes.map((attr) => attr.num));
+// Given a `leftTable`, trace through the foreign key relations
+// and identify a `junctionTable` and `rightTable`.
+// Returns a list of data objects for these many-to-many relationships.
+const manyToManyRelationships = (leftTable, build) => {
+    const { pgIntrospectionResultsByKind: introspectionResultsByKind, pgOmit: omit } = build;
+    return leftTable.foreignConstraints
+        .filter((con) => con.type === 'f')
+        .reduce((memoLeft, junctionLeftConstraint) => {
+        if (omit(junctionLeftConstraint, 'read') || omit(junctionLeftConstraint, 'manyToMany')) {
+            return memoLeft;
+        }
+        const junctionTable = introspectionResultsByKind.classById[junctionLeftConstraint.classId];
+        if (!junctionTable) {
+            throw new Error(`Could not find the table that referenced us (constraint: ${junctionLeftConstraint.name})`);
+        }
+        if (omit(junctionTable, 'read') || omit(junctionTable, 'manyToMany')) {
+            return memoLeft;
+        }
+        const memoRight = junctionTable.constraints
+            .filter((con) => con.id !== junctionLeftConstraint.id &&
+            con.type === 'f' &&
+            !omit(con, 'read') &&
+            !omit(con, 'manyToMany'))
+            .reduce((memoRightInner, junctionRightConstraint) => {
+            const rightTable = junctionRightConstraint.foreignClass;
+            if (omit(rightTable, 'read') || omit(rightTable, 'manyToMany')) {
+                return memoRightInner;
+            }
+            const leftKeyAttributes = junctionLeftConstraint.foreignKeyAttributes;
+            const junctionLeftKeyAttributes = junctionLeftConstraint.keyAttributes;
+            const junctionRightKeyAttributes = junctionRightConstraint.keyAttributes;
+            const rightKeyAttributes = junctionRightConstraint.foreignKeyAttributes;
+            // Ensure keys were found
+            if (!leftKeyAttributes.every(Boolean) ||
+                !junctionLeftKeyAttributes.every(Boolean) ||
+                !junctionRightKeyAttributes.every(Boolean) ||
+                !rightKeyAttributes.every(Boolean)) {
+                throw new Error('Could not find key columns!');
+            }
+            // Ensure keys can be read
+            if (leftKeyAttributes.some((attr) => omit(attr, 'read')) ||
+                junctionLeftKeyAttributes.some((attr) => omit(attr, 'read')) ||
+                junctionRightKeyAttributes.some((attr) => omit(attr, 'read')) ||
+                rightKeyAttributes.some((attr) => omit(attr, 'read'))) {
+                return memoRightInner;
+            }
+            // Ensure both constraints are single-column
+            // TODO: handle multi-column
+            if (leftKeyAttributes.length > 1 || rightKeyAttributes.length > 1) {
+                return memoRightInner;
+            }
+            // Ensure junction constraint keys are not unique (which would result in a one-to-one relation)
+            const junctionLeftConstraintIsUnique = !!junctionTable.constraints.find((c) => isUniqueConstraint(c, junctionLeftKeyAttributes));
+            const junctionRightConstraintIsUnique = !!junctionTable.constraints.find((c) => isUniqueConstraint(c, junctionRightKeyAttributes));
+            if (junctionLeftConstraintIsUnique || junctionRightConstraintIsUnique) {
+                return memoRightInner;
+            }
+            const allowsMultipleEdgesToNode = !junctionTable.constraints.find((c) => ['p', 'u'].includes(c.type) &&
+                arraysAreEqual(c.keyAttributeNums.concat().sort(), [
+                    ...junctionLeftKeyAttributes.map((obj) => obj.num),
+                    ...junctionRightKeyAttributes.map((obj) => obj.num)
+                ].sort()));
+            return [
+                ...memoRightInner,
+                {
+                    leftKeyAttributes,
+                    junctionLeftKeyAttributes,
+                    junctionRightKeyAttributes,
+                    rightKeyAttributes,
+                    junctionTable,
+                    rightTable,
+                    junctionLeftConstraint,
+                    junctionRightConstraint,
+                    allowsMultipleEdgesToNode
+                }
+            ];
+        }, []);
+        return [...memoLeft, ...memoRight];
+    }, []);
+};
+export default manyToManyRelationships;

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/index.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from 'graphile-build';
+import type { PgManyToManyOptions } from './types';
+declare const PgManyToManyPlugin: Plugin;
+export { PgManyToManyPlugin };
+export type { PgManyToManyOptions };
+export default PgManyToManyPlugin;

package/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgManyToManyPlugin = void 0;
+const package_json_1 = __importDefault(require("../package.json"));
+const PgManyToManyRelationEdgeColumnsPlugin_1 = __importDefault(require("./PgManyToManyRelationEdgeColumnsPlugin"));
+const PgManyToManyRelationEdgeTablePlugin_1 = __importDefault(require("./PgManyToManyRelationEdgeTablePlugin"));
+const PgManyToManyRelationInflectionPlugin_1 = __importDefault(require("./PgManyToManyRelationInflectionPlugin"));
+const PgManyToManyRelationPlugin_1 = __importDefault(require("./PgManyToManyRelationPlugin"));
+const PgManyToManyPlugin = (builder, options = {}) => {
+    builder.hook('build', (build) => {
+        // Check dependencies
+        if (!build.versions) {
+            throw new Error(`Plugin ${package_json_1.default.name}@${package_json_1.default.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 ${package_json_1.default.name}@${package_json_1.default.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, { [package_json_1.default.name]: package_json_1.default.version });
+        return build;
+    });
+    (0, PgManyToManyRelationInflectionPlugin_1.default)(builder, options);
+    (0, PgManyToManyRelationPlugin_1.default)(builder, options);
+    (0, PgManyToManyRelationEdgeColumnsPlugin_1.default)(builder, options);
+    (0, PgManyToManyRelationEdgeTablePlugin_1.default)(builder, options);
+};
+exports.PgManyToManyPlugin = PgManyToManyPlugin;
+exports.default = PgManyToManyPlugin;

package/manyToManyRelationships.d.ts

@@ -0,0 +1,4 @@
+import type { PgClass } from 'graphile-build-pg';
+import type { ManyToManyRelationship } from './types';
+declare const manyToManyRelationships: (leftTable: PgClass, build: any) => ManyToManyRelationship[];
+export default manyToManyRelationships;

package/manyToManyRelationships.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const arraysAreEqual = (array1, array2) => array1.length === array2.length && array1.every((el, i) => array2[i] === el);
+const isUniqueConstraint = (constraint, attributes) => ['p', 'u'].includes(constraint.type) &&
+    arraysAreEqual(constraint.keyAttributeNums, attributes.map((attr) => attr.num));
+// Given a `leftTable`, trace through the foreign key relations
+// and identify a `junctionTable` and `rightTable`.
+// Returns a list of data objects for these many-to-many relationships.
+const manyToManyRelationships = (leftTable, build) => {
+    const { pgIntrospectionResultsByKind: introspectionResultsByKind, pgOmit: omit } = build;
+    return leftTable.foreignConstraints
+        .filter((con) => con.type === 'f')
+        .reduce((memoLeft, junctionLeftConstraint) => {
+        if (omit(junctionLeftConstraint, 'read') || omit(junctionLeftConstraint, 'manyToMany')) {
+            return memoLeft;
+        }
+        const junctionTable = introspectionResultsByKind.classById[junctionLeftConstraint.classId];
+        if (!junctionTable) {
+            throw new Error(`Could not find the table that referenced us (constraint: ${junctionLeftConstraint.name})`);
+        }
+        if (omit(junctionTable, 'read') || omit(junctionTable, 'manyToMany')) {
+            return memoLeft;
+        }
+        const memoRight = junctionTable.constraints
+            .filter((con) => con.id !== junctionLeftConstraint.id &&
+            con.type === 'f' &&
+            !omit(con, 'read') &&
+            !omit(con, 'manyToMany'))
+            .reduce((memoRightInner, junctionRightConstraint) => {
+            const rightTable = junctionRightConstraint.foreignClass;
+            if (omit(rightTable, 'read') || omit(rightTable, 'manyToMany')) {
+                return memoRightInner;
+            }
+            const leftKeyAttributes = junctionLeftConstraint.foreignKeyAttributes;
+            const junctionLeftKeyAttributes = junctionLeftConstraint.keyAttributes;
+            const junctionRightKeyAttributes = junctionRightConstraint.keyAttributes;
+            const rightKeyAttributes = junctionRightConstraint.foreignKeyAttributes;
+            // Ensure keys were found
+            if (!leftKeyAttributes.every(Boolean) ||
+                !junctionLeftKeyAttributes.every(Boolean) ||
+                !junctionRightKeyAttributes.every(Boolean) ||
+                !rightKeyAttributes.every(Boolean)) {
+                throw new Error('Could not find key columns!');
+            }
+            // Ensure keys can be read
+            if (leftKeyAttributes.some((attr) => omit(attr, 'read')) ||
+                junctionLeftKeyAttributes.some((attr) => omit(attr, 'read')) ||
+                junctionRightKeyAttributes.some((attr) => omit(attr, 'read')) ||
+                rightKeyAttributes.some((attr) => omit(attr, 'read'))) {
+                return memoRightInner;
+            }
+            // Ensure both constraints are single-column
+            // TODO: handle multi-column
+            if (leftKeyAttributes.length > 1 || rightKeyAttributes.length > 1) {
+                return memoRightInner;
+            }
+            // Ensure junction constraint keys are not unique (which would result in a one-to-one relation)
+            const junctionLeftConstraintIsUnique = !!junctionTable.constraints.find((c) => isUniqueConstraint(c, junctionLeftKeyAttributes));
+            const junctionRightConstraintIsUnique = !!junctionTable.constraints.find((c) => isUniqueConstraint(c, junctionRightKeyAttributes));
+            if (junctionLeftConstraintIsUnique || junctionRightConstraintIsUnique) {
+                return memoRightInner;
+            }
+            const allowsMultipleEdgesToNode = !junctionTable.constraints.find((c) => ['p', 'u'].includes(c.type) &&
+                arraysAreEqual(c.keyAttributeNums.concat().sort(), [
+                    ...junctionLeftKeyAttributes.map((obj) => obj.num),
+                    ...junctionRightKeyAttributes.map((obj) => obj.num)
+                ].sort()));
+            return [
+                ...memoRightInner,
+                {
+                    leftKeyAttributes,
+                    junctionLeftKeyAttributes,
+                    junctionRightKeyAttributes,
+                    rightKeyAttributes,
+                    junctionTable,
+                    rightTable,
+                    junctionLeftConstraint,
+                    junctionRightConstraint,
+                    allowsMultipleEdgesToNode
+                }
+            ];
+        }, []);
+        return [...memoLeft, ...memoRight];
+    }, []);
+};
+exports.default = manyToManyRelationships;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "graphile-many-to-many",
+  "version": "1.0.3",
+  "description": "Add connection fields for many-to-many relations",
+  "author": "Matt Bretl",
+  "homepage": "https://github.com/constructive-io/constructive",
+  "license": "MIT",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "clean": "makage clean",
+    "copy": "makage assets",
+    "prepack": "pnpm run build",
+    "build": "makage build",
+    "build:dev": "makage build --dev",
+    "lint": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/constructive-io/constructive"
+  },
+  "bugs": {
+    "url": "https://github.com/constructive-io/constructive/issues"
+  },
+  "keywords": [
+    "postgraphile",
+    "graphile",
+    "postgres",
+    "graphql",
+    "plugin"
+  ],
+  "dependencies": {
+    "graphile-build": "^4.14.1",
+    "graphile-build-pg": "^4.14.1"
+  },
+  "devDependencies": {
+    "graphile-test": "^2.9.2",
+    "graphql": "15.10.1",
+    "makage": "^0.1.8",
+    "pgsql-test": "^2.15.2",
+    "postgraphile": "^4.14.1"
+  },
+  "gitHead": "8efb023ff0cb814f9097e0b08fcbafeac25eee07"
+}

package/types.d.ts

@@ -0,0 +1,23 @@
+import type { Build } from 'graphile-build';
+import type { PgAttribute, PgClass, PgConstraint, PgIntrospectionResultsByKind } from 'graphile-build-pg';
+export type SimpleCollectionSetting = 'only' | 'both' | 'omit' | null | undefined;
+export interface PgManyToManyOptions {
+    pgSimpleCollections?: SimpleCollectionSetting;
+    pgForbidSetofFunctionsToReturnNull?: boolean;
+}
+export interface ManyToManyRelationship {
+    leftKeyAttributes: PgAttribute[];
+    junctionLeftKeyAttributes: PgAttribute[];
+    junctionRightKeyAttributes: PgAttribute[];
+    rightKeyAttributes: PgAttribute[];
+    junctionTable: PgClass;
+    rightTable: PgClass;
+    junctionLeftConstraint: PgConstraint;
+    junctionRightConstraint: PgConstraint;
+    allowsMultipleEdgesToNode: boolean;
+}
+export interface PgManyToManyBuild extends Build {
+    pgIntrospectionResultsByKind: PgIntrospectionResultsByKind;
+    pgOmit: (entity: any, permission: string) => boolean;
+    describePgEntity: (entity: any) => string;
+}

package/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });