@constructive-io/graphql-codegen 4.6.1 → 4.7.0

package/esm/core/meta-object/convert.js

@@ -1,60 +1,4 @@
 /**
- * Convert from raw _meta schema response to internal MetaObject format
+ * Re-export meta-object conversion from @constructive-io/graphql-query.
  */
-export 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) => pickConstraintField(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((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
-        if (matchingBelongsTo) {
-            fromKey.alias = matchingBelongsTo.fieldName;
-        }
-        return {
-            refTable: refTable.name,
-            fromKey,
-            toKey,
-        };
-    });
-}
-function pickField(field) {
-    return {
-        name: field.name,
-        type: field.type,
-    };
-}
-function pickConstraintField(field) {
-    return {
-        name: field.name,
-        type: field.type,
-    };
-}
+export { convertFromMetaSchema } from '@constructive-io/graphql-query';

package/esm/core/meta-object/validate.d.ts

@@ -1,9 +1,4 @@
-export interface ValidationResult {
-    errors: unknown[] | null | undefined;
-    message: string;
-}
 /**
- * Validate a MetaObject against the JSON schema
- * @returns true if valid, or an object with errors and message if invalid
+ * Re-export meta-object validation from @constructive-io/graphql-query.
  */
-export declare function validateMetaObject(obj: unknown): true | ValidationResult;
+export { validateMetaObject, type ValidationResult, } from '@constructive-io/graphql-query';

package/esm/core/meta-object/validate.js

@@ -1,28 +1,4 @@
-import Ajv from 'ajv';
-import format from './format.json';
-let cachedAjv = null;
-let cachedValidator = null;
-function getValidator() {
-    if (!cachedAjv) {
-        cachedAjv = new Ajv({ allErrors: true });
-        cachedValidator = cachedAjv.compile(format);
-    }
-    return {
-        ajv: cachedAjv,
-        validator: cachedValidator,
-    };
-}
 /**
- * Validate a MetaObject against the JSON schema
- * @returns true if valid, or an object with errors and message if invalid
+ * Re-export meta-object validation from @constructive-io/graphql-query.
  */
-export function validateMetaObject(obj) {
-    const { ajv, validator } = getValidator();
-    const valid = validator(obj);
-    if (valid)
-        return true;
-    return {
-        errors: validator.errors,
-        message: ajv.errorsText(validator.errors, { separator: '\n' }),
-    };
-}
+export { validateMetaObject, } from '@constructive-io/graphql-query';

package/esm/core/query-builder.d.ts

@@ -1,46 +1,7 @@
-import type { IntrospectionSchema, MetaObject, QueryBuilderOptions, QueryBuilderResult, QueryDefinition, QueryFieldSelection, QuerySelectionOptions } from './types';
-export * as MetaObject from './meta-object';
-export declare class QueryBuilder {
-    _introspection: IntrospectionSchema;
-    _meta: MetaObject;
-    private _models;
-    private _model;
-    private _key;
-    private _queryName;
-    private _ast;
-    _edges: boolean;
-    private _op;
-    private _mutation;
-    private _select;
-    constructor({ meta, introspection }: QueryBuilderOptions);
-    initModelMap(): void;
-    clear(): void;
-    query(model: string): QueryBuilder;
-    _findQuery(): string;
-    _findMutation(): string;
-    select(selection?: QuerySelectionOptions | null): QueryBuilder;
-    edges(useEdges: boolean): QueryBuilder;
-    getMany({ select }?: {
-        select?: QuerySelectionOptions;
-    }): QueryBuilder;
-    all({ select }?: {
-        select?: QuerySelectionOptions;
-    }): QueryBuilder;
-    count(): QueryBuilder;
-    getOne({ select }?: {
-        select?: QuerySelectionOptions;
-    }): QueryBuilder;
-    create({ select }?: {
-        select?: QuerySelectionOptions;
-    }): QueryBuilder;
-    delete({ select }?: {
-        select?: QuerySelectionOptions;
-    }): QueryBuilder;
-    update({ select }?: {
-        select?: QuerySelectionOptions;
-    }): QueryBuilder;
-    queryName(name: string): QueryBuilder;
-    print(): QueryBuilderResult;
-    pickScalarFields: (selection: QuerySelectionOptions | null, defn: QueryDefinition) => QueryFieldSelection[];
-    pickAllFields: (selection: QuerySelectionOptions, defn: QueryDefinition) => QueryFieldSelection[];
-}
+/**
+ * Re-export QueryBuilder from @constructive-io/graphql-query.
+ *
+ * The QueryBuilder class and MetaObject namespace now live in graphql-query.
+ * Re-exported here for backward compatibility.
+ */
+export { QueryBuilder, MetaObject } from '@constructive-io/graphql-query';

package/esm/core/query-builder.js

@@ -1,375 +1,7 @@
-import { print as gqlPrint } from 'graphql';
-import { camelize, pluralize, underscore } from 'inflekt';
-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${camelize(this._model)}Input`;
-                }
-                case 'create': {
-                    return `Create${camelize(this._model)}Input`;
-                }
-                case 'patch': {
-                    return `Update${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(camelize(['get', 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(camelize(['get', 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(camelize(['get', 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(camelize(['get', 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(camelize([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(camelize([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(camelize([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}
+ * Re-export QueryBuilder from @constructive-io/graphql-query.
+ *
+ * The QueryBuilder class and MetaObject namespace now live in graphql-query.
+ * Re-exported here for backward compatibility.
  */
-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 camelize(pluralize(underscore(model)), true);
-}
+export { QueryBuilder, MetaObject } from '@constructive-io/graphql-query';

package/esm/core/types.d.ts

@@ -1,139 +1,9 @@
-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;
-};
+/**
+ * Re-export core types from @constructive-io/graphql-query.
+ *
+ * This file used to contain the canonical type definitions. They now live in
+ * the `graphql-query` package and are re-exported here for backward
+ * compatibility so existing codegen consumers continue to work unchanged.
+ */
+export { type ASTNode, type NestedProperties, type QueryProperty, type QueryDefinition, type MutationDefinition, type MetaFieldType, type MetaField, type MetaConstraint, type MetaForeignConstraint, type MetaTable, type MetaObject, type GraphQLVariableValue, type GraphQLVariables, type QueryFieldSelection, type QuerySelectionOptions, type QueryBuilderInstance, type ASTFunctionParams, type MutationASTParams, type QueryBuilderOptions, type QueryBuilderResult, type IQueryBuilder, type ObjectArrayItem, isGraphQLVariableValue, isGraphQLVariables, type StrictRecord, } from '@constructive-io/graphql-query';
+export { type QueryIntrospectionSchema as IntrospectionSchema } from '@constructive-io/graphql-query';