graphile-settings 4.1.1 → 4.3.1

package/esm/plugins/primary-key-only.js

@@ -1,143 +0,0 @@
-/**
- * PrimaryKeyOnlyPlugin - Disables non-primary-key unique constraint lookups for
- * BOTH queries AND mutations.
- *
- * WHY THIS EXISTS:
- * PostGraphile v5 creates fields for EVERY unique constraint on a table:
- *
- * QUERIES (PgRowByUniquePlugin):
- * - `user(id)`, `userByEmail(email)`, `userByUsername(username)`
- *
- * MUTATIONS (PgMutationUpdateDeletePlugin):
- * - `updateUser`, `updateUserByEmail`, `updateUserByUsername`
- * - `deleteUser`, `deleteUserByEmail`, `deleteUserByUsername`
- *
- * For code generation (React Query, etc.), this creates unnecessary complexity.
- * The same operations can be done using the primary key lookup or filters.
- * Standardizing on primary keys reduces the API surface and generated code.
- *
- * SOURCE CODE REFERENCES:
- *
- * 1. Query fields (PgRowByUniquePlugin):
- * https://github.com/graphile/crystal/blob/924b2515c6bd30e5905ac1419a25244b40c8bb4d/graphile-build/graphile-build-pg/src/plugins/PgRowByUniquePlugin.ts#L42-L257
- *
- * The behavior check for queries:
- * ```typescript
- * const fieldBehaviorScope = "query:resource:single";
- * if (!build.behavior.pgResourceUniqueMatches([resource, unique], fieldBehaviorScope)) {
- *   return memo;  // Skip this field
- * }
- * ```
- *
- * 2. Mutation fields (PgMutationUpdateDeletePlugin):
- * https://github.com/graphile/crystal/blob/924b2515c6bd30e5905ac1419a25244b40c8bb4d/graphile-build/graphile-build-pg/src/plugins/PgMutationUpdateDeletePlugin.ts
- *
- * The behavior check for mutations:
- * ```typescript
- * const constraintMode = `constraint:${mode}`;  // "constraint:resource:update" or "constraint:resource:delete"
- * ...resource.uniques.filter((unique) => {
- *   return build.behavior.pgResourceUniqueMatches([resource, unique], constraintMode);
- * })
- * ```
- *
- * OUR FIX:
- * We use the behavior system's OVERRIDE phase (not inferred) to disable these behaviors.
- * The override phase runs AFTER the behavior multiplication/preferences system processes
- * behaviors, giving us the final say on what's enabled/disabled.
- *
- * Behaviors we control:
- * - `-single` - Disables query lookups (userByEmail, etc.)
- * - `-constraint:resource:update` - Disables updateByX mutations
- * - `-constraint:resource:delete` - Disables deleteByX mutations
- *
- * CONFIGURATION OPTIONS:
- *
- * 1. `disableAllUniqueLookups: false` (default - PrimaryKeyOnlyPreset):
- *    - Primary key: query lookup + mutations enabled
- *    - Non-primary-key: everything disabled
- *    Result: `user(id)`, `updateUser`, `deleteUser` only
- *
- * 2. `disableAllUniqueLookups: true` (NoUniqueLookupPreset):
- *    - Primary key: query lookup DISABLED, mutations ENABLED
- *    - Non-primary-key: everything disabled
- *    Result: No query lookups (use filters), but `updateUser`, `deleteUser` still work
- */
-/**
- * Creates a plugin that controls unique constraint lookup behavior.
- *
- * @param options - Configuration options
- * @param options.disableAllUniqueLookups - If true, disables ALL unique lookups including primary keys
- */
-export function createUniqueLookupPlugin(options = {}) {
-    const { disableAllUniqueLookups = false } = options;
-    return {
-        name: 'UniqueLookupPlugin',
-        version: '1.0.0',
-        description: disableAllUniqueLookups
-            ? 'Disables all unique constraint lookups (use filters instead)'
-            : 'Disables non-primary-key unique constraint lookups to reduce API surface',
-        schema: {
-            entityBehavior: {
-                pgResourceUnique: {
-                    // Use 'override' phase instead of 'inferred' - override runs AFTER
-                    // the behavior multiplication/preferences system processes behaviors,
-                    // so it has the final say on what behaviors are enabled/disabled.
-                    override: {
-                        provides: ['uniqueLookupControl'],
-                        callback(behavior, [_resource, unique]) {
-                            if (disableAllUniqueLookups) {
-                                // Disable ALL unique QUERY lookups - users must use filters
-                                // But KEEP primary key mutations (updateX, deleteX)
-                                if (unique.isPrimary) {
-                                    // Primary key: only disable query lookups, keep mutations
-                                    return [behavior, '-single'];
-                                }
-                                // Non-primary-key: disable everything (queries and mutations)
-                                return [
-                                    behavior,
-                                    '-single',
-                                    '-constraint:resource:update',
-                                    '-constraint:resource:delete',
-                                ];
-                            }
-                            // Only allow primary key lookups (both queries and mutations)
-                            if (!unique.isPrimary) {
-                                // Disable non-primary-key unique constraint lookups for queries and mutations
-                                return [
-                                    behavior,
-                                    '-single',
-                                    '-constraint:resource:update',
-                                    '-constraint:resource:delete',
-                                ];
-                            }
-                            return behavior;
-                        },
-                    },
-                },
-            },
-        },
-    };
-}
-// Default plugin instance (primary key only)
-export const PrimaryKeyOnlyPlugin = createUniqueLookupPlugin({
-    disableAllUniqueLookups: false,
-});
-// Plugin that disables ALL unique lookups
-export const NoUniqueLookupPlugin = createUniqueLookupPlugin({
-    disableAllUniqueLookups: true,
-});
-/**
- * Preset that keeps only primary key lookups.
- * Use this in your main preset's `extends` array.
- */
-export const PrimaryKeyOnlyPreset = {
-    plugins: [PrimaryKeyOnlyPlugin],
-};
-/**
- * Preset that disables ALL unique lookups (including primary keys).
- * Users must use collection queries with filters instead.
- * Use this in your main preset's `extends` array.
- */
-export const NoUniqueLookupPreset = {
-    plugins: [NoUniqueLookupPlugin],
-};

package/plugins/conflict-detector.d.ts

@@ -1,7 +0,0 @@
-import type { GraphileConfig } from 'graphile-config';
-export declare const ConflictDetectorPlugin: GraphileConfig.Plugin;
-/**
- * Preset that includes the conflict detector plugin.
- */
-export declare const ConflictDetectorPreset: GraphileConfig.Preset;
-export default ConflictDetectorPlugin;

package/plugins/conflict-detector.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConflictDetectorPreset = exports.ConflictDetectorPlugin = void 0;
-exports.ConflictDetectorPlugin = {
-    name: 'ConflictDetectorPlugin',
-    version: '1.0.0',
-    schema: {
-        hooks: {
-            build(build) {
-                // Track codecs by their GraphQL name to detect conflicts
-                const codecsByName = new Map();
-                // Get configured schemas from pgServices to only check relevant codecs
-                const configuredSchemas = new Set();
-                const pgServices = build.resolvedPreset?.pgServices ?? [];
-                for (const service of pgServices) {
-                    for (const schema of service.schemas ?? ['public']) {
-                        configuredSchemas.add(schema);
-                    }
-                }
-                // Iterate through all codecs to find tables
-                for (const codec of Object.values(build.input.pgRegistry.pgCodecs)) {
-                    // Skip non-table codecs (those without attributes or anonymous ones)
-                    if (!codec.attributes || codec.isAnonymous)
-                        continue;
-                    // Get the schema name from the codec's extensions
-                    const pgExtensions = codec.extensions?.pg;
-                    const schemaName = pgExtensions?.schemaName || 'unknown';
-                    const tableName = codec.name;
-                    // Skip codecs from schemas not in the configured list
-                    if (configuredSchemas.size > 0 && !configuredSchemas.has(schemaName)) {
-                        continue;
-                    }
-                    // Get the GraphQL name that would be generated
-                    const graphqlName = build.inflection.tableType(codec);
-                    const info = {
-                        name: graphqlName,
-                        schemaName,
-                        tableName,
-                    };
-                    if (!codecsByName.has(graphqlName)) {
-                        codecsByName.set(graphqlName, []);
-                    }
-                    codecsByName.get(graphqlName).push(info);
-                }
-                // Check for conflicts and log warnings
-                for (const [graphqlName, codecs] of codecsByName) {
-                    if (codecs.length > 1) {
-                        const locations = codecs
-                            .map((c) => `${c.schemaName}.${c.tableName}`)
-                            .join(', ');
-                        console.warn(`\nNAMING CONFLICT DETECTED: GraphQL type "${graphqlName}" would be generated from multiple tables:\n` +
-                            `   Tables: ${locations}\n` +
-                            `   Resolution options:\n` +
-                            `   1. Add @name smart tag to one table: COMMENT ON TABLE schema.table IS E'@name UniqueTypeName';\n` +
-                            `   2. Rename one of the tables in the database\n` +
-                            `   3. Exclude one table from the schema using @omit smart tag\n`);
-                    }
-                }
-                return build;
-            },
-        },
-    },
-};
-/**
- * Preset that includes the conflict detector plugin.
- */
-exports.ConflictDetectorPreset = {
-    plugins: [exports.ConflictDetectorPlugin],
-};
-exports.default = exports.ConflictDetectorPlugin;

package/plugins/custom-inflector.d.ts

@@ -1,9 +0,0 @@
-import type { GraphileConfig } from 'graphile-config';
-export declare const InflektPlugin: GraphileConfig.Plugin;
-/**
- * Preset that includes the inflekt-based inflector plugin.
- * Use this in your main preset's `extends` array.
- */
-export declare const InflektPreset: GraphileConfig.Preset;
-export declare const CustomInflectorPlugin: GraphileConfig.Plugin;
-export declare const CustomInflectorPreset: GraphileConfig.Preset;

package/plugins/custom-inflector.js

@@ -1,385 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomInflectorPreset = exports.CustomInflectorPlugin = exports.InflektPreset = exports.InflektPlugin = void 0;
-const inflekt_1 = require("inflekt");
-/**
- * Custom inflector plugin for Constructive using the inflekt library.
- *
- * This plugin provides inflection rules based on the inflekt package from dev-utils.
- * It gives us full control over naming conventions and handles Latin plural suffixes
- * correctly (e.g., "schemata" -> "schema" instead of "schematum").
- *
- * Key features:
- * - Uses inflekt for pluralization/singularization with PostGraphile-compatible Latin handling
- * - Simplifies field names (allUsers -> users, postsByAuthorId -> posts)
- * - Customizable opposite name mappings for relations
- */
-/**
- * Custom opposite name mappings for relations.
- * For example, if you have a `parent_id` column, this determines
- * what the reverse relation should be called.
- *
- * Add your own mappings here as needed.
- */
-const CUSTOM_OPPOSITES = {
-    parent: 'child',
-    child: 'parent',
-    author: 'authored',
-    editor: 'edited',
-    reviewer: 'reviewed',
-    owner: 'owned',
-    creator: 'created',
-    updater: 'updated',
-};
-/**
- * Extract base name from attribute names like "author_id" -> "author"
- */
-function getBaseName(attributeName) {
-    const matches = attributeName.match(/^(.+?)(_row_id|_id|_uuid|_fk|_pk|RowId|Id|Uuid|UUID|Fk|Pk)$/);
-    if (matches) {
-        return matches[1];
-    }
-    return null;
-}
-/**
- * Check if a base name matches another name (singularized)
- */
-function baseNameMatches(baseName, otherName) {
-    const singularizedName = (0, inflekt_1.singularize)(otherName);
-    return (0, inflekt_1.camelize)(baseName, true) === (0, inflekt_1.camelize)(singularizedName, true);
-}
-/**
- * Get the opposite name for a relation base name
- */
-function getOppositeBaseName(baseName) {
-    return CUSTOM_OPPOSITES[baseName] || null;
-}
-/**
- * Returns true if array1 and array2 have the same length and values
- */
-function arraysMatch(array1, array2, comparator = (v1, v2) => v1 === v2) {
-    if (array1 === array2)
-        return true;
-    const l = array1.length;
-    if (l !== array2.length)
-        return false;
-    for (let i = 0; i < l; i++) {
-        if (!comparator(array1[i], array2[i]))
-            return false;
-    }
-    return true;
-}
-exports.InflektPlugin = {
-    name: 'InflektPlugin',
-    version: '1.0.0',
-    inflection: {
-        replace: {
-            /**
-             * Remove schema prefixes from all schemas.
-             *
-             * WHY THIS EXISTS:
-             * PostGraphile v5's default `_schemaPrefix` inflector only removes the prefix
-             * for the FIRST schema in the pgServices.schemas array. All other schemas get
-             * prefixed with their schema name (e.g., "services_public_api" -> "servicesPublicApi").
-             *
-             * This is problematic for multi-schema setups where you want clean, consistent
-             * naming across all schemas.
-             *
-             * SOURCE CODE REFERENCE:
-             * https://github.com/graphile/crystal/blob/924b2515c6bd30e5905ac1419a25244b40c8bb4d/graphile-build/graphile-build-pg/src/plugins/PgTablesPlugin.ts#L261-L271
-             *
-             * The relevant v5 code:
-             * ```typescript
-             * _schemaPrefix(options, { pgNamespace, serviceName }) {
-             *   const pgService = options.pgServices?.find((db) => db.name === serviceName);
-             *   const databasePrefix = serviceName === "main" ? "" : `${serviceName}_`;
-             *   const schemaPrefix =
-             *     pgNamespace.nspname === pgService?.schemas?.[0]  // <-- Only first schema!
-             *       ? ""
-             *       : `${pgNamespace.nspname}_`;
-             *   return `${databasePrefix}${schemaPrefix}`;
-             * }
-             * ```
-             *
-             * OUR FIX:
-             * We override this to always return an empty string, giving clean names for
-             * all schemas. Use the ConflictDetectorPlugin to detect naming conflicts.
-             *
-             * WARNING: This may cause naming conflicts if you have tables with the
-             * same name in different schemas. Use @name smart tags to disambiguate.
-             */
-            _schemaPrefix(_previous, _options, _details) {
-                return '';
-            },
-            /**
-             * Keep `id` columns as `id` instead of renaming to `rowId`.
-             *
-             * WHY THIS EXISTS:
-             * PostGraphile v5's default `_attributeName` inflector renames any column
-             * named "id" to "row_id" to avoid conflicts with the Relay Global Object
-             * Identification spec's `id` field. Since we don't use Relay/Node (we use
-             * UUIDs), there's no conflict to avoid.
-             *
-             * NOTE: Disabling NodePlugin does NOT fix this! The renaming happens in
-             * PgAttributesPlugin which is a core plugin we need for basic column
-             * functionality.
-             *
-             * SOURCE CODE REFERENCE:
-             * https://github.com/graphile/crystal/blob/924b2515c6bd30e5905ac1419a25244b40c8bb4d/graphile-build/graphile-build-pg/src/plugins/PgAttributesPlugin.ts#L289-L298
-             *
-             * The relevant v5 code:
-             * ```typescript
-             * _attributeName(options, { attributeName, codec, skipRowId }) {
-             *   const attribute = codec.attributes[attributeName];
-             *   const name = attribute.extensions?.tags?.name || attributeName;
-             *   // Avoid conflict with 'id' field used for Relay.
-             *   const nonconflictName =
-             *     !skipRowId && name.toLowerCase() === "id" && !codec.isAnonymous
-             *       ? "row_id"  // <-- This renames id to row_id!
-             *       : name;
-             *   return this.coerceToGraphQLName(nonconflictName);
-             * }
-             * ```
-             *
-             * OUR FIX:
-             * We override this to always use the original attribute name, never
-             * renaming `id` to `row_id`. Since we use UUIDs and don't use Relay,
-             * there's no naming conflict.
-             */
-            _attributeName(_previous, _options, details) {
-                const attribute = details.codec.attributes[details.attributeName];
-                const name = attribute?.extensions?.tags?.name || details.attributeName;
-                return this.coerceToGraphQLName(name);
-            },
-            /**
-             * Fix capitalized plurals (e.g., "Table1S" -> "Table1s")
-             */
-            camelCase(previous, _preset, str) {
-                const original = previous(str);
-                return (0, inflekt_1.fixCapitalisedPlural)(original);
-            },
-            upperCamelCase(previous, _preset, str) {
-                const original = previous(str);
-                return (0, inflekt_1.fixCapitalisedPlural)(original);
-            },
-            /**
-             * Use inflekt's singularize/pluralize which only changes the last word
-             */
-            pluralize(_previous, _preset, str) {
-                return (0, inflekt_1.pluralizeLast)(str);
-            },
-            singularize(_previous, _preset, str) {
-                return (0, inflekt_1.singularizeLast)(str);
-            },
-            /**
-             * Simplify root query connection fields (allUsers -> users)
-             */
-            allRowsConnection(_previous, _options, resource) {
-                const resourceName = this._singularizedResourceName(resource);
-                return (0, inflekt_1.camelize)((0, inflekt_1.distinctPluralize)(resourceName), true);
-            },
-            /**
-             * Simplify root query list fields
-             */
-            allRowsList(_previous, _options, resource) {
-                const resourceName = this._singularizedResourceName(resource);
-                return (0, inflekt_1.camelize)((0, inflekt_1.distinctPluralize)(resourceName), true) + 'List';
-            },
-            /**
-             * Simplify single relation field names (userByAuthorId -> author)
-             */
-            singleRelation(previous, _options, details) {
-                const { registry, codec, relationName } = details;
-                const relation = registry.pgRelations[codec.name]?.[relationName];
-                if (typeof relation.extensions?.tags?.fieldName === 'string') {
-                    return relation.extensions.tags.fieldName;
-                }
-                // Try to extract base name from the local attribute
-                if (relation.localAttributes.length === 1) {
-                    const attributeName = relation.localAttributes[0];
-                    const baseName = getBaseName(attributeName);
-                    if (baseName) {
-                        return (0, inflekt_1.camelize)(baseName, true);
-                    }
-                }
-                // Fall back to the remote resource name
-                const foreignPk = relation.remoteResource.uniques.find((u) => u.isPrimary);
-                if (foreignPk &&
-                    arraysMatch(foreignPk.attributes, relation.remoteAttributes)) {
-                    return (0, inflekt_1.camelize)(this._singularizedCodecName(relation.remoteResource.codec), true);
-                }
-                return previous(details);
-            },
-            /**
-             * Simplify backwards single relation field names
-             */
-            singleRelationBackwards(previous, _options, details) {
-                const { registry, codec, relationName } = details;
-                const relation = registry.pgRelations[codec.name]?.[relationName];
-                if (typeof relation.extensions?.tags?.foreignSingleFieldName === 'string') {
-                    return relation.extensions.tags.foreignSingleFieldName;
-                }
-                if (typeof relation.extensions?.tags?.foreignFieldName === 'string') {
-                    return relation.extensions.tags.foreignFieldName;
-                }
-                // Try to extract base name from the remote attribute
-                if (relation.remoteAttributes.length === 1) {
-                    const attributeName = relation.remoteAttributes[0];
-                    const baseName = getBaseName(attributeName);
-                    if (baseName) {
-                        const oppositeBaseName = getOppositeBaseName(baseName);
-                        if (oppositeBaseName) {
-                            return (0, inflekt_1.camelize)(`${oppositeBaseName}_${this._singularizedCodecName(relation.remoteResource.codec)}`, true);
-                        }
-                        if (baseNameMatches(baseName, codec.name)) {
-                            return (0, inflekt_1.camelize)(this._singularizedCodecName(relation.remoteResource.codec), true);
-                        }
-                    }
-                }
-                return previous(details);
-            },
-            /**
-             * Simplify many relation field names (postsByAuthorId -> posts)
-             */
-            _manyRelation(previous, _options, details) {
-                const { registry, codec, relationName } = details;
-                const relation = registry.pgRelations[codec.name]?.[relationName];
-                const baseOverride = relation.extensions?.tags.foreignFieldName;
-                if (typeof baseOverride === 'string') {
-                    return baseOverride;
-                }
-                // Try to extract base name from the remote attribute
-                if (relation.remoteAttributes.length === 1) {
-                    const attributeName = relation.remoteAttributes[0];
-                    const baseName = getBaseName(attributeName);
-                    if (baseName) {
-                        const oppositeBaseName = getOppositeBaseName(baseName);
-                        if (oppositeBaseName) {
-                            return (0, inflekt_1.camelize)(`${oppositeBaseName}_${(0, inflekt_1.distinctPluralize)(this._singularizedCodecName(relation.remoteResource.codec))}`, true);
-                        }
-                        if (baseNameMatches(baseName, codec.name)) {
-                            return (0, inflekt_1.camelize)((0, inflekt_1.distinctPluralize)(this._singularizedCodecName(relation.remoteResource.codec)), true);
-                        }
-                    }
-                }
-                // Fall back to pluralized remote resource name
-                const pk = relation.remoteResource.uniques.find((u) => u.isPrimary);
-                if (pk && arraysMatch(pk.attributes, relation.remoteAttributes)) {
-                    return (0, inflekt_1.camelize)((0, inflekt_1.distinctPluralize)(this._singularizedCodecName(relation.remoteResource.codec)), true);
-                }
-                return previous(details);
-            },
-            /**
-             * Simplify many-to-many relation field names with conflict detection.
-             *
-             * Default pg-many-to-many naming: tagsByPostTagPostIdAndTagId
-             * Our simplified naming: tags
-             *
-             * Falls back to verbose naming if:
-             * - Smart tag override exists (manyToManyFieldName)
-             * - There's a direct relation to the same target table (would conflict)
-             * - There are multiple many-to-many relations to the same target table
-             */
-            _manyToManyRelation(previous, _options, details) {
-                const { leftTable, rightTable, junctionTable, rightRelationName } = details;
-                const junctionRightRelation = junctionTable.getRelation(rightRelationName);
-                const baseOverride = junctionRightRelation.extensions?.tags?.manyToManyFieldName;
-                if (typeof baseOverride === 'string') {
-                    return baseOverride;
-                }
-                const simpleName = (0, inflekt_1.camelize)((0, inflekt_1.distinctPluralize)(this._singularizedCodecName(rightTable.codec)), true);
-                const leftRelations = leftTable.getRelations();
-                let hasDirectRelation = false;
-                let manyToManyCount = 0;
-                for (const [_relName, rel] of Object.entries(leftRelations)) {
-                    if (rel.remoteResource?.codec?.name === rightTable.codec.name) {
-                        if (!rel.isReferencee) {
-                            hasDirectRelation = true;
-                        }
-                    }
-                    if (rel.isReferencee &&
-                        rel.remoteResource?.codec?.name !== rightTable.codec.name) {
-                        const junctionRelations = rel.remoteResource?.getRelations?.() || {};
-                        for (const [_jRelName, jRel] of Object.entries(junctionRelations)) {
-                            if (!jRel.isReferencee &&
-                                jRel.remoteResource?.codec?.name === rightTable.codec.name) {
-                                manyToManyCount++;
-                            }
-                        }
-                    }
-                }
-                if (hasDirectRelation || manyToManyCount > 1) {
-                    return previous(details);
-                }
-                return simpleName;
-            },
-            /**
-             * Shorten primary key lookups (userById -> user)
-             */
-            rowByUnique(previous, _options, details) {
-                const { unique, resource } = details;
-                if (typeof unique.extensions?.tags?.fieldName === 'string') {
-                    return unique.extensions?.tags?.fieldName;
-                }
-                if (unique.isPrimary) {
-                    return (0, inflekt_1.camelize)(this._singularizedCodecName(resource.codec), true);
-                }
-                return previous(details);
-            },
-            /**
-             * Shorten update mutation names
-             */
-            updateByKeysField(previous, _options, details) {
-                const { resource, unique } = details;
-                if (typeof unique.extensions?.tags.updateFieldName === 'string') {
-                    return unique.extensions.tags.updateFieldName;
-                }
-                if (unique.isPrimary) {
-                    return (0, inflekt_1.camelize)(`update_${this._singularizedCodecName(resource.codec)}`, true);
-                }
-                return previous(details);
-            },
-            /**
-             * Shorten delete mutation names
-             */
-            deleteByKeysField(previous, _options, details) {
-                const { resource, unique } = details;
-                if (typeof unique.extensions?.tags.deleteFieldName === 'string') {
-                    return unique.extensions.tags.deleteFieldName;
-                }
-                if (unique.isPrimary) {
-                    return (0, inflekt_1.camelize)(`delete_${this._singularizedCodecName(resource.codec)}`, true);
-                }
-                return previous(details);
-            },
-            /**
-             * Uppercase enum values to match GraphQL CONSTANT_CASE convention.
-             *
-             * WHY THIS EXISTS:
-             * In PostGraphile v4, custom PostgreSQL enum values (e.g., 'app', 'core', 'module')
-             * were automatically uppercased to CONSTANT_CASE ('APP', 'CORE', 'MODULE').
-             * In PostGraphile v5, the default `enumValue` inflector preserves the original
-             * PostgreSQL casing via `coerceToGraphQLName(value)`, resulting in lowercase
-             * enum values in the GraphQL schema.
-             *
-             * OUR FIX:
-             * We call the previous inflector to retain all special character handling
-             * (asterisks, symbols, etc.), then uppercase the result to restore v4 behavior.
-             */
-            enumValue(previous, _options, value, codec) {
-                const result = previous(value, codec);
-                return result.toUpperCase();
-            },
-        },
-    },
-};
-/**
- * Preset that includes the inflekt-based inflector plugin.
- * Use this in your main preset's `extends` array.
- */
-exports.InflektPreset = {
-    plugins: [exports.InflektPlugin],
-};
-// Re-export for backwards compatibility
-exports.CustomInflectorPlugin = exports.InflektPlugin;
-exports.CustomInflectorPreset = exports.InflektPreset;

package/plugins/enable-all-filter-columns.d.ts

@@ -1,60 +0,0 @@
-import type { GraphileConfig } from 'graphile-config';
-/**
- * EnableAllFilterColumnsPlugin - Enables filtering on ALL columns, not just indexed ones.
- *
- * WHY THIS EXISTS:
- * PostGraphile v5's `PgIndexBehaviorsPlugin` restricts filtering to only indexed columns
- * by default. This is a performance optimization - filtering on non-indexed columns can
- * cause slow table scans. However, for development and flexibility, we want to allow
- * filtering on all columns and let developers/DBAs decide which columns need indexes.
- *
- * SOURCE CODE REFERENCE:
- * PgIndexBehaviorsPlugin marks non-indexed columns with `extensions.isIndexed = false`
- * and then adds `-filterBy` behavior to remove them from filters:
- * https://github.com/graphile/crystal/blob/924b2515c6bd30e5905ac1419a25244b40c8bb4d/graphile-build/graphile-build-pg/src/plugins/PgIndexBehaviorsPlugin.ts
- *
- * The relevant v5 code (from PgIndexBehaviorsPlugin):
- * ```typescript
- * entityBehavior: {
- *   pgCodecAttribute: {
- *     inferred: {
- *       after: ["inferred"],
- *       provides: ["postInferred"],
- *       callback(behavior, [codec, attributeName]) {
- *         const newBehavior = [behavior];
- *         const attr = codec.attributes[attributeName];
- *         if (attr.extensions?.isIndexed === false) {
- *           newBehavior.push("-filterBy", "-orderBy");  // <-- This removes filterBy!
- *         }
- *         return newBehavior;
- *       },
- *     },
- *   },
- * },
- * ```
- *
- * OUR FIX:
- * We add a behavior callback that runs AFTER PgIndexBehaviorsPlugin's "postInferred" phase
- * and adds `+attribute:filterBy` back to ALL columns, regardless of index status.
- *
- * This means:
- * - All columns will appear in the connection filter's filter argument
- * - Developers can filter by any column
- * - It's the developer's/DBA's responsibility to add indexes for frequently filtered columns
- *
- * PERFORMANCE WARNING:
- * Filtering on non-indexed columns can cause full table scans, which may be slow on large
- * tables. Monitor your query performance and add indexes as needed. You can check which
- * columns are indexed by querying pg_indexes or using EXPLAIN ANALYZE on your queries.
- *
- * To identify non-indexed columns being filtered, you can:
- * 1. Enable slow query logging in PostgreSQL (log_min_duration_statement)
- * 2. Use EXPLAIN ANALYZE on queries to see if they're doing sequential scans
- * 3. Check pg_stat_user_tables for seq_scan counts
- */
-export declare const EnableAllFilterColumnsPlugin: GraphileConfig.Plugin;
-/**
- * Preset that includes the EnableAllFilterColumnsPlugin.
- * Add this to your main preset's `extends` array.
- */
-export declare const EnableAllFilterColumnsPreset: GraphileConfig.Preset;