@constructive-io/graphql-codegen 2.19.0 → 2.20.0

package/esm/types/schema.d.ts

@@ -0,0 +1,253 @@
+/**
+ * Core schema types for representing PostGraphile table metadata
+ * These are "clean" versions that remove nullable/undefined complexity
+ */
+/**
+ * Represents a database table with its fields and relations
+ */
+export interface CleanTable {
+    name: string;
+    fields: CleanField[];
+    relations: CleanRelations;
+    /** PostGraphile inflection rules for this table */
+    inflection?: TableInflection;
+    /** Query operation names from _meta */
+    query?: TableQueryNames;
+    /** Constraint information */
+    constraints?: TableConstraints;
+}
+/**
+ * PostGraphile-generated names for this table
+ */
+export interface TableInflection {
+    /** All rows connection query name (e.g., "users") */
+    allRows: string;
+    /** Simple all rows query name */
+    allRowsSimple: string;
+    /** Condition type name (e.g., "UserCondition") */
+    conditionType: string;
+    /** Connection type name (e.g., "UsersConnection") */
+    connection: string;
+    /** Create field name */
+    createField: string;
+    /** Create input type (e.g., "CreateUserInput") */
+    createInputType: string;
+    /** Create payload type */
+    createPayloadType: string;
+    /** Delete by primary key mutation name */
+    deleteByPrimaryKey: string | null;
+    /** Delete payload type */
+    deletePayloadType: string;
+    /** Edge type name */
+    edge: string;
+    /** Edge field name */
+    edgeField: string;
+    /** Enum type name */
+    enumType: string;
+    /** Filter type name (e.g., "UserFilter") */
+    filterType: string | null;
+    /** Input type name (e.g., "UserInput") */
+    inputType: string;
+    /** OrderBy enum type (e.g., "UsersOrderBy") */
+    orderByType: string;
+    /** Patch field name */
+    patchField: string;
+    /** Patch type (e.g., "UserPatch") */
+    patchType: string | null;
+    /** Table field name (singular, e.g., "user") */
+    tableFieldName: string;
+    /** Table type name (e.g., "User") */
+    tableType: string;
+    /** Type name */
+    typeName: string;
+    /** Update by primary key mutation name */
+    updateByPrimaryKey: string | null;
+    /** Update payload type */
+    updatePayloadType: string | null;
+}
+/**
+ * Query operation names from _meta.query
+ */
+export interface TableQueryNames {
+    /** All rows query name */
+    all: string;
+    /** Single row query name */
+    one: string;
+    /** Create mutation name */
+    create: string;
+    /** Update mutation name */
+    update: string | null;
+    /** Delete mutation name */
+    delete: string | null;
+}
+/**
+ * Table constraints
+ */
+export interface TableConstraints {
+    primaryKey: ConstraintInfo[];
+    foreignKey: ForeignKeyConstraint[];
+    unique: ConstraintInfo[];
+}
+export interface ConstraintInfo {
+    name: string;
+    fields: CleanField[];
+}
+export interface ForeignKeyConstraint extends ConstraintInfo {
+    refTable: string;
+    refFields: CleanField[];
+}
+/**
+ * Represents a field/column in a table
+ */
+export interface CleanField {
+    name: string;
+    type: CleanFieldType;
+}
+/**
+ * Field type information from PostGraphile introspection
+ */
+export interface CleanFieldType {
+    /** GraphQL type name (e.g., "String", "UUID", "Int") */
+    gqlType: string;
+    /** Whether this is an array type */
+    isArray: boolean;
+    /** Type modifier (for precision, length, etc.) */
+    modifier?: string | number | null;
+    /** PostgreSQL type alias (domain name) */
+    pgAlias?: string | null;
+    /** PostgreSQL native type (e.g., "text", "uuid", "integer") */
+    pgType?: string | null;
+    /** Subtype for composite types */
+    subtype?: string | null;
+    /** Type modifier from PostgreSQL */
+    typmod?: number | null;
+}
+/**
+ * All relation types for a table
+ */
+export interface CleanRelations {
+    belongsTo: CleanBelongsToRelation[];
+    hasOne: CleanHasOneRelation[];
+    hasMany: CleanHasManyRelation[];
+    manyToMany: CleanManyToManyRelation[];
+}
+/**
+ * BelongsTo relation (foreign key on this table)
+ */
+export interface CleanBelongsToRelation {
+    fieldName: string | null;
+    isUnique: boolean;
+    referencesTable: string;
+    type: string | null;
+    keys: CleanField[];
+}
+/**
+ * HasOne relation (foreign key on other table, unique)
+ */
+export interface CleanHasOneRelation {
+    fieldName: string | null;
+    isUnique: boolean;
+    referencedByTable: string;
+    type: string | null;
+    keys: CleanField[];
+}
+/**
+ * HasMany relation (foreign key on other table, not unique)
+ */
+export interface CleanHasManyRelation {
+    fieldName: string | null;
+    isUnique: boolean;
+    referencedByTable: string;
+    type: string | null;
+    keys: CleanField[];
+}
+/**
+ * ManyToMany relation (through junction table)
+ */
+export interface CleanManyToManyRelation {
+    fieldName: string | null;
+    rightTable: string;
+    junctionTable: string;
+    type: string | null;
+}
+/**
+ * Clean representation of a GraphQL operation (query or mutation)
+ * Derived from introspection data
+ */
+export interface CleanOperation {
+    /** Operation name (e.g., "login", "currentUser", "cars") */
+    name: string;
+    /** Operation kind */
+    kind: 'query' | 'mutation';
+    /** Arguments/variables for the operation */
+    args: CleanArgument[];
+    /** Return type */
+    returnType: CleanTypeRef;
+    /** Description from schema */
+    description?: string;
+    /** Whether this is deprecated */
+    isDeprecated?: boolean;
+    /** Deprecation reason */
+    deprecationReason?: string;
+}
+/**
+ * Clean representation of an operation argument
+ */
+export interface CleanArgument {
+    /** Argument name */
+    name: string;
+    /** Argument type */
+    type: CleanTypeRef;
+    /** Default value (as string) */
+    defaultValue?: string;
+    /** Description from schema */
+    description?: string;
+}
+/**
+ * Clean type reference - simplified from introspection TypeRef
+ */
+export interface CleanTypeRef {
+    /** Type kind */
+    kind: 'SCALAR' | 'OBJECT' | 'INPUT_OBJECT' | 'ENUM' | 'LIST' | 'NON_NULL';
+    /** Type name (null for LIST and NON_NULL wrappers) */
+    name: string | null;
+    /** Inner type for LIST and NON_NULL wrappers */
+    ofType?: CleanTypeRef;
+    /** Resolved TypeScript type string */
+    tsType?: string;
+    /** Fields for OBJECT types */
+    fields?: CleanObjectField[];
+    /** Input fields for INPUT_OBJECT types */
+    inputFields?: CleanArgument[];
+    /** Values for ENUM types */
+    enumValues?: string[];
+}
+/**
+ * Field on an object type
+ */
+export interface CleanObjectField {
+    /** Field name */
+    name: string;
+    /** Field type */
+    type: CleanTypeRef;
+    /** Description */
+    description?: string;
+}
+/**
+ * Registry of all types in the schema for resolution
+ */
+export type TypeRegistry = Map<string, ResolvedType>;
+/**
+ * Resolved type with all details populated
+ */
+export interface ResolvedType {
+    kind: 'SCALAR' | 'OBJECT' | 'INPUT_OBJECT' | 'ENUM' | 'INTERFACE' | 'UNION';
+    name: string;
+    description?: string;
+    /** Fields for OBJECT types */
+    fields?: CleanObjectField[];
+    /** Input fields for INPUT_OBJECT types */
+    inputFields?: CleanArgument[];
+    /** Values for ENUM types */
+    enumValues?: string[];
+}

package/esm/types/schema.js

@@ -0,0 +1,5 @@
+/**
+ * Core schema types for representing PostGraphile table metadata
+ * These are "clean" versions that remove nullable/undefined complexity
+ */
+export {};

package/esm/types/selection.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Field selection types for controlling which fields are included in queries
+ */
+/**
+ * Simple field selection options
+ */
+export interface SimpleFieldSelection {
+    /** Specific fields to include */
+    select?: string[];
+    /** Relations to include with their fields */
+    include?: Record<string, string[] | boolean>;
+    /** Simple relation inclusion (just names) */
+    includeRelations?: string[];
+    /** Fields to exclude */
+    exclude?: string[];
+    /** Maximum depth for nested relations */
+    maxDepth?: number;
+}
+/**
+ * Predefined field selection presets
+ */
+export type FieldSelectionPreset = 
+/** Just id and primary display field */
+'minimal'
+/** Common display fields */
+ | 'display'
+/** All scalar fields */
+ | 'all'
+/** All fields including relations */
+ | 'full';
+/**
+ * Main field selection type - preset or custom
+ */
+export type FieldSelection = FieldSelectionPreset | SimpleFieldSelection;
+/**
+ * Internal selection options format used by query builder
+ */
+export interface SelectionOptions {
+    [fieldName: string]: boolean | {
+        select: Record<string, boolean>;
+        variables?: Record<string, unknown>;
+    };
+}

package/esm/types/selection.js

@@ -0,0 +1,4 @@
+/**
+ * Field selection types for controlling which fields are included in queries
+ */
+export {};

package/esm/utils/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Utility exports
+ */
+export declare const UTILS_VERSION = "0.1.0";

package/esm/utils/index.js

@@ -0,0 +1,4 @@
+/**
+ * Utility exports
+ */
+export const UTILS_VERSION = '0.1.0';

package/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[];
+};