graphile-settings 5.15.1 → 5.17.0

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

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

@@ -0,0 +1,84 @@
+/**
+ * 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.js

@@ -1,4 +1,4 @@
-import { GraphQLBoolean, GraphQLFloat, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLString, } from 'graphql';
+import { GraphQLBoolean, GraphQLFloat, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLString } from 'graphql';
 function nn(type) {
     return new GraphQLNonNull(type);
 }
@@ -6,6 +6,21 @@ 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',
@@ -16,15 +31,19 @@ function createMetaSchemaType() {
             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' },
-        }),
+            values: { type: nnList(GraphQLString), description: 'Allowed values for this enum' }
+        })
     });
     const MetaFieldType = new GraphQLObjectType({
         name: 'MetaField',
@@ -37,8 +56,8 @@ function createMetaSchemaType() {
             isPrimaryKey: { type: nn(GraphQLBoolean) },
             isForeignKey: { type: nn(GraphQLBoolean) },
             description: { type: GraphQLString },
-            enumValues: { type: MetaEnumType, description: 'Enum metadata if this field has an enum type' },
-        }),
+            enumValues: { type: MetaEnumType, description: 'Enum metadata if this field has an enum type' }
+        })
     });
     const MetaIndexType = new GraphQLObjectType({
         name: 'MetaIndex',
@@ -48,31 +67,31 @@ function createMetaSchemaType() {
             isUnique: { type: nn(GraphQLBoolean) },
             isPrimary: { type: nn(GraphQLBoolean) },
             columns: { type: nnList(GraphQLString) },
-            fields: { type: new GraphQLList(nn(MetaFieldType)) },
-        }),
+            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) },
-        }),
+            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) },
-        }),
+            fields: { type: nnList(MetaFieldType) }
+        })
     });
     const MetaRefTableType = new GraphQLObjectType({
         name: 'MetaRefTable',
         description: 'Reference to a related table',
         fields: () => ({
-            name: { type: nn(GraphQLString) },
-        }),
+            name: { type: nn(GraphQLString) }
+        })
     });
     const MetaForeignKeyConstraintType = new GraphQLObjectType({
         name: 'MetaForeignKeyConstraint',
@@ -83,8 +102,8 @@ function createMetaSchemaType() {
             referencedTable: { type: nn(GraphQLString) },
             referencedFields: { type: nnList(GraphQLString) },
             refFields: { type: new GraphQLList(nn(MetaFieldType)) },
-            refTable: { type: MetaRefTableType },
-        }),
+            refTable: { type: MetaRefTableType }
+        })
     });
     const MetaConstraintsType = new GraphQLObjectType({
         name: 'MetaConstraints',
@@ -92,8 +111,8 @@ function createMetaSchemaType() {
         fields: () => ({
             primaryKey: { type: MetaPrimaryKeyConstraintType },
             unique: { type: nnList(MetaUniqueConstraintType) },
-            foreignKey: { type: nnList(MetaForeignKeyConstraintType) },
-        }),
+            foreignKey: { type: nnList(MetaForeignKeyConstraintType) }
+        })
     });
     const MetaInflectionType = new GraphQLObjectType({
         name: 'MetaInflection',
@@ -110,8 +129,8 @@ function createMetaSchemaType() {
             createInputType: { type: nn(GraphQLString) },
             createPayloadType: { type: nn(GraphQLString) },
             updatePayloadType: { type: GraphQLString },
-            deletePayloadType: { type: nn(GraphQLString) },
-        }),
+            deletePayloadType: { type: nn(GraphQLString) }
+        })
     });
     const MetaQueryType = new GraphQLObjectType({
         name: 'MetaQuery',
@@ -121,8 +140,8 @@ function createMetaSchemaType() {
             one: { type: GraphQLString },
             create: { type: GraphQLString },
             update: { type: GraphQLString },
-            delete: { type: GraphQLString },
-        }),
+            delete: { type: GraphQLString }
+        })
     });
     const MetaBelongsToRelationType = new GraphQLObjectType({
         name: 'MetaBelongsToRelation',
@@ -132,8 +151,8 @@ function createMetaSchemaType() {
             isUnique: { type: nn(GraphQLBoolean) },
             type: { type: GraphQLString },
             keys: { type: nnList(MetaFieldType) },
-            references: { type: nn(MetaRefTableType) },
-        }),
+            references: { type: nn(MetaRefTableType) }
+        })
     });
     const MetaHasRelationType = new GraphQLObjectType({
         name: 'MetaHasRelation',
@@ -143,8 +162,8 @@ function createMetaSchemaType() {
             isUnique: { type: nn(GraphQLBoolean) },
             type: { type: GraphQLString },
             keys: { type: nnList(MetaFieldType) },
-            referencedBy: { type: nn(MetaRefTableType) },
-        }),
+            referencedBy: { type: nn(MetaRefTableType) }
+        })
     });
     const MetaManyToManyRelationType = new GraphQLObjectType({
         name: 'MetaManyToManyRelation',
@@ -159,8 +178,8 @@ function createMetaSchemaType() {
             junctionRightKeyAttributes: { type: nnList(MetaFieldType) },
             leftKeyAttributes: { type: nnList(MetaFieldType) },
             rightKeyAttributes: { type: nnList(MetaFieldType) },
-            rightTable: { type: nn(MetaRefTableType) },
-        }),
+            rightTable: { type: nn(MetaRefTableType) }
+        })
     });
     const MetaRelationsType = new GraphQLObjectType({
         name: 'MetaRelations',
@@ -170,16 +189,16 @@ function createMetaSchemaType() {
             has: { type: nnList(MetaHasRelationType) },
             hasOne: { type: nnList(MetaHasRelationType) },
             hasMany: { type: nnList(MetaHasRelationType) },
-            manyToMany: { type: nnList(MetaManyToManyRelationType) },
-        }),
+            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' },
-        }),
+            isBucketsTable: { type: nn(GraphQLBoolean), description: 'Whether this table is a storage buckets table' }
+        })
     });
     const MetaSearchConfigType = new GraphQLObjectType({
         name: 'MetaSearchConfig',
@@ -190,20 +209,20 @@ function createMetaSchemaType() {
                 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' },
-        }),
+            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' },
-        }),
+            algorithm: { type: nn(GraphQLString), description: 'Search algorithm: tsvector, bm25, trgm, or vector' }
+        })
     });
     const MetaSearchType = new GraphQLObjectType({
         name: 'MetaSearch',
@@ -212,31 +231,42 @@ function createMetaSchemaType() {
             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' },
-        }),
+            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)' },
-        }),
+            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' },
-        }),
+            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)' },
-        }),
+            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',
@@ -257,14 +287,15 @@ function createMetaSchemaType() {
             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) },
-        }),
+            tables: { type: nnList(MetaTableType) }
+        })
     });
 }
 export function extendQueryWithMetaField(fields, tablesMeta) {
@@ -274,10 +305,10 @@ export function extendQueryWithMetaField(fields, tablesMeta) {
         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,
+        _meta: metaField
     };
 }

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

@@ -0,0 +1,15 @@
+import type { PgCodec, ScopeMeta } from './types';
+/**
+ * Detect provisioning scope metadata for a table.
+ *
+ * The `@scope` smart tag emitted by the constructive-db generators is the sole
+ * source of truth. `apply_scope_fields` knows the exact scope, tier, key column,
+ * and entity table, and emits them via
+ * `metaschema.append_table_smart_tags(id, { scope, scopeTier, scopeKey, scopeEntityTable })`.
+ * PostGraphile surfaces these as `codec.extensions.tags.*`.
+ *
+ * There is NO inference from column names — a table without the tag returns
+ * `null` (the same convention as every other nullable metadata block). This
+ * avoids guessing key columns, whose names are chosen freely by each generator.
+ */
+export declare function buildScopeMeta(codec: PgCodec, inflectAttr: (attrName: string, codec: PgCodec) => string): ScopeMeta | null;

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

@@ -0,0 +1,40 @@
+const VALID_TIERS = new Set(['global', 'database', 'entity']);
+function readString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+/**
+ * Detect provisioning scope metadata for a table.
+ *
+ * The `@scope` smart tag emitted by the constructive-db generators is the sole
+ * source of truth. `apply_scope_fields` knows the exact scope, tier, key column,
+ * and entity table, and emits them via
+ * `metaschema.append_table_smart_tags(id, { scope, scopeTier, scopeKey, scopeEntityTable })`.
+ * PostGraphile surfaces these as `codec.extensions.tags.*`.
+ *
+ * There is NO inference from column names — a table without the tag returns
+ * `null` (the same convention as every other nullable metadata block). This
+ * avoids guessing key columns, whose names are chosen freely by each generator.
+ */
+export function buildScopeMeta(codec, inflectAttr) {
+    const tags = codec.extensions?.tags;
+    const scope = readString(tags?.scope);
+    if (!scope)
+        return null;
+    const rawTier = readString(tags.scopeTier);
+    const tier = rawTier && VALID_TIERS.has(rawTier)
+        ? rawTier
+        : null;
+    if (!tier) {
+        throw new Error(`@scope tag on codec "${codec.name}" is missing a valid scopeTier ` +
+            `(expected one of global|database|entity, got ${JSON.stringify(rawTier)})`);
+    }
+    const keyColumn = readString(tags.scopeKey);
+    const entityTable = readString(tags.scopeEntityTable);
+    return {
+        scope,
+        tier,
+        keyColumn: keyColumn ? inflectAttr(keyColumn, codec) : null,
+        entityTable,
+        source: 'smartTag'
+    };
+}

package/esm/plugins/meta-schema/table-meta-builder.js

@@ -1,10 +1,11 @@
-import { buildForeignKeyConstraints, buildIndexes, buildPrimaryKey, buildUniqueConstraints, } from './constraint-meta-builders';
+import { buildForeignKeyConstraints, buildIndexes, buildPrimaryKey, buildUniqueConstraints } from './constraint-meta-builders';
 import { buildInflectionMeta, buildQueryMeta, resolveTableType } from './name-meta-builders';
-import { buildBelongsToRelations, buildManyToManyRelations, buildReverseRelations, } from './relation-meta-builders';
-import { buildStorageMeta, buildSearchMeta, buildI18nMeta, buildRealtimeMeta } from './storage-search-meta-builders';
+import { buildBelongsToRelations, buildManyToManyRelations, buildReverseRelations } from './relation-meta-builders';
+import { buildScopeMeta } from './scope-meta-builders';
+import { buildI18nMeta, buildRealtimeMeta, buildSearchMeta, buildStorageMeta } from './storage-search-meta-builders';
+import { createBuildContext } from './table-meta-context';
+import { getConfiguredSchemas, getRelations, getSchemaName, getUniques, isTableResource } from './table-resource-utils';
 import { buildFieldMeta } from './type-mappings';
-import { createBuildContext, } from './table-meta-context';
-import { getConfiguredSchemas, getRelations, getSchemaName, getUniques, isTableResource, } from './table-resource-utils';
 function buildTableMeta(resource, schemaName, context) {
     const codec = resource.codec;
     const attributes = codec.attributes;
@@ -27,7 +28,7 @@ function buildTableMeta(resource, schemaName, context) {
     }
     const fields = Object.entries(attributes).map(([attrName, attr]) => buildFieldMeta(context.inflectAttr(attrName, codec), attr, context.build, {
         isPrimaryKey: pkAttrNames.has(attrName),
-        isForeignKey: fkAttrNames.has(attrName),
+        isForeignKey: fkAttrNames.has(attrName)
     }));
     const indexes = buildIndexes(codec, attributes, uniques, context);
     const primaryKey = buildPrimaryKey(codec, attributes, uniques, context);
@@ -36,7 +37,7 @@ function buildTableMeta(resource, schemaName, context) {
     const constraints = {
         primaryKey,
         unique: uniqueConstraints,
-        foreignKey: foreignKeyConstraints,
+        foreignKey: foreignKeyConstraints
     };
     const belongsTo = buildBelongsToRelations(codec, attributes, uniques, relations, context);
     const { hasOne, hasMany } = buildReverseRelations(codec, attributes, relations, context);
@@ -46,13 +47,14 @@ function buildTableMeta(resource, schemaName, context) {
         has: [...hasOne, ...hasMany],
         hasOne,
         hasMany,
-        manyToMany,
+        manyToMany
     };
     const tableType = resolveTableType(context.build, codec);
     const storage = buildStorageMeta(codec);
     const search = buildSearchMeta(codec, context.build, context.inflectAttr);
     const i18n = buildI18nMeta(codec, context.build, context.inflectAttr);
     const realtime = buildRealtimeMeta(codec, context.build);
+    const scope = buildScopeMeta(codec, context.inflectAttr);
     return {
         name: tableType,
         schemaName,
@@ -69,6 +71,7 @@ function buildTableMeta(resource, schemaName, context) {
         search,
         i18n,
         realtime,
+        scope
     };
 }
 export function collectTablesMeta(build) {

package/esm/plugins/meta-schema/type-mappings.js

@@ -1,3 +1,4 @@
+import { buildScalarEncoding } from './encoding-meta-builders';
 const PG_TO_GQL_TYPE = {
     text: 'String',
     varchar: 'String',
@@ -87,6 +88,7 @@ export function buildFieldMeta(name, attr, build, options) {
             isNotNull,
             hasDefault,
             subtype,
+            encoding: buildScalarEncoding(attr),
         },
         isNotNull,
         hasDefault,

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

@@ -14,6 +14,21 @@ export interface TableMeta {
     search: SearchMeta | null;
     i18n: I18nMeta | null;
     realtime: RealtimeMeta | null;
+    scope: ScopeMeta | null;
+}
+/** Coarse provisioning tier a table's scope belongs to. */
+export type ScopeTier = 'global' | 'database' | 'entity';
+export interface ScopeMeta {
+    /** The provisioning scope, e.g. 'platform', 'app', 'database', 'org', 'user' */
+    scope: string;
+    /** Coarse bucket: global (platform/app), database, or entity */
+    tier: ScopeTier;
+    /** Inflected scope key column (e.g. 'databaseId', 'orgId'), or null for global tiers */
+    keyColumn: string | null;
+    /** SQL name of the entity table for entity scopes, else null */
+    entityTable: string | null;
+    /** Provenance of the scope metadata. Always the @scope smart tag. */
+    source: 'smartTag';
 }
 export interface StorageMeta {
     /** Whether this table is tagged as a storage files table */
@@ -86,6 +101,33 @@ export interface TypeMeta {
     isNotNull?: boolean;
     hasDefault?: boolean;
     subtype?: string | null;
+    /**
+     * How the client must serialize/parse this scalar. `null` for plain scalars
+     * (String/Int/Float/Boolean/JSON/enum) whose wire format is obvious from
+     * `gqlType` — populated only for scalars introspection can't fully describe.
+     */
+    encoding?: ScalarEncodingMeta | null;
+}
+/** The machine kind a scalar marshals as on the client. */
+export type ScalarEncodingKind = 'bigint' | 'datetime' | 'date' | 'time' | 'interval' | 'uuid' | 'geojson' | 'point' | 'inet' | 'ltree' | 'vector' | 'bytea' | 'composite';
+export interface ScalarEncodingMeta {
+    /** Deterministic kind derived from the underlying (unwrapped) codec. */
+    kind: ScalarEncodingKind;
+    /** For 'vector': element scalar (e.g. 'float'), else null. */
+    elementType?: string | null;
+    /** For 'vector': declared length from typmod, else null. */
+    dimensions?: number | null;
+    /** For 'geojson': geometry subtype (Point/LineString/Polygon/…), else null. */
+    geometrySubtype?: string | null;
+    /** For 'geojson': spatial reference id, else null. */
+    srid?: number | null;
+    /** For 'ltree': values are dot-separated path strings ('a.b.c'). */
+    dotPath?: boolean;
+    /** For 'composite': nested attribute encodings. */
+    fields?: {
+        name: string;
+        type: TypeMeta;
+    }[] | null;
 }
 export interface IndexMeta {
     name: string;
@@ -183,6 +225,7 @@ export interface PgCodec {
     name: string;
     attributes?: Record<string, PgAttribute>;
     arrayOfCodec?: PgCodec | null;
+    domainOfCodec?: PgCodec | null;
     isAnonymous?: boolean;
     extensions?: {
         pg?: {
@@ -192,6 +235,8 @@ export interface PgCodec {
 }
 export interface PgAttributeExtensions extends Record<string, unknown> {
     geometrySubtype?: string | null;
+    geometrySrid?: number | null;
+    vectorDimensions?: number | null;
 }
 export interface PgAttribute {
     codec?: PgCodec | null;

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

@@ -6,6 +6,7 @@
  */
 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 };
@@ -16,4 +17,6 @@ export { pgTypeToGqlType as _pgTypeToGqlType };
 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;

package/esm/plugins/meta-schema.js

@@ -5,6 +5,7 @@
  * constraints, indexes, and relations for code generation tooling.
  */
 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 };
@@ -17,4 +18,6 @@ export { pgTypeToGqlType as _pgTypeToGqlType };
 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;