graphile-settings 6.5.1 → 6.5.3

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

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

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

@@ -1,4 +0,0 @@
-import type { MetaInflection, PgCodec } from './types';
-export declare function safeInflection<T>(fn: () => T, fallback: T): T;
-export declare function createAttributeInflector(inflection: MetaInflection): (attrName: string, codec: PgCodec) => string;
-export declare function fallbackTableType(codecName: string): string;

package/esm/plugins/meta-schema/inflection-utils.js

@@ -1,20 +0,0 @@
-export function safeInflection(fn, fallback) {
-    try {
-        return fn() ?? fallback;
-    }
-    catch {
-        return fallback;
-    }
-}
-export function createAttributeInflector(inflection) {
-    return (attrName, codec) => {
-        const attributeName = safeInflection(() => inflection._attributeName?.({ attributeName: attrName, codec }), attrName);
-        return safeInflection(() => inflection.camelCase?.(attributeName), attributeName);
-    };
-}
-export function fallbackTableType(codecName) {
-    return codecName
-        .replace(/_/g, ' ')
-        .replace(/\b\w/g, (char) => char.toUpperCase())
-        .replace(/ /g, '');
-}

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

@@ -1,4 +0,0 @@
-import type { InflectionMeta, MetaBuild, PgCodec, PgTableResource, PgUnique, QueryMeta } from './types';
-export declare function resolveTableType(build: MetaBuild, codec: PgCodec): string;
-export declare function buildInflectionMeta(resource: PgTableResource, tableType: string, build: MetaBuild): InflectionMeta;
-export declare function buildQueryMeta(resource: PgTableResource, uniques: PgUnique[], tableType: string, build: MetaBuild): QueryMeta;

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

@@ -1,38 +0,0 @@
-import { fallbackTableType, safeInflection } from './inflection-utils';
-export function resolveTableType(build, codec) {
-    return safeInflection(() => build.inflection.tableType(codec), fallbackTableType(codec.name));
-}
-export function buildInflectionMeta(resource, tableType, build) {
-    const inflection = build.inflection;
-    return {
-        tableType,
-        allRows: safeInflection(() => inflection.allRows?.(resource), `${tableType.toLowerCase()}s`),
-        connection: safeInflection(() => inflection.connectionType?.(tableType), `${tableType}Connection`),
-        edge: safeInflection(() => inflection.edgeType?.(tableType), `${tableType}Edge`),
-        filterType: safeInflection(() => inflection.filterType?.(tableType), `${tableType}Filter`),
-        orderByType: safeInflection(() => inflection.orderByType?.(tableType), `${tableType}OrderBy`),
-        conditionType: safeInflection(() => inflection.conditionType?.(tableType), `${tableType}Condition`),
-        patchType: safeInflection(() => inflection.patchType?.(tableType), `${tableType}Patch`),
-        createInputType: safeInflection(() => inflection.createInputType?.(resource), `Create${tableType}Input`),
-        createPayloadType: safeInflection(() => inflection.createPayloadType?.(resource), `Create${tableType}Payload`),
-        updatePayloadType: safeInflection(() => inflection.updatePayloadType?.(resource), `Update${tableType}Payload`),
-        deletePayloadType: safeInflection(() => inflection.deletePayloadType?.(resource), `Delete${tableType}Payload`),
-    };
-}
-export function buildQueryMeta(resource, uniques, tableType, build) {
-    const inflection = build.inflection;
-    const hasPrimaryKey = uniques.some((unique) => unique.isPrimary);
-    return {
-        all: safeInflection(() => inflection.allRows?.(resource), `${tableType.toLowerCase()}s`),
-        one: hasPrimaryKey
-            ? safeInflection(() => inflection.tableFieldName?.(resource), tableType.toLowerCase())
-            : null,
-        create: safeInflection(() => inflection.createField?.(resource), `create${tableType}`),
-        update: hasPrimaryKey
-            ? safeInflection(() => inflection.updateByKeys?.(resource), `update${tableType}`)
-            : null,
-        delete: hasPrimaryKey
-            ? safeInflection(() => inflection.deleteByKeys?.(resource), `delete${tableType}`)
-            : null,
-    };
-}

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

@@ -1,2 +0,0 @@
-import type { GraphileConfig } from 'graphile-config';
-export declare const MetaSchemaPlugin: GraphileConfig.Plugin;

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

@@ -1,23 +0,0 @@
-import { getCachedTablesMeta, setCachedTablesMeta } from './cache';
-import { extendQueryWithMetaField } from './graphql-meta-field';
-import { collectTablesMeta } from './table-meta-builder';
-export const MetaSchemaPlugin = {
-    name: 'MetaSchemaPlugin',
-    version: '1.0.0',
-    description: 'Exposes _meta query for database schema introspection',
-    schema: {
-        hooks: {
-            init(input, rawBuild) {
-                const build = rawBuild;
-                setCachedTablesMeta(collectTablesMeta(build));
-                return input;
-            },
-            GraphQLObjectType_fields(rawFields, _rawBuild, rawContext) {
-                const context = rawContext;
-                if (context.Self?.name !== 'Query')
-                    return rawFields;
-                return extendQueryWithMetaField(rawFields, getCachedTablesMeta());
-            },
-        },
-    },
-};

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

@@ -1,8 +0,0 @@
-import { type BuildContext } from './table-meta-context';
-import type { BelongsToRelation, HasRelation, ManyToManyRelation, PgAttribute, PgCodec, PgRelation, PgTableResource, PgUnique } from './types';
-export declare function buildBelongsToRelations(codec: PgCodec, attributes: Record<string, PgAttribute>, uniques: PgUnique[], relations: Record<string, PgRelation>, context: BuildContext): BelongsToRelation[];
-export declare function buildReverseRelations(codec: PgCodec, attributes: Record<string, PgAttribute>, relations: Record<string, PgRelation>, context: BuildContext): {
-    hasOne: HasRelation[];
-    hasMany: HasRelation[];
-};
-export declare function buildManyToManyRelations(resource: PgTableResource, codec: PgCodec, context: BuildContext): ManyToManyRelation[];

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

@@ -1,119 +0,0 @@
-import { safeInflection } from './inflection-utils';
-import { buildForeignKeyConstraint, } from './constraint-meta-builders';
-import { buildFieldList } from './table-meta-context';
-import { getRelation, getResourceCodec, getUniques, sameAttributes, } from './table-resource-utils';
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
-export function buildBelongsToRelations(codec, attributes, uniques, relations, context) {
-    const belongsTo = [];
-    for (const [relationName, relation] of Object.entries(relations)) {
-        // PostGraphile only sets isReferencee when true (reverse FK);
-        // forward relations have isReferencee undefined, not false.
-        if (relation.isReferencee)
-            continue;
-        const localAttributes = relation.localAttributes || [];
-        const isUnique = uniques.some((unique) => sameAttributes(unique.attributes, localAttributes));
-        const remoteCodec = relation.remoteResource?.codec;
-        belongsTo.push({
-            fieldName: relationName,
-            isUnique,
-            type: remoteCodec?.name || null,
-            keys: buildFieldList(localAttributes, codec, attributes, context),
-            references: { name: remoteCodec?.name || 'unknown' },
-        });
-    }
-    return belongsTo;
-}
-export function buildReverseRelations(codec, attributes, relations, context) {
-    const hasOne = [];
-    const hasMany = [];
-    for (const [relationName, relation] of Object.entries(relations)) {
-        if (relation.isReferencee !== true)
-            continue;
-        const remoteUniques = getUniques(relation.remoteResource || {});
-        const remoteAttributes = relation.remoteAttributes || [];
-        const isUnique = remoteUniques.some((unique) => sameAttributes(unique.attributes, remoteAttributes));
-        const remoteCodec = relation.remoteResource?.codec;
-        const meta = {
-            fieldName: relationName,
-            isUnique,
-            type: remoteCodec?.name || null,
-            keys: buildFieldList(relation.localAttributes || [], codec, attributes, context),
-            referencedBy: { name: remoteCodec?.name || 'unknown' },
-        };
-        if (isUnique) {
-            hasOne.push(meta);
-        }
-        else {
-            hasMany.push(meta);
-        }
-    }
-    return { hasOne, hasMany };
-}
-function isManyToManyDetails(value) {
-    if (!isRecord(value))
-        return false;
-    return (isRecord(value.leftTable) &&
-        isRecord(value.junctionTable) &&
-        isRecord(value.rightTable) &&
-        typeof value.leftRelationName === 'string' &&
-        typeof value.rightRelationName === 'string');
-}
-function parseManyToManyRelationships(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.filter(isManyToManyDetails);
-}
-function getManyToManyRelationships(build, tableResource, codec) {
-    const relationshipsByResource = build.pgManyToManyRealtionshipsByResource;
-    if (!(relationshipsByResource instanceof Map))
-        return [];
-    const direct = parseManyToManyRelationships(relationshipsByResource.get(tableResource));
-    if (direct.length > 0)
-        return direct;
-    for (const [leftTable, relationships] of relationshipsByResource.entries()) {
-        const details = parseManyToManyRelationships(relationships);
-        if (details.length === 0 || !isRecord(leftTable))
-            continue;
-        if (leftTable.codec === codec) {
-            return details;
-        }
-    }
-    return [];
-}
-function buildManyToManyRelation(details, context) {
-    const leftCodec = getResourceCodec(details.leftTable);
-    const junctionCodec = getResourceCodec(details.junctionTable);
-    const rightCodec = getResourceCodec(details.rightTable);
-    if (!leftCodec || !junctionCodec || !rightCodec)
-        return null;
-    const leftRelation = getRelation(details.leftTable, details.leftRelationName);
-    const junctionRightRelation = getRelation(details.junctionTable, details.rightRelationName);
-    if (!leftRelation || !junctionRightRelation)
-        return null;
-    const leftJunctionAttributes = leftRelation.remoteAttributes || [];
-    const leftTableAttributes = leftRelation.localAttributes || [];
-    const rightJunctionAttributes = junctionRightRelation.localAttributes || [];
-    const rightTableAttributes = junctionRightRelation.remoteAttributes || [];
-    const relationFieldName = safeInflection(() => context.build.inflection._manyToManyRelation?.(details), details.rightRelationName || rightCodec.name || null);
-    const junctionLeftConstraint = buildForeignKeyConstraint(details.leftRelationName || `${junctionCodec.name}_${leftCodec.name}_fkey`, junctionCodec, junctionCodec.attributes, leftJunctionAttributes, leftCodec, leftCodec.attributes, leftTableAttributes, context);
-    const junctionRightConstraint = buildForeignKeyConstraint(details.rightRelationName || `${junctionCodec.name}_${rightCodec.name}_fkey`, junctionCodec, junctionCodec.attributes, rightJunctionAttributes, rightCodec, rightCodec.attributes, rightTableAttributes, context);
-    return {
-        fieldName: relationFieldName,
-        type: rightCodec.name || null,
-        junctionTable: { name: junctionCodec.name || 'unknown' },
-        junctionLeftConstraint,
-        junctionLeftKeyAttributes: buildFieldList(leftJunctionAttributes, junctionCodec, junctionCodec.attributes, context),
-        junctionRightConstraint,
-        junctionRightKeyAttributes: buildFieldList(rightJunctionAttributes, junctionCodec, junctionCodec.attributes, context),
-        leftKeyAttributes: buildFieldList(leftTableAttributes, leftCodec, leftCodec.attributes, context),
-        rightKeyAttributes: buildFieldList(rightTableAttributes, rightCodec, rightCodec.attributes, context),
-        rightTable: { name: rightCodec.name || 'unknown' },
-    };
-}
-export function buildManyToManyRelations(resource, codec, context) {
-    return getManyToManyRelationships(context.build, resource, codec)
-        .map((details) => buildManyToManyRelation(details, context))
-        .filter((relation) => relation !== null);
-}

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

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

@@ -1,40 +0,0 @@
-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/storage-search-meta-builders.d.ts

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