graphile-settings 5.7.1 → 5.8.1

package/esm/index.d.ts

@@ -34,6 +34,5 @@ export type { ConstructivePresetOptions } from './presets/constructive-preset';
 export * from './plugins/index';
 export * from './presets/index';
 export { makePgService };
-export { streamToStorage } from './upload-resolver';
 export { getPresignedUrlS3Config } from './presigned-url-resolver';
 export { getBucketProvisionerConnection } from './bucket-provisioner-resolver';

package/esm/index.js

@@ -48,8 +48,6 @@ export * from './presets/index';
 // ============================================================================
 // Re-export makePgService for convenience
 export { makePgService };
-// Upload utilities
-export { streamToStorage } from './upload-resolver';
 // Presigned URL utilities
 export { getPresignedUrlS3Config } from './presigned-url-resolver';
 // Bucket provisioner utilities

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

@@ -1,4 +1,4 @@
-import { GraphQLBoolean, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLString, } from 'graphql';
+import { GraphQLBoolean, GraphQLFloat, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLString, } from 'graphql';
 function nn(type) {
     return new GraphQLNonNull(type);
 }
@@ -18,6 +18,14 @@ function createMetaSchemaType() {
             subtype: { type: GraphQLString },
         }),
     });
+    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',
@@ -29,6 +37,7 @@ 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' },
         }),
     });
     const MetaIndexType = new GraphQLObjectType({
@@ -164,6 +173,71 @@ function createMetaSchemaType() {
             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 MetaTableType = new GraphQLObjectType({
         name: 'MetaTable',
         description: 'Information about a database table',
@@ -179,6 +253,10 @@ function createMetaSchemaType() {
             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)' },
         }),
     });
     return new GraphQLObjectType({

package/esm/plugins/meta-schema/storage-search-meta-builders.d.ts

@@ -0,0 +1,29 @@
+import type { I18nMeta, PgCodec, RealtimeMeta, SearchMeta, StorageMeta } from './types';
+/**
+ * Detect storage metadata from a codec's smart tags.
+ * Storage tables are identified by @storageFiles and @storageBuckets smart tags.
+ */
+export declare function buildStorageMeta(codec: PgCodec): StorageMeta | null;
+/**
+ * Detect search metadata from a codec's columns and smart tags.
+ *
+ * Looks for:
+ * - tsvector columns (full-text search)
+ * - vector columns (pgvector semantic search)
+ * - @searchConfig smart tag (per-table search configuration)
+ * - @bm25Index smart tag on columns (BM25 search)
+ * - @trgmSearch smart tag (trigram search)
+ */
+export declare function buildSearchMeta(codec: PgCodec, _build: unknown, inflectAttr: (attrName: string, codec: PgCodec) => string): SearchMeta | null;
+/**
+ * Detect i18n metadata from a codec's @i18n smart tag.
+ * The @i18n tag value is the name of the translation table.
+ * Translatable fields are discovered by matching text/citext columns
+ * between the base table and the translation table codec.
+ */
+export declare function buildI18nMeta(codec: PgCodec, build: unknown, inflectAttr: (attrName: string, codec: PgCodec) => string): I18nMeta | null;
+/**
+ * Detect realtime metadata from a codec's @realtime smart tag.
+ * Tables tagged with @realtime get subscription fields generated.
+ */
+export declare function buildRealtimeMeta(codec: PgCodec, build: unknown): RealtimeMeta | null;

package/esm/plugins/meta-schema/storage-search-meta-builders.js

@@ -0,0 +1,180 @@
+/**
+ * Detect storage metadata from a codec's smart tags.
+ * Storage tables are identified by @storageFiles and @storageBuckets smart tags.
+ */
+export function buildStorageMeta(codec) {
+    const tags = codec.extensions?.tags;
+    if (!tags)
+        return null;
+    const isFilesTable = !!tags.storageFiles;
+    const isBucketsTable = !!tags.storageBuckets;
+    if (!isFilesTable && !isBucketsTable)
+        return null;
+    return {
+        isFilesTable,
+        isBucketsTable,
+    };
+}
+/**
+ * Detect search metadata from a codec's columns and smart tags.
+ *
+ * Looks for:
+ * - tsvector columns (full-text search)
+ * - vector columns (pgvector semantic search)
+ * - @searchConfig smart tag (per-table search configuration)
+ * - @bm25Index smart tag on columns (BM25 search)
+ * - @trgmSearch smart tag (trigram search)
+ */
+export function buildSearchMeta(codec, _build, inflectAttr) {
+    const attributes = codec.attributes;
+    if (!attributes)
+        return null;
+    const tags = codec.extensions?.tags || {};
+    const columns = [];
+    const algorithmSet = new Set();
+    // Detect columns by type
+    for (const [attrName, attr] of Object.entries(attributes)) {
+        const pgType = attr?.codec?.name;
+        if (!pgType)
+            continue;
+        const inflectedName = inflectAttr(attrName, codec);
+        if (pgType === 'tsvector') {
+            columns.push({ name: inflectedName, algorithm: 'tsvector' });
+            algorithmSet.add('tsvector');
+        }
+        else if (pgType === 'vector') {
+            columns.push({ name: inflectedName, algorithm: 'vector' });
+            algorithmSet.add('vector');
+        }
+        // Check per-column @bm25Index tag
+        const attrTags = attr?.extensions?.tags;
+        if (attrTags?.bm25Index) {
+            columns.push({ name: inflectedName, algorithm: 'bm25' });
+            algorithmSet.add('bm25');
+        }
+    }
+    // Check for table-level @trgmSearch tag
+    if (tags.trgmSearch) {
+        algorithmSet.add('trgm');
+        // trgm operates on text columns — detect which ones
+        for (const [attrName, attr] of Object.entries(attributes)) {
+            const pgType = attr?.codec?.name;
+            if (pgType === 'text' || pgType === 'varchar' || pgType === 'citext') {
+                const attrTags = attr?.extensions?.tags;
+                if (attrTags?.trgmSearch) {
+                    columns.push({ name: inflectAttr(attrName, codec), algorithm: 'trgm' });
+                }
+            }
+        }
+    }
+    // Parse @searchConfig smart tag
+    const config = parseSearchConfig(tags);
+    // If nothing search-related was found, return null
+    if (columns.length === 0 && !config)
+        return null;
+    // Determine if unified search is available
+    // unifiedSearch requires at least one text-compatible adapter (tsvector or bm25)
+    const hasUnifiedSearch = algorithmSet.has('tsvector') || algorithmSet.has('bm25');
+    return {
+        algorithms: Array.from(algorithmSet).sort(),
+        columns,
+        hasUnifiedSearch,
+        config,
+    };
+}
+/**
+ * Detect i18n metadata from a codec's @i18n smart tag.
+ * The @i18n tag value is the name of the translation table.
+ * Translatable fields are discovered by matching text/citext columns
+ * between the base table and the translation table codec.
+ */
+export function buildI18nMeta(codec, build, inflectAttr) {
+    const tags = codec.extensions?.tags;
+    if (!tags)
+        return null;
+    const i18nTag = tags.i18n;
+    if (typeof i18nTag !== 'string' || i18nTag.length === 0)
+        return null;
+    const attributes = codec.attributes;
+    if (!attributes)
+        return { translationTable: i18nTag, translatableFields: [] };
+    // Discover translatable fields: text/citext columns on the base table
+    const allowedTypes = ['text', 'citext'];
+    const translatableFields = [];
+    // Try to find the translation codec to get the intersection of fields
+    const pgRegistry = build?.input?.pgRegistry;
+    let translationAttrs = null;
+    if (pgRegistry?.pgResources) {
+        for (const r of Object.values(pgRegistry.pgResources)) {
+            const sqlName = r?.codec?.extensions?.pg?.name ?? r?.codec?.name;
+            if (sqlName === i18nTag) {
+                const tAttrs = r?.codec?.attributes;
+                if (tAttrs) {
+                    translationAttrs = new Set(Object.keys(tAttrs));
+                }
+                break;
+            }
+        }
+    }
+    for (const [attrName, attr] of Object.entries(attributes)) {
+        const pgType = attr?.codec?.name;
+        if (!pgType || !allowedTypes.includes(pgType))
+            continue;
+        // If we found the translation table, only include columns that exist there too
+        if (translationAttrs && !translationAttrs.has(attrName))
+            continue;
+        translatableFields.push({
+            name: inflectAttr(attrName, codec),
+            type: pgType,
+        });
+    }
+    return {
+        translationTable: i18nTag,
+        translatableFields,
+    };
+}
+/**
+ * Detect realtime metadata from a codec's @realtime smart tag.
+ * Tables tagged with @realtime get subscription fields generated.
+ */
+export function buildRealtimeMeta(codec, build) {
+    const tags = codec.extensions?.tags;
+    if (!tags?.realtime)
+        return null;
+    const typeName = build.inflection?.tableType?.(codec);
+    if (!typeName)
+        return null;
+    return {
+        subscriptionFieldName: `on${typeName}Changed`,
+    };
+}
+function parseSearchConfig(tags) {
+    const raw = tags.searchConfig;
+    if (!raw)
+        return null;
+    let parsed;
+    if (typeof raw === 'string') {
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    else if (typeof raw === 'object') {
+        parsed = raw;
+    }
+    else {
+        return null;
+    }
+    return {
+        weights: parsed.weights && typeof parsed.weights === 'object'
+            ? parsed.weights
+            : null,
+        boostRecent: !!parsed.boost_recent,
+        boostRecencyField: parsed.boost_recency_field || null,
+        boostRecencyDecay: typeof parsed.boost_recency_decay === 'number'
+            ? parsed.boost_recency_decay
+            : null,
+    };
+}

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

@@ -1,6 +1,7 @@
 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 { buildFieldMeta } from './type-mappings';
 import { createBuildContext, } from './table-meta-context';
 import { getConfiguredSchemas, getRelations, getSchemaName, getUniques, isTableResource, } from './table-resource-utils';
@@ -48,6 +49,10 @@ function buildTableMeta(resource, schemaName, context) {
         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);
     return {
         name: tableType,
         schemaName,
@@ -60,6 +65,10 @@ function buildTableMeta(resource, schemaName, context) {
         relations: relationsMeta,
         inflection: buildInflectionMeta(resource, tableType, context.build),
         query: buildQueryMeta(resource, uniques, tableType, context.build),
+        storage,
+        search,
+        i18n,
+        realtime,
     };
 }
 export function collectTablesMeta(build) {

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

@@ -60,6 +60,19 @@ function resolveGqlTypeName(build, codec) {
     const nestedTypeName = codec.arrayOfCodec?.name;
     return nestedTypeName ? pgTypeToGqlType(nestedTypeName) : pgTypeName;
 }
+function extractEnumMeta(codec) {
+    if (!codec)
+        return null;
+    // Check the codec itself, or unwrap domain/array wrappers
+    const inner = codec.domainOfCodec ?? codec.arrayOfCodec ?? codec;
+    const values = inner.values;
+    if (!Array.isArray(values) || values.length === 0)
+        return null;
+    return {
+        name: inner.name || codec.name || 'unknown',
+        values: values.map((v) => (typeof v === 'string' ? v : v.value)),
+    };
+}
 export function buildFieldMeta(name, attr, build, options) {
     const pgType = attr?.codec?.name || 'unknown';
     const isNotNull = attr?.notNull || false;
@@ -80,5 +93,6 @@ export function buildFieldMeta(name, attr, build, options) {
         isPrimaryKey: options?.isPrimaryKey ?? false,
         isForeignKey: options?.isForeignKey ?? false,
         description: attr?.description ?? null,
+        enumValues: extractEnumMeta(attr?.codec),
     };
 }

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

@@ -10,6 +10,64 @@ export interface TableMeta {
     relations: RelationsMeta;
     inflection: InflectionMeta;
     query: QueryMeta;
+    storage: StorageMeta | null;
+    search: SearchMeta | null;
+    i18n: I18nMeta | null;
+    realtime: RealtimeMeta | null;
+}
+export interface StorageMeta {
+    /** Whether this table is tagged as a storage files table */
+    isFilesTable: boolean;
+    /** Whether this table is tagged as a storage buckets table */
+    isBucketsTable: boolean;
+}
+export interface SearchColumnMeta {
+    /** Column name (camelCase inflected) */
+    name: string;
+    /** Search algorithm: 'tsvector', 'bm25', 'trgm', 'vector' */
+    algorithm: string;
+}
+export interface SearchMeta {
+    /** Which search algorithms are active on this table */
+    algorithms: string[];
+    /** Searchable columns with their algorithm */
+    columns: SearchColumnMeta[];
+    /** Whether unifiedSearch composite filter is available */
+    hasUnifiedSearch: boolean;
+    /** Per-table search config from @searchConfig smart tag */
+    config: SearchConfigMeta | null;
+}
+export interface SearchConfigMeta {
+    /** Per-adapter score weights */
+    weights: Record<string, number> | null;
+    /** Whether recency boosting is enabled */
+    boostRecent: boolean;
+    /** Field used for recency decay */
+    boostRecencyField: string | null;
+    /** Exponential decay factor per day */
+    boostRecencyDecay: number | null;
+}
+export interface I18nFieldMeta {
+    /** Inflected GraphQL field name */
+    name: string;
+    /** PostgreSQL column type (text, citext) */
+    type: string;
+}
+export interface I18nMeta {
+    /** Name of the translation table */
+    translationTable: string;
+    /** Fields that are translatable */
+    translatableFields: I18nFieldMeta[];
+}
+export interface RealtimeMeta {
+    /** The generated subscription field name (e.g. onPostChanged) */
+    subscriptionFieldName: string;
+}
+export interface EnumMeta {
+    /** The PostgreSQL enum type name */
+    name: string;
+    /** Allowed values for this enum */
+    values: string[];
 }
 export interface FieldMeta {
     name: string;
@@ -19,6 +77,7 @@ export interface FieldMeta {
     isPrimaryKey: boolean;
     isForeignKey: boolean;
     description: string | null;
+    enumValues: EnumMeta | null;
 }
 export interface TypeMeta {
     pgType: string;
@@ -213,3 +272,9 @@ export interface MetaBuild extends GqlTypeResolverBuild {
     };
     pgManyToManyRealtionshipsByResource?: Map<unknown, unknown>;
 }
+export interface PgCodecExtensions {
+    pg?: {
+        schemaName?: string;
+    };
+    tags?: Record<string, unknown>;
+}

package/esm/upload-resolver.d.ts

@@ -15,18 +15,7 @@
  *   AWS_SECRET_KEY   - secret key (default: 'minioadmin')
  *   CDN_ENDPOINT     - S3-compatible endpoint (default: 'http://localhost:9000')
  */
-import type { Readable } from 'stream';
 import type { UploadFieldDefinition } from 'graphile-upload-plugin';
-/**
- * Streams a file to S3/MinIO storage and returns the URL and metadata.
- *
- * Reusable by both the GraphQL upload resolver and REST /upload endpoint.
- */
-export declare function streamToStorage(readStream: Readable, filename: string): Promise<{
-    url: string;
-    filename: string;
-    mime: string;
-}>;
 /**
  * Upload field definitions for Constructive's three upload domain types.
  *

package/esm/upload-resolver.js

@@ -59,26 +59,6 @@ function generateKey(filename) {
     const rand = randomBytes(12).toString('hex');
     return `${rand}-${uploadNames(filename)}`;
 }
-/**
- * Streams a file to S3/MinIO storage and returns the URL and metadata.
- *
- * Reusable by both the GraphQL upload resolver and REST /upload endpoint.
- */
-export async function streamToStorage(readStream, filename) {
-    const s3 = getStreamer();
-    const key = generateKey(filename);
-    const result = await s3.upload({
-        readStream,
-        filename,
-        key,
-        bucket: bucketName,
-    });
-    return {
-        url: result.upload.Location,
-        filename,
-        mime: result.contentType,
-    };
-}
 /**
  * Upload resolver that streams files to S3/MinIO.
  *

package/index.d.ts

@@ -34,6 +34,5 @@ export type { ConstructivePresetOptions } from './presets/constructive-preset';
 export * from './plugins/index';
 export * from './presets/index';
 export { makePgService };
-export { streamToStorage } from './upload-resolver';
 export { getPresignedUrlS3Config } from './presigned-url-resolver';
 export { getBucketProvisionerConnection } from './bucket-provisioner-resolver';

package/index.js

@@ -42,7 +42,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBucketProvisionerConnection = exports.getPresignedUrlS3Config = exports.streamToStorage = exports.makePgService = exports.createConstructivePreset = exports.ConstructivePreset = void 0;
+exports.getBucketProvisionerConnection = exports.getPresignedUrlS3Config = exports.makePgService = exports.createConstructivePreset = exports.ConstructivePreset = void 0;
 const pg_1 = require("postgraphile/adaptors/pg");
 Object.defineProperty(exports, "makePgService", { enumerable: true, get: function () { return pg_1.makePgService; } });
 // Import modules for type augmentation
@@ -63,9 +63,6 @@ Object.defineProperty(exports, "createConstructivePreset", { enumerable: true, g
 __exportStar(require("./plugins/index"), exports);
 // Re-export presets
 __exportStar(require("./presets/index"), exports);
-// Upload utilities
-var upload_resolver_1 = require("./upload-resolver");
-Object.defineProperty(exports, "streamToStorage", { enumerable: true, get: function () { return upload_resolver_1.streamToStorage; } });
 // Presigned URL utilities
 var presigned_url_resolver_1 = require("./presigned-url-resolver");
 Object.defineProperty(exports, "getPresignedUrlS3Config", { enumerable: true, get: function () { return presigned_url_resolver_1.getPresignedUrlS3Config; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphile-settings",
-  "version": "5.7.1",
+  "version": "5.8.1",
   "author": "Constructive <developers@constructive.io>",
   "description": "graphile settings",
   "main": "index.js",
@@ -57,10 +57,10 @@
     "graphile-ltree": "^1.9.5",
     "graphile-pg-aggregates": "^1.5.4",
     "graphile-postgis": "^2.18.4",
-    "graphile-presigned-url-plugin": "^0.20.0",
+    "graphile-presigned-url-plugin": "^0.20.1",
     "graphile-realtime-subscriptions": "^0.8.1",
     "graphile-search": "^1.17.0",
-    "graphile-upload-plugin": "^2.12.0",
+    "graphile-upload-plugin": "^2.12.2",
     "graphile-utils": "5.0.1",
     "graphql": "16.13.0",
     "inflekt": "^0.7.1",
@@ -89,5 +89,5 @@
     "constructive",
     "graphql"
   ],
-  "gitHead": "fc6f9780ea1cab2c9344c2e392649ae644e84849"
+  "gitHead": "d398ac2288f57fa02713353ce36024a63dd6b9f1"
 }

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

@@ -21,6 +21,14 @@ function createMetaSchemaType() {
             subtype: { type: graphql_1.GraphQLString },
         }),
     });
+    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' },
+        }),
+    });
     const MetaFieldType = new graphql_1.GraphQLObjectType({
         name: 'MetaField',
         description: 'Information about a table field/column',
@@ -32,6 +40,7 @@ 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' },
         }),
     });
     const MetaIndexType = new graphql_1.GraphQLObjectType({
@@ -167,6 +176,71 @@ function createMetaSchemaType() {
             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' },
+        }),
+    });
+    const MetaSearchConfigType = new graphql_1.GraphQLObjectType({
+        name: 'MetaSearchConfig',
+        description: 'Per-table search configuration from @searchConfig smart tag',
+        fields: () => ({
+            weights: {
+                type: graphql_1.GraphQLString,
+                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' },
+        }),
+    });
+    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' },
+        }),
+    });
+    const MetaSearchType = new graphql_1.GraphQLObjectType({
+        name: 'MetaSearch',
+        description: 'Search metadata for a table',
+        fields: () => ({
+            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' },
+        }),
+    });
+    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)' },
+        }),
+    });
+    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' },
+        }),
+    });
+    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)' },
+        }),
+    });
     const MetaTableType = new graphql_1.GraphQLObjectType({
         name: 'MetaTable',
         description: 'Information about a database table',
@@ -182,6 +256,10 @@ function createMetaSchemaType() {
             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)' },
         }),
     });
     return new graphql_1.GraphQLObjectType({

package/plugins/meta-schema/storage-search-meta-builders.d.ts

@@ -0,0 +1,29 @@
+import type { I18nMeta, PgCodec, RealtimeMeta, SearchMeta, StorageMeta } from './types';
+/**
+ * Detect storage metadata from a codec's smart tags.
+ * Storage tables are identified by @storageFiles and @storageBuckets smart tags.
+ */
+export declare function buildStorageMeta(codec: PgCodec): StorageMeta | null;
+/**
+ * Detect search metadata from a codec's columns and smart tags.
+ *
+ * Looks for:
+ * - tsvector columns (full-text search)
+ * - vector columns (pgvector semantic search)
+ * - @searchConfig smart tag (per-table search configuration)
+ * - @bm25Index smart tag on columns (BM25 search)
+ * - @trgmSearch smart tag (trigram search)
+ */
+export declare function buildSearchMeta(codec: PgCodec, _build: unknown, inflectAttr: (attrName: string, codec: PgCodec) => string): SearchMeta | null;
+/**
+ * Detect i18n metadata from a codec's @i18n smart tag.
+ * The @i18n tag value is the name of the translation table.
+ * Translatable fields are discovered by matching text/citext columns
+ * between the base table and the translation table codec.
+ */
+export declare function buildI18nMeta(codec: PgCodec, build: unknown, inflectAttr: (attrName: string, codec: PgCodec) => string): I18nMeta | null;
+/**
+ * Detect realtime metadata from a codec's @realtime smart tag.
+ * Tables tagged with @realtime get subscription fields generated.
+ */
+export declare function buildRealtimeMeta(codec: PgCodec, build: unknown): RealtimeMeta | null;

package/plugins/meta-schema/storage-search-meta-builders.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStorageMeta = buildStorageMeta;
+exports.buildSearchMeta = buildSearchMeta;
+exports.buildI18nMeta = buildI18nMeta;
+exports.buildRealtimeMeta = buildRealtimeMeta;
+/**
+ * Detect storage metadata from a codec's smart tags.
+ * Storage tables are identified by @storageFiles and @storageBuckets smart tags.
+ */
+function buildStorageMeta(codec) {
+    const tags = codec.extensions?.tags;
+    if (!tags)
+        return null;
+    const isFilesTable = !!tags.storageFiles;
+    const isBucketsTable = !!tags.storageBuckets;
+    if (!isFilesTable && !isBucketsTable)
+        return null;
+    return {
+        isFilesTable,
+        isBucketsTable,
+    };
+}
+/**
+ * Detect search metadata from a codec's columns and smart tags.
+ *
+ * Looks for:
+ * - tsvector columns (full-text search)
+ * - vector columns (pgvector semantic search)
+ * - @searchConfig smart tag (per-table search configuration)
+ * - @bm25Index smart tag on columns (BM25 search)
+ * - @trgmSearch smart tag (trigram search)
+ */
+function buildSearchMeta(codec, _build, inflectAttr) {
+    const attributes = codec.attributes;
+    if (!attributes)
+        return null;
+    const tags = codec.extensions?.tags || {};
+    const columns = [];
+    const algorithmSet = new Set();
+    // Detect columns by type
+    for (const [attrName, attr] of Object.entries(attributes)) {
+        const pgType = attr?.codec?.name;
+        if (!pgType)
+            continue;
+        const inflectedName = inflectAttr(attrName, codec);
+        if (pgType === 'tsvector') {
+            columns.push({ name: inflectedName, algorithm: 'tsvector' });
+            algorithmSet.add('tsvector');
+        }
+        else if (pgType === 'vector') {
+            columns.push({ name: inflectedName, algorithm: 'vector' });
+            algorithmSet.add('vector');
+        }
+        // Check per-column @bm25Index tag
+        const attrTags = attr?.extensions?.tags;
+        if (attrTags?.bm25Index) {
+            columns.push({ name: inflectedName, algorithm: 'bm25' });
+            algorithmSet.add('bm25');
+        }
+    }
+    // Check for table-level @trgmSearch tag
+    if (tags.trgmSearch) {
+        algorithmSet.add('trgm');
+        // trgm operates on text columns — detect which ones
+        for (const [attrName, attr] of Object.entries(attributes)) {
+            const pgType = attr?.codec?.name;
+            if (pgType === 'text' || pgType === 'varchar' || pgType === 'citext') {
+                const attrTags = attr?.extensions?.tags;
+                if (attrTags?.trgmSearch) {
+                    columns.push({ name: inflectAttr(attrName, codec), algorithm: 'trgm' });
+                }
+            }
+        }
+    }
+    // Parse @searchConfig smart tag
+    const config = parseSearchConfig(tags);
+    // If nothing search-related was found, return null
+    if (columns.length === 0 && !config)
+        return null;
+    // Determine if unified search is available
+    // unifiedSearch requires at least one text-compatible adapter (tsvector or bm25)
+    const hasUnifiedSearch = algorithmSet.has('tsvector') || algorithmSet.has('bm25');
+    return {
+        algorithms: Array.from(algorithmSet).sort(),
+        columns,
+        hasUnifiedSearch,
+        config,
+    };
+}
+/**
+ * Detect i18n metadata from a codec's @i18n smart tag.
+ * The @i18n tag value is the name of the translation table.
+ * Translatable fields are discovered by matching text/citext columns
+ * between the base table and the translation table codec.
+ */
+function buildI18nMeta(codec, build, inflectAttr) {
+    const tags = codec.extensions?.tags;
+    if (!tags)
+        return null;
+    const i18nTag = tags.i18n;
+    if (typeof i18nTag !== 'string' || i18nTag.length === 0)
+        return null;
+    const attributes = codec.attributes;
+    if (!attributes)
+        return { translationTable: i18nTag, translatableFields: [] };
+    // Discover translatable fields: text/citext columns on the base table
+    const allowedTypes = ['text', 'citext'];
+    const translatableFields = [];
+    // Try to find the translation codec to get the intersection of fields
+    const pgRegistry = build?.input?.pgRegistry;
+    let translationAttrs = null;
+    if (pgRegistry?.pgResources) {
+        for (const r of Object.values(pgRegistry.pgResources)) {
+            const sqlName = r?.codec?.extensions?.pg?.name ?? r?.codec?.name;
+            if (sqlName === i18nTag) {
+                const tAttrs = r?.codec?.attributes;
+                if (tAttrs) {
+                    translationAttrs = new Set(Object.keys(tAttrs));
+                }
+                break;
+            }
+        }
+    }
+    for (const [attrName, attr] of Object.entries(attributes)) {
+        const pgType = attr?.codec?.name;
+        if (!pgType || !allowedTypes.includes(pgType))
+            continue;
+        // If we found the translation table, only include columns that exist there too
+        if (translationAttrs && !translationAttrs.has(attrName))
+            continue;
+        translatableFields.push({
+            name: inflectAttr(attrName, codec),
+            type: pgType,
+        });
+    }
+    return {
+        translationTable: i18nTag,
+        translatableFields,
+    };
+}
+/**
+ * Detect realtime metadata from a codec's @realtime smart tag.
+ * Tables tagged with @realtime get subscription fields generated.
+ */
+function buildRealtimeMeta(codec, build) {
+    const tags = codec.extensions?.tags;
+    if (!tags?.realtime)
+        return null;
+    const typeName = build.inflection?.tableType?.(codec);
+    if (!typeName)
+        return null;
+    return {
+        subscriptionFieldName: `on${typeName}Changed`,
+    };
+}
+function parseSearchConfig(tags) {
+    const raw = tags.searchConfig;
+    if (!raw)
+        return null;
+    let parsed;
+    if (typeof raw === 'string') {
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    else if (typeof raw === 'object') {
+        parsed = raw;
+    }
+    else {
+        return null;
+    }
+    return {
+        weights: parsed.weights && typeof parsed.weights === 'object'
+            ? parsed.weights
+            : null,
+        boostRecent: !!parsed.boost_recent,
+        boostRecencyField: parsed.boost_recency_field || null,
+        boostRecencyDecay: typeof parsed.boost_recency_decay === 'number'
+            ? parsed.boost_recency_decay
+            : null,
+    };
+}

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

@@ -4,6 +4,7 @@ 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 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");
@@ -51,6 +52,10 @@ function buildTableMeta(resource, schemaName, context) {
         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);
     return {
         name: tableType,
         schemaName,
@@ -63,6 +68,10 @@ function buildTableMeta(resource, schemaName, context) {
         relations: relationsMeta,
         inflection: (0, name_meta_builders_1.buildInflectionMeta)(resource, tableType, context.build),
         query: (0, name_meta_builders_1.buildQueryMeta)(resource, uniques, tableType, context.build),
+        storage,
+        search,
+        i18n,
+        realtime,
     };
 }
 function collectTablesMeta(build) {

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

@@ -64,6 +64,19 @@ function resolveGqlTypeName(build, codec) {
     const nestedTypeName = codec.arrayOfCodec?.name;
     return nestedTypeName ? pgTypeToGqlType(nestedTypeName) : pgTypeName;
 }
+function extractEnumMeta(codec) {
+    if (!codec)
+        return null;
+    // Check the codec itself, or unwrap domain/array wrappers
+    const inner = codec.domainOfCodec ?? codec.arrayOfCodec ?? codec;
+    const values = inner.values;
+    if (!Array.isArray(values) || values.length === 0)
+        return null;
+    return {
+        name: inner.name || codec.name || 'unknown',
+        values: values.map((v) => (typeof v === 'string' ? v : v.value)),
+    };
+}
 function buildFieldMeta(name, attr, build, options) {
     const pgType = attr?.codec?.name || 'unknown';
     const isNotNull = attr?.notNull || false;
@@ -84,5 +97,6 @@ function buildFieldMeta(name, attr, build, options) {
         isPrimaryKey: options?.isPrimaryKey ?? false,
         isForeignKey: options?.isForeignKey ?? false,
         description: attr?.description ?? null,
+        enumValues: extractEnumMeta(attr?.codec),
     };
 }

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

@@ -10,6 +10,64 @@ export interface TableMeta {
     relations: RelationsMeta;
     inflection: InflectionMeta;
     query: QueryMeta;
+    storage: StorageMeta | null;
+    search: SearchMeta | null;
+    i18n: I18nMeta | null;
+    realtime: RealtimeMeta | null;
+}
+export interface StorageMeta {
+    /** Whether this table is tagged as a storage files table */
+    isFilesTable: boolean;
+    /** Whether this table is tagged as a storage buckets table */
+    isBucketsTable: boolean;
+}
+export interface SearchColumnMeta {
+    /** Column name (camelCase inflected) */
+    name: string;
+    /** Search algorithm: 'tsvector', 'bm25', 'trgm', 'vector' */
+    algorithm: string;
+}
+export interface SearchMeta {
+    /** Which search algorithms are active on this table */
+    algorithms: string[];
+    /** Searchable columns with their algorithm */
+    columns: SearchColumnMeta[];
+    /** Whether unifiedSearch composite filter is available */
+    hasUnifiedSearch: boolean;
+    /** Per-table search config from @searchConfig smart tag */
+    config: SearchConfigMeta | null;
+}
+export interface SearchConfigMeta {
+    /** Per-adapter score weights */
+    weights: Record<string, number> | null;
+    /** Whether recency boosting is enabled */
+    boostRecent: boolean;
+    /** Field used for recency decay */
+    boostRecencyField: string | null;
+    /** Exponential decay factor per day */
+    boostRecencyDecay: number | null;
+}
+export interface I18nFieldMeta {
+    /** Inflected GraphQL field name */
+    name: string;
+    /** PostgreSQL column type (text, citext) */
+    type: string;
+}
+export interface I18nMeta {
+    /** Name of the translation table */
+    translationTable: string;
+    /** Fields that are translatable */
+    translatableFields: I18nFieldMeta[];
+}
+export interface RealtimeMeta {
+    /** The generated subscription field name (e.g. onPostChanged) */
+    subscriptionFieldName: string;
+}
+export interface EnumMeta {
+    /** The PostgreSQL enum type name */
+    name: string;
+    /** Allowed values for this enum */
+    values: string[];
 }
 export interface FieldMeta {
     name: string;
@@ -19,6 +77,7 @@ export interface FieldMeta {
     isPrimaryKey: boolean;
     isForeignKey: boolean;
     description: string | null;
+    enumValues: EnumMeta | null;
 }
 export interface TypeMeta {
     pgType: string;
@@ -213,3 +272,9 @@ export interface MetaBuild extends GqlTypeResolverBuild {
     };
     pgManyToManyRealtionshipsByResource?: Map<unknown, unknown>;
 }
+export interface PgCodecExtensions {
+    pg?: {
+        schemaName?: string;
+    };
+    tags?: Record<string, unknown>;
+}

package/upload-resolver.d.ts

@@ -15,18 +15,7 @@
  *   AWS_SECRET_KEY   - secret key (default: 'minioadmin')
  *   CDN_ENDPOINT     - S3-compatible endpoint (default: 'http://localhost:9000')
  */
-import type { Readable } from 'stream';
 import type { UploadFieldDefinition } from 'graphile-upload-plugin';
-/**
- * Streams a file to S3/MinIO storage and returns the URL and metadata.
- *
- * Reusable by both the GraphQL upload resolver and REST /upload endpoint.
- */
-export declare function streamToStorage(readStream: Readable, filename: string): Promise<{
-    url: string;
-    filename: string;
-    mime: string;
-}>;
 /**
  * Upload field definitions for Constructive's three upload domain types.
  *

package/upload-resolver.js

@@ -21,7 +21,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.constructiveUploadFieldDefinitions = void 0;
-exports.streamToStorage = streamToStorage;
 const s3_streamer_1 = __importDefault(require("@constructive-io/s3-streamer"));
 const upload_names_1 = __importDefault(require("@constructive-io/upload-names"));
 const graphql_env_1 = require("@constructive-io/graphql-env");
@@ -66,26 +65,6 @@ function generateKey(filename) {
     const rand = (0, crypto_1.randomBytes)(12).toString('hex');
     return `${rand}-${(0, upload_names_1.default)(filename)}`;
 }
-/**
- * Streams a file to S3/MinIO storage and returns the URL and metadata.
- *
- * Reusable by both the GraphQL upload resolver and REST /upload endpoint.
- */
-async function streamToStorage(readStream, filename) {
-    const s3 = getStreamer();
-    const key = generateKey(filename);
-    const result = await s3.upload({
-        readStream,
-        filename,
-        key,
-        bucket: bucketName,
-    });
-    return {
-        url: result.upload.Location,
-        filename,
-        mime: result.contentType,
-    };
-}
 /**
  * Upload resolver that streams files to S3/MinIO.
  *