graphile-settings 4.1.1 → 4.3.0

package/upload-resolver.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Upload resolver for the Constructive upload plugin.
+ *
+ * Reads CDN/S3/MinIO configuration from environment variables (via getEnvOptions)
+ * and streams uploaded files to the configured storage backend.
+ *
+ * Lazily initializes the S3 streamer on first upload to avoid requiring
+ * env vars at module load time.
+ *
+ * ENV VARS:
+ *   BUCKET_PROVIDER  - 'minio' | 's3' (default: 'minio')
+ *   BUCKET_NAME      - bucket name (default: 'test-bucket')
+ *   AWS_REGION       - AWS region (default: 'us-east-1')
+ *   AWS_ACCESS_KEY   - access key (default: 'minioadmin')
+ *   AWS_SECRET_KEY   - secret key (default: 'minioadmin')
+ *   MINIO_ENDPOINT   - MinIO endpoint (default: 'http://localhost:9000')
+ */
+import type { Readable } from 'stream';
+import type { UploadFieldDefinition } from 'graphile-upload-plugin';
+/**
+ * Streams a file to S3/MinIO storage and returns the URL and metadata.
+ *
+ * Reusable by both the GraphQL upload resolver and REST /upload endpoint.
+ */
+export declare function streamToStorage(readStream: Readable, filename: string): Promise<{
+    url: string;
+    filename: string;
+    mime: string;
+}>;
+/**
+ * Upload field definitions for Constructive's three upload domain types.
+ *
+ * These match columns whose PostgreSQL type is one of the domains defined
+ * in constructive-db/pgpm-modules/types/:
+ *
+ * - `image`      (public schema) — jsonb domain for images with versions
+ * - `upload`     (public schema) — jsonb domain for generic file uploads
+ * - `attachment` (public schema) — text domain for simple URL attachments
+ *
+ * These domain types are part of the platform's core type system, deployed
+ * to every application database. They rarely change, so this config is stable.
+ */
+export declare const constructiveUploadFieldDefinitions: UploadFieldDefinition[];

package/upload-resolver.js

@@ -0,0 +1,175 @@
+"use strict";
+/**
+ * Upload resolver for the Constructive upload plugin.
+ *
+ * Reads CDN/S3/MinIO configuration from environment variables (via getEnvOptions)
+ * and streams uploaded files to the configured storage backend.
+ *
+ * Lazily initializes the S3 streamer on first upload to avoid requiring
+ * env vars at module load time.
+ *
+ * ENV VARS:
+ *   BUCKET_PROVIDER  - 'minio' | 's3' (default: 'minio')
+ *   BUCKET_NAME      - bucket name (default: 'test-bucket')
+ *   AWS_REGION       - AWS region (default: 'us-east-1')
+ *   AWS_ACCESS_KEY   - access key (default: 'minioadmin')
+ *   AWS_SECRET_KEY   - secret key (default: 'minioadmin')
+ *   MINIO_ENDPOINT   - MinIO endpoint (default: 'http://localhost:9000')
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructiveUploadFieldDefinitions = void 0;
+exports.streamToStorage = streamToStorage;
+const s3_streamer_1 = __importDefault(require("@constructive-io/s3-streamer"));
+const upload_names_1 = __importDefault(require("@constructive-io/upload-names"));
+const graphql_env_1 = require("@constructive-io/graphql-env");
+const logger_1 = require("@pgpmjs/logger");
+const crypto_1 = require("crypto");
+const log = new logger_1.Logger('upload-resolver');
+const DEFAULT_IMAGE_MIME_TYPES = ['image/jpeg', 'image/png', 'image/svg+xml'];
+let streamer = null;
+let bucketName;
+function getStreamer() {
+    if (streamer)
+        return streamer;
+    const opts = (0, graphql_env_1.getEnvOptions)();
+    const cdn = opts.cdn || {};
+    const provider = cdn.provider || 'minio';
+    bucketName = cdn.bucketName || 'test-bucket';
+    const awsRegion = cdn.awsRegion || 'us-east-1';
+    const awsAccessKey = cdn.awsAccessKey || 'minioadmin';
+    const awsSecretKey = cdn.awsSecretKey || 'minioadmin';
+    const minioEndpoint = cdn.minioEndpoint || 'http://localhost:9000';
+    if (process.env.NODE_ENV === 'production') {
+        if (!cdn.awsAccessKey || !cdn.awsSecretKey) {
+            log.warn('[upload-resolver] WARNING: Using default credentials in production.');
+        }
+    }
+    log.info(`[upload-resolver] Initializing: provider=${provider} bucket=${bucketName}`);
+    streamer = new s3_streamer_1.default({
+        defaultBucket: bucketName,
+        awsRegion,
+        awsSecretKey,
+        awsAccessKey,
+        minioEndpoint,
+        provider,
+    });
+    return streamer;
+}
+/**
+ * Generates a randomized storage key from a filename.
+ * Format: {random10chars}-{sanitized-filename}
+ */
+function generateKey(filename) {
+    const rand = (0, crypto_1.randomBytes)(12).toString('hex');
+    return `${rand}-${(0, upload_names_1.default)(filename)}`;
+}
+/**
+ * Streams a file to S3/MinIO storage and returns the URL and metadata.
+ *
+ * Reusable by both the GraphQL upload resolver and REST /upload endpoint.
+ */
+async function streamToStorage(readStream, filename) {
+    const s3 = getStreamer();
+    const key = generateKey(filename);
+    const result = await s3.upload({
+        readStream,
+        filename,
+        key,
+        bucket: bucketName,
+    });
+    return {
+        url: result.upload.Location,
+        filename,
+        mime: result.contentType,
+    };
+}
+/**
+ * Upload resolver that streams files to S3/MinIO.
+ *
+ * Returns different shapes based on the column's type hint:
+ * - 'image' / 'upload' → { filename, mime, url } (for jsonb domain columns)
+ * - 'attachment' / default → url string (for text domain columns)
+ *
+ * MIME validation happens before persistence: content type is detected from
+ * stream bytes, validated against smart-tag/type rules, and only then uploaded.
+ */
+async function uploadResolver(upload, _args, _context, info) {
+    const { tags, type } = info.uploadPlugin;
+    const s3 = getStreamer();
+    const { filename } = upload;
+    const key = generateKey(filename);
+    // MIME type validation from smart tags
+    const typ = type || tags?.type;
+    const VALID_MIME = /^[a-z]+\/[a-z0-9][a-z0-9!#$&\-.^_+]*$/i;
+    const mim = tags?.mime
+        ? String(tags.mime)
+            .trim()
+            .split(',')
+            .map((a) => a.trim())
+            .filter((m) => VALID_MIME.test(m))
+        : typ === 'image'
+            ? DEFAULT_IMAGE_MIME_TYPES
+            : [];
+    const detected = await s3.detectContentType({
+        readStream: upload.createReadStream(),
+        filename,
+    });
+    const detectedContentType = detected.contentType;
+    if (mim.length && !mim.includes(detectedContentType)) {
+        detected.stream.destroy();
+        throw new Error('UPLOAD_MIMETYPE');
+    }
+    const result = await s3.uploadWithContentType({
+        readStream: detected.stream,
+        contentType: detectedContentType,
+        magic: detected.magic,
+        key,
+        bucket: bucketName,
+    });
+    const url = result.upload.Location;
+    const { contentType } = result;
+    switch (typ) {
+        case 'image':
+        case 'upload':
+            return { filename, mime: contentType, url };
+        case 'attachment':
+        default:
+            return url;
+    }
+}
+/**
+ * Upload field definitions for Constructive's three upload domain types.
+ *
+ * These match columns whose PostgreSQL type is one of the domains defined
+ * in constructive-db/pgpm-modules/types/:
+ *
+ * - `image`      (public schema) — jsonb domain for images with versions
+ * - `upload`     (public schema) — jsonb domain for generic file uploads
+ * - `attachment` (public schema) — text domain for simple URL attachments
+ *
+ * These domain types are part of the platform's core type system, deployed
+ * to every application database. They rarely change, so this config is stable.
+ */
+exports.constructiveUploadFieldDefinitions = [
+    {
+        name: 'image',
+        namespaceName: 'public',
+        type: 'image',
+        resolve: uploadResolver,
+    },
+    {
+        name: 'upload',
+        namespaceName: 'public',
+        type: 'upload',
+        resolve: uploadResolver,
+    },
+    {
+        name: 'attachment',
+        namespaceName: 'public',
+        type: 'attachment',
+        resolve: uploadResolver,
+    },
+];

package/esm/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/esm/plugins/conflict-detector.js

@@ -1,67 +0,0 @@
-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

@@ -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/esm/plugins/custom-inflector.js

@@ -1,382 +0,0 @@
-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 (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 (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];
-                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);
-                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;