@constructive-io/graphql-codegen 2.19.0 → 2.20.0

package/esm/core/custom-ast.js

@@ -0,0 +1,161 @@
+import * as t from 'gql-ast';
+/**
+ * Get custom AST for MetaField type - handles PostgreSQL types that need subfield selections
+ */
+export function getCustomAst(fieldDefn) {
+    if (!fieldDefn) {
+        return null;
+    }
+    const { pgType } = fieldDefn.type;
+    if (pgType === 'geometry') {
+        return geometryAst(fieldDefn.name);
+    }
+    if (pgType === 'interval') {
+        return intervalAst(fieldDefn.name);
+    }
+    return t.field({
+        name: fieldDefn.name,
+    });
+}
+/**
+ * Generate custom AST for CleanField type - handles GraphQL types that need subfield selections
+ */
+export function getCustomAstForCleanField(field) {
+    const { name, type } = field;
+    const { gqlType, pgType } = type;
+    // Handle by GraphQL type first (this is what the error messages reference)
+    if (gqlType === 'GeometryPoint') {
+        return geometryPointAst(name);
+    }
+    if (gqlType === 'Interval') {
+        return intervalAst(name);
+    }
+    if (gqlType === 'GeometryGeometryCollection') {
+        return geometryCollectionAst(name);
+    }
+    // Handle by pgType as fallback
+    if (pgType === 'geometry') {
+        return geometryAst(name);
+    }
+    if (pgType === 'interval') {
+        return intervalAst(name);
+    }
+    // Return simple field for scalar types
+    return t.field({
+        name,
+    });
+}
+/**
+ * Check if a CleanField requires subfield selection based on its GraphQL type
+ */
+export function requiresSubfieldSelection(field) {
+    const { gqlType } = field.type;
+    // Complex GraphQL types that require subfield selection
+    const complexTypes = [
+        'GeometryPoint',
+        'Interval',
+        'GeometryGeometryCollection',
+        'GeoJSON',
+    ];
+    return complexTypes.includes(gqlType);
+}
+/**
+ * Generate AST for GeometryPoint type
+ */
+export function geometryPointAst(name) {
+    return t.field({
+        name,
+        selectionSet: t.selectionSet({
+            selections: toFieldArray(['x', 'y']),
+        }),
+    });
+}
+/**
+ * Generate AST for GeometryGeometryCollection type
+ */
+export function geometryCollectionAst(name) {
+    // Manually create inline fragment since gql-ast doesn't support it
+    const inlineFragment = {
+        kind: 'InlineFragment',
+        typeCondition: {
+            kind: 'NamedType',
+            name: {
+                kind: 'Name',
+                value: 'GeometryPoint',
+            },
+        },
+        selectionSet: {
+            kind: 'SelectionSet',
+            selections: [
+                {
+                    kind: 'Field',
+                    name: {
+                        kind: 'Name',
+                        value: 'x',
+                    },
+                },
+                {
+                    kind: 'Field',
+                    name: {
+                        kind: 'Name',
+                        value: 'y',
+                    },
+                },
+            ],
+        },
+    };
+    return t.field({
+        name,
+        selectionSet: t.selectionSet({
+            selections: [
+                t.field({
+                    name: 'geometries',
+                    selectionSet: t.selectionSet({
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        selections: [inlineFragment], // gql-ast limitation with inline fragments
+                    }),
+                }),
+            ],
+        }),
+    });
+}
+/**
+ * Generate AST for generic geometry type (returns geojson)
+ */
+export function geometryAst(name) {
+    return t.field({
+        name,
+        selectionSet: t.selectionSet({
+            selections: toFieldArray(['geojson']),
+        }),
+    });
+}
+/**
+ * Generate AST for interval type
+ */
+export function intervalAst(name) {
+    return t.field({
+        name,
+        selectionSet: t.selectionSet({
+            selections: toFieldArray([
+                'days',
+                'hours',
+                'minutes',
+                'months',
+                'seconds',
+                'years',
+            ]),
+        }),
+    });
+}
+function toFieldArray(strArr) {
+    return strArr.map((fieldName) => t.field({ name: fieldName }));
+}
+/**
+ * Check if an object has interval type shape
+ */
+export function isIntervalType(obj) {
+    if (!obj || typeof obj !== 'object')
+        return false;
+    return ['days', 'hours', 'minutes', 'months', 'seconds', 'years'].every((key) => Object.prototype.hasOwnProperty.call(obj, key));
+}

package/esm/core/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Core query building exports
+ */
+export * from './types';
+export * from './ast';
+export * from './custom-ast';
+export { QueryBuilder, MetaObject } from './query-builder';
+export { validateMetaObject, convertFromMetaSchema } from './meta-object';

package/esm/core/index.js

@@ -0,0 +1,12 @@
+/**
+ * Core query building exports
+ */
+// Types
+export * from './types';
+// AST generation
+export * from './ast';
+export * from './custom-ast';
+// Query builder
+export { QueryBuilder, MetaObject } from './query-builder';
+// Meta object utilities
+export { validateMetaObject, convertFromMetaSchema } from './meta-object';

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

@@ -0,0 +1,65 @@
+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[];
+}
+/**
+ * Convert from raw _meta schema response to internal MetaObject format
+ */
+export declare function convertFromMetaSchema(metaSchema: MetaSchemaInput): ConvertedMetaObject;
+export {};

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

@@ -0,0 +1,60 @@
+/**
+ * Convert from raw _meta schema response to internal MetaObject format
+ */
+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,
+    };
+}

package/esm/core/meta-object/format.json

@@ -0,0 +1,93 @@
+{
+    "$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/esm/core/meta-object/index.d.ts

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

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

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

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

@@ -0,0 +1,9 @@
+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
+ */
+export declare function validateMetaObject(obj: unknown): true | ValidationResult;

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

@@ -0,0 +1,28 @@
+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
+ */
+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' }),
+    };
+}

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

@@ -0,0 +1,46 @@
+import type { QueryFieldSelection, IntrospectionSchema, MetaObject, QueryBuilderOptions, QueryBuilderResult, QueryDefinition, 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[];
+}