@constructive-io/graphql-query 2.4.3

package/index.js

@@ -0,0 +1,382 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        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 = __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

@@ -0,0 +1,3 @@
+export declare function convertFromMetaSchema(metaSchema: any): {
+    tables: any[];
+};

package/meta-object/convert.js

@@ -0,0 +1,55 @@
+"use strict";
+// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertFromMetaSchema = convertFromMetaSchema;
+function convertFromMetaSchema(metaSchema) {
+    const { _meta: { tables } } = metaSchema;
+    const result = {
+        tables: []
+    };
+    for (const table of tables) {
+        result.tables.push({
+            name: table.name,
+            fields: table.fields.map((f) => pickField(f)),
+            primaryConstraints: pickArrayConstraint(table.primaryKeyConstraints),
+            uniqueConstraints: pickArrayConstraint(table.uniqueConstraints),
+            foreignConstraints: pickForeignConstraint(table.foreignKeyConstraints, table.relations)
+        });
+    }
+    return result;
+}
+function pickArrayConstraint(constraints) {
+    if (constraints.length === 0)
+        return [];
+    const c = constraints[0];
+    return c.fields.map((field) => pickField(field));
+}
+function pickForeignConstraint(constraints, relations) {
+    if (constraints.length === 0)
+        return [];
+    const { belongsTo } = relations;
+    return constraints.map((c) => {
+        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]);
+            return field.name === fromKey.name;
+        });
+        // Ex: 'ownerId' will have an alias of 'owner', which has further selection of 'User' type
+        if (matchingBelongsTo) {
+            fromKey.alias = matchingBelongsTo.fieldName;
+        }
+        return {
+            refTable: refTable.name,
+            fromKey,
+            toKey
+        };
+    });
+}
+function pickField(field) {
+    return {
+        name: field.name,
+        type: field.type
+    };
+}

package/meta-object/format.json

@@ -0,0 +1,83 @@
+{
+    "$id": "root",
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "type": "object",
+    "definitions": {
+        "field": {
+            "type": "object",
+            "required": ["name", "type"],
+            "additionalProperties": true,
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "default": "id",
+                    "examples": ["id"]
+                },
+                "type": {
+                    "type": "object",
+                    "required": ["pgType", "gqlType"],
+                    "additionalProperties": true,
+                    "properties": {
+                        "gqlType": {
+                            "type": ["string", "null"]
+                        },
+                        "pgType": {
+                            "type": ["string", "null"]
+                        },
+                        "subtype": {
+                            "type": ["string", "null"]
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "properties": {
+        "tables": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "name": {
+                        "type": "string",
+                        "default": "User",
+                        "examples": ["User"]
+                    },
+                    "fields": {
+                        "type": "array",
+                        "items": { "$ref": "#/definitions/field" }
+                    },
+                    "primaryConstraints": {
+                        "type": "array",
+                        "items": { "$ref": "#/definitions/field" }
+                    },
+                    "uniqueConstraints": {
+                        "type": "array",
+                        "items": { "$ref": "#/definitions/field" }
+                    },
+                    "foreignConstraints": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "refTable": {
+                                    "type": "string",
+                                    "default": "User",
+                                    "examples": ["User"]
+                                },
+                                "fromKey": { "$ref": "#/definitions/field" },
+                                "toKey": { "$ref": "#/definitions/field" }
+                            },
+                            "required": ["refTable", "fromKey", "toKey"],
+                            "additionalProperties": false
+                        }
+                    }
+                },
+                "required": ["name", "fields"],
+                "additionalProperties": false
+            }
+        }
+    },
+    "required": ["tables"],
+    "additionalProperties": false
+}

package/meta-object/index.d.ts

@@ -0,0 +1,2 @@
+export * from './convert';
+export * from './validate';

package/meta-object/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./convert"), exports);
+__exportStar(require("./validate"), exports);

package/meta-object/validate.d.ts

@@ -0,0 +1,4 @@
+export declare function validateMetaObject(obj: any): true | {
+    errors: import("ajv").ErrorObject<string, Record<string, any>, unknown>[];
+    message: string;
+};

package/meta-object/validate.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMetaObject = validateMetaObject;
+const ajv_1 = __importDefault(require("ajv"));
+const format_json_1 = __importDefault(require("./format.json"));
+function validateMetaObject(obj) {
+    const ajv = new ajv_1.default({ allErrors: true });
+    const valid = ajv.validate(format_json_1.default, obj);
+    if (valid)
+        return true;
+    return {
+        errors: ajv.errors,
+        message: ajv.errorsText(ajv.errors, { separator: '\n' })
+    };
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@constructive-io/graphql-query",
+  "version": "2.4.3",
+  "description": "Constructive GraphQL Query",
+  "author": "Constructive <developers@constructive.io>",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/constructive-io/constructive",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/constructive-io/constructive"
+  },
+  "bugs": {
+    "url": "https://github.com/constructive-io/constructive/issues"
+  },
+  "scripts": {
+    "clean": "makage clean",
+    "prepack": "npm run build",
+    "build": "makage build",
+    "build:dev": "makage build --dev",
+    "lint": "eslint . --fix",
+    "test": "jest --passWithNoTests",
+    "test:watch": "jest --watch"
+  },
+  "dependencies": {
+    "ajv": "^7.0.4",
+    "gql-ast": "^2.4.3",
+    "graphql": "15.10.1",
+    "inflection": "1.12.0",
+    "pluralize": "8.0.0"
+  },
+  "keywords": [
+    "query",
+    "builder",
+    "graphql",
+    "constructive",
+    "database"
+  ],
+  "devDependencies": {
+    "makage": "^0.1.8"
+  },
+  "gitHead": "22cfe32e994e26a6490e04e28bab26d1e7e6345c"
+}