graphile-settings 4.9.3 → 4.10.1

package/esm/plugins/PublicKeySignature.d.ts

@@ -0,0 +1,11 @@
+import type { GraphileConfig } from 'graphile-config';
+export interface PublicKeyChallengeConfig {
+    schema: string;
+    crypto_network: string;
+    sign_up_with_key: string;
+    sign_in_request_challenge: string;
+    sign_in_record_failure: string;
+    sign_in_with_challenge: string;
+}
+export declare const PublicKeySignature: (pubkey_challenge: PublicKeyChallengeConfig) => GraphileConfig.Plugin;
+export default PublicKeySignature;

package/esm/plugins/PublicKeySignature.js

@@ -0,0 +1,184 @@
+// import Networks from '@pyramation/crypto-networks';
+// import { verifyMessage } from '@pyramation/crypto-keys';
+import { context as grafastContext, lambda, object } from 'grafast';
+import { extendSchema, gql } from 'graphile-utils';
+import { QuoteUtils } from '@pgsql/quotes';
+import pgQueryWithContext from 'pg-query-context';
+const SAFE_IDENTIFIER = /^[a-z_][a-z0-9_]*$/;
+const SAFE_CRYPTO_NETWORK = /^[a-z0-9_-]{1,64}$/i;
+function validateIdentifier(name, label) {
+    if (!SAFE_IDENTIFIER.test(name)) {
+        throw new Error(`PublicKeySignature: invalid ${label} "${name}" — must match /^[a-z_][a-z0-9_]*$/`);
+    }
+}
+function validateCryptoNetwork(name) {
+    if (!SAFE_CRYPTO_NETWORK.test(name)) {
+        throw new Error('PublicKeySignature: invalid crypto_network — must match /^[a-z0-9_-]{1,64}$/i');
+    }
+}
+const MAX_PUBLIC_KEY_LENGTH = 256;
+const MAX_MESSAGE_LENGTH = 4096;
+const MAX_SIGNATURE_LENGTH = 1024;
+const ENABLE_SIGNATURE_VERIFICATION = process.env.ENABLE_SIGNATURE_VERIFICATION === 'true';
+export const PublicKeySignature = (pubkey_challenge) => {
+    const { schema, crypto_network, sign_up_with_key, sign_in_request_challenge, sign_in_record_failure, sign_in_with_challenge } = pubkey_challenge;
+    validateIdentifier(schema, 'schema');
+    validateIdentifier(sign_up_with_key, 'sign_up_with_key');
+    validateIdentifier(sign_in_request_challenge, 'sign_in_request_challenge');
+    validateIdentifier(sign_in_record_failure, 'sign_in_record_failure');
+    validateIdentifier(sign_in_with_challenge, 'sign_in_with_challenge');
+    validateCryptoNetwork(crypto_network);
+    return extendSchema(() => ({
+        typeDefs: gql `
+      input CreateUserAccountWithPublicKeyInput {
+        publicKey: String!
+      }
+
+      input GetMessageForSigningInput {
+        publicKey: String!
+      }
+
+      input VerifyMessageForSigningInput {
+        publicKey: String!
+        message: String!
+        signature: String!
+      }
+
+      type createUserAccountWithPublicKeyPayload {
+        message: String!
+      }
+
+      type getMessageForSigningPayload {
+        message: String!
+      }
+
+      type verifyMessageForSigningPayload {
+        access_token: String!
+        access_token_expires_at: Datetime!
+      }
+
+      extend type Mutation {
+        createUserAccountWithPublicKey(
+          input: CreateUserAccountWithPublicKeyInput
+        ): createUserAccountWithPublicKeyPayload
+
+        getMessageForSigning(
+          input: GetMessageForSigningInput
+        ): getMessageForSigningPayload
+
+        verifyMessageForSigning(
+          input: VerifyMessageForSigningInput
+        ): verifyMessageForSigningPayload
+      }
+    `,
+        plans: {
+            Mutation: {
+                createUserAccountWithPublicKey(_$mutation, fieldArgs) {
+                    const $input = fieldArgs.getRaw('input');
+                    const $withPgClient = grafastContext().get('withPgClient');
+                    const $combined = object({ input: $input, withPgClient: $withPgClient });
+                    return lambda($combined, async ({ input, withPgClient }) => {
+                        if (!input.publicKey || typeof input.publicKey !== 'string' || input.publicKey.length > MAX_PUBLIC_KEY_LENGTH) {
+                            throw new Error('INVALID_PUBLIC_KEY');
+                        }
+                        return withPgClient(null, async (pgClient) => {
+                            await pgClient.query('BEGIN');
+                            try {
+                                await pgQueryWithContext({
+                                    client: pgClient,
+                                    context: { role: 'anonymous' },
+                                    query: `SELECT * FROM ${QuoteUtils.quoteQualifiedIdentifier(schema, sign_up_with_key)}($1)`,
+                                    variables: [input.publicKey],
+                                    skipTransaction: true
+                                });
+                                const { rows: [{ [sign_in_request_challenge]: message }] } = await pgQueryWithContext({
+                                    client: pgClient,
+                                    context: { role: 'anonymous' },
+                                    query: `SELECT * FROM ${QuoteUtils.quoteQualifiedIdentifier(schema, sign_in_request_challenge)}($1)`,
+                                    variables: [input.publicKey],
+                                    skipTransaction: true
+                                });
+                                await pgClient.query('COMMIT');
+                                return { message };
+                            }
+                            catch (err) {
+                                await pgClient.query('ROLLBACK');
+                                throw err;
+                            }
+                        });
+                    });
+                },
+                getMessageForSigning(_$mutation, fieldArgs) {
+                    const $input = fieldArgs.getRaw('input');
+                    const $withPgClient = grafastContext().get('withPgClient');
+                    const $combined = object({ input: $input, withPgClient: $withPgClient });
+                    return lambda($combined, async ({ input, withPgClient }) => {
+                        if (!input.publicKey || typeof input.publicKey !== 'string' || input.publicKey.length > MAX_PUBLIC_KEY_LENGTH) {
+                            throw new Error('INVALID_PUBLIC_KEY');
+                        }
+                        return withPgClient(null, async (pgClient) => {
+                            const { rows: [{ [sign_in_request_challenge]: message }] } = await pgQueryWithContext({
+                                client: pgClient,
+                                context: { role: 'anonymous' },
+                                query: `SELECT * FROM ${QuoteUtils.quoteQualifiedIdentifier(schema, sign_in_request_challenge)}($1)`,
+                                variables: [input.publicKey]
+                            });
+                            if (!message)
+                                throw new Error('NO_ACCOUNT_EXISTS');
+                            return { message };
+                        });
+                    });
+                },
+                // NOTE: Verification remains behind a feature flag until crypto
+                // verification is re-implemented.
+                verifyMessageForSigning(_$mutation, fieldArgs) {
+                    const $input = fieldArgs.getRaw('input');
+                    const $withPgClient = grafastContext().get('withPgClient');
+                    const $combined = object({ input: $input, withPgClient: $withPgClient });
+                    return lambda($combined, async ({ input, withPgClient }) => {
+                        const { publicKey, message, signature: _signature } = input;
+                        if (!publicKey || typeof publicKey !== 'string' || publicKey.length > MAX_PUBLIC_KEY_LENGTH) {
+                            throw new Error('INVALID_PUBLIC_KEY');
+                        }
+                        if (!message || typeof message !== 'string' || message.length > MAX_MESSAGE_LENGTH) {
+                            throw new Error('INVALID_MESSAGE');
+                        }
+                        if (!_signature || typeof _signature !== 'string' || _signature.length > MAX_SIGNATURE_LENGTH) {
+                            throw new Error('INVALID_SIGNATURE');
+                        }
+                        if (!ENABLE_SIGNATURE_VERIFICATION) {
+                            // Fail closed without mutating lockout counters while verification
+                            // is disabled.
+                            throw new Error('FEATURE_DISABLED');
+                        }
+                        return withPgClient(null, async (pgClient) => {
+                            // Only the success path needs a transaction (multi-step)
+                            await pgClient.query('BEGIN');
+                            try {
+                                const { rows: [token] } = await pgQueryWithContext({
+                                    client: pgClient,
+                                    context: { role: 'anonymous' },
+                                    query: `SELECT * FROM ${QuoteUtils.quoteQualifiedIdentifier(schema, sign_in_with_challenge)}($1, $2)`,
+                                    variables: [publicKey, message],
+                                    skipTransaction: true
+                                });
+                                if (!token?.access_token)
+                                    throw new Error('BAD_SIGNIN');
+                                await pgClient.query('COMMIT');
+                                return {
+                                    access_token: token.access_token,
+                                    access_token_expires_at: token.access_token_expires_at
+                                };
+                            }
+                            catch (err) {
+                                await pgClient.query('ROLLBACK');
+                                throw err;
+                            }
+                        });
+                    });
+                }
+            }
+        }
+    }));
+};
+export default PublicKeySignature;

package/esm/plugins/conflict-detector.d.ts

@@ -0,0 +1,7 @@
+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/esm/plugins/conflict-detector.js

@@ -0,0 +1,67 @@
+export const 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.
+ */
+export const ConflictDetectorPreset = {
+    plugins: [ConflictDetectorPlugin],
+};
+export default ConflictDetectorPlugin;

package/esm/plugins/custom-inflector.d.ts

@@ -0,0 +1,9 @@
+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/esm/plugins/custom-inflector.js

@@ -0,0 +1,394 @@
+import { singularize, singularizeLast, pluralizeLast, distinctPluralize, fixCapitalisedPlural, camelize, } from '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 = singularize(otherName);
+    return camelize(baseName, true) === 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;
+}
+export const 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 fixCapitalisedPlural(original);
+            },
+            upperCamelCase(previous, _preset, str) {
+                const original = previous(str);
+                return fixCapitalisedPlural(original);
+            },
+            /**
+             * Use inflekt's singularize/pluralize which only changes the last word
+             */
+            pluralize(_previous, _preset, str) {
+                return pluralizeLast(str);
+            },
+            singularize(_previous, _preset, str) {
+                return singularizeLast(str);
+            },
+            /**
+             * Simplify root query connection fields (allUsers -> users)
+             */
+            allRowsConnection(_previous, _options, resource) {
+                const resourceName = this._singularizedResourceName(resource);
+                return camelize(distinctPluralize(resourceName), true);
+            },
+            /**
+             * Simplify root query list fields
+             */
+            allRowsList(_previous, _options, resource) {
+                const resourceName = this._singularizedResourceName(resource);
+                return camelize(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 (!relation) {
+                    return previous(details);
+                }
+                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 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 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 (!relation) {
+                    return previous(details);
+                }
+                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 camelize(`${oppositeBaseName}_${this._singularizedCodecName(relation.remoteResource.codec)}`, true);
+                        }
+                        if (baseNameMatches(baseName, codec.name)) {
+                            return 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];
+                if (!relation) {
+                    return previous(details);
+                }
+                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 camelize(`${oppositeBaseName}_${distinctPluralize(this._singularizedCodecName(relation.remoteResource.codec))}`, true);
+                        }
+                        if (baseNameMatches(baseName, codec.name)) {
+                            return camelize(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 camelize(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);
+                if (!junctionRightRelation) {
+                    return previous(details);
+                }
+                const baseOverride = junctionRightRelation.extensions?.tags?.manyToManyFieldName;
+                if (typeof baseOverride === 'string') {
+                    return baseOverride;
+                }
+                const simpleName = camelize(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 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 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 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.
+ */
+export const InflektPreset = {
+    plugins: [InflektPlugin],
+};
+// Re-export for backwards compatibility
+export const CustomInflectorPlugin = InflektPlugin;
+export const CustomInflectorPreset = InflektPreset;