graphile-settings 4.9.3 → 4.10.0

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

@@ -0,0 +1,51 @@
+import { buildFieldMeta } from './type-mappings';
+import { buildFieldList } from './table-meta-context';
+export function buildForeignKeyConstraint(constraintName, localCodec, localAttributes, localAttributeNames, remoteCodec, remoteAttributes, remoteAttributeNames, context) {
+    const referencedTable = remoteCodec?.name || 'unknown';
+    const referencedFields = remoteAttributeNames.map((attrName) => remoteCodec ? context.inflectAttr(attrName, remoteCodec) : attrName);
+    return {
+        name: constraintName,
+        fields: buildFieldList(localAttributeNames, localCodec, localAttributes, context),
+        referencedTable,
+        referencedFields,
+        refFields: remoteAttributeNames.map((attrName) => buildFieldMeta(remoteCodec ? context.inflectAttr(attrName, remoteCodec) : attrName, remoteAttributes[attrName], context.build)),
+        refTable: { name: referencedTable },
+    };
+}
+export function buildIndexes(codec, attributes, uniques, context) {
+    return uniques.map((unique) => ({
+        name: unique.tags?.name || `${codec.name}_${unique.attributes.join('_')}_idx`,
+        isUnique: true,
+        isPrimary: !!unique.isPrimary,
+        columns: unique.attributes.map((attrName) => context.inflectAttr(attrName, codec)),
+        fields: buildFieldList(unique.attributes, codec, attributes, context),
+    }));
+}
+export function buildPrimaryKey(codec, attributes, uniques, context) {
+    const primaryUnique = uniques.find((unique) => unique.isPrimary);
+    if (!primaryUnique)
+        return null;
+    return {
+        name: primaryUnique.tags?.name || `${codec.name}_pkey`,
+        fields: buildFieldList(primaryUnique.attributes, codec, attributes, context),
+    };
+}
+export function buildUniqueConstraints(codec, attributes, uniques, context) {
+    return uniques
+        .filter((unique) => !unique.isPrimary)
+        .map((unique) => ({
+        name: unique.tags?.name || `${codec.name}_${unique.attributes.join('_')}_key`,
+        fields: buildFieldList(unique.attributes, codec, attributes, context),
+    }));
+}
+export function buildForeignKeyConstraints(codec, attributes, relations, context) {
+    const constraints = [];
+    for (const [relationName, relation] of Object.entries(relations)) {
+        if (relation.isReferencee !== false)
+            continue;
+        const remoteCodec = relation.remoteResource?.codec;
+        const remoteAttributes = remoteCodec?.attributes || {};
+        constraints.push(buildForeignKeyConstraint(relationName, codec, attributes, relation.localAttributes || [], remoteCodec, remoteAttributes, relation.remoteAttributes || [], context));
+    }
+    return constraints;
+}

package/esm/plugins/meta-schema/graphql-meta-field.d.ts

@@ -0,0 +1,4 @@
+import type { TableMeta } from './types';
+type FieldMap = Record<string, unknown>;
+export declare function extendQueryWithMetaField(fields: FieldMap, tablesMeta: TableMeta[]): FieldMap;
+export {};

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

@@ -0,0 +1,201 @@
+import { GraphQLBoolean, 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 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 },
+        }),
+    });
+    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) },
+        }),
+    });
+    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 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) },
+        }),
+    });
+    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

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

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

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

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

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

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

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

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

@@ -0,0 +1,115 @@
+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)) {
+        if (relation.isReferencee !== false)
+            continue;
+        const localAttributes = relation.localAttributes || [];
+        const isUnique = uniques.some((unique) => sameAttributes(unique.attributes, localAttributes));
+        belongsTo.push({
+            fieldName: relationName,
+            isUnique,
+            type: relation.remoteResource?.codec?.name || null,
+            keys: buildFieldList(localAttributes, codec, attributes, context),
+            references: { name: relation.remoteResource?.codec?.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 meta = {
+            fieldName: relationName,
+            isUnique,
+            type: relation.remoteResource?.codec?.name || null,
+            keys: buildFieldList(relation.localAttributes || [], codec, attributes, context),
+            referencedBy: { name: relation.remoteResource?.codec?.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/table-meta-builder.d.ts

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

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

@@ -0,0 +1,69 @@
+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 { buildFieldMeta } from './type-mappings';
+import { createBuildContext, } from './table-meta-context';
+import { getConfiguredSchemas, getRelations, getSchemaName, getUniques, isTableResource, } from './table-resource-utils';
+function buildTableMeta(resource, schemaName, context) {
+    const codec = resource.codec;
+    const attributes = codec.attributes;
+    const uniques = getUniques(resource);
+    const relations = getRelations(resource);
+    const fields = Object.entries(attributes).map(([attrName, attr]) => buildFieldMeta(context.inflectAttr(attrName, codec), attr, context.build));
+    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);
+    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),
+    };
+}
+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

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

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

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

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

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