@constructive-io/graphql-query 2.4.7 → 2.5.0

package/index.js

@@ -15,6 +15,9 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __importStar = (this && this.__importStar) || (function () {
     var ownKeys = function(o) {
         ownKeys = Object.getOwnPropertyNames || function (o) {
@@ -32,351 +35,9 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryBuilder = exports.MetaObject = void 0;
-// @ts-nocheck
-const graphql_1 = require("graphql");
-const inflection_1 = __importDefault(require("inflection"));
-const ast_1 = require("./ast");
-const meta_object_1 = require("./meta-object");
+exports.MetaObject = exports.QueryBuilder = void 0;
+var query_builder_1 = require("./query-builder");
+Object.defineProperty(exports, "QueryBuilder", { enumerable: true, get: function () { return query_builder_1.QueryBuilder; } });
+__exportStar(require("./types"), exports);
 exports.MetaObject = __importStar(require("./meta-object"));
-const isObject = val => val !== null && typeof val === 'object';
-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 = (0, meta_object_1.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_1.default.camelize(this._model)}Input`;
-                }
-                case 'create': {
-                    return `Create${inflection_1.default.camelize(this._model)}Input`;
-                }
-                case 'patch': {
-                    return `Update${inflection_1.default.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_1.default.camelize(['get', inflection_1.default.underscore(this._key), 'query'].join('_'), true));
-        const defn = this._introspection[this._key];
-        this.select(select);
-        this._ast = (0, ast_1.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_1.default.camelize(['get', inflection_1.default.underscore(this._key), 'query', 'all'].join('_'), true));
-        const defn = this._introspection[this._key];
-        this.select(select);
-        this._ast = (0, ast_1.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_1.default.camelize(['get', inflection_1.default.underscore(this._key), 'query'].join('_'), true));
-        const defn = this._introspection[this._key];
-        this.select(select);
-        this._ast = (0, ast_1.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_1.default.camelize([inflection_1.default.underscore(this._key), 'mutation'].join('_'), true));
-        const defn = this._introspection[this._key];
-        this.select(select);
-        this._ast = (0, ast_1.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_1.default.camelize([inflection_1.default.underscore(this._key), 'mutation'].join('_'), true));
-        const defn = this._introspection[this._key];
-        this.select(select);
-        this._ast = (0, ast_1.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_1.default.camelize([inflection_1.default.underscore(this._key), 'mutation'].join('_'), true));
-        const defn = this._introspection[this._key];
-        this.select(select);
-        this._ast = (0, ast_1.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 = (0, graphql_1.print)(this._ast);
-        return this;
-    }
-}
-exports.QueryBuilder = QueryBuilder;
-/**
- * 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_1.default.camelize(inflection_1.default.pluralize(inflection_1.default.underscore(model)), true);
-}

package/meta-object/convert.d.ts

@@ -1,3 +1,62 @@
-export declare function convertFromMetaSchema(metaSchema: any): {
-    tables: any[];
-};
+import type { MetaFieldType } from '../types';
+interface MetaSchemaField {
+    name: string;
+    type: MetaFieldType;
+}
+interface MetaSchemaConstraint {
+    fields: MetaSchemaField[];
+}
+interface MetaSchemaForeignConstraint {
+    fields: MetaSchemaField[];
+    refFields: MetaSchemaField[];
+    refTable: {
+        name: string;
+    };
+}
+interface MetaSchemaBelongsTo {
+    keys: MetaSchemaField[];
+    fieldName: string;
+}
+interface MetaSchemaRelations {
+    belongsTo: MetaSchemaBelongsTo[];
+}
+interface MetaSchemaTable {
+    name: string;
+    fields: MetaSchemaField[];
+    primaryKeyConstraints: MetaSchemaConstraint[];
+    uniqueConstraints: MetaSchemaConstraint[];
+    foreignKeyConstraints: MetaSchemaForeignConstraint[];
+    relations: MetaSchemaRelations;
+}
+interface MetaSchemaInput {
+    _meta: {
+        tables: MetaSchemaTable[];
+    };
+}
+interface ConvertedField {
+    name: string;
+    type: MetaFieldType;
+    alias?: string;
+}
+interface ConvertedConstraint {
+    name: string;
+    type: MetaFieldType;
+    alias?: string;
+}
+interface ConvertedForeignConstraint {
+    refTable: string;
+    fromKey: ConvertedField;
+    toKey: ConvertedField;
+}
+interface ConvertedTable {
+    name: string;
+    fields: ConvertedField[];
+    primaryConstraints: ConvertedConstraint[];
+    uniqueConstraints: ConvertedConstraint[];
+    foreignConstraints: ConvertedForeignConstraint[];
+}
+interface ConvertedMetaObject {
+    tables: ConvertedTable[];
+}
+export declare function convertFromMetaSchema(metaSchema: MetaSchemaInput): ConvertedMetaObject;
+export {};

package/meta-object/convert.js

@@ -1,11 +1,10 @@
 "use strict";
-// @ts-nocheck
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertFromMetaSchema = convertFromMetaSchema;
 function convertFromMetaSchema(metaSchema) {
-    const { _meta: { tables } } = metaSchema;
+    const { _meta: { tables }, } = metaSchema;
     const result = {
-        tables: []
+        tables: [],
     };
     for (const table of tables) {
         result.tables.push({
@@ -13,7 +12,7 @@ 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;
@@ -22,7 +21,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)
@@ -32,8 +31,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
@@ -43,13 +42,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/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/meta-object/validate.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructive-io/graphql-query",
-  "version": "2.4.7",
+  "version": "2.5.0",
   "description": "Constructive GraphQL Query",
   "author": "Constructive <developers@constructive.io>",
   "main": "index.js",
@@ -44,5 +44,5 @@
   "devDependencies": {
     "makage": "^0.1.10"
   },
-  "gitHead": "f2f9c9851beff3214790dfca371e4ca7f6c1373f"
+  "gitHead": "baa2f7598cde3baf3f05f161a11bafa12c66f6aa"
 }