@constructive-io/graphql-codegen 2.18.0 → 2.20.0

package/esm/core/query-builder.js

@@ -0,0 +1,375 @@
+import { print as gqlPrint } from 'graphql';
+import * as inflection from 'inflection';
+import { createOne, deleteOne, getAll, getCount, getMany, getOne, patchOne, } from './ast';
+import { validateMetaObject } from './meta-object';
+export * as MetaObject from './meta-object';
+const isObject = (val) => val !== null && typeof val === 'object';
+export class QueryBuilder {
+    _introspection;
+    _meta;
+    _models;
+    _model;
+    _key;
+    _queryName;
+    _ast;
+    _edges;
+    _op;
+    _mutation;
+    _select;
+    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 = {};
+        for (const [key, defn] of Object.entries(this._introspection)) {
+            if (!this._models[defn.model]) {
+                this._models[defn.model] = {};
+            }
+            this._models[defn.model][key] = defn;
+        }
+    }
+    clear() {
+        this._model = '';
+        this._key = null;
+        this._queryName = '';
+        this._ast = null;
+        this._edges = false;
+        this._op = '';
+        this._mutation = '';
+        this._select = [];
+    }
+    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({
+            queryName: this._queryName,
+            operationName: this._key,
+            query: defn,
+            selection: this._select,
+        });
+        return this;
+    }
+    count() {
+        this._op = 'getMany';
+        this._key = this._findQuery();
+        this.queryName(inflection.camelize(['get', inflection.underscore(this._key), 'count', 'query'].join('_'), true));
+        const defn = this._introspection[this._key];
+        this._ast = getCount({
+            queryName: this._queryName,
+            operationName: this._key,
+            query: defn,
+        });
+        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({
+            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({
+            operationName: this._key,
+            mutationName: this._queryName,
+            mutation: defn,
+        });
+        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({
+            operationName: this._key,
+            mutationName: this._queryName,
+            mutation: defn,
+            selection: this._select,
+        });
+        return this;
+    }
+    queryName(name) {
+        this._queryName = name;
+        return this;
+    }
+    print() {
+        if (!this._ast) {
+            throw new Error('No AST generated. Please call a query method first.');
+        }
+        const _hash = gqlPrint(this._ast);
+        return {
+            _hash,
+            _queryName: this._queryName,
+            _ast: this._ast,
+        };
+    }
+    // Bind methods that will be called with different this context
+    pickScalarFields;
+    pickAllFields;
+}
+/**
+ * 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);
+    if (!modelMeta) {
+        throw new Error(`Model meta not found for ${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 Object.keys(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);
+    if (!modelMeta) {
+        throw new Error(`Model meta not found for ${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)) {
+                continue;
+            }
+            const referencedForeignConstraint = modelMeta.foreignConstraints.find((constraint) => constraint.fromKey.name === fieldName ||
+                constraint.fromKey.alias === fieldName);
+            const selectOptions = fieldOptions;
+            const subFields = Object.keys(selectOptions.select).filter((subField) => {
+                return (!isRelationalField(subField, modelMeta) &&
+                    isWhiteListed(selectOptions.select[subField]));
+            });
+            const isBelongTo = !!referencedForeignConstraint;
+            const fieldSelection = {
+                name: fieldName,
+                isObject: true,
+                isBelongTo,
+                selection: subFields.map((name) => ({ name, isObject: false })),
+                variables: selectOptions.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, { [fieldName]: true }, 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/core/types.d.ts

@@ -0,0 +1,139 @@
+import type { DocumentNode, FieldNode, SelectionSetNode, VariableDefinitionNode } from 'graphql';
+import type { CleanField } from '../types/schema';
+export type ASTNode = DocumentNode | FieldNode | SelectionSetNode | VariableDefinitionNode;
+export interface NestedProperties {
+    [key: string]: QueryProperty | NestedProperties;
+}
+export interface QueryProperty {
+    name: string;
+    type: string;
+    isNotNull: boolean;
+    isArray: boolean;
+    isArrayNotNull: boolean;
+    properties?: NestedProperties;
+}
+export interface QueryDefinition {
+    model: string;
+    qtype: 'getMany' | 'getOne' | 'mutation';
+    mutationType?: 'create' | 'patch' | 'delete';
+    selection: string[];
+    properties: Record<string, QueryProperty>;
+}
+export interface MutationDefinition extends QueryDefinition {
+    qtype: 'mutation';
+    mutationType: 'create' | 'patch' | 'delete';
+}
+export interface IntrospectionSchema {
+    [key: string]: QueryDefinition | MutationDefinition;
+}
+export interface MetaFieldType {
+    gqlType: string;
+    isArray: boolean;
+    modifier?: string | number | null;
+    pgAlias?: string | null;
+    pgType?: string | null;
+    subtype?: string | null;
+    typmod?: number | null;
+}
+export interface MetaField {
+    name: string;
+    type: MetaFieldType;
+}
+export interface MetaConstraint {
+    name: string;
+    type: MetaFieldType;
+    alias?: string;
+}
+export interface MetaForeignConstraint {
+    fromKey: MetaConstraint;
+    refTable: string;
+    toKey: MetaConstraint;
+}
+export interface MetaTable {
+    name: string;
+    fields: MetaField[];
+    primaryConstraints: MetaConstraint[];
+    uniqueConstraints: MetaConstraint[];
+    foreignConstraints: MetaForeignConstraint[];
+}
+export interface MetaObject {
+    tables: MetaTable[];
+}
+export type GraphQLVariableValue = string | number | boolean | null;
+export interface GraphQLVariables {
+    [key: string]: GraphQLVariableValue | GraphQLVariableValue[] | GraphQLVariables | GraphQLVariables[];
+}
+export interface QueryFieldSelection {
+    name: string;
+    isObject: boolean;
+    fieldDefn?: MetaField | CleanField;
+    selection?: QueryFieldSelection[];
+    variables?: GraphQLVariables;
+    isBelongTo?: boolean;
+}
+export interface QuerySelectionOptions {
+    [fieldName: string]: boolean | {
+        select: Record<string, boolean>;
+        variables?: GraphQLVariables;
+    };
+}
+export interface QueryBuilderInstance {
+    _introspection: IntrospectionSchema;
+    _meta: MetaObject;
+    _edges?: boolean;
+}
+export interface ASTFunctionParams {
+    queryName: string;
+    operationName: string;
+    query: QueryDefinition;
+    selection: QueryFieldSelection[];
+    builder?: QueryBuilderInstance;
+}
+export interface MutationASTParams {
+    mutationName: string;
+    operationName: string;
+    mutation: MutationDefinition;
+    selection?: QueryFieldSelection[];
+}
+export interface QueryBuilderOptions {
+    meta: MetaObject;
+    introspection: IntrospectionSchema;
+}
+export interface QueryBuilderResult {
+    _hash: string;
+    _queryName: string;
+    _ast: DocumentNode;
+}
+export interface IQueryBuilder {
+    query(model: string): IQueryBuilder;
+    getMany(options?: {
+        select?: QuerySelectionOptions;
+    }): IQueryBuilder;
+    getOne(options?: {
+        select?: QuerySelectionOptions;
+    }): IQueryBuilder;
+    all(options?: {
+        select?: QuerySelectionOptions;
+    }): IQueryBuilder;
+    count(): IQueryBuilder;
+    create(options?: {
+        select?: QuerySelectionOptions;
+    }): IQueryBuilder;
+    update(options?: {
+        select?: QuerySelectionOptions;
+    }): IQueryBuilder;
+    delete(options?: {
+        select?: QuerySelectionOptions;
+    }): IQueryBuilder;
+    edges(useEdges: boolean): IQueryBuilder;
+    print(): QueryBuilderResult;
+}
+export interface ObjectArrayItem extends QueryProperty {
+    name: string;
+    key?: string;
+}
+export declare function isGraphQLVariableValue(value: unknown): value is GraphQLVariableValue;
+export declare function isGraphQLVariables(obj: unknown): obj is GraphQLVariables;
+export type StrictRecord<K extends PropertyKey, V> = Record<K, V> & {
+    [P in PropertyKey]: P extends K ? V : never;
+};

package/esm/core/types.js

@@ -0,0 +1,24 @@
+// Type guards for runtime validation
+export function isGraphQLVariableValue(value) {
+    return (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean');
+}
+export function isGraphQLVariables(obj) {
+    if (!obj || typeof obj !== 'object')
+        return false;
+    for (const [key, value] of Object.entries(obj)) {
+        if (typeof key !== 'string')
+            return false;
+        if (Array.isArray(value)) {
+            if (!value.every((item) => isGraphQLVariableValue(item) || isGraphQLVariables(item))) {
+                return false;
+            }
+        }
+        else if (!isGraphQLVariableValue(value) && !isGraphQLVariables(value)) {
+            return false;
+        }
+    }
+    return true;
+}

package/esm/generators/field-selector.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Simplified field selection system
+ * Converts user-friendly selection options to internal SelectionOptions format
+ */
+import type { QuerySelectionOptions } from '../core/types';
+import type { CleanTable } from '../types/schema';
+import type { FieldSelection } from '../types/selection';
+/**
+ * Convert simplified field selection to QueryBuilder SelectionOptions
+ */
+export declare function convertToSelectionOptions(table: CleanTable, allTables: CleanTable[], selection?: FieldSelection): QuerySelectionOptions | null;
+/**
+ * Check if a field is relational using table metadata
+ */
+export declare function isRelationalField(fieldName: string, table: CleanTable): boolean;
+/**
+ * Get all available relation fields from a table
+ */
+export declare function getAvailableRelations(table: CleanTable): Array<{
+    fieldName: string;
+    type: 'belongsTo' | 'hasOne' | 'hasMany' | 'manyToMany';
+    referencedTable?: string;
+}>;
+/**
+ * Validate field selection against table schema
+ */
+export declare function validateFieldSelection(selection: FieldSelection, table: CleanTable): {
+    isValid: boolean;
+    errors: string[];
+};