@constructive-io/graphql-query 2.4.7 → 2.5.1

package/esm/custom-ast.js

@@ -1,6 +1,8 @@
-// @ts-nocheck
 import * as t from 'gql-ast';
 export function getCustomAst(fieldDefn) {
+    if (!fieldDefn) {
+        return null;
+    }
     const { pgType } = fieldDefn.type;
     if (pgType === 'geometry') {
         return geometryAst(fieldDefn.name);
@@ -9,15 +11,116 @@ export function getCustomAst(fieldDefn) {
         return intervalAst(fieldDefn.name);
     }
     return t.field({
-        name: fieldDefn.name
+        name: fieldDefn.name,
+    });
+}
+/**
+ * Generate custom AST for CleanField type - handles GraphQL types that need subfield selections
+ */
+export function getCustomAstForCleanField(field) {
+    const { name, type } = field;
+    const { gqlType, pgType } = type;
+    // Handle by GraphQL type first (this is what the error messages reference)
+    if (gqlType === 'GeometryPoint') {
+        return geometryPointAst(name);
+    }
+    if (gqlType === 'Interval') {
+        return intervalAst(name);
+    }
+    if (gqlType === 'GeometryGeometryCollection') {
+        return geometryCollectionAst(name);
+    }
+    // Handle by pgType as fallback
+    if (pgType === 'geometry') {
+        return geometryAst(name);
+    }
+    if (pgType === 'interval') {
+        return intervalAst(name);
+    }
+    // Return simple field for scalar types
+    return t.field({
+        name,
+    });
+}
+/**
+ * Check if a CleanField requires subfield selection based on its GraphQL type
+ */
+export function requiresSubfieldSelection(field) {
+    const { gqlType } = field.type;
+    // Complex GraphQL types that require subfield selection
+    const complexTypes = [
+        'GeometryPoint',
+        'Interval',
+        'GeometryGeometryCollection',
+        'GeoJSON',
+    ];
+    return complexTypes.includes(gqlType);
+}
+/**
+ * Generate AST for GeometryPoint type
+ */
+export function geometryPointAst(name) {
+    return t.field({
+        name,
+        selectionSet: t.selectionSet({
+            selections: toFieldArray(['x', 'y']),
+        }),
+    });
+}
+/**
+ * Generate AST for GeometryGeometryCollection type
+ */
+export function geometryCollectionAst(name) {
+    // Manually create inline fragment since gql-ast doesn't support it
+    const inlineFragment = {
+        kind: 'InlineFragment',
+        typeCondition: {
+            kind: 'NamedType',
+            name: {
+                kind: 'Name',
+                value: 'GeometryPoint',
+            },
+        },
+        selectionSet: {
+            kind: 'SelectionSet',
+            selections: [
+                {
+                    kind: 'Field',
+                    name: {
+                        kind: 'Name',
+                        value: 'x',
+                    },
+                },
+                {
+                    kind: 'Field',
+                    name: {
+                        kind: 'Name',
+                        value: 'y',
+                    },
+                },
+            ],
+        },
+    };
+    return t.field({
+        name,
+        selectionSet: t.selectionSet({
+            selections: [
+                t.field({
+                    name: 'geometries',
+                    selectionSet: t.selectionSet({
+                        selections: [inlineFragment], // gql-ast limitation with inline fragments
+                    }),
+                }),
+            ],
+        }),
     });
 }
 export function geometryAst(name) {
     return t.field({
         name,
         selectionSet: t.selectionSet({
-            selections: toFieldArray(['geojson'])
-        })
+            selections: toFieldArray(['geojson']),
+        }),
     });
 }
 export function intervalAst(name) {
@@ -30,21 +133,14 @@ export function intervalAst(name) {
                 'minutes',
                 'months',
                 'seconds',
-                'years'
-            ])
-        })
+                'years',
+            ]),
+        }),
     });
 }
 function toFieldArray(strArr) {
     return strArr.map((fieldName) => t.field({ name: fieldName }));
 }
 export function isIntervalType(obj) {
-    return [
-        'days',
-        'hours',
-        'minutes',
-        'months',
-        'seconds',
-        'years'
-    ].every((key) => obj.hasOwnProperty(key));
+    return ['days', 'hours', 'minutes', 'months', 'seconds', 'years'].every((key) => obj.hasOwnProperty(key));
 }

package/esm/index.js

@@ -1,342 +1,3 @@
-// @ts-nocheck
-import { print as gqlPrint } from 'graphql';
-import inflection from 'inflection';
-import { createOne, deleteOne, getAll, getMany, getOne, patchOne } from './ast';
-import { validateMetaObject } from './meta-object';
+export { QueryBuilder } from './query-builder';
+export * from './types';
 export * as MetaObject from './meta-object';
-const isObject = val => val !== null && typeof val === 'object';
-export class QueryBuilder {
-    constructor({ meta = {}, introspection }) {
-        this._introspection = introspection;
-        this._meta = meta;
-        this.clear();
-        this.initModelMap();
-        this.pickScalarFields = pickScalarFields.bind(this);
-        this.pickAllFields = pickAllFields.bind(this);
-        const result = validateMetaObject(this._meta);
-        if (typeof result === 'object' && result.errors) {
-            throw new Error(`QueryBuilder: meta object is invalid:\n${result.message}`);
-        }
-    }
-    /*
-     * Save all gql queries and mutations by model name for quicker lookup
-     */
-    initModelMap() {
-        this._models = Object.keys(this._introspection).reduce((map, key) => {
-            const defn = this._introspection[key];
-            map = {
-                ...map,
-                [defn.model]: {
-                    ...map[defn.model],
-                    ...{ [key]: defn }
-                }
-            };
-            return map;
-        }, {});
-    }
-    clear() {
-        this._model = '';
-        this._fields = [];
-        this._key = null;
-        this._queryName = '';
-        this._ast = null;
-        this._edges = false;
-    }
-    query(model) {
-        this.clear();
-        this._model = model;
-        return this;
-    }
-    _findQuery() {
-        // based on the op, finds the relevant GQL query
-        const queries = this._models[this._model];
-        if (!queries) {
-            throw new Error('No queries found for ' + this._model);
-        }
-        const matchQuery = Object.entries(queries).find(([_, defn]) => defn.qtype === this._op);
-        if (!matchQuery) {
-            throw new Error('No query found for ' + this._model + ':' + this._op);
-        }
-        const queryKey = matchQuery[0];
-        return queryKey;
-    }
-    _findMutation() {
-        // For mutation, there can be many defns that match the operation being requested
-        // .ie: deleteAction, deleteActionBySlug, deleteActionByName
-        const matchingDefns = Object.keys(this._introspection).reduce((arr, mutationKey) => {
-            const defn = this._introspection[mutationKey];
-            if (defn.model === this._model &&
-                defn.qtype === this._op &&
-                defn.qtype === 'mutation' &&
-                defn.mutationType === this._mutation) {
-                arr = [...arr, { defn, mutationKey }];
-            }
-            return arr;
-        }, []);
-        if (!matchingDefns.length === 0) {
-            throw new Error('no mutation found for ' + this._model + ':' + this._mutation);
-        }
-        // We only need deleteAction from all of [deleteAction, deleteActionBySlug, deleteActionByName]
-        const getInputName = (mutationType) => {
-            switch (mutationType) {
-                case 'delete': {
-                    return `Delete${inflection.camelize(this._model)}Input`;
-                }
-                case 'create': {
-                    return `Create${inflection.camelize(this._model)}Input`;
-                }
-                case 'patch': {
-                    return `Update${inflection.camelize(this._model)}Input`;
-                }
-                default:
-                    throw new Error('Unhandled mutation type' + mutationType);
-            }
-        };
-        const matchDefn = matchingDefns.find(({ defn }) => defn.properties.input.type === getInputName(this._mutation));
-        if (!matchDefn) {
-            throw new Error('no mutation found for ' + this._model + ':' + this._mutation);
-        }
-        return matchDefn.mutationKey;
-    }
-    select(selection) {
-        const defn = this._introspection[this._key];
-        // If selection not given, pick only scalar fields
-        if (selection == null) {
-            this._select = this.pickScalarFields(null, defn);
-            return this;
-        }
-        this._select = this.pickAllFields(selection, defn);
-        return this;
-    }
-    edges(useEdges) {
-        this._edges = useEdges;
-        return this;
-    }
-    getMany({ select } = {}) {
-        this._op = 'getMany';
-        this._key = this._findQuery();
-        this.queryName(inflection.camelize(['get', inflection.underscore(this._key), 'query'].join('_'), true));
-        const defn = this._introspection[this._key];
-        this.select(select);
-        this._ast = getMany({
-            builder: this,
-            queryName: this._queryName,
-            operationName: this._key,
-            query: defn,
-            selection: this._select
-        });
-        return this;
-    }
-    all({ select } = {}) {
-        this._op = 'getMany';
-        this._key = this._findQuery();
-        this.queryName(inflection.camelize(['get', inflection.underscore(this._key), 'query', 'all'].join('_'), true));
-        const defn = this._introspection[this._key];
-        this.select(select);
-        this._ast = getAll({
-            builder: this,
-            queryName: this._queryName,
-            operationName: this._key,
-            query: defn,
-            selection: this._select
-        });
-        return this;
-    }
-    getOne({ select } = {}) {
-        this._op = 'getOne';
-        this._key = this._findQuery();
-        this.queryName(inflection.camelize(['get', inflection.underscore(this._key), 'query'].join('_'), true));
-        const defn = this._introspection[this._key];
-        this.select(select);
-        this._ast = getOne({
-            builder: this,
-            queryName: this._queryName,
-            operationName: this._key,
-            query: defn,
-            selection: this._select
-        });
-        return this;
-    }
-    create({ select } = {}) {
-        this._op = 'mutation';
-        this._mutation = 'create';
-        this._key = this._findMutation();
-        this.queryName(inflection.camelize([inflection.underscore(this._key), 'mutation'].join('_'), true));
-        const defn = this._introspection[this._key];
-        this.select(select);
-        this._ast = createOne({
-            builder: this,
-            operationName: this._key,
-            mutationName: this._queryName,
-            mutation: defn,
-            selection: this._select
-        });
-        return this;
-    }
-    delete({ select } = {}) {
-        this._op = 'mutation';
-        this._mutation = 'delete';
-        this._key = this._findMutation();
-        this.queryName(inflection.camelize([inflection.underscore(this._key), 'mutation'].join('_'), true));
-        const defn = this._introspection[this._key];
-        this.select(select);
-        this._ast = deleteOne({
-            builder: this,
-            operationName: this._key,
-            mutationName: this._queryName,
-            mutation: defn,
-            selection: this._select
-        });
-        return this;
-    }
-    update({ select } = {}) {
-        this._op = 'mutation';
-        this._mutation = 'patch';
-        this._key = this._findMutation();
-        this.queryName(inflection.camelize([inflection.underscore(this._key), 'mutation'].join('_'), true));
-        const defn = this._introspection[this._key];
-        this.select(select);
-        this._ast = patchOne({
-            builder: this,
-            operationName: this._key,
-            mutationName: this._queryName,
-            mutation: defn,
-            selection: this._select
-        });
-        return this;
-    }
-    queryName(name) {
-        this._queryName = name;
-        return this;
-    }
-    print() {
-        this._hash = gqlPrint(this._ast);
-        return this;
-    }
-}
-/**
- * Pick scalar fields of a query definition
- * @param {Object} defn Query definition
- * @param {Object} meta Meta object containing info about table relations
- * @returns {Array}
- */
-function pickScalarFields(selection, defn) {
-    const model = defn.model;
-    const modelMeta = this._meta.tables.find((t) => t.name === model);
-    const isInTableSchema = (fieldName) => !!modelMeta.fields.find((field) => field.name === fieldName);
-    const pickFrom = (modelSelection) => modelSelection
-        .filter((fieldName) => {
-        // If not specified or not a valid selection list, allow all
-        if (selection == null || !Array.isArray(selection))
-            return true;
-        return selection.includes(fieldName);
-    })
-        .filter((fieldName) => !isRelationalField(fieldName, modelMeta) && isInTableSchema(fieldName))
-        .map((fieldName) => ({
-        name: fieldName,
-        isObject: false,
-        fieldDefn: modelMeta.fields.find((f) => f.name === fieldName)
-    }));
-    // This is for inferring the sub-selection of a mutation query
-    // from a definition model .eg UserSetting, find its related queries in the introspection object, and pick its selection fields
-    if (defn.qtype === 'mutation') {
-        const relatedQuery = this._introspection[`${modelNameToGetMany(defn.model)}`];
-        return pickFrom(relatedQuery.selection);
-    }
-    return pickFrom(defn.selection);
-}
-/**
- * Pick scalar fields and sub-selection fields of a query definition
- * @param {Object} selection Selection clause object
- * @param {Object} defn Query definition
- * @param {Object} meta Meta object containing info about table relations
- * @returns {Array}
- */
-function pickAllFields(selection, defn) {
-    const model = defn.model;
-    const modelMeta = this._meta.tables.find((t) => t.name === model);
-    const selectionEntries = Object.entries(selection);
-    let fields = [];
-    const isWhiteListed = (selectValue) => {
-        return typeof selectValue === 'boolean' && selectValue;
-    };
-    for (const entry of selectionEntries) {
-        const [fieldName, fieldOptions] = entry;
-        // Case
-        // {
-        //   goalResults: // fieldName
-        //    { select: { id: true }, variables: { first: 100 } } // fieldOptions
-        // }
-        if (isObject(fieldOptions)) {
-            if (!isFieldInDefinition(fieldName, defn, modelMeta, this)) {
-                continue;
-            }
-            const referencedForeignConstraint = modelMeta.foreignConstraints.find((constraint) => constraint.fromKey.name === fieldName ||
-                constraint.fromKey.alias === fieldName);
-            const subFields = Object.keys(fieldOptions.select).filter((subField) => {
-                return (!isRelationalField(subField, modelMeta) &&
-                    isWhiteListed(fieldOptions.select[subField]));
-            });
-            const isBelongTo = !!referencedForeignConstraint;
-            const fieldSelection = {
-                name: fieldName,
-                isObject: true,
-                isBelongTo,
-                selection: subFields,
-                variables: fieldOptions.variables
-            };
-            // Need to further expand selection of object fields,
-            // but only non-graphql-builtin, non-relation fields
-            // .ie action { id location }
-            // location is non-scalar and non-relational, thus need to further expand into { x y ... }
-            if (isBelongTo) {
-                const getManyName = modelNameToGetMany(referencedForeignConstraint.refTable);
-                const refDefn = this._introspection[getManyName];
-                fieldSelection.selection = pickScalarFields.call(this, subFields, refDefn);
-            }
-            fields = [...fields, fieldSelection];
-        }
-        else {
-            // Case
-            // {
-            //   userId: true // [fieldName, fieldOptions]
-            // }
-            if (isWhiteListed(fieldOptions)) {
-                fields = [
-                    ...fields,
-                    {
-                        name: fieldName,
-                        isObject: false,
-                        fieldDefn: modelMeta.fields.find((f) => f.name === fieldName)
-                    }
-                ];
-            }
-        }
-    }
-    return fields;
-}
-function isFieldInDefinition(fieldName, defn, modelMeta) {
-    const isReferenced = !!modelMeta.foreignConstraints.find((constraint) => constraint.fromKey.name === fieldName ||
-        constraint.fromKey.alias === fieldName);
-    return (isReferenced ||
-        defn.selection.some((selectionItem) => {
-            if (typeof selectionItem === 'string') {
-                return fieldName === selectionItem;
-            }
-            if (isObject(selectionItem)) {
-                return selectionItem.name === fieldName;
-            }
-            return false;
-        }));
-}
-// TODO: see if there is a possibility of supertyping table (a key is both a foreign and primary key)
-// A relational field is a foreign key but not a primary key
-function isRelationalField(fieldName, modelMeta) {
-    return (!modelMeta.primaryConstraints.find((field) => field.name === fieldName) &&
-        !!modelMeta.foreignConstraints.find((constraint) => constraint.fromKey.name === fieldName));
-}
-// Get getMany op name from model
-// ie. UserSetting => userSettings
-function modelNameToGetMany(model) {
-    return inflection.camelize(inflection.pluralize(inflection.underscore(model)), true);
-}

package/esm/meta-object/convert.js

@@ -1,8 +1,7 @@
-// @ts-nocheck
 export function convertFromMetaSchema(metaSchema) {
-    const { _meta: { tables } } = metaSchema;
+    const { _meta: { tables }, } = metaSchema;
     const result = {
-        tables: []
+        tables: [],
     };
     for (const table of tables) {
         result.tables.push({
@@ -10,7 +9,7 @@ export function convertFromMetaSchema(metaSchema) {
             fields: table.fields.map((f) => pickField(f)),
             primaryConstraints: pickArrayConstraint(table.primaryKeyConstraints),
             uniqueConstraints: pickArrayConstraint(table.uniqueConstraints),
-            foreignConstraints: pickForeignConstraint(table.foreignKeyConstraints, table.relations)
+            foreignConstraints: pickForeignConstraint(table.foreignKeyConstraints, table.relations),
         });
     }
     return result;
@@ -19,7 +18,7 @@ function pickArrayConstraint(constraints) {
     if (constraints.length === 0)
         return [];
     const c = constraints[0];
-    return c.fields.map((field) => pickField(field));
+    return c.fields.map((field) => pickConstraintField(field));
 }
 function pickForeignConstraint(constraints, relations) {
     if (constraints.length === 0)
@@ -29,8 +28,8 @@ function pickForeignConstraint(constraints, relations) {
         const { fields, refFields, refTable } = c;
         const fromKey = pickField(fields[0]);
         const toKey = pickField(refFields[0]);
-        const matchingBelongsTo = belongsTo.find((c) => {
-            const field = pickField(c.keys[0]);
+        const matchingBelongsTo = belongsTo.find((belongsToItem) => {
+            const field = pickField(belongsToItem.keys[0]);
             return field.name === fromKey.name;
         });
         // Ex: 'ownerId' will have an alias of 'owner', which has further selection of 'User' type
@@ -40,13 +39,19 @@ function pickForeignConstraint(constraints, relations) {
         return {
             refTable: refTable.name,
             fromKey,
-            toKey
+            toKey,
         };
     });
 }
 function pickField(field) {
     return {
         name: field.name,
-        type: field.type
+        type: field.type,
+    };
+}
+function pickConstraintField(field) {
+    return {
+        name: field.name,
+        type: field.type,
     };
 }

package/esm/meta-object/format.json

@@ -5,27 +5,44 @@
     "definitions": {
         "field": {
             "type": "object",
-            "required": ["name", "type"],
+            "required": [
+                "name",
+                "type"
+            ],
             "additionalProperties": true,
             "properties": {
                 "name": {
                     "type": "string",
                     "default": "id",
-                    "examples": ["id"]
+                    "examples": [
+                        "id"
+                    ]
                 },
                 "type": {
                     "type": "object",
-                    "required": ["pgType", "gqlType"],
+                    "required": [
+                        "pgType",
+                        "gqlType"
+                    ],
                     "additionalProperties": true,
                     "properties": {
                         "gqlType": {
-                            "type": ["string", "null"]
+                            "type": [
+                                "string",
+                                "null"
+                            ]
                         },
                         "pgType": {
-                            "type": ["string", "null"]
+                            "type": [
+                                "string",
+                                "null"
+                            ]
                         },
                         "subtype": {
-                            "type": ["string", "null"]
+                            "type": [
+                                "string",
+                                "null"
+                            ]
                         }
                     }
                 }
@@ -41,19 +58,27 @@
                     "name": {
                         "type": "string",
                         "default": "User",
-                        "examples": ["User"]
+                        "examples": [
+                            "User"
+                        ]
                     },
                     "fields": {
                         "type": "array",
-                        "items": { "$ref": "#/definitions/field" }
+                        "items": {
+                            "$ref": "#/definitions/field"
+                        }
                     },
                     "primaryConstraints": {
                         "type": "array",
-                        "items": { "$ref": "#/definitions/field" }
+                        "items": {
+                            "$ref": "#/definitions/field"
+                        }
                     },
                     "uniqueConstraints": {
                         "type": "array",
-                        "items": { "$ref": "#/definitions/field" }
+                        "items": {
+                            "$ref": "#/definitions/field"
+                        }
                     },
                     "foreignConstraints": {
                         "type": "array",
@@ -63,21 +88,36 @@
                                 "refTable": {
                                     "type": "string",
                                     "default": "User",
-                                    "examples": ["User"]
+                                    "examples": [
+                                        "User"
+                                    ]
+                                },
+                                "fromKey": {
+                                    "$ref": "#/definitions/field"
                                 },
-                                "fromKey": { "$ref": "#/definitions/field" },
-                                "toKey": { "$ref": "#/definitions/field" }
+                                "toKey": {
+                                    "$ref": "#/definitions/field"
+                                }
                             },
-                            "required": ["refTable", "fromKey", "toKey"],
+                            "required": [
+                                "refTable",
+                                "fromKey",
+                                "toKey"
+                            ],
                             "additionalProperties": false
                         }
                     }
                 },
-                "required": ["name", "fields"],
+                "required": [
+                    "name",
+                    "fields"
+                ],
                 "additionalProperties": false
             }
         }
     },
-    "required": ["tables"],
+    "required": [
+        "tables"
+    ],
     "additionalProperties": false
 }

package/esm/meta-object/validate.js

@@ -7,6 +7,6 @@ export function validateMetaObject(obj) {
         return true;
     return {
         errors: ajv.errors,
-        message: ajv.errorsText(ajv.errors, { separator: '\n' })
+        message: ajv.errorsText(ajv.errors, { separator: '\n' }),
     };
 }