graphile-settings 6.5.1 → 6.5.3

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

@@ -1,180 +0,0 @@
-/**
- * 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.d.ts

@@ -1,2 +0,0 @@
-import type { MetaBuild, TableMeta } from './types';
-export declare function collectTablesMeta(build: MetaBuild): TableMeta[];

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

@@ -1,99 +0,0 @@
-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 { buildScopeMeta } from './scope-meta-builders';
-import { buildI18nMeta, buildRealtimeMeta, buildSearchMeta, buildStorageMeta } from './storage-search-meta-builders';
-import { createBuildContext } from './table-meta-context';
-import { getConfiguredSchemas, getRelations, getSchemaName, getUniques, isTableResource } from './table-resource-utils';
-import { buildFieldMeta } from './type-mappings';
-function buildTableMeta(resource, schemaName, context) {
-    const codec = resource.codec;
-    const attributes = codec.attributes;
-    const uniques = getUniques(resource);
-    const relations = getRelations(resource);
-    // Compute PK and FK attribute name sets for field metadata
-    const pkAttrNames = new Set();
-    const fkAttrNames = new Set();
-    for (const unique of uniques) {
-        if (unique.isPrimary) {
-            for (const attrName of unique.attributes)
-                pkAttrNames.add(attrName);
-        }
-    }
-    for (const relation of Object.values(relations)) {
-        if (relation.isReferencee)
-            continue;
-        for (const attrName of relation.localAttributes || [])
-            fkAttrNames.add(attrName);
-    }
-    const fields = Object.entries(attributes).map(([attrName, attr]) => buildFieldMeta(context.inflectAttr(attrName, codec), attr, context.build, {
-        isPrimaryKey: pkAttrNames.has(attrName),
-        isForeignKey: fkAttrNames.has(attrName)
-    }));
-    const indexes = buildIndexes(codec, attributes, uniques, context);
-    const primaryKey = buildPrimaryKey(codec, attributes, uniques, context);
-    const uniqueConstraints = buildUniqueConstraints(codec, attributes, uniques, context);
-    const foreignKeyConstraints = buildForeignKeyConstraints(codec, attributes, relations, context);
-    const constraints = {
-        primaryKey,
-        unique: uniqueConstraints,
-        foreignKey: foreignKeyConstraints
-    };
-    const belongsTo = buildBelongsToRelations(codec, attributes, uniques, relations, context);
-    const { hasOne, hasMany } = buildReverseRelations(codec, attributes, relations, context);
-    const manyToMany = buildManyToManyRelations(resource, codec, context);
-    const relationsMeta = {
-        belongsTo,
-        has: [...hasOne, ...hasMany],
-        hasOne,
-        hasMany,
-        manyToMany
-    };
-    const tableType = resolveTableType(context.build, codec);
-    const storage = buildStorageMeta(codec);
-    const search = buildSearchMeta(codec, context.build, context.inflectAttr);
-    const i18n = buildI18nMeta(codec, context.build, context.inflectAttr);
-    const realtime = buildRealtimeMeta(codec, context.build);
-    const scope = buildScopeMeta(codec, context.inflectAttr);
-    return {
-        name: tableType,
-        schemaName,
-        fields,
-        indexes,
-        constraints,
-        foreignKeyConstraints,
-        primaryKeyConstraints: primaryKey ? [primaryKey] : [],
-        uniqueConstraints,
-        relations: relationsMeta,
-        inflection: buildInflectionMeta(resource, tableType, context.build),
-        query: buildQueryMeta(resource, uniques, tableType, context.build),
-        storage,
-        search,
-        i18n,
-        realtime,
-        scope
-    };
-}
-export function collectTablesMeta(build) {
-    const configuredSchemas = getConfiguredSchemas(build);
-    const context = createBuildContext(build);
-    const seenCodecs = new Set();
-    const tablesMeta = [];
-    for (const resource of Object.values(build.input.pgRegistry.pgResources || {})) {
-        if (!isTableResource(resource))
-            continue;
-        const codec = resource.codec;
-        if (seenCodecs.has(codec))
-            continue;
-        seenCodecs.add(codec);
-        const schemaName = getSchemaName(resource);
-        if (!schemaName)
-            continue;
-        if (configuredSchemas.length > 0 &&
-            !configuredSchemas.includes(schemaName)) {
-            continue;
-        }
-        tablesMeta.push(buildTableMeta(resource, schemaName, context));
-    }
-    return tablesMeta;
-}

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

@@ -1,13 +0,0 @@
-import type { FieldMeta, MetaBuild, PgAttribute, PgCodec, PgTableResource } from './types';
-export type AttributeInflector = (attrName: string, codec: PgCodec) => string;
-export interface BuildContext {
-    build: MetaBuild;
-    inflectAttr: AttributeInflector;
-}
-export type TableResourceWithCodec = PgTableResource & {
-    codec: PgCodec & {
-        attributes: Record<string, PgAttribute>;
-    };
-};
-export declare function createBuildContext(build: MetaBuild): BuildContext;
-export declare function buildFieldList(attrNames: string[], codec: PgCodec, attributes: Record<string, PgAttribute>, context: BuildContext): FieldMeta[];

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

@@ -1,11 +0,0 @@
-import { createAttributeInflector } from './inflection-utils';
-import { buildFieldMeta } from './type-mappings';
-export function createBuildContext(build) {
-    return {
-        build,
-        inflectAttr: createAttributeInflector(build.inflection),
-    };
-}
-export function buildFieldList(attrNames, codec, attributes, context) {
-    return attrNames.map((attrName) => buildFieldMeta(context.inflectAttr(attrName, codec), attributes[attrName], context.build));
-}

package/esm/plugins/meta-schema/table-resource-utils.d.ts

@@ -1,12 +0,0 @@
-import type { MetaBuild, PgAttribute, PgCodec, PgRelation, PgTableResource, PgUnique } from './types';
-import type { TableResourceWithCodec } from './table-meta-context';
-export declare function isTableResource(resource: PgTableResource): resource is TableResourceWithCodec;
-export declare function getSchemaName(resource: PgTableResource): string | null;
-export declare function getUniques(resource: PgTableResource): PgUnique[];
-export declare function getRelations(resource: PgTableResource): Record<string, PgRelation>;
-export declare function getRelation(resource: PgTableResource, relationName: string): PgRelation | null;
-export declare function sameAttributes(uniqueAttributes: string[] | undefined, relationAttributes: string[] | undefined): boolean;
-export declare function getConfiguredSchemas(build: MetaBuild): string[];
-export declare function getResourceCodec(resource: PgTableResource): (PgCodec & {
-    attributes: Record<string, PgAttribute>;
-}) | null;

package/esm/plugins/meta-schema/table-resource-utils.js

@@ -1,50 +0,0 @@
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
-export function isTableResource(resource) {
-    return (!!resource.codec &&
-        !resource.codec.isAnonymous &&
-        isRecord(resource.codec.attributes) &&
-        !resource.parameters &&
-        !resource.isVirtual &&
-        !resource.isUnique);
-}
-export function getSchemaName(resource) {
-    const schemaName = resource.codec?.extensions?.pg?.schemaName;
-    if (typeof schemaName !== 'string' || schemaName.length === 0)
-        return null;
-    return schemaName;
-}
-export function getUniques(resource) {
-    return Array.isArray(resource.uniques) ? resource.uniques : [];
-}
-export function getRelations(resource) {
-    return resource.relations || resource.getRelations?.() || {};
-}
-export function getRelation(resource, relationName) {
-    if (!relationName)
-        return null;
-    if (typeof resource.getRelation === 'function') {
-        return resource.getRelation(relationName) || null;
-    }
-    const relations = getRelations(resource);
-    return relations[relationName] || null;
-}
-export function sameAttributes(uniqueAttributes, relationAttributes) {
-    if (!uniqueAttributes || !relationAttributes)
-        return false;
-    return (uniqueAttributes.length === relationAttributes.length &&
-        uniqueAttributes.every((attrName) => relationAttributes.includes(attrName)));
-}
-export function getConfiguredSchemas(build) {
-    const pgSchemas = build.options?.pgSchemas;
-    if (!Array.isArray(pgSchemas))
-        return [];
-    return pgSchemas.filter((schemaName) => typeof schemaName === 'string');
-}
-export function getResourceCodec(resource) {
-    const codec = resource.codec;
-    if (!codec?.attributes)
-        return null;
-    return codec;
-}

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

@@ -1,7 +0,0 @@
-import type { FieldMeta, GqlTypeResolverBuild, PgAttribute } from './types';
-export declare function pgTypeToGqlType(pgTypeName: string): string;
-export interface BuildFieldMetaOptions {
-    isPrimaryKey?: boolean;
-    isForeignKey?: boolean;
-}
-export declare function buildFieldMeta(name: string, attr: PgAttribute | null | undefined, build?: GqlTypeResolverBuild, options?: BuildFieldMetaOptions): FieldMeta;

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

@@ -1,100 +0,0 @@
-import { buildScalarEncoding } from './encoding-meta-builders';
-const PG_TO_GQL_TYPE = {
-    text: 'String',
-    varchar: 'String',
-    char: 'String',
-    name: 'String',
-    bpchar: 'String',
-    uuid: 'UUID',
-    int2: 'Int',
-    int4: 'Int',
-    integer: 'Int',
-    int8: 'BigInt',
-    bigint: 'BigInt',
-    float4: 'Float',
-    float8: 'Float',
-    numeric: 'BigFloat',
-    bool: 'Boolean',
-    boolean: 'Boolean',
-    timestamptz: 'Datetime',
-    timestamp: 'Datetime',
-    date: 'Date',
-    time: 'Time',
-    timetz: 'Time',
-    json: 'JSON',
-    jsonb: 'JSON',
-    interval: 'Interval',
-    point: 'Point',
-    geometry: 'GeoJSON',
-    geography: 'GeoJSON',
-    inet: 'InternetAddress',
-    cidr: 'InternetAddress',
-    xml: 'String',
-    bytea: 'String',
-    macaddr: 'String',
-};
-export function pgTypeToGqlType(pgTypeName) {
-    return PG_TO_GQL_TYPE[pgTypeName] || pgTypeName;
-}
-function getGeometrySubtype(attr) {
-    const subtype = attr?.extensions?.geometrySubtype;
-    return typeof subtype === 'string' ? subtype : null;
-}
-function resolveGqlTypeName(build, codec) {
-    if (!codec)
-        return 'unknown';
-    try {
-        const codecForLookup = codec.arrayOfCodec || codec;
-        if (build?.hasGraphQLTypeForPgCodec?.(codecForLookup, 'output')) {
-            const resolved = build.getGraphQLTypeNameByPgCodec?.(codecForLookup, 'output');
-            if (resolved)
-                return resolved;
-        }
-    }
-    catch {
-        // Fall through to static fallback mapping.
-    }
-    const pgTypeName = codec.name || 'unknown';
-    const mapped = pgTypeToGqlType(pgTypeName);
-    if (mapped !== pgTypeName)
-        return mapped;
-    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;
-    const hasDefault = attr?.hasDefault || false;
-    const subtype = getGeometrySubtype(attr);
-    return {
-        name,
-        type: {
-            pgType,
-            gqlType: build ? resolveGqlTypeName(build, attr?.codec) : pgTypeToGqlType(pgType),
-            isArray: !!attr?.codec?.arrayOfCodec,
-            isNotNull,
-            hasDefault,
-            subtype,
-            encoding: buildScalarEncoding(attr),
-        },
-        isNotNull,
-        hasDefault,
-        isPrimaryKey: options?.isPrimaryKey ?? false,
-        isForeignKey: options?.isForeignKey ?? false,
-        description: attr?.description ?? null,
-        enumValues: extractEnumMeta(attr?.codec),
-    };
-}