graphile-meta-schema 0.2.4 → 0.2.6

package/esm/index.js

@@ -0,0 +1,503 @@
+import { gql, makeExtendSchemaPlugin } from 'graphile-utils';
+import { getNamedType } from 'graphql';
+import belongsTo from './belongs-to';
+import has from './has';
+import manyToMany from './many-to-many';
+const GIS_TYPES = [
+    'Geometry',
+    'Point',
+    'LineString',
+    'Polygon',
+    'MultiPoint',
+    'MultiLineString',
+    'MultiPolygon',
+    'GeometryCollection'
+];
+const TYPE_ALIASES = {
+    int8: 'bigint',
+    bool: 'boolean',
+    bpchar: 'char',
+    float8: 'float',
+    float4: 'real',
+    int4: 'int',
+    int2: 'smallint'
+};
+const aliasTypes = (typeName) => TYPE_ALIASES[typeName] ?? typeName;
+const getTypeName = (graphQLType) => getNamedType(graphQLType).name;
+const PgMetaschemaPlugin = makeExtendSchemaPlugin((build, schemaOptions) => {
+    const pgBuild = build;
+    const pgSchemaOptions = schemaOptions;
+    const introspection = pgBuild.pgIntrospectionResultsByKind;
+    const inflection = pgBuild.inflection;
+    const schemas = pgSchemaOptions.pgSchemas ?? [];
+    const pgGetGqlTypeByTypeIdAndModifier = pgBuild.pgGetGqlTypeByTypeIdAndModifier;
+    return {
+        typeDefs: gql `
+        type MetaschemaType {
+          pgAlias: String!
+          pgType: String!
+          gqlType: String!
+          subtype: String
+          modifier: Int
+          typmod: JSON
+          isArray: Boolean!
+        }
+        type MetaschemaField {
+          name: String!
+          type: MetaschemaType!
+        }
+        type MetaschemaTableInflection {
+          # https://github.com/graphile/graphile-engine/blob/v4/packages/graphile-build-pg/src/plugins/PgBasicsPlugin.js
+          allRows: String!
+          allRowsSimple: String!
+          tableFieldName: String!
+          tableType: String!
+          createPayloadType: String!
+          orderByType: String!
+          filterType: String
+          inputType: String!
+          patchType: String
+          conditionType: String!
+          patchField: String!
+          edge: String!
+          edgeField: String!
+          connection: String!
+          typeName: String!
+          enumType: String!
+
+          updatePayloadType: String
+          deletePayloadType: String!
+          deleteByPrimaryKey: String
+          updateByPrimaryKey: String
+
+          createField: String!
+          createInputType: String!
+        }
+        type MetaschemaTableQuery {
+          all: String!
+          one: String!
+          create: String!
+          update: String
+          delete: String
+        }
+        type MetaschemaTableManyToManyRelation {
+          fieldName: String
+          type: String
+          leftKeyAttributes: [MetaschemaField]!
+          rightKeyAttributes: [MetaschemaField]!
+          junctionLeftKeyAttributes: [MetaschemaField]!
+          junctionRightKeyAttributes: [MetaschemaField]!
+          junctionTable: MetaschemaTable!
+          rightTable: MetaschemaTable!
+          junctionLeftConstraint: MetaschemaForeignKeyConstraint!
+          junctionRightConstraint: MetaschemaForeignKeyConstraint!
+        }
+        type MetaschemaTableHasRelation {
+          fieldName: String
+          type: String
+          referencedBy: MetaschemaTable!
+          isUnique: Boolean!
+          keys: [MetaschemaField]
+        }
+        type MetaschemaTableBelongsToRelation {
+          fieldName: String
+          type: String
+          references: MetaschemaTable!
+          isUnique: Boolean!
+          keys: [MetaschemaField]
+        }
+        type MetaschemaTableRelation {
+          hasOne: [MetaschemaTableHasRelation]
+          hasMany: [MetaschemaTableHasRelation]
+          has: [MetaschemaTableHasRelation]
+          belongsTo: [MetaschemaTableBelongsToRelation]
+          manyToMany: [MetaschemaTableManyToManyRelation]
+        }
+
+        type MetaschemaTable {
+          name: String!
+          query: MetaschemaTableQuery!
+          inflection: MetaschemaTableInflection!
+          relations: MetaschemaTableRelation
+          fields: [MetaschemaField]
+          constraints: [MetaschemaConstraint]
+          foreignKeyConstraints: [MetaschemaForeignKeyConstraint]
+          primaryKeyConstraints: [MetaschemaPrimaryKeyConstraint]
+          uniqueConstraints: [MetaschemaUniqueConstraint]
+          checkConstraints: [MetaschemaCheckConstraint]
+          exclusionConstraints: [MetaschemaExclusionConstraint]
+        }
+        union MetaschemaConstraint =
+            MetaschemaForeignKeyConstraint
+          | MetaschemaUniqueConstraint
+          | MetaschemaPrimaryKeyConstraint
+          | MetaschemaCheckConstraint
+          | MetaschemaExclusionConstraint
+        type MetaschemaForeignKeyConstraint {
+          name: String!
+          fields: [MetaschemaField]
+          refTable: MetaschemaTable
+          refFields: [MetaschemaField]
+        }
+        type MetaschemaUniqueConstraint {
+          name: String!
+          fields: [MetaschemaField]
+        }
+        type MetaschemaPrimaryKeyConstraint {
+          name: String!
+          fields: [MetaschemaField]
+        }
+        type MetaschemaCheckConstraint {
+          name: String!
+          fields: [MetaschemaField]
+        }
+        type MetaschemaExclusionConstraint {
+          name: String!
+          fields: [MetaschemaField]
+        }
+        type Metaschema {
+          tables: [MetaschemaTable]
+        }
+        extend type Query {
+          _meta: Metaschema
+        }
+      `,
+        resolvers: {
+            MetaschemaCheckConstraint: {
+                fields(constraint) {
+                    return constraint.keyAttributes;
+                }
+            },
+            MetaschemaExclusionConstraint: {
+                fields(constraint) {
+                    return constraint.keyAttributes;
+                }
+            },
+            MetaschemaUniqueConstraint: {
+                fields(constraint) {
+                    return constraint.keyAttributes;
+                }
+            },
+            MetaschemaPrimaryKeyConstraint: {
+                fields(constraint) {
+                    return constraint.keyAttributes;
+                }
+            },
+            MetaschemaForeignKeyConstraint: {
+                fields(constraint) {
+                    return constraint.keyAttributes;
+                },
+                refTable(constraint) {
+                    return constraint.foreignClass;
+                },
+                refFields(constraint) {
+                    return constraint.foreignKeyAttributes;
+                }
+            },
+            MetaschemaType: {
+                pgType(type) {
+                    if (type.isPgArray && type.arrayItemType?.name) {
+                        return type.arrayItemType.name;
+                    }
+                    return type.name;
+                },
+                pgAlias(type) {
+                    if (type.isPgArray && type.arrayItemType?.name) {
+                        return aliasTypes(type.arrayItemType.name);
+                    }
+                    return aliasTypes(type.name);
+                },
+                gqlType(type) {
+                    const gqlType = pgGetGqlTypeByTypeIdAndModifier(type.id, type.attrTypeModifier ?? null);
+                    const typeName = getTypeName(gqlType);
+                    switch (typeName) {
+                        case 'GeometryInterface':
+                        case 'GeometryPoint':
+                        case 'GeometryPolygon':
+                            return 'GeoJSON';
+                        default:
+                            return typeName;
+                    }
+                },
+                subtype(type) {
+                    const gqlType = pgGetGqlTypeByTypeIdAndModifier(type.id, type.attrTypeModifier ?? null);
+                    const typeName = getTypeName(gqlType);
+                    switch (typeName) {
+                        case 'GeometryInterface':
+                        case 'GeometryPoint':
+                        case 'GeometryPolygon':
+                            return typeName;
+                        default:
+                            return null;
+                    }
+                },
+                typmod(type) {
+                    const modifier = type.attrTypeModifier;
+                    if (!modifier)
+                        return null;
+                    if (type.name === 'geography' || type.name === 'geometry') {
+                        const srid = ((modifier & 0x0fffff00) - (modifier & 0x10000000)) >> 8;
+                        const subtype = (modifier & 0x000000fc) >> 2;
+                        const hasZ = ((modifier & 0x00000002) >> 1) === 1;
+                        const hasM = (modifier & 0x00000001) === 1;
+                        if (subtype < GIS_TYPES.length) {
+                            return {
+                                srid,
+                                subtype,
+                                hasZ,
+                                hasM,
+                                gisType: GIS_TYPES[subtype]
+                            };
+                        }
+                    }
+                    return { modifier };
+                },
+                modifier(type) {
+                    return type.attrTypeModifier;
+                },
+                isArray(type) {
+                    return type.isPgArray;
+                }
+            },
+            MetaschemaField: {
+                name(attr) {
+                    return inflection.column(attr);
+                },
+                type(attr) {
+                    if (attr.typeModifier > 0) {
+                        return {
+                            ...attr.type,
+                            attrTypeModifier: attr.typeModifier
+                        };
+                    }
+                    return attr.type;
+                }
+            },
+            MetaschemaTableInflection: {
+                deleteByPrimaryKey(table) {
+                    if (!table.primaryKeyConstraint?.keyAttributes?.length)
+                        return null;
+                    return inflection.deleteByKeys(table.primaryKeyConstraint.keyAttributes, table, table.primaryKeyConstraint);
+                },
+                updateByPrimaryKey(table) {
+                    if (!table.primaryKeyConstraint?.keyAttributes?.length)
+                        return null;
+                    return inflection.updateByKeys(table.primaryKeyConstraint.keyAttributes, table, table.primaryKeyConstraint);
+                },
+                createField(table) {
+                    return inflection.createField(table);
+                },
+                createInputType(table) {
+                    return inflection.createInputType(table);
+                },
+                allRows(table) {
+                    return inflection.allRows(table);
+                },
+                allRowsSimple(table) {
+                    return inflection.allRowsSimple(table);
+                },
+                tableFieldName(table) {
+                    return inflection.tableFieldName(table);
+                },
+                tableType(table) {
+                    return inflection.tableType(table);
+                },
+                orderByType(table) {
+                    return inflection.orderByType(inflection.tableType(table));
+                },
+                filterType(table) {
+                    if (typeof inflection.filterType === 'function') {
+                        return inflection.filterType(inflection.tableType(table)) ?? null;
+                    }
+                    return null;
+                },
+                inputType(table) {
+                    return inflection.inputType(inflection.tableType(table));
+                },
+                patchType(table) {
+                    return inflection.patchType(inflection.tableType(table));
+                },
+                conditionType(table) {
+                    return inflection.conditionType(inflection.tableType(table));
+                },
+                patchField(table) {
+                    return inflection.patchField(inflection.tableType(table));
+                },
+                edge(table) {
+                    return inflection.edge(inflection.tableType(table));
+                },
+                edgeField(table) {
+                    return inflection.edgeField(table);
+                },
+                connection(table) {
+                    return inflection.connection(inflection.tableType(table));
+                },
+                typeName(table) {
+                    return inflection._typeName(table);
+                },
+                enumType(table) {
+                    return inflection.enumType(table);
+                },
+                createPayloadType(table) {
+                    return inflection.createPayloadType(table);
+                },
+                updatePayloadType(table) {
+                    return inflection.updatePayloadType(table);
+                },
+                deletePayloadType(table) {
+                    return inflection.deletePayloadType(table);
+                }
+            },
+            MetaschemaTableQuery: {
+                delete(table) {
+                    if (!table.primaryKeyConstraint?.keyAttributes?.length)
+                        return null;
+                    return inflection.deleteByKeys(table.primaryKeyConstraint.keyAttributes, table, table.primaryKeyConstraint);
+                },
+                update(table) {
+                    if (!table.primaryKeyConstraint?.keyAttributes?.length)
+                        return null;
+                    return inflection.updateByKeys(table.primaryKeyConstraint.keyAttributes, table, table.primaryKeyConstraint);
+                },
+                create(table) {
+                    return inflection.createField(table);
+                },
+                all(table) {
+                    return inflection.allRows(table);
+                },
+                one(table) {
+                    return inflection.tableFieldName(table);
+                }
+            },
+            MetaschemaTableRelation: {
+                hasOne(table) {
+                    return has(table, pgBuild).filter((relation) => relation.type === 'hasOne');
+                },
+                hasMany(table) {
+                    return has(table, pgBuild).filter((relation) => relation.type === 'hasMany');
+                },
+                belongsTo(table) {
+                    return belongsTo(table, pgBuild);
+                },
+                has(table) {
+                    return has(table, pgBuild);
+                },
+                manyToMany(table) {
+                    return manyToMany(table, pgBuild);
+                }
+            },
+            MetaschemaTableBelongsToRelation: {
+                type() {
+                    return 'BelongsTo';
+                }
+            },
+            MetaschemaTableManyToManyRelation: {
+                type() {
+                    return 'ManyToMany';
+                },
+                leftKeyAttributes(relation) {
+                    return relation.leftKeyAttributes;
+                },
+                junctionLeftKeyAttributes(relation) {
+                    return relation.junctionLeftKeyAttributes;
+                },
+                junctionRightKeyAttributes(relation) {
+                    return relation.junctionRightKeyAttributes;
+                },
+                rightKeyAttributes(relation) {
+                    return relation.rightKeyAttributes;
+                },
+                junctionTable(relation) {
+                    return relation.junctionTable;
+                },
+                rightTable(relation) {
+                    return relation.rightTable;
+                },
+                junctionLeftConstraint(relation) {
+                    return relation.junctionLeftConstraint;
+                },
+                junctionRightConstraint(relation) {
+                    return relation.junctionRightConstraint;
+                },
+                fieldName(relation) {
+                    if (!inflection.manyToManyRelationByKeys) {
+                        return null;
+                    }
+                    const { leftKeyAttributes, junctionLeftKeyAttributes, junctionRightKeyAttributes, rightKeyAttributes, junctionTable, rightTable, junctionLeftConstraint, junctionRightConstraint } = relation;
+                    return inflection.manyToManyRelationByKeys(leftKeyAttributes, junctionLeftKeyAttributes, junctionRightKeyAttributes, rightKeyAttributes, junctionTable, rightTable, junctionLeftConstraint, junctionRightConstraint);
+                }
+            },
+            MetaschemaTable: {
+                relations(table) {
+                    return table;
+                },
+                name(table) {
+                    return inflection.tableType(table);
+                },
+                fields(table) {
+                    return table.attributes.filter((attr) => attr.num >= 1);
+                },
+                inflection(table) {
+                    return table;
+                },
+                query(table) {
+                    return table;
+                },
+                constraints(table) {
+                    return table.constraints;
+                },
+                foreignKeyConstraints(table) {
+                    return table.constraints.filter((constraint) => constraint.type === 'f');
+                },
+                primaryKeyConstraints(table) {
+                    return table.constraints.filter((constraint) => constraint.type === 'p');
+                },
+                uniqueConstraints(table) {
+                    return table.constraints.filter((constraint) => constraint.type === 'u');
+                },
+                checkConstraints(table) {
+                    return table.constraints.filter((constraint) => constraint.type === 'c');
+                },
+                exclusionConstraints(table) {
+                    return table.constraints.filter((constraint) => constraint.type === 'x');
+                }
+            },
+            MetaschemaConstraint: {
+                __resolveType(obj) {
+                    switch (obj.type) {
+                        case 'p':
+                            return 'MetaschemaPrimaryKeyConstraint';
+                        case 'f':
+                            return 'MetaschemaForeignKeyConstraint';
+                        case 'c':
+                            return 'MetaschemaCheckConstraint';
+                        case 'u':
+                            return 'MetaschemaUniqueConstraint';
+                        case 'x':
+                            return 'MetaschemaExclusionConstraint';
+                        default:
+                            return null;
+                    }
+                }
+            },
+            Metaschema: {
+                tables() {
+                    return introspection.class.filter((table) => {
+                        if (!schemas.includes(table.namespaceName))
+                            return false;
+                        if (table.classKind !== 'r')
+                            return false;
+                        return true;
+                    });
+                }
+            },
+            Query: {
+                _meta() {
+                    return {};
+                }
+            }
+        }
+    };
+});
+export { PgMetaschemaPlugin };
+export default PgMetaschemaPlugin;

package/esm/many-to-many.js

@@ -0,0 +1,81 @@
+const arraysAreEqual = (array1, array2) => array1.length === array2.length && array1.every((value, index) => array2[index] === value);
+const getManyToManyRelations = (leftTable, build) => {
+    const { pgIntrospectionResultsByKind: introspectionResultsByKind, pgOmit: omit } = build;
+    return leftTable.foreignConstraints
+        .filter((constraint) => constraint.type === 'f')
+        .reduce((memoLeft, junctionLeftConstraint) => {
+        if (omit(junctionLeftConstraint, 'read') ||
+            omit(junctionLeftConstraint, 'manyToMany')) {
+            return memoLeft;
+        }
+        const junctionTable = introspectionResultsByKind.classById[String(junctionLeftConstraint.classId)] ??
+            junctionLeftConstraint.foreignClass;
+        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((constraint) => constraint.id !== junctionLeftConstraint.id &&
+            constraint.type === 'f' &&
+            !omit(constraint, 'read') &&
+            !omit(constraint, 'manyToMany'))
+            .reduce((memoRightInner, junctionRightConstraint) => {
+            const rightTable = junctionRightConstraint.foreignClass ??
+                (junctionRightConstraint.foreignClassId !== undefined
+                    ? introspectionResultsByKind.classById[String(junctionRightConstraint.foreignClassId)]
+                    : undefined);
+            if (!rightTable || omit(rightTable, 'read') || omit(rightTable, 'manyToMany')) {
+                return memoRightInner;
+            }
+            const leftKeyAttributes = junctionLeftConstraint.foreignKeyAttributes;
+            const junctionLeftKeyAttributes = junctionLeftConstraint.keyAttributes;
+            const junctionRightKeyAttributes = junctionRightConstraint.keyAttributes;
+            const rightKeyAttributes = junctionRightConstraint.foreignKeyAttributes;
+            if (!leftKeyAttributes.every(Boolean) ||
+                !junctionLeftKeyAttributes.every(Boolean) ||
+                !junctionRightKeyAttributes.every(Boolean) ||
+                !rightKeyAttributes.every(Boolean)) {
+                throw new Error('Could not find key columns!');
+            }
+            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;
+            }
+            if (leftKeyAttributes.length > 1 || rightKeyAttributes.length > 1) {
+                return memoRightInner;
+            }
+            const junctionLeftConstraintIsUnique = junctionTable.constraints.some((constraint) => ['p', 'u'].includes(constraint.type) &&
+                arraysAreEqual(constraint.keyAttributeNums, junctionLeftKeyAttributes.map((attr) => attr.num)));
+            const junctionRightConstraintIsUnique = junctionTable.constraints.some((constraint) => ['p', 'u'].includes(constraint.type) &&
+                arraysAreEqual(constraint.keyAttributeNums, junctionRightKeyAttributes.map((attr) => attr.num)));
+            if (junctionLeftConstraintIsUnique || junctionRightConstraintIsUnique) {
+                return memoRightInner;
+            }
+            const allowsMultipleEdgesToNode = !junctionTable.constraints.find((constraint) => ['p', 'u'].includes(constraint.type) &&
+                arraysAreEqual(constraint.keyAttributeNums.concat().sort(), [
+                    ...junctionLeftKeyAttributes.map((attr) => attr.num),
+                    ...junctionRightKeyAttributes.map((attr) => attr.num)
+                ].sort()));
+            return [
+                ...memoRightInner,
+                {
+                    leftKeyAttributes,
+                    junctionLeftKeyAttributes,
+                    junctionRightKeyAttributes,
+                    rightKeyAttributes,
+                    junctionTable,
+                    rightTable,
+                    junctionLeftConstraint,
+                    junctionRightConstraint,
+                    allowsMultipleEdgesToNode
+                }
+            ];
+        }, []);
+        return [...memoLeft, ...memoRight];
+    }, []);
+};
+export default getManyToManyRelations;

package/esm/types.js

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

package/has.d.ts

@@ -0,0 +1,3 @@
+import type { HasRelation, PgBuild, PgClass } from './types';
+declare const getHasRelations: (foreignTable: PgClass, build: PgBuild) => HasRelation[];
+export default getHasRelations;

package/has.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getHasRelations = (foreignTable, build) => {
+    const { pgIntrospectionResultsByKind: introspectionResultsByKind, inflection, pgOmit: omit } = build;
+    return foreignTable.foreignConstraints
+        .filter((constraint) => constraint.type === 'f')
+        .reduce((memo, constraint) => {
+        if (omit(constraint, 'read')) {
+            return memo;
+        }
+        const table = introspectionResultsByKind.classById[String(constraint.classId)] ?? constraint.foreignClass;
+        if (!table || omit(table, 'read')) {
+            return memo;
+        }
+        const keys = constraint.keyAttributes;
+        const foreignKeys = constraint.foreignKeyAttributes;
+        if (keys.some((key) => omit(key, 'read')) || foreignKeys.some((key) => omit(key, 'read'))) {
+            return memo;
+        }
+        const isUnique = table.constraints.some((c) => (c.type === 'p' || c.type === 'u') &&
+            c.keyAttributeNums.length === keys.length &&
+            c.keyAttributeNums.every((n, i) => keys[i].num === n));
+        const fieldName = isUnique
+            ? inflection.singleRelationByKeysBackwards(keys, table, foreignTable, constraint)
+            : inflection.manyRelationByKeys(keys, table, foreignTable, constraint);
+        return [
+            ...memo,
+            {
+                referencedBy: table,
+                isUnique,
+                fieldName,
+                type: isUnique ? 'hasOne' : 'hasMany',
+                keys
+            }
+        ];
+    }, []);
+};
+exports.default = getHasRelations;

package/index.d.ts

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