graphile-settings 5.15.1 → 5.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphile-settings",
-  "version": "5.15.1",
+  "version": "5.17.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "graphile settings",
   "main": "index.js",
@@ -31,16 +31,16 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.1052.0",
     "@constructive-io/bucket-provisioner": "^0.14.0",
-    "@constructive-io/graphql-env": "^3.16.1",
-    "@constructive-io/graphql-types": "^3.14.1",
-    "@constructive-io/s3-streamer": "^2.29.1",
+    "@constructive-io/graphql-env": "^3.16.3",
+    "@constructive-io/graphql-types": "^3.15.0",
+    "@constructive-io/s3-streamer": "^2.29.2",
     "@constructive-io/s3-utils": "^2.20.0",
     "@constructive-io/upload-names": "^2.19.0",
     "@dataplan/json": "1.0.0",
     "@dataplan/pg": "1.0.3",
     "@graphile-contrib/pg-many-to-many": "2.0.0-rc.2",
     "@pgpmjs/logger": "^2.14.0",
-    "@pgpmjs/types": "^2.35.0",
+    "@pgpmjs/types": "^2.35.1",
     "@pgsql/quotes": "^17.1.0",
     "cors": "^2.8.6",
     "express": "^5.2.1",
@@ -49,17 +49,17 @@
     "graphile-bucket-provisioner-plugin": "0.14.0",
     "graphile-build": "5.0.2",
     "graphile-build-pg": "5.0.2",
-    "graphile-bulk-mutations": "^0.9.1",
+    "graphile-bulk-mutations": "^0.9.3",
     "graphile-config": "1.0.1",
-    "graphile-connection-filter": "^1.16.1",
-    "graphile-i18n": "^1.6.1",
-    "graphile-llm": "^0.19.1",
-    "graphile-ltree": "^1.14.1",
-    "graphile-pg-aggregates": "^1.10.1",
-    "graphile-postgis": "^2.23.1",
+    "graphile-connection-filter": "^1.16.3",
+    "graphile-i18n": "^1.6.3",
+    "graphile-llm": "^0.19.3",
+    "graphile-ltree": "^1.14.3",
+    "graphile-pg-aggregates": "^1.10.3",
+    "graphile-postgis": "^2.23.3",
     "graphile-presigned-url-plugin": "^0.22.1",
     "graphile-realtime-subscriptions": "^0.10.0",
-    "graphile-search": "^1.21.1",
+    "graphile-search": "^1.21.3",
     "graphile-upload-plugin": "^2.14.0",
     "graphile-utils": "5.0.1",
     "graphql": "16.13.0",
@@ -77,7 +77,7 @@
     "@types/express": "^5.0.6",
     "@types/pg": "^8.20.0",
     "@types/request-ip": "^0.0.41",
-    "graphile-test": "^4.21.1",
+    "graphile-test": "^4.21.3",
     "makage": "^0.3.0",
     "nodemon": "^3.1.14",
     "ts-node": "^10.9.2"
@@ -89,5 +89,5 @@
     "constructive",
     "graphql"
   ],
-  "gitHead": "dd2accb683fe20c7278a0d58fd36a04a3b07ac63"
+  "gitHead": "b0843e23070cf4e28a119b06e4ebd1828be1ebde"
 }

package/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/plugins/meta-schema/encoding-meta-builders.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildScalarEncoding = buildScalarEncoding;
+/**
+ * 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;
+}
+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/plugins/meta-schema/graphql-meta-field.js

@@ -9,6 +9,21 @@ function nnList(type) {
     return nn(new graphql_1.GraphQLList(nn(type)));
 }
 function createMetaSchemaType() {
+    const MetaScalarEncodingType = new graphql_1.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(graphql_1.GraphQLString),
+                description: "Machine kind: bigint, datetime, date, time, interval, uuid, geojson, point, inet, ltree, vector, bytea, or composite."
+            },
+            elementType: { type: graphql_1.GraphQLString, description: "For 'vector': element scalar (e.g. 'float')." },
+            dimensions: { type: graphql_1.GraphQLInt, description: "For 'vector': declared length, else null." },
+            geometrySubtype: { type: graphql_1.GraphQLString, description: "For 'geojson': Point/LineString/Polygon/…, else null." },
+            srid: { type: graphql_1.GraphQLInt, description: "For 'geojson': spatial reference id, else null." },
+            dotPath: { type: graphql_1.GraphQLBoolean, description: "For 'ltree': values are dot-separated path strings." }
+        })
+    });
     const MetaTypeType = new graphql_1.GraphQLObjectType({
         name: 'MetaType',
         description: 'Information about a PostgreSQL type',
@@ -19,15 +34,19 @@ function createMetaSchemaType() {
             isNotNull: { type: graphql_1.GraphQLBoolean },
             hasDefault: { type: graphql_1.GraphQLBoolean },
             subtype: { type: graphql_1.GraphQLString },
-        }),
+            encoding: {
+                type: MetaScalarEncodingType,
+                description: 'Scalar serialization contract (null for plain scalars)'
+            }
+        })
     });
     const MetaEnumType = new graphql_1.GraphQLObjectType({
         name: 'MetaEnum',
         description: 'Information about a PostgreSQL enum type',
         fields: () => ({
             name: { type: nn(graphql_1.GraphQLString), description: 'The PostgreSQL enum type name' },
-            values: { type: nnList(graphql_1.GraphQLString), description: 'Allowed values for this enum' },
-        }),
+            values: { type: nnList(graphql_1.GraphQLString), description: 'Allowed values for this enum' }
+        })
     });
     const MetaFieldType = new graphql_1.GraphQLObjectType({
         name: 'MetaField',
@@ -40,8 +59,8 @@ function createMetaSchemaType() {
             isPrimaryKey: { type: nn(graphql_1.GraphQLBoolean) },
             isForeignKey: { type: nn(graphql_1.GraphQLBoolean) },
             description: { type: graphql_1.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 graphql_1.GraphQLObjectType({
         name: 'MetaIndex',
@@ -51,31 +70,31 @@ function createMetaSchemaType() {
             isUnique: { type: nn(graphql_1.GraphQLBoolean) },
             isPrimary: { type: nn(graphql_1.GraphQLBoolean) },
             columns: { type: nnList(graphql_1.GraphQLString) },
-            fields: { type: new graphql_1.GraphQLList(nn(MetaFieldType)) },
-        }),
+            fields: { type: new graphql_1.GraphQLList(nn(MetaFieldType)) }
+        })
     });
     const MetaPrimaryKeyConstraintType = new graphql_1.GraphQLObjectType({
         name: 'MetaPrimaryKeyConstraint',
         description: 'Information about a primary key constraint',
         fields: () => ({
             name: { type: nn(graphql_1.GraphQLString) },
-            fields: { type: nnList(MetaFieldType) },
-        }),
+            fields: { type: nnList(MetaFieldType) }
+        })
     });
     const MetaUniqueConstraintType = new graphql_1.GraphQLObjectType({
         name: 'MetaUniqueConstraint',
         description: 'Information about a unique constraint',
         fields: () => ({
             name: { type: nn(graphql_1.GraphQLString) },
-            fields: { type: nnList(MetaFieldType) },
-        }),
+            fields: { type: nnList(MetaFieldType) }
+        })
     });
     const MetaRefTableType = new graphql_1.GraphQLObjectType({
         name: 'MetaRefTable',
         description: 'Reference to a related table',
         fields: () => ({
-            name: { type: nn(graphql_1.GraphQLString) },
-        }),
+            name: { type: nn(graphql_1.GraphQLString) }
+        })
     });
     const MetaForeignKeyConstraintType = new graphql_1.GraphQLObjectType({
         name: 'MetaForeignKeyConstraint',
@@ -86,8 +105,8 @@ function createMetaSchemaType() {
             referencedTable: { type: nn(graphql_1.GraphQLString) },
             referencedFields: { type: nnList(graphql_1.GraphQLString) },
             refFields: { type: new graphql_1.GraphQLList(nn(MetaFieldType)) },
-            refTable: { type: MetaRefTableType },
-        }),
+            refTable: { type: MetaRefTableType }
+        })
     });
     const MetaConstraintsType = new graphql_1.GraphQLObjectType({
         name: 'MetaConstraints',
@@ -95,8 +114,8 @@ function createMetaSchemaType() {
         fields: () => ({
             primaryKey: { type: MetaPrimaryKeyConstraintType },
             unique: { type: nnList(MetaUniqueConstraintType) },
-            foreignKey: { type: nnList(MetaForeignKeyConstraintType) },
-        }),
+            foreignKey: { type: nnList(MetaForeignKeyConstraintType) }
+        })
     });
     const MetaInflectionType = new graphql_1.GraphQLObjectType({
         name: 'MetaInflection',
@@ -113,8 +132,8 @@ function createMetaSchemaType() {
             createInputType: { type: nn(graphql_1.GraphQLString) },
             createPayloadType: { type: nn(graphql_1.GraphQLString) },
             updatePayloadType: { type: graphql_1.GraphQLString },
-            deletePayloadType: { type: nn(graphql_1.GraphQLString) },
-        }),
+            deletePayloadType: { type: nn(graphql_1.GraphQLString) }
+        })
     });
     const MetaQueryType = new graphql_1.GraphQLObjectType({
         name: 'MetaQuery',
@@ -124,8 +143,8 @@ function createMetaSchemaType() {
             one: { type: graphql_1.GraphQLString },
             create: { type: graphql_1.GraphQLString },
             update: { type: graphql_1.GraphQLString },
-            delete: { type: graphql_1.GraphQLString },
-        }),
+            delete: { type: graphql_1.GraphQLString }
+        })
     });
     const MetaBelongsToRelationType = new graphql_1.GraphQLObjectType({
         name: 'MetaBelongsToRelation',
@@ -135,8 +154,8 @@ function createMetaSchemaType() {
             isUnique: { type: nn(graphql_1.GraphQLBoolean) },
             type: { type: graphql_1.GraphQLString },
             keys: { type: nnList(MetaFieldType) },
-            references: { type: nn(MetaRefTableType) },
-        }),
+            references: { type: nn(MetaRefTableType) }
+        })
     });
     const MetaHasRelationType = new graphql_1.GraphQLObjectType({
         name: 'MetaHasRelation',
@@ -146,8 +165,8 @@ function createMetaSchemaType() {
             isUnique: { type: nn(graphql_1.GraphQLBoolean) },
             type: { type: graphql_1.GraphQLString },
             keys: { type: nnList(MetaFieldType) },
-            referencedBy: { type: nn(MetaRefTableType) },
-        }),
+            referencedBy: { type: nn(MetaRefTableType) }
+        })
     });
     const MetaManyToManyRelationType = new graphql_1.GraphQLObjectType({
         name: 'MetaManyToManyRelation',
@@ -162,8 +181,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 graphql_1.GraphQLObjectType({
         name: 'MetaRelations',
@@ -173,16 +192,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 graphql_1.GraphQLObjectType({
         name: 'MetaStorage',
         description: 'Storage metadata for a table',
         fields: () => ({
             isFilesTable: { type: nn(graphql_1.GraphQLBoolean), description: 'Whether this table is a storage files table' },
-            isBucketsTable: { type: nn(graphql_1.GraphQLBoolean), description: 'Whether this table is a storage buckets table' },
-        }),
+            isBucketsTable: { type: nn(graphql_1.GraphQLBoolean), description: 'Whether this table is a storage buckets table' }
+        })
     });
     const MetaSearchConfigType = new graphql_1.GraphQLObjectType({
         name: 'MetaSearchConfig',
@@ -193,20 +212,20 @@ function createMetaSchemaType() {
                 description: 'JSON-encoded per-adapter score weights',
                 resolve(source) {
                     return source.weights ? JSON.stringify(source.weights) : null;
-                },
+                }
             },
             boostRecent: { type: nn(graphql_1.GraphQLBoolean), description: 'Whether recency boosting is enabled' },
             boostRecencyField: { type: graphql_1.GraphQLString, description: 'Field used for recency decay' },
-            boostRecencyDecay: { type: graphql_1.GraphQLFloat, description: 'Exponential decay factor per day' },
-        }),
+            boostRecencyDecay: { type: graphql_1.GraphQLFloat, description: 'Exponential decay factor per day' }
+        })
     });
     const MetaSearchColumnType = new graphql_1.GraphQLObjectType({
         name: 'MetaSearchColumn',
         description: 'A searchable column with its algorithm',
         fields: () => ({
             name: { type: nn(graphql_1.GraphQLString), description: 'Column name (camelCase)' },
-            algorithm: { type: nn(graphql_1.GraphQLString), description: 'Search algorithm: tsvector, bm25, trgm, or vector' },
-        }),
+            algorithm: { type: nn(graphql_1.GraphQLString), description: 'Search algorithm: tsvector, bm25, trgm, or vector' }
+        })
     });
     const MetaSearchType = new graphql_1.GraphQLObjectType({
         name: 'MetaSearch',
@@ -215,31 +234,42 @@ function createMetaSchemaType() {
             algorithms: { type: nnList(graphql_1.GraphQLString), description: 'Active search algorithms on this table' },
             columns: { type: nnList(MetaSearchColumnType), description: 'Searchable columns with their algorithm' },
             hasUnifiedSearch: { type: nn(graphql_1.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 graphql_1.GraphQLObjectType({
         name: 'MetaI18nField',
         description: 'A translatable field',
         fields: () => ({
             name: { type: nn(graphql_1.GraphQLString), description: 'GraphQL field name' },
-            type: { type: nn(graphql_1.GraphQLString), description: 'PostgreSQL column type (text, citext)' },
-        }),
+            type: { type: nn(graphql_1.GraphQLString), description: 'PostgreSQL column type (text, citext)' }
+        })
     });
     const MetaI18nType = new graphql_1.GraphQLObjectType({
         name: 'MetaI18n',
         description: 'i18n metadata for a table with @i18n tag',
         fields: () => ({
             translationTable: { type: nn(graphql_1.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 graphql_1.GraphQLObjectType({
         name: 'MetaRealtime',
         description: 'Realtime metadata for a table with @realtime tag',
         fields: () => ({
-            subscriptionFieldName: { type: nn(graphql_1.GraphQLString), description: 'The generated subscription field name (e.g. onPostChanged)' },
-        }),
+            subscriptionFieldName: { type: nn(graphql_1.GraphQLString), description: 'The generated subscription field name (e.g. onPostChanged)' }
+        })
+    });
+    const MetaScopeType = new graphql_1.GraphQLObjectType({
+        name: 'MetaScope',
+        description: 'Provisioning scope metadata for a table',
+        fields: () => ({
+            scope: { type: nn(graphql_1.GraphQLString), description: "Provisioning scope: 'platform', 'app', 'database', or an entity scope (e.g. 'org')" },
+            tier: { type: nn(graphql_1.GraphQLString), description: "Coarse bucket: 'global', 'database', or 'entity'" },
+            keyColumn: { type: graphql_1.GraphQLString, description: 'Inflected scope key column (e.g. databaseId, orgId), null for global tiers' },
+            entityTable: { type: graphql_1.GraphQLString, description: 'SQL name of the entity table for entity scopes, else null' },
+            source: { type: nn(graphql_1.GraphQLString), description: "Provenance of the scope metadata (always 'smartTag')" }
+        })
     });
     const MetaTableType = new graphql_1.GraphQLObjectType({
         name: 'MetaTable',
@@ -260,14 +290,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 graphql_1.GraphQLObjectType({
         name: 'MetaSchema',
         description: 'Root meta schema type',
         fields: () => ({
-            tables: { type: nnList(MetaTableType) },
-        }),
+            tables: { type: nnList(MetaTableType) }
+        })
     });
 }
 function extendQueryWithMetaField(fields, tablesMeta) {
@@ -277,10 +308,10 @@ 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/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/plugins/meta-schema/scope-meta-builders.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildScopeMeta = buildScopeMeta;
+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.
+ */
+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/plugins/meta-schema/table-meta-builder.js

@@ -4,10 +4,11 @@ exports.collectTablesMeta = collectTablesMeta;
 const constraint_meta_builders_1 = require("./constraint-meta-builders");
 const name_meta_builders_1 = require("./name-meta-builders");
 const relation_meta_builders_1 = require("./relation-meta-builders");
+const scope_meta_builders_1 = require("./scope-meta-builders");
 const storage_search_meta_builders_1 = require("./storage-search-meta-builders");
-const type_mappings_1 = require("./type-mappings");
 const table_meta_context_1 = require("./table-meta-context");
 const table_resource_utils_1 = require("./table-resource-utils");
+const type_mappings_1 = require("./type-mappings");
 function buildTableMeta(resource, schemaName, context) {
     const codec = resource.codec;
     const attributes = codec.attributes;
@@ -30,7 +31,7 @@ function buildTableMeta(resource, schemaName, context) {
     }
     const fields = Object.entries(attributes).map(([attrName, attr]) => (0, type_mappings_1.buildFieldMeta)(context.inflectAttr(attrName, codec), attr, context.build, {
         isPrimaryKey: pkAttrNames.has(attrName),
-        isForeignKey: fkAttrNames.has(attrName),
+        isForeignKey: fkAttrNames.has(attrName)
     }));
     const indexes = (0, constraint_meta_builders_1.buildIndexes)(codec, attributes, uniques, context);
     const primaryKey = (0, constraint_meta_builders_1.buildPrimaryKey)(codec, attributes, uniques, context);
@@ -39,7 +40,7 @@ function buildTableMeta(resource, schemaName, context) {
     const constraints = {
         primaryKey,
         unique: uniqueConstraints,
-        foreignKey: foreignKeyConstraints,
+        foreignKey: foreignKeyConstraints
     };
     const belongsTo = (0, relation_meta_builders_1.buildBelongsToRelations)(codec, attributes, uniques, relations, context);
     const { hasOne, hasMany } = (0, relation_meta_builders_1.buildReverseRelations)(codec, attributes, relations, context);
@@ -49,13 +50,14 @@ function buildTableMeta(resource, schemaName, context) {
         has: [...hasOne, ...hasMany],
         hasOne,
         hasMany,
-        manyToMany,
+        manyToMany
     };
     const tableType = (0, name_meta_builders_1.resolveTableType)(context.build, codec);
     const storage = (0, storage_search_meta_builders_1.buildStorageMeta)(codec);
     const search = (0, storage_search_meta_builders_1.buildSearchMeta)(codec, context.build, context.inflectAttr);
     const i18n = (0, storage_search_meta_builders_1.buildI18nMeta)(codec, context.build, context.inflectAttr);
     const realtime = (0, storage_search_meta_builders_1.buildRealtimeMeta)(codec, context.build);
+    const scope = (0, scope_meta_builders_1.buildScopeMeta)(codec, context.inflectAttr);
     return {
         name: tableType,
         schemaName,
@@ -72,6 +74,7 @@ function buildTableMeta(resource, schemaName, context) {
         search,
         i18n,
         realtime,
+        scope
     };
 }
 function collectTablesMeta(build) {

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pgTypeToGqlType = pgTypeToGqlType;
 exports.buildFieldMeta = buildFieldMeta;
+const encoding_meta_builders_1 = require("./encoding-meta-builders");
 const PG_TO_GQL_TYPE = {
     text: 'String',
     varchar: 'String',
@@ -91,6 +92,7 @@ function buildFieldMeta(name, attr, build, options) {
             isNotNull,
             hasDefault,
             subtype,
+            encoding: (0, encoding_meta_builders_1.buildScalarEncoding)(attr),
         },
         isNotNull,
         hasDefault,

package/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;