graphile-settings 6.5.2 → 6.5.3

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;

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;