@constructive-io/graphql-codegen 2.19.0 → 2.20.0

package/types/mutation.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Mutation-related types
+ */
+import type { FieldSelection } from './selection';
+/**
+ * Options for mutation operations
+ */
+export interface MutationOptions {
+    /** Fields to return after mutation */
+    returning?: string[];
+    /** Field selection for returned data */
+    fieldSelection?: FieldSelection;
+}
+/**
+ * Input for create mutations
+ * Wraps the actual data in PostGraphile's expected format
+ */
+export interface CreateInput<T = Record<string, unknown>> {
+    [tableName: string]: T;
+}
+/**
+ * Input for update mutations
+ */
+export interface UpdateInput<T = Record<string, unknown>> {
+    /** Primary key value */
+    id: string | number;
+    /** Fields to update */
+    patch: T;
+}
+/**
+ * Input for delete mutations
+ */
+export interface DeleteInput {
+    /** Primary key value */
+    id: string | number;
+}
+/**
+ * Standard mutation result
+ */
+export interface MutationResult<T = unknown> {
+    /** The affected record */
+    data?: T;
+    /** Client mutation ID (PostGraphile) */
+    clientMutationId?: string;
+}

package/types/mutation.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Mutation-related types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/query.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Query-related types for building GraphQL operations
+ */
+import type { FieldSelection } from './selection';
+/**
+ * Relay-style pagination info
+ */
+export interface PageInfo {
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    startCursor?: string | null;
+    endCursor?: string | null;
+}
+/**
+ * Relay-style connection result
+ */
+export interface ConnectionResult<T = unknown> {
+    nodes: T[];
+    totalCount: number;
+    pageInfo: PageInfo;
+}
+/**
+ * Options for building SELECT queries
+ */
+export interface QueryOptions {
+    /** Number of records to fetch (alias for first) */
+    first?: number;
+    /** Alias for first */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+    /** Cursor for forward pagination */
+    after?: string;
+    /** Cursor for backward pagination */
+    before?: string;
+    /** Filter conditions */
+    where?: Filter;
+    /** Sort order */
+    orderBy?: OrderByItem[];
+    /** Field selection options */
+    fieldSelection?: FieldSelection;
+    /** Include pageInfo in response */
+    includePageInfo?: boolean;
+}
+/**
+ * Single order by specification
+ */
+export interface OrderByItem {
+    field: string;
+    direction: 'asc' | 'desc';
+}
+/**
+ * All supported filter operators
+ */
+export type FilterOperator = 'isNull' | 'equalTo' | 'notEqualTo' | 'distinctFrom' | 'notDistinctFrom' | 'in' | 'notIn' | 'lessThan' | 'lessThanOrEqualTo' | 'greaterThan' | 'greaterThanOrEqualTo' | 'includes' | 'notIncludes' | 'includesInsensitive' | 'notIncludesInsensitive' | 'startsWith' | 'notStartsWith' | 'startsWithInsensitive' | 'notStartsWithInsensitive' | 'endsWith' | 'notEndsWith' | 'endsWithInsensitive' | 'notEndsWithInsensitive' | 'like' | 'notLike' | 'likeInsensitive' | 'notLikeInsensitive' | 'equalToInsensitive' | 'notEqualToInsensitive' | 'distinctFromInsensitive' | 'notDistinctFromInsensitive' | 'inInsensitive' | 'notInInsensitive' | 'contains' | 'containedBy' | 'overlaps' | 'intersects' | 'intersects3D' | 'containsProperly' | 'coveredBy' | 'covers' | 'crosses' | 'disjoint' | 'orderingEquals' | 'touches' | 'within' | 'bboxIntersects2D' | 'bboxIntersects3D' | 'bboxOverlapsOrLeftOf' | 'bboxOverlapsOrRightOf' | 'bboxOverlapsOrBelow' | 'bboxOverlapsOrAbove' | 'bboxLeftOf' | 'bboxRightOf' | 'bboxBelow' | 'bboxAbove' | 'bboxContains' | 'bboxEquals';
+/**
+ * Filter on a single field
+ */
+export type FieldFilter = {
+    [K in FilterOperator]?: unknown;
+};
+/**
+ * Filter on related records
+ */
+export interface RelationalFilter {
+    /** All related records must match */
+    every?: Filter;
+    /** At least one related record must match */
+    some?: Filter;
+    /** No related records match */
+    none?: Filter;
+}
+/**
+ * Main filter type - can be nested
+ */
+export type Filter = {
+    [field: string]: FieldFilter | RelationalFilter | Filter;
+} & {
+    and?: Filter[];
+    or?: Filter[];
+    not?: Filter;
+};

package/types/query.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Query-related types for building GraphQL operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/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/types/schema.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Core schema types for representing PostGraphile table metadata
+ * These are "clean" versions that remove nullable/undefined complexity
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/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/types/selection.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Field selection types for controlling which fields are included in queries
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/utils/index.d.ts

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

package/utils/index.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Utility exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UTILS_VERSION = void 0;
+exports.UTILS_VERSION = '0.1.0';

package/codegen.d.ts

@@ -1,13 +0,0 @@
-import { GraphQLCodegenOptions } from './options';
-export declare function runCodegen(opts: GraphQLCodegenOptions, cwd: string): Promise<{
-    root: string;
-    typesFile: string;
-    operationsDir: string;
-    sdkFile: string;
-}>;
-export declare function runCodegenFromJSONConfig(configPath: string, cwd: string): Promise<{
-    root: string;
-    typesFile: string;
-    operationsDir: string;
-    sdkFile: string;
-}>;