graphile-settings 6.5.2 → 6.5.4

package/esm/plugins/index.d.ts

@@ -12,7 +12,7 @@ export { ManyToManyOptInPlugin, ManyToManyOptInPreset, } from './many-to-many-pr
 export { createUniqueLookupPlugin, PrimaryKeyOnlyPlugin, NoUniqueLookupPlugin, PrimaryKeyOnlyPreset, NoUniqueLookupPreset, } from './primary-key-only';
 export type { UniqueLookupOptions } from './primary-key-only';
 export { MetaSchemaPlugin, MetaSchemaPreset, } from './meta-schema';
-export type { TableMeta, FieldMeta, TypeMeta, IndexMeta, ConstraintsMeta, PrimaryKeyConstraintMeta, UniqueConstraintMeta, ForeignKeyConstraintMeta, RelationsMeta, BelongsToRelation, HasRelation, ManyToManyRelation, InflectionMeta, QueryMeta, } from './meta-schema/types';
+export type { TableMeta, FieldMeta, TypeMeta, IndexMeta, ConstraintsMeta, PrimaryKeyConstraintMeta, UniqueConstraintMeta, ForeignKeyConstraintMeta, RelationsMeta, BelongsToRelation, HasRelation, ManyToManyRelation, InflectionMeta, QueryMeta, } from 'graphile-meta';
 export { PgTypeMappingsPlugin, PgTypeMappingsPreset, } from './pg-type-mappings';
 export type { TypeMapping } from './pg-type-mappings';
 export { PublicKeySignature } from './PublicKeySignature';

package/esm/plugins/meta-schema.d.ts

@@ -1,22 +1,7 @@
 /**
  * PostGraphile v5 Meta Schema Plugin
  *
- * Exposes a `_meta` GraphQL query that provides metadata about tables, fields,
- * constraints, indexes, and relations for code generation tooling.
+ * Re-exported from the `graphile-meta` package for backward compatibility.
  */
-import type { GraphileConfig } from 'graphile-config';
-import { cachedTablesMeta } from './meta-schema/cache';
-import { buildScalarEncoding } from './meta-schema/encoding-meta-builders';
-import { MetaSchemaPlugin } from './meta-schema/plugin';
-import { buildFieldMeta, pgTypeToGqlType } from './meta-schema/type-mappings';
-export { MetaSchemaPlugin };
-export declare const MetaSchemaPreset: GraphileConfig.Preset;
-/** @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 };
-/** @internal Exported for testing only */
-export { buildScalarEncoding as _buildScalarEncoding };
-export default MetaSchemaPlugin;
+export { _buildFieldMeta, _buildScalarEncoding, _cachedTablesMeta, _pgTypeToGqlType, MetaSchemaPlugin, MetaSchemaPreset, } from 'graphile-meta';
+export { MetaSchemaPlugin as default } from 'graphile-meta';

package/esm/plugins/meta-schema.js

@@ -1,23 +1,7 @@
 /**
  * PostGraphile v5 Meta Schema Plugin
  *
- * Exposes a `_meta` GraphQL query that provides metadata about tables, fields,
- * constraints, indexes, and relations for code generation tooling.
+ * Re-exported from the `graphile-meta` package for backward compatibility.
  */
-import { cachedTablesMeta } from './meta-schema/cache';
-import { buildScalarEncoding } from './meta-schema/encoding-meta-builders';
-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 };
-/** @internal Exported for testing only */
-export { buildScalarEncoding as _buildScalarEncoding };
-export default MetaSchemaPlugin;
+export { _buildFieldMeta, _buildScalarEncoding, _cachedTablesMeta, _pgTypeToGqlType, MetaSchemaPlugin, MetaSchemaPreset, } from 'graphile-meta';
+export { MetaSchemaPlugin as default } from 'graphile-meta';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphile-settings",
-  "version": "6.5.2",
+  "version": "6.5.4",
   "author": "Constructive <developers@constructive.io>",
   "description": "graphile settings",
   "main": "index.js",
@@ -53,8 +53,9 @@
     "graphile-config": "1.0.1",
     "graphile-connection-filter": "^2.5.2",
     "graphile-i18n": "^2.5.2",
-    "graphile-llm": "^1.5.2",
+    "graphile-llm": "^1.5.3",
     "graphile-ltree": "^2.5.2",
+    "graphile-meta": "^1.1.1",
     "graphile-pg-aggregates": "^2.5.2",
     "graphile-postgis": "^3.5.2",
     "graphile-presigned-url-plugin": "^1.4.0",
@@ -89,5 +90,5 @@
     "constructive",
     "graphql"
   ],
-  "gitHead": "dd16395013ff8c9d5e4cd2f5f5bec72c46f4099b"
+  "gitHead": "31f7cd3d3cc28cf069056eae5b2a0d4198d154a1"
 }

package/plugins/index.d.ts

@@ -12,7 +12,7 @@ export { ManyToManyOptInPlugin, ManyToManyOptInPreset, } from './many-to-many-pr
 export { createUniqueLookupPlugin, PrimaryKeyOnlyPlugin, NoUniqueLookupPlugin, PrimaryKeyOnlyPreset, NoUniqueLookupPreset, } from './primary-key-only';
 export type { UniqueLookupOptions } from './primary-key-only';
 export { MetaSchemaPlugin, MetaSchemaPreset, } from './meta-schema';
-export type { TableMeta, FieldMeta, TypeMeta, IndexMeta, ConstraintsMeta, PrimaryKeyConstraintMeta, UniqueConstraintMeta, ForeignKeyConstraintMeta, RelationsMeta, BelongsToRelation, HasRelation, ManyToManyRelation, InflectionMeta, QueryMeta, } from './meta-schema/types';
+export type { TableMeta, FieldMeta, TypeMeta, IndexMeta, ConstraintsMeta, PrimaryKeyConstraintMeta, UniqueConstraintMeta, ForeignKeyConstraintMeta, RelationsMeta, BelongsToRelation, HasRelation, ManyToManyRelation, InflectionMeta, QueryMeta, } from 'graphile-meta';
 export { PgTypeMappingsPlugin, PgTypeMappingsPreset, } from './pg-type-mappings';
 export type { TypeMapping } from './pg-type-mappings';
 export { PublicKeySignature } from './PublicKeySignature';

package/plugins/meta-schema.d.ts

@@ -1,22 +1,7 @@
 /**
  * PostGraphile v5 Meta Schema Plugin
  *
- * Exposes a `_meta` GraphQL query that provides metadata about tables, fields,
- * constraints, indexes, and relations for code generation tooling.
+ * Re-exported from the `graphile-meta` package for backward compatibility.
  */
-import type { GraphileConfig } from 'graphile-config';
-import { cachedTablesMeta } from './meta-schema/cache';
-import { buildScalarEncoding } from './meta-schema/encoding-meta-builders';
-import { MetaSchemaPlugin } from './meta-schema/plugin';
-import { buildFieldMeta, pgTypeToGqlType } from './meta-schema/type-mappings';
-export { MetaSchemaPlugin };
-export declare const MetaSchemaPreset: GraphileConfig.Preset;
-/** @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 };
-/** @internal Exported for testing only */
-export { buildScalarEncoding as _buildScalarEncoding };
-export default MetaSchemaPlugin;
+export { _buildFieldMeta, _buildScalarEncoding, _cachedTablesMeta, _pgTypeToGqlType, MetaSchemaPlugin, MetaSchemaPreset, } from 'graphile-meta';
+export { MetaSchemaPlugin as default } from 'graphile-meta';

package/plugins/meta-schema.js

@@ -2,21 +2,16 @@
 /**
  * PostGraphile v5 Meta Schema Plugin
  *
- * Exposes a `_meta` GraphQL query that provides metadata about tables, fields,
- * constraints, indexes, and relations for code generation tooling.
+ * Re-exported from the `graphile-meta` package for backward compatibility.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._buildScalarEncoding = exports._cachedTablesMeta = exports._buildFieldMeta = exports._pgTypeToGqlType = exports.MetaSchemaPreset = exports.MetaSchemaPlugin = void 0;
-const cache_1 = require("./meta-schema/cache");
-Object.defineProperty(exports, "_cachedTablesMeta", { enumerable: true, get: function () { return cache_1.cachedTablesMeta; } });
-const encoding_meta_builders_1 = require("./meta-schema/encoding-meta-builders");
-Object.defineProperty(exports, "_buildScalarEncoding", { enumerable: true, get: function () { return encoding_meta_builders_1.buildScalarEncoding; } });
-const plugin_1 = require("./meta-schema/plugin");
-Object.defineProperty(exports, "MetaSchemaPlugin", { enumerable: true, get: function () { return plugin_1.MetaSchemaPlugin; } });
-const type_mappings_1 = require("./meta-schema/type-mappings");
-Object.defineProperty(exports, "_buildFieldMeta", { enumerable: true, get: function () { return type_mappings_1.buildFieldMeta; } });
-Object.defineProperty(exports, "_pgTypeToGqlType", { enumerable: true, get: function () { return type_mappings_1.pgTypeToGqlType; } });
-exports.MetaSchemaPreset = {
-    plugins: [plugin_1.MetaSchemaPlugin],
-};
-exports.default = plugin_1.MetaSchemaPlugin;
+exports.default = exports.MetaSchemaPreset = exports.MetaSchemaPlugin = exports._pgTypeToGqlType = exports._cachedTablesMeta = exports._buildScalarEncoding = exports._buildFieldMeta = void 0;
+var graphile_meta_1 = require("graphile-meta");
+Object.defineProperty(exports, "_buildFieldMeta", { enumerable: true, get: function () { return graphile_meta_1._buildFieldMeta; } });
+Object.defineProperty(exports, "_buildScalarEncoding", { enumerable: true, get: function () { return graphile_meta_1._buildScalarEncoding; } });
+Object.defineProperty(exports, "_cachedTablesMeta", { enumerable: true, get: function () { return graphile_meta_1._cachedTablesMeta; } });
+Object.defineProperty(exports, "_pgTypeToGqlType", { enumerable: true, get: function () { return graphile_meta_1._pgTypeToGqlType; } });
+Object.defineProperty(exports, "MetaSchemaPlugin", { enumerable: true, get: function () { return graphile_meta_1.MetaSchemaPlugin; } });
+Object.defineProperty(exports, "MetaSchemaPreset", { enumerable: true, get: function () { return graphile_meta_1.MetaSchemaPreset; } });
+var graphile_meta_2 = require("graphile-meta");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return graphile_meta_2.MetaSchemaPlugin; } });

package/esm/plugins/meta-schema/cache.d.ts

@@ -1,4 +0,0 @@
-import type { TableMeta } from './types';
-export declare let cachedTablesMeta: TableMeta[];
-export declare function getCachedTablesMeta(): TableMeta[];
-export declare function setCachedTablesMeta(tablesMeta: TableMeta[]): void;

package/esm/plugins/meta-schema/cache.js

@@ -1,7 +0,0 @@
-export let cachedTablesMeta = [];
-export function getCachedTablesMeta() {
-    return cachedTablesMeta;
-}
-export function setCachedTablesMeta(tablesMeta) {
-    cachedTablesMeta = tablesMeta;
-}

package/esm/plugins/meta-schema/constraint-meta-builders.d.ts

@@ -1,13 +0,0 @@
-import { type BuildContext } from './table-meta-context';
-import type { ForeignKeyConstraintMeta, PgAttribute, PgCodec, PgRelation, PgUnique, PrimaryKeyConstraintMeta, UniqueConstraintMeta } from './types';
-export declare function buildForeignKeyConstraint(constraintName: string, localCodec: PgCodec, localAttributes: Record<string, PgAttribute>, localAttributeNames: string[], remoteCodec: PgCodec | undefined, remoteAttributes: Record<string, PgAttribute>, remoteAttributeNames: string[], context: BuildContext): ForeignKeyConstraintMeta;
-export declare function buildIndexes(codec: PgCodec, attributes: Record<string, PgAttribute>, uniques: PgUnique[], context: BuildContext): {
-    name: string;
-    isUnique: boolean;
-    isPrimary: boolean;
-    columns: string[];
-    fields: import("./types").FieldMeta[];
-}[];
-export declare function buildPrimaryKey(codec: PgCodec, attributes: Record<string, PgAttribute>, uniques: PgUnique[], context: BuildContext): PrimaryKeyConstraintMeta | null;
-export declare function buildUniqueConstraints(codec: PgCodec, attributes: Record<string, PgAttribute>, uniques: PgUnique[], context: BuildContext): UniqueConstraintMeta[];
-export declare function buildForeignKeyConstraints(codec: PgCodec, attributes: Record<string, PgAttribute>, relations: Record<string, PgRelation>, context: BuildContext): ForeignKeyConstraintMeta[];

package/esm/plugins/meta-schema/constraint-meta-builders.js

@@ -1,51 +0,0 @@
-import { buildFieldMeta } from './type-mappings';
-import { buildFieldList } from './table-meta-context';
-export function buildForeignKeyConstraint(constraintName, localCodec, localAttributes, localAttributeNames, remoteCodec, remoteAttributes, remoteAttributeNames, context) {
-    const referencedTable = remoteCodec?.name || 'unknown';
-    const referencedFields = remoteAttributeNames.map((attrName) => remoteCodec ? context.inflectAttr(attrName, remoteCodec) : attrName);
-    return {
-        name: constraintName,
-        fields: buildFieldList(localAttributeNames, localCodec, localAttributes, context),
-        referencedTable,
-        referencedFields,
-        refFields: remoteAttributeNames.map((attrName) => buildFieldMeta(remoteCodec ? context.inflectAttr(attrName, remoteCodec) : attrName, remoteAttributes[attrName], context.build)),
-        refTable: { name: referencedTable },
-    };
-}
-export function buildIndexes(codec, attributes, uniques, context) {
-    return uniques.map((unique) => ({
-        name: unique.tags?.name || `${codec.name}_${unique.attributes.join('_')}_idx`,
-        isUnique: true,
-        isPrimary: !!unique.isPrimary,
-        columns: unique.attributes.map((attrName) => context.inflectAttr(attrName, codec)),
-        fields: buildFieldList(unique.attributes, codec, attributes, context),
-    }));
-}
-export function buildPrimaryKey(codec, attributes, uniques, context) {
-    const primaryUnique = uniques.find((unique) => unique.isPrimary);
-    if (!primaryUnique)
-        return null;
-    return {
-        name: primaryUnique.tags?.name || `${codec.name}_pkey`,
-        fields: buildFieldList(primaryUnique.attributes, codec, attributes, context),
-    };
-}
-export function buildUniqueConstraints(codec, attributes, uniques, context) {
-    return uniques
-        .filter((unique) => !unique.isPrimary)
-        .map((unique) => ({
-        name: unique.tags?.name || `${codec.name}_${unique.attributes.join('_')}_key`,
-        fields: buildFieldList(unique.attributes, codec, attributes, context),
-    }));
-}
-export function buildForeignKeyConstraints(codec, attributes, relations, context) {
-    const constraints = [];
-    for (const [relationName, relation] of Object.entries(relations)) {
-        if (relation.isReferencee)
-            continue;
-        const remoteCodec = relation.remoteResource?.codec;
-        const remoteAttributes = remoteCodec?.attributes || {};
-        constraints.push(buildForeignKeyConstraint(relationName, codec, attributes, relation.localAttributes || [], remoteCodec, remoteAttributes, relation.remoteAttributes || [], context));
-    }
-    return constraints;
-}

package/esm/plugins/meta-schema/encoding-meta-builders.d.ts

@@ -1,2 +0,0 @@
-import type { PgAttribute, ScalarEncodingMeta } from './types';
-export declare function buildScalarEncoding(attr: PgAttribute | null | undefined): ScalarEncodingMeta | null;

package/esm/plugins/meta-schema/encoding-meta-builders.js

@@ -1,84 +0,0 @@
-/**
- * Scalar encoding contracts — the one piece of field metadata standard GraphQL
- * introspection can't provide.
- *
- * Introspection tells a client a field's scalar *name* (`GeoJSON`, `LTree`,
- * `Interval`, `BigInt`, `vector`, …) but not how to serialize/parse it or its
- * structural parameters (geometry subtype/SRID, vector dimensions, ltree
- * dot-path semantics). Without that, generated clients treat these as opaque
- * strings / `any` and mis-encode inputs or fail to parse outputs.
- *
- * `kind` is derived deterministically from the *underlying* codec (array and
- * domain wrappers unwrapped first, first match wins) so exactly one kind is
- * ever assigned and nothing can clobber it. Structural extras (subtype, SRID,
- * dimensions) are read verbatim from attribute extensions — never guessed, and
- * `null` when absent.
- */
-/** pg type name → encoding kind. Plain scalars are intentionally absent → null. */
-const KIND_BY_PG_TYPE = {
-    int8: 'bigint',
-    bigint: 'bigint',
-    numeric: 'bigint',
-    timestamptz: 'datetime',
-    timestamp: 'datetime',
-    date: 'date',
-    time: 'time',
-    timetz: 'time',
-    interval: 'interval',
-    uuid: 'uuid',
-    geometry: 'geojson',
-    geography: 'geojson',
-    point: 'point',
-    inet: 'inet',
-    cidr: 'inet',
-    ltree: 'ltree',
-    vector: 'vector',
-    bytea: 'bytea'
-};
-/** Unwrap array-of and domain-of wrappers to the underlying scalar/record codec. */
-function underlyingCodec(codec) {
-    let current = codec ?? null;
-    const seen = new Set();
-    while (current && !seen.has(current) && (current.arrayOfCodec || current.domainOfCodec)) {
-        seen.add(current);
-        current = current.arrayOfCodec || current.domainOfCodec || null;
-    }
-    return current;
-}
-/** True when a codec is a composite/record type (has named attributes). */
-function isCompositeCodec(codec) {
-    return !!codec?.attributes && Object.keys(codec.attributes).length > 0;
-}
-export function buildScalarEncoding(attr) {
-    const codec = underlyingCodec(attr?.codec);
-    if (!codec)
-        return null;
-    const ext = attr?.extensions ?? undefined;
-    const kind = KIND_BY_PG_TYPE[codec.name];
-    if (!kind) {
-        // Composite/record types are the only non-mapped scalars worth describing;
-        // everything else (text, int, bool, json, enum, …) is fully covered by gqlType.
-        if (isCompositeCodec(codec)) {
-            return { kind: 'composite', fields: null };
-        }
-        return null;
-    }
-    switch (kind) {
-        case 'geojson':
-            return {
-                kind,
-                geometrySubtype: typeof ext?.geometrySubtype === 'string' ? ext.geometrySubtype : null,
-                srid: typeof ext?.geometrySrid === 'number' ? ext.geometrySrid : null
-            };
-        case 'vector':
-            return {
-                kind,
-                elementType: 'float',
-                dimensions: typeof ext?.vectorDimensions === 'number' ? ext.vectorDimensions : null
-            };
-        case 'ltree':
-            return { kind, dotPath: true };
-        default:
-            return { kind };
-    }
-}

package/esm/plugins/meta-schema/graphql-meta-field.d.ts

@@ -1,4 +0,0 @@
-import type { TableMeta } from './types';
-type FieldMap = Record<string, unknown>;
-export declare function extendQueryWithMetaField(fields: FieldMap, tablesMeta: TableMeta[]): FieldMap;
-export {};

package/esm/plugins/meta-schema/graphql-meta-field.js

@@ -1,314 +0,0 @@
-import { GraphQLBoolean, GraphQLFloat, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLString } from 'graphql';
-function nn(type) {
-    return new GraphQLNonNull(type);
-}
-function nnList(type) {
-    return nn(new GraphQLList(nn(type)));
-}
-function createMetaSchemaType() {
-    const MetaScalarEncodingType = new GraphQLObjectType({
-        name: 'MetaScalarEncoding',
-        description: 'How a client must serialize/parse a scalar — the one field-type detail standard GraphQL introspection cannot describe. Null for plain scalars whose wire format is obvious from gqlType.',
-        fields: () => ({
-            kind: {
-                type: nn(GraphQLString),
-                description: "Machine kind: bigint, datetime, date, time, interval, uuid, geojson, point, inet, ltree, vector, bytea, or composite."
-            },
-            elementType: { type: GraphQLString, description: "For 'vector': element scalar (e.g. 'float')." },
-            dimensions: { type: GraphQLInt, description: "For 'vector': declared length, else null." },
-            geometrySubtype: { type: GraphQLString, description: "For 'geojson': Point/LineString/Polygon/…, else null." },
-            srid: { type: GraphQLInt, description: "For 'geojson': spatial reference id, else null." },
-            dotPath: { type: GraphQLBoolean, description: "For 'ltree': values are dot-separated path strings." }
-        })
-    });
-    const MetaTypeType = new GraphQLObjectType({
-        name: 'MetaType',
-        description: 'Information about a PostgreSQL type',
-        fields: () => ({
-            pgType: { type: nn(GraphQLString) },
-            gqlType: { type: nn(GraphQLString) },
-            isArray: { type: nn(GraphQLBoolean) },
-            isNotNull: { type: GraphQLBoolean },
-            hasDefault: { type: GraphQLBoolean },
-            subtype: { type: GraphQLString },
-            encoding: {
-                type: MetaScalarEncodingType,
-                description: 'Scalar serialization contract (null for plain scalars)'
-            }
-        })
-    });
-    const MetaEnumType = new GraphQLObjectType({
-        name: 'MetaEnum',
-        description: 'Information about a PostgreSQL enum type',
-        fields: () => ({
-            name: { type: nn(GraphQLString), description: 'The PostgreSQL enum type name' },
-            values: { type: nnList(GraphQLString), description: 'Allowed values for this enum' }
-        })
-    });
-    const MetaFieldType = new GraphQLObjectType({
-        name: 'MetaField',
-        description: 'Information about a table field/column',
-        fields: () => ({
-            name: { type: nn(GraphQLString) },
-            type: { type: nn(MetaTypeType) },
-            isNotNull: { type: nn(GraphQLBoolean) },
-            hasDefault: { type: nn(GraphQLBoolean) },
-            isPrimaryKey: { type: nn(GraphQLBoolean) },
-            isForeignKey: { type: nn(GraphQLBoolean) },
-            description: { type: GraphQLString },
-            enumValues: { type: MetaEnumType, description: 'Enum metadata if this field has an enum type' }
-        })
-    });
-    const MetaIndexType = new GraphQLObjectType({
-        name: 'MetaIndex',
-        description: 'Information about a database index',
-        fields: () => ({
-            name: { type: nn(GraphQLString) },
-            isUnique: { type: nn(GraphQLBoolean) },
-            isPrimary: { type: nn(GraphQLBoolean) },
-            columns: { type: nnList(GraphQLString) },
-            fields: { type: new GraphQLList(nn(MetaFieldType)) }
-        })
-    });
-    const MetaPrimaryKeyConstraintType = new GraphQLObjectType({
-        name: 'MetaPrimaryKeyConstraint',
-        description: 'Information about a primary key constraint',
-        fields: () => ({
-            name: { type: nn(GraphQLString) },
-            fields: { type: nnList(MetaFieldType) }
-        })
-    });
-    const MetaUniqueConstraintType = new GraphQLObjectType({
-        name: 'MetaUniqueConstraint',
-        description: 'Information about a unique constraint',
-        fields: () => ({
-            name: { type: nn(GraphQLString) },
-            fields: { type: nnList(MetaFieldType) }
-        })
-    });
-    const MetaRefTableType = new GraphQLObjectType({
-        name: 'MetaRefTable',
-        description: 'Reference to a related table',
-        fields: () => ({
-            name: { type: nn(GraphQLString) }
-        })
-    });
-    const MetaForeignKeyConstraintType = new GraphQLObjectType({
-        name: 'MetaForeignKeyConstraint',
-        description: 'Information about a foreign key constraint',
-        fields: () => ({
-            name: { type: nn(GraphQLString) },
-            fields: { type: nnList(MetaFieldType) },
-            referencedTable: { type: nn(GraphQLString) },
-            referencedFields: { type: nnList(GraphQLString) },
-            refFields: { type: new GraphQLList(nn(MetaFieldType)) },
-            refTable: { type: MetaRefTableType }
-        })
-    });
-    const MetaConstraintsType = new GraphQLObjectType({
-        name: 'MetaConstraints',
-        description: 'Table constraints',
-        fields: () => ({
-            primaryKey: { type: MetaPrimaryKeyConstraintType },
-            unique: { type: nnList(MetaUniqueConstraintType) },
-            foreignKey: { type: nnList(MetaForeignKeyConstraintType) }
-        })
-    });
-    const MetaInflectionType = new GraphQLObjectType({
-        name: 'MetaInflection',
-        description: 'Table inflection names',
-        fields: () => ({
-            tableType: { type: nn(GraphQLString) },
-            allRows: { type: nn(GraphQLString) },
-            connection: { type: nn(GraphQLString) },
-            edge: { type: nn(GraphQLString) },
-            filterType: { type: GraphQLString },
-            orderByType: { type: nn(GraphQLString) },
-            conditionType: { type: nn(GraphQLString) },
-            patchType: { type: GraphQLString },
-            createInputType: { type: nn(GraphQLString) },
-            createPayloadType: { type: nn(GraphQLString) },
-            updatePayloadType: { type: GraphQLString },
-            deletePayloadType: { type: nn(GraphQLString) }
-        })
-    });
-    const MetaQueryType = new GraphQLObjectType({
-        name: 'MetaQuery',
-        description: 'Table query/mutation names',
-        fields: () => ({
-            all: { type: nn(GraphQLString) },
-            one: { type: GraphQLString },
-            create: { type: GraphQLString },
-            update: { type: GraphQLString },
-            delete: { type: GraphQLString }
-        })
-    });
-    const MetaBelongsToRelationType = new GraphQLObjectType({
-        name: 'MetaBelongsToRelation',
-        description: 'A belongs-to (forward FK) relation',
-        fields: () => ({
-            fieldName: { type: GraphQLString },
-            isUnique: { type: nn(GraphQLBoolean) },
-            type: { type: GraphQLString },
-            keys: { type: nnList(MetaFieldType) },
-            references: { type: nn(MetaRefTableType) }
-        })
-    });
-    const MetaHasRelationType = new GraphQLObjectType({
-        name: 'MetaHasRelation',
-        description: 'A has-one or has-many (reverse FK) relation',
-        fields: () => ({
-            fieldName: { type: GraphQLString },
-            isUnique: { type: nn(GraphQLBoolean) },
-            type: { type: GraphQLString },
-            keys: { type: nnList(MetaFieldType) },
-            referencedBy: { type: nn(MetaRefTableType) }
-        })
-    });
-    const MetaManyToManyRelationType = new GraphQLObjectType({
-        name: 'MetaManyToManyRelation',
-        description: 'A many-to-many relation via junction table',
-        fields: () => ({
-            fieldName: { type: GraphQLString },
-            type: { type: GraphQLString },
-            junctionTable: { type: nn(MetaRefTableType) },
-            junctionLeftConstraint: { type: nn(MetaForeignKeyConstraintType) },
-            junctionLeftKeyAttributes: { type: nnList(MetaFieldType) },
-            junctionRightConstraint: { type: nn(MetaForeignKeyConstraintType) },
-            junctionRightKeyAttributes: { type: nnList(MetaFieldType) },
-            leftKeyAttributes: { type: nnList(MetaFieldType) },
-            rightKeyAttributes: { type: nnList(MetaFieldType) },
-            rightTable: { type: nn(MetaRefTableType) }
-        })
-    });
-    const MetaRelationsType = new GraphQLObjectType({
-        name: 'MetaRelations',
-        description: 'Table relations',
-        fields: () => ({
-            belongsTo: { type: nnList(MetaBelongsToRelationType) },
-            has: { type: nnList(MetaHasRelationType) },
-            hasOne: { type: nnList(MetaHasRelationType) },
-            hasMany: { type: nnList(MetaHasRelationType) },
-            manyToMany: { type: nnList(MetaManyToManyRelationType) }
-        })
-    });
-    const MetaStorageType = new GraphQLObjectType({
-        name: 'MetaStorage',
-        description: 'Storage metadata for a table',
-        fields: () => ({
-            isFilesTable: { type: nn(GraphQLBoolean), description: 'Whether this table is a storage files table' },
-            isBucketsTable: { type: nn(GraphQLBoolean), description: 'Whether this table is a storage buckets table' }
-        })
-    });
-    const MetaSearchConfigType = new GraphQLObjectType({
-        name: 'MetaSearchConfig',
-        description: 'Per-table search configuration from @searchConfig smart tag',
-        fields: () => ({
-            weights: {
-                type: GraphQLString,
-                description: 'JSON-encoded per-adapter score weights',
-                resolve(source) {
-                    return source.weights ? JSON.stringify(source.weights) : null;
-                }
-            },
-            boostRecent: { type: nn(GraphQLBoolean), description: 'Whether recency boosting is enabled' },
-            boostRecencyField: { type: GraphQLString, description: 'Field used for recency decay' },
-            boostRecencyDecay: { type: GraphQLFloat, description: 'Exponential decay factor per day' }
-        })
-    });
-    const MetaSearchColumnType = new GraphQLObjectType({
-        name: 'MetaSearchColumn',
-        description: 'A searchable column with its algorithm',
-        fields: () => ({
-            name: { type: nn(GraphQLString), description: 'Column name (camelCase)' },
-            algorithm: { type: nn(GraphQLString), description: 'Search algorithm: tsvector, bm25, trgm, or vector' }
-        })
-    });
-    const MetaSearchType = new GraphQLObjectType({
-        name: 'MetaSearch',
-        description: 'Search metadata for a table',
-        fields: () => ({
-            algorithms: { type: nnList(GraphQLString), description: 'Active search algorithms on this table' },
-            columns: { type: nnList(MetaSearchColumnType), description: 'Searchable columns with their algorithm' },
-            hasUnifiedSearch: { type: nn(GraphQLBoolean), description: 'Whether unifiedSearch composite filter is available' },
-            config: { type: MetaSearchConfigType, description: 'Per-table search configuration' }
-        })
-    });
-    const MetaI18nFieldType = new GraphQLObjectType({
-        name: 'MetaI18nField',
-        description: 'A translatable field',
-        fields: () => ({
-            name: { type: nn(GraphQLString), description: 'GraphQL field name' },
-            type: { type: nn(GraphQLString), description: 'PostgreSQL column type (text, citext)' }
-        })
-    });
-    const MetaI18nType = new GraphQLObjectType({
-        name: 'MetaI18n',
-        description: 'i18n metadata for a table with @i18n tag',
-        fields: () => ({
-            translationTable: { type: nn(GraphQLString), description: 'Name of the translation table' },
-            translatableFields: { type: nnList(MetaI18nFieldType), description: 'Fields that are translatable' }
-        })
-    });
-    const MetaRealtimeType = new GraphQLObjectType({
-        name: 'MetaRealtime',
-        description: 'Realtime metadata for a table with @realtime tag',
-        fields: () => ({
-            subscriptionFieldName: { type: nn(GraphQLString), description: 'The generated subscription field name (e.g. onPostChanged)' }
-        })
-    });
-    const MetaScopeType = new GraphQLObjectType({
-        name: 'MetaScope',
-        description: 'Provisioning scope metadata for a table',
-        fields: () => ({
-            scope: { type: nn(GraphQLString), description: "Provisioning scope: 'platform', 'app', 'database', or an entity scope (e.g. 'org')" },
-            tier: { type: nn(GraphQLString), description: "Coarse bucket: 'global', 'database', or 'entity'" },
-            keyColumn: { type: GraphQLString, description: 'Inflected scope key column (e.g. databaseId, orgId), null for global tiers' },
-            entityTable: { type: GraphQLString, description: 'SQL name of the entity table for entity scopes, else null' },
-            source: { type: nn(GraphQLString), description: "Provenance of the scope metadata (always 'smartTag')" }
-        })
-    });
-    const MetaTableType = new GraphQLObjectType({
-        name: 'MetaTable',
-        description: 'Information about a database table',
-        fields: () => ({
-            name: { type: nn(GraphQLString) },
-            schemaName: { type: nn(GraphQLString) },
-            fields: { type: nnList(MetaFieldType) },
-            indexes: { type: nnList(MetaIndexType) },
-            constraints: { type: nn(MetaConstraintsType) },
-            foreignKeyConstraints: { type: nnList(MetaForeignKeyConstraintType) },
-            primaryKeyConstraints: { type: nnList(MetaPrimaryKeyConstraintType) },
-            uniqueConstraints: { type: nnList(MetaUniqueConstraintType) },
-            relations: { type: nn(MetaRelationsType) },
-            inflection: { type: nn(MetaInflectionType) },
-            query: { type: nn(MetaQueryType) },
-            storage: { type: MetaStorageType, description: 'Storage metadata (null if not a storage table)' },
-            search: { type: MetaSearchType, description: 'Search metadata (null if no search configured)' },
-            i18n: { type: MetaI18nType, description: 'i18n metadata (null if no @i18n tag)' },
-            realtime: { type: MetaRealtimeType, description: 'Realtime metadata (null if no @realtime tag)' },
-            scope: { type: MetaScopeType, description: 'Provisioning scope metadata (null if no @scope tag)' }
-        })
-    });
-    return new GraphQLObjectType({
-        name: 'MetaSchema',
-        description: 'Root meta schema type',
-        fields: () => ({
-            tables: { type: nnList(MetaTableType) }
-        })
-    });
-}
-export function extendQueryWithMetaField(fields, tablesMeta) {
-    const metaSchemaType = createMetaSchemaType();
-    const metaField = {
-        type: metaSchemaType,
-        description: 'Metadata about the database schema, including tables, fields, indexes, and constraints. Useful for code generation tools.',
-        resolve() {
-            return { tables: tablesMeta };
-        }
-    };
-    return {
-        ...fields,
-        _meta: metaField
-    };
-}