graphile-settings 3.1.1 → 4.0.1

package/esm/plugins/meta-schema.js

@@ -0,0 +1,20 @@
+/**
+ * PostGraphile v5 Meta Schema Plugin
+ *
+ * Exposes a `_meta` GraphQL query that provides metadata about tables, fields,
+ * constraints, indexes, and relations for code generation tooling.
+ */
+import { cachedTablesMeta } from './meta-schema/cache';
+import { MetaSchemaPlugin } from './meta-schema/plugin';
+import { buildFieldMeta, pgTypeToGqlType } from './meta-schema/type-mappings';
+export { MetaSchemaPlugin };
+export const MetaSchemaPreset = {
+    plugins: [MetaSchemaPlugin],
+};
+/** @internal Exported for testing only */
+export { pgTypeToGqlType as _pgTypeToGqlType };
+/** @internal Exported for testing only */
+export { buildFieldMeta as _buildFieldMeta };
+/** @internal Exported for testing only */
+export { cachedTablesMeta as _cachedTablesMeta };
+export default MetaSchemaPlugin;

package/esm/plugins/minimal-preset.d.ts

@@ -0,0 +1,7 @@
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * Minimal preset with all the PostgreSQL functionality but without Node/Relay features.
+ * This keeps `id` columns as `id` (no renaming to `rowId`).
+ */
+export declare const MinimalPreset: GraphileConfig.Preset;
+export default MinimalPreset;

package/esm/plugins/minimal-preset.js

@@ -0,0 +1,42 @@
+import { defaultPreset as graphileBuildPreset } from 'graphile-build';
+import { defaultPreset as graphileBuildPgPreset } from 'graphile-build-pg';
+/**
+ * Minimal PostGraphile v5 preset without Node/Relay features.
+ *
+ * This preset builds a clean GraphQL API from PostgreSQL without:
+ * - Global Node ID (Relay spec) - so `id` columns stay as `id`
+ * - Schema prefixing for naming conflicts
+ *
+ * We use the default presets from graphile-build and graphile-build-pg
+ * and disable all Node-related plugins.
+ */
+/**
+ * List of Node/Relay-related plugins to disable.
+ * These implement the Relay Global Object Identification spec which:
+ * - Adds a global `id` field to types
+ * - Renames actual `id` columns to `rowId`
+ * - Adds Node interface and nodeId lookups
+ *
+ * Since we use UUIDs, we don't need any of this.
+ */
+const NODE_PLUGINS_TO_DISABLE = [
+    // Core Node plugins from graphile-build
+    'NodePlugin',
+    'AddNodeInterfaceToSuitableTypesPlugin',
+    'NodeIdCodecBase64JSONPlugin',
+    'NodeIdCodecPipeStringPlugin',
+    'RegisterQueryNodePlugin',
+    'NodeAccessorPlugin',
+    // PG-specific Node plugins from graphile-build-pg
+    'PgNodeIdAttributesPlugin',
+    'PgTableNodePlugin',
+];
+/**
+ * Minimal preset with all the PostgreSQL functionality but without Node/Relay features.
+ * This keeps `id` columns as `id` (no renaming to `rowId`).
+ */
+export const MinimalPreset = {
+    extends: [graphileBuildPreset, graphileBuildPgPreset],
+    disablePlugins: NODE_PLUGINS_TO_DISABLE,
+};
+export default MinimalPreset;

package/esm/plugins/pg-type-mappings.d.ts

@@ -0,0 +1,41 @@
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * Type mapping configuration for custom PostgreSQL types.
+ */
+export interface TypeMapping {
+    /** PostgreSQL type name */
+    name: string;
+    /** PostgreSQL schema/namespace name */
+    namespaceName: string;
+    /** GraphQL type to map to */
+    type: 'String';
+}
+/**
+ * Plugin that maps custom PostgreSQL types to GraphQL scalar types.
+ *
+ * This is useful for domain types or composite types that should be
+ * represented as simple scalars (String, JSON) in the GraphQL API.
+ *
+ * For example, if you have:
+ *   CREATE DOMAIN email AS text;
+ *   CREATE TYPE url AS (value text);
+ *
+ * This plugin will map them to GraphQL String type instead of creating
+ * complex object types.
+ *
+ * The plugin handles both:
+ * 1. Domain types (simple aliases) - maps directly to the target scalar
+ * 2. Composite types - extracts the first field's value when converting from PG
+ */
+export declare const PgTypeMappingsPlugin: GraphileConfig.Plugin;
+/**
+ * Preset that includes the PG type mappings plugin.
+ *
+ * This preset maps common custom PostgreSQL types to GraphQL scalars:
+ * - email -> String
+ * - hostname -> String
+ * - url -> String
+ * - origin -> String
+ */
+export declare const PgTypeMappingsPreset: GraphileConfig.Preset;
+export default PgTypeMappingsPlugin;

package/esm/plugins/pg-type-mappings.js

@@ -0,0 +1,122 @@
+import { GraphQLString } from 'graphql';
+import sql from 'pg-sql2';
+/**
+ * Default type mappings for common custom PostgreSQL types.
+ * These are typically domain types or composite types that should be
+ * represented as simple scalars in GraphQL.
+ */
+const DEFAULT_MAPPINGS = [
+    { name: 'email', namespaceName: 'public', type: 'String' },
+    { name: 'hostname', namespaceName: 'public', type: 'String' },
+    { name: 'origin', namespaceName: 'public', type: 'String' },
+    { name: 'url', namespaceName: 'public', type: 'String' },
+];
+/**
+ * Plugin that maps custom PostgreSQL types to GraphQL scalar types.
+ *
+ * This is useful for domain types or composite types that should be
+ * represented as simple scalars (String, JSON) in the GraphQL API.
+ *
+ * For example, if you have:
+ *   CREATE DOMAIN email AS text;
+ *   CREATE TYPE url AS (value text);
+ *
+ * This plugin will map them to GraphQL String type instead of creating
+ * complex object types.
+ *
+ * The plugin handles both:
+ * 1. Domain types (simple aliases) - maps directly to the target scalar
+ * 2. Composite types - extracts the first field's value when converting from PG
+ */
+export const PgTypeMappingsPlugin = {
+    name: 'PgTypeMappingsPlugin',
+    version: '1.0.0',
+    gather: {
+        hooks: {
+            async pgCodecs_findPgCodec(info, event) {
+                if (event.pgCodec) {
+                    return;
+                }
+                const { pgType: type, serviceName } = event;
+                // Find the namespace for this type
+                const namespace = await info.helpers.pgIntrospection.getNamespace(serviceName, type.typnamespace);
+                if (!namespace) {
+                    return;
+                }
+                // Check if this type matches any of our mappings
+                const mapping = DEFAULT_MAPPINGS.find(m => m.name === type.typname && m.namespaceName === namespace.nspname);
+                if (!mapping) {
+                    return;
+                }
+                // Create a codec for this type
+                // For composite types, the fromPg function extracts the first field's value
+                // For domain types, it just passes through the value
+                event.pgCodec = {
+                    name: type.typname,
+                    sqlType: sql.identifier(namespace.nspname, type.typname),
+                    fromPg: (value) => {
+                        if (value == null) {
+                            return null;
+                        }
+                        // If it's already a scalar, return it
+                        if (typeof value !== 'object' || Array.isArray(value)) {
+                            return value;
+                        }
+                        // For composite types, extract the first field's value
+                        const obj = value;
+                        const keys = Object.keys(obj);
+                        if (keys.length > 0) {
+                            return obj[keys[0]];
+                        }
+                        return value;
+                    },
+                    toPg: (value) => value,
+                    attributes: undefined,
+                    executor: null,
+                    extensions: {
+                        oid: type._id,
+                        pg: {
+                            serviceName,
+                            schemaName: namespace.nspname,
+                            name: type.typname,
+                        },
+                        tags: {
+                            // Mark this as a custom mapped type
+                            pgTypeMappings: mapping.type,
+                        },
+                    },
+                };
+            },
+        },
+    },
+    schema: {
+        hooks: {
+            init(_, build) {
+                const { setGraphQLTypeForPgCodec } = build;
+                // Map our custom codecs to GraphQL types
+                for (const codec of Object.values(build.input.pgRegistry.pgCodecs)) {
+                    const mappingType = codec.extensions?.tags?.pgTypeMappings;
+                    if (mappingType) {
+                        const gqlTypeName = GraphQLString.name;
+                        setGraphQLTypeForPgCodec(codec, 'input', gqlTypeName);
+                        setGraphQLTypeForPgCodec(codec, 'output', gqlTypeName);
+                    }
+                }
+                return _;
+            },
+        },
+    },
+};
+/**
+ * Preset that includes the PG type mappings plugin.
+ *
+ * This preset maps common custom PostgreSQL types to GraphQL scalars:
+ * - email -> String
+ * - hostname -> String
+ * - url -> String
+ * - origin -> String
+ */
+export const PgTypeMappingsPreset = {
+    plugins: [PgTypeMappingsPlugin],
+};
+export default PgTypeMappingsPlugin;

package/esm/plugins/primary-key-only.d.ts

@@ -0,0 +1,96 @@
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * Configuration options for unique lookup behavior.
+ */
+export interface UniqueLookupOptions {
+    /**
+     * If true, disables ALL unique constraint lookups including primary keys.
+     * Users must use collection queries with filters instead.
+     * Default: false (primary key lookups are kept)
+     */
+    disableAllUniqueLookups?: boolean;
+}
+/**
+ * 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 declare function createUniqueLookupPlugin(options?: UniqueLookupOptions): GraphileConfig.Plugin;
+export declare const PrimaryKeyOnlyPlugin: GraphileConfig.Plugin;
+export declare const NoUniqueLookupPlugin: GraphileConfig.Plugin;
+/**
+ * Preset that keeps only primary key lookups.
+ * Use this in your main preset's `extends` array.
+ */
+export declare const PrimaryKeyOnlyPreset: GraphileConfig.Preset;
+/**
+ * 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 declare const NoUniqueLookupPreset: GraphileConfig.Preset;

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

@@ -0,0 +1,143 @@
+/**
+ * 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/esm/presets/constructive-preset.d.ts

@@ -0,0 +1,40 @@
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * Constructive PostGraphile v5 Preset
+ *
+ * This is the main preset that combines all our custom plugins and configurations.
+ * It provides a clean, opinionated GraphQL API built from PostgreSQL.
+ *
+ * FEATURES:
+ * - No Node/Relay features (keeps `id` as `id`, no global object identification)
+ * - Custom inflection using inflekt library
+ * - Conflict detection for multi-schema setups
+ * - Inflector logging for debugging (enable with INFLECTOR_LOG=1)
+ * - Primary key only lookups (no *ByEmail, *ByUsername, etc.)
+ * - Connection filter plugin with all columns filterable
+ * - Many-to-many relationships (opt-in via @behavior +manyToMany)
+ * - Meta schema plugin (_meta query for introspection of tables, fields, indexes)
+ * - PG type mappings (maps custom types like email, url to GraphQL scalars)
+ *
+ * DISABLED PLUGINS:
+ * - PgConnectionArgFilterBackwardRelationsPlugin (relation filters bloat the API)
+ * - PgConnectionArgFilterForwardRelationsPlugin (relation filters bloat the API)
+ *
+ * USAGE:
+ * ```typescript
+ * import { ConstructivePreset } from 'graphile-settings/presets';
+ * import { makePgService } from 'postgraphile/adaptors/pg';
+ *
+ * const preset: GraphileConfig.Preset = {
+ *   extends: [ConstructivePreset],
+ *   pgServices: [
+ *     makePgService({
+ *       connectionString: DATABASE_URL,
+ *       schemas: ['public'],
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+export declare const ConstructivePreset: GraphileConfig.Preset;
+export default ConstructivePreset;

package/esm/presets/constructive-preset.js

@@ -0,0 +1,137 @@
+import { PostGraphileConnectionFilterPreset } from 'postgraphile-plugin-connection-filter';
+import { MinimalPreset } from '../plugins/minimal-preset';
+import { InflektPreset } from '../plugins/custom-inflector';
+import { ConflictDetectorPreset } from '../plugins/conflict-detector';
+import { InflectorLoggerPreset } from '../plugins/inflector-logger';
+import { NoUniqueLookupPreset } from '../plugins/primary-key-only';
+import { EnableAllFilterColumnsPreset } from '../plugins/enable-all-filter-columns';
+import { ManyToManyOptInPreset } from '../plugins/many-to-many-preset';
+import { MetaSchemaPreset } from '../plugins/meta-schema';
+import { PgSearchPreset } from 'graphile-search-plugin';
+import { PgTypeMappingsPreset } from '../plugins/pg-type-mappings';
+/**
+ * Constructive PostGraphile v5 Preset
+ *
+ * This is the main preset that combines all our custom plugins and configurations.
+ * It provides a clean, opinionated GraphQL API built from PostgreSQL.
+ *
+ * FEATURES:
+ * - No Node/Relay features (keeps `id` as `id`, no global object identification)
+ * - Custom inflection using inflekt library
+ * - Conflict detection for multi-schema setups
+ * - Inflector logging for debugging (enable with INFLECTOR_LOG=1)
+ * - Primary key only lookups (no *ByEmail, *ByUsername, etc.)
+ * - Connection filter plugin with all columns filterable
+ * - Many-to-many relationships (opt-in via @behavior +manyToMany)
+ * - Meta schema plugin (_meta query for introspection of tables, fields, indexes)
+ * - PG type mappings (maps custom types like email, url to GraphQL scalars)
+ *
+ * DISABLED PLUGINS:
+ * - PgConnectionArgFilterBackwardRelationsPlugin (relation filters bloat the API)
+ * - PgConnectionArgFilterForwardRelationsPlugin (relation filters bloat the API)
+ *
+ * USAGE:
+ * ```typescript
+ * import { ConstructivePreset } from 'graphile-settings/presets';
+ * import { makePgService } from 'postgraphile/adaptors/pg';
+ *
+ * const preset: GraphileConfig.Preset = {
+ *   extends: [ConstructivePreset],
+ *   pgServices: [
+ *     makePgService({
+ *       connectionString: DATABASE_URL,
+ *       schemas: ['public'],
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+export const ConstructivePreset = {
+    extends: [
+        MinimalPreset,
+        ConflictDetectorPreset,
+        InflektPreset,
+        InflectorLoggerPreset,
+        NoUniqueLookupPreset,
+        PostGraphileConnectionFilterPreset,
+        EnableAllFilterColumnsPreset,
+        ManyToManyOptInPreset,
+        MetaSchemaPreset,
+        PgSearchPreset({ pgSearchPrefix: 'fullText' }),
+        PgTypeMappingsPreset,
+    ],
+    /**
+     * Disable relation filter plugins from postgraphile-plugin-connection-filter.
+     *
+     * WHY THIS EXISTS:
+     * The connection filter plugin includes PgConnectionArgFilterBackwardRelationsPlugin and
+     * PgConnectionArgFilterForwardRelationsPlugin which add relation filter fields like
+     * `apiExtensions`, `apiExtensionsExist`, `database`, `domains`, etc. to every filter type.
+     *
+     * The `connectionFilterRelations: false` schema option does NOT work - it's defined in the
+     * plugin's TypeScript types but the actual code always includes the plugins regardless.
+     * See: https://github.com/graphile-contrib/postgraphile-plugin-connection-filter/blob/master/src/index.ts
+     * The comments `//if (connectionFilterRelations)` are just comments, not actual conditional logic.
+     *
+     * The entityBehavior approach (setting `pgCodecRelation: '-filterBy'`) also doesn't work
+     * because the behavior system doesn't properly negate the plugin's default `filterBy` behavior.
+     *
+     * OUR FIX:
+     * We use `disablePlugins` to directly disable the two relation filter plugins.
+     * This is the most reliable way to prevent relation filter fields from being generated.
+     */
+    disablePlugins: [
+        'PgConnectionArgFilterBackwardRelationsPlugin',
+        'PgConnectionArgFilterForwardRelationsPlugin',
+    ],
+    /**
+     * Connection Filter Plugin Configuration
+     *
+     * These options control what fields appear in the `filter` argument on connections.
+     * We disable relation filters to keep the API surface clean and match our v4 behavior.
+     *
+     * NOTE: By default, PostGraphile v5 only allows filtering on INDEXED columns.
+     * We override this with EnableAllFilterColumnsPreset to allow filtering on ALL columns.
+     * This gives developers flexibility but requires monitoring for slow queries on
+     * non-indexed columns. See the plugin documentation for performance considerations.
+     *
+     * NOTE: Relation filtering is disabled via `disablePlugins` above.
+     *
+     * Documentation: https://github.com/graphile-contrib/postgraphile-plugin-connection-filter
+     */
+    schema: {
+        /**
+         * connectionFilterRelations: false
+         * This option is defined in the plugin's types but does NOT actually work.
+         * The relation filter plugins are disabled via `disablePlugins` above.
+         * We keep this option set to false for documentation purposes.
+         */
+        connectionFilterRelations: false,
+        /**
+         * connectionFilterComputedColumns: false
+         * Disables filtering on computed columns (functions that return a value for a row).
+         * Computed columns can be expensive to filter on since they may not be indexed.
+         * To selectively enable, use `@filterable` smart tag on specific functions.
+         */
+        connectionFilterComputedColumns: false,
+        /**
+         * connectionFilterSetofFunctions: false
+         * Disables filtering on functions that return `setof` (multiple rows).
+         * These can be expensive operations. To selectively enable, use `@filterable` smart tag.
+         */
+        connectionFilterSetofFunctions: false,
+        /**
+         * connectionFilterLogicalOperators: true (default)
+         * Keeps `and`, `or`, `not` operators for combining filter conditions.
+         * Example: filter: { or: [{ name: { eq: "foo" } }, { name: { eq: "bar" } }] }
+         */
+        connectionFilterLogicalOperators: true,
+        /**
+         * connectionFilterArrays: true (default)
+         * Allows filtering on PostgreSQL array columns.
+         * Example: filter: { tags: { contains: ["important"] } }
+         */
+        connectionFilterArrays: true,
+    },
+};
+export default ConstructivePreset;

package/esm/presets/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * PostGraphile v5 Presets
+ *
+ * This module exports pre-configured presets that combine multiple plugins
+ * for common use cases.
+ */
+export { ConstructivePreset } from './constructive-preset';

package/esm/presets/index.js

@@ -0,0 +1,7 @@
+/**
+ * PostGraphile v5 Presets
+ *
+ * This module exports pre-configured presets that combine multiple plugins
+ * for common use cases.
+ */
+export { ConstructivePreset } from './constructive-preset';