graphile-settings 4.9.2 → 4.10.0

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

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendQueryWithMetaField = extendQueryWithMetaField;
+const graphql_1 = require("graphql");
+function nn(type) {
+    return new graphql_1.GraphQLNonNull(type);
+}
+function nnList(type) {
+    return nn(new graphql_1.GraphQLList(nn(type)));
+}
+function createMetaSchemaType() {
+    const MetaTypeType = new graphql_1.GraphQLObjectType({
+        name: 'MetaType',
+        description: 'Information about a PostgreSQL type',
+        fields: () => ({
+            pgType: { type: nn(graphql_1.GraphQLString) },
+            gqlType: { type: nn(graphql_1.GraphQLString) },
+            isArray: { type: nn(graphql_1.GraphQLBoolean) },
+            isNotNull: { type: graphql_1.GraphQLBoolean },
+            hasDefault: { type: graphql_1.GraphQLBoolean },
+        }),
+    });
+    const MetaFieldType = new graphql_1.GraphQLObjectType({
+        name: 'MetaField',
+        description: 'Information about a table field/column',
+        fields: () => ({
+            name: { type: nn(graphql_1.GraphQLString) },
+            type: { type: nn(MetaTypeType) },
+            isNotNull: { type: nn(graphql_1.GraphQLBoolean) },
+            hasDefault: { type: nn(graphql_1.GraphQLBoolean) },
+        }),
+    });
+    const MetaIndexType = new graphql_1.GraphQLObjectType({
+        name: 'MetaIndex',
+        description: 'Information about a database index',
+        fields: () => ({
+            name: { type: nn(graphql_1.GraphQLString) },
+            isUnique: { type: nn(graphql_1.GraphQLBoolean) },
+            isPrimary: { type: nn(graphql_1.GraphQLBoolean) },
+            columns: { type: nnList(graphql_1.GraphQLString) },
+            fields: { type: new graphql_1.GraphQLList(nn(MetaFieldType)) },
+        }),
+    });
+    const MetaPrimaryKeyConstraintType = new graphql_1.GraphQLObjectType({
+        name: 'MetaPrimaryKeyConstraint',
+        description: 'Information about a primary key constraint',
+        fields: () => ({
+            name: { type: nn(graphql_1.GraphQLString) },
+            fields: { type: nnList(MetaFieldType) },
+        }),
+    });
+    const MetaUniqueConstraintType = new graphql_1.GraphQLObjectType({
+        name: 'MetaUniqueConstraint',
+        description: 'Information about a unique constraint',
+        fields: () => ({
+            name: { type: nn(graphql_1.GraphQLString) },
+            fields: { type: nnList(MetaFieldType) },
+        }),
+    });
+    const MetaRefTableType = new graphql_1.GraphQLObjectType({
+        name: 'MetaRefTable',
+        description: 'Reference to a related table',
+        fields: () => ({
+            name: { type: nn(graphql_1.GraphQLString) },
+        }),
+    });
+    const MetaForeignKeyConstraintType = new graphql_1.GraphQLObjectType({
+        name: 'MetaForeignKeyConstraint',
+        description: 'Information about a foreign key constraint',
+        fields: () => ({
+            name: { type: nn(graphql_1.GraphQLString) },
+            fields: { type: nnList(MetaFieldType) },
+            referencedTable: { type: nn(graphql_1.GraphQLString) },
+            referencedFields: { type: nnList(graphql_1.GraphQLString) },
+            refFields: { type: new graphql_1.GraphQLList(nn(MetaFieldType)) },
+            refTable: { type: MetaRefTableType },
+        }),
+    });
+    const MetaConstraintsType = new graphql_1.GraphQLObjectType({
+        name: 'MetaConstraints',
+        description: 'Table constraints',
+        fields: () => ({
+            primaryKey: { type: MetaPrimaryKeyConstraintType },
+            unique: { type: nnList(MetaUniqueConstraintType) },
+            foreignKey: { type: nnList(MetaForeignKeyConstraintType) },
+        }),
+    });
+    const MetaInflectionType = new graphql_1.GraphQLObjectType({
+        name: 'MetaInflection',
+        description: 'Table inflection names',
+        fields: () => ({
+            tableType: { type: nn(graphql_1.GraphQLString) },
+            allRows: { type: nn(graphql_1.GraphQLString) },
+            connection: { type: nn(graphql_1.GraphQLString) },
+            edge: { type: nn(graphql_1.GraphQLString) },
+            filterType: { type: graphql_1.GraphQLString },
+            orderByType: { type: nn(graphql_1.GraphQLString) },
+            conditionType: { type: nn(graphql_1.GraphQLString) },
+            patchType: { type: graphql_1.GraphQLString },
+            createInputType: { type: nn(graphql_1.GraphQLString) },
+            createPayloadType: { type: nn(graphql_1.GraphQLString) },
+            updatePayloadType: { type: graphql_1.GraphQLString },
+            deletePayloadType: { type: nn(graphql_1.GraphQLString) },
+        }),
+    });
+    const MetaQueryType = new graphql_1.GraphQLObjectType({
+        name: 'MetaQuery',
+        description: 'Table query/mutation names',
+        fields: () => ({
+            all: { type: nn(graphql_1.GraphQLString) },
+            one: { type: graphql_1.GraphQLString },
+            create: { type: graphql_1.GraphQLString },
+            update: { type: graphql_1.GraphQLString },
+            delete: { type: graphql_1.GraphQLString },
+        }),
+    });
+    const MetaBelongsToRelationType = new graphql_1.GraphQLObjectType({
+        name: 'MetaBelongsToRelation',
+        description: 'A belongs-to (forward FK) relation',
+        fields: () => ({
+            fieldName: { type: graphql_1.GraphQLString },
+            isUnique: { type: nn(graphql_1.GraphQLBoolean) },
+            type: { type: graphql_1.GraphQLString },
+            keys: { type: nnList(MetaFieldType) },
+            references: { type: nn(MetaRefTableType) },
+        }),
+    });
+    const MetaHasRelationType = new graphql_1.GraphQLObjectType({
+        name: 'MetaHasRelation',
+        description: 'A has-one or has-many (reverse FK) relation',
+        fields: () => ({
+            fieldName: { type: graphql_1.GraphQLString },
+            isUnique: { type: nn(graphql_1.GraphQLBoolean) },
+            type: { type: graphql_1.GraphQLString },
+            keys: { type: nnList(MetaFieldType) },
+            referencedBy: { type: nn(MetaRefTableType) },
+        }),
+    });
+    const MetaManyToManyRelationType = new graphql_1.GraphQLObjectType({
+        name: 'MetaManyToManyRelation',
+        description: 'A many-to-many relation via junction table',
+        fields: () => ({
+            fieldName: { type: graphql_1.GraphQLString },
+            type: { type: graphql_1.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 graphql_1.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 graphql_1.GraphQLObjectType({
+        name: 'MetaTable',
+        description: 'Information about a database table',
+        fields: () => ({
+            name: { type: nn(graphql_1.GraphQLString) },
+            schemaName: { type: nn(graphql_1.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 graphql_1.GraphQLObjectType({
+        name: 'MetaSchema',
+        description: 'Root meta schema type',
+        fields: () => ({
+            tables: { type: nnList(MetaTableType) },
+        }),
+    });
+}
+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/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/plugins/meta-schema/inflection-utils.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeInflection = safeInflection;
+exports.createAttributeInflector = createAttributeInflector;
+exports.fallbackTableType = fallbackTableType;
+function safeInflection(fn, fallback) {
+    try {
+        return fn() ?? fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+function createAttributeInflector(inflection) {
+    return (attrName, codec) => {
+        const attributeName = safeInflection(() => inflection._attributeName?.({ attributeName: attrName, codec }), attrName);
+        return safeInflection(() => inflection.camelCase?.(attributeName), attributeName);
+    };
+}
+function fallbackTableType(codecName) {
+    return codecName
+        .replace(/_/g, ' ')
+        .replace(/\b\w/g, (char) => char.toUpperCase())
+        .replace(/ /g, '');
+}

package/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/plugins/meta-schema/name-meta-builders.js

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

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

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

package/plugins/meta-schema/plugin.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetaSchemaPlugin = void 0;
+const cache_1 = require("./cache");
+const graphql_meta_field_1 = require("./graphql-meta-field");
+const table_meta_builder_1 = require("./table-meta-builder");
+exports.MetaSchemaPlugin = {
+    name: 'MetaSchemaPlugin',
+    version: '1.0.0',
+    description: 'Exposes _meta query for database schema introspection',
+    schema: {
+        hooks: {
+            init(input, rawBuild) {
+                const build = rawBuild;
+                (0, cache_1.setCachedTablesMeta)((0, table_meta_builder_1.collectTablesMeta)(build));
+                return input;
+            },
+            GraphQLObjectType_fields(rawFields, _rawBuild, rawContext) {
+                const context = rawContext;
+                if (context.Self?.name !== 'Query')
+                    return rawFields;
+                return (0, graphql_meta_field_1.extendQueryWithMetaField)(rawFields, (0, cache_1.getCachedTablesMeta)());
+            },
+        },
+    },
+};

package/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/plugins/meta-schema/relation-meta-builders.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBelongsToRelations = buildBelongsToRelations;
+exports.buildReverseRelations = buildReverseRelations;
+exports.buildManyToManyRelations = buildManyToManyRelations;
+const inflection_utils_1 = require("./inflection-utils");
+const constraint_meta_builders_1 = require("./constraint-meta-builders");
+const table_meta_context_1 = require("./table-meta-context");
+const table_resource_utils_1 = require("./table-resource-utils");
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+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) => (0, table_resource_utils_1.sameAttributes)(unique.attributes, localAttributes));
+        belongsTo.push({
+            fieldName: relationName,
+            isUnique,
+            type: relation.remoteResource?.codec?.name || null,
+            keys: (0, table_meta_context_1.buildFieldList)(localAttributes, codec, attributes, context),
+            references: { name: relation.remoteResource?.codec?.name || 'unknown' },
+        });
+    }
+    return belongsTo;
+}
+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 = (0, table_resource_utils_1.getUniques)(relation.remoteResource || {});
+        const remoteAttributes = relation.remoteAttributes || [];
+        const isUnique = remoteUniques.some((unique) => (0, table_resource_utils_1.sameAttributes)(unique.attributes, remoteAttributes));
+        const meta = {
+            fieldName: relationName,
+            isUnique,
+            type: relation.remoteResource?.codec?.name || null,
+            keys: (0, table_meta_context_1.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 = (0, table_resource_utils_1.getResourceCodec)(details.leftTable);
+    const junctionCodec = (0, table_resource_utils_1.getResourceCodec)(details.junctionTable);
+    const rightCodec = (0, table_resource_utils_1.getResourceCodec)(details.rightTable);
+    if (!leftCodec || !junctionCodec || !rightCodec)
+        return null;
+    const leftRelation = (0, table_resource_utils_1.getRelation)(details.leftTable, details.leftRelationName);
+    const junctionRightRelation = (0, table_resource_utils_1.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 = (0, inflection_utils_1.safeInflection)(() => context.build.inflection._manyToManyRelation?.(details), details.rightRelationName || rightCodec.name || null);
+    const junctionLeftConstraint = (0, constraint_meta_builders_1.buildForeignKeyConstraint)(details.leftRelationName || `${junctionCodec.name}_${leftCodec.name}_fkey`, junctionCodec, junctionCodec.attributes, leftJunctionAttributes, leftCodec, leftCodec.attributes, leftTableAttributes, context);
+    const junctionRightConstraint = (0, constraint_meta_builders_1.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: (0, table_meta_context_1.buildFieldList)(leftJunctionAttributes, junctionCodec, junctionCodec.attributes, context),
+        junctionRightConstraint,
+        junctionRightKeyAttributes: (0, table_meta_context_1.buildFieldList)(rightJunctionAttributes, junctionCodec, junctionCodec.attributes, context),
+        leftKeyAttributes: (0, table_meta_context_1.buildFieldList)(leftTableAttributes, leftCodec, leftCodec.attributes, context),
+        rightKeyAttributes: (0, table_meta_context_1.buildFieldList)(rightTableAttributes, rightCodec, rightCodec.attributes, context),
+        rightTable: { name: rightCodec.name || 'unknown' },
+    };
+}
+function buildManyToManyRelations(resource, codec, context) {
+    return getManyToManyRelationships(context.build, resource, codec)
+        .map((details) => buildManyToManyRelation(details, context))
+        .filter((relation) => relation !== null);
+}

package/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/plugins/meta-schema/table-meta-builder.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectTablesMeta = collectTablesMeta;
+const constraint_meta_builders_1 = require("./constraint-meta-builders");
+const name_meta_builders_1 = require("./name-meta-builders");
+const relation_meta_builders_1 = require("./relation-meta-builders");
+const type_mappings_1 = require("./type-mappings");
+const table_meta_context_1 = require("./table-meta-context");
+const table_resource_utils_1 = require("./table-resource-utils");
+function buildTableMeta(resource, schemaName, context) {
+    const codec = resource.codec;
+    const attributes = codec.attributes;
+    const uniques = (0, table_resource_utils_1.getUniques)(resource);
+    const relations = (0, table_resource_utils_1.getRelations)(resource);
+    const fields = Object.entries(attributes).map(([attrName, attr]) => (0, type_mappings_1.buildFieldMeta)(context.inflectAttr(attrName, codec), attr, context.build));
+    const indexes = (0, constraint_meta_builders_1.buildIndexes)(codec, attributes, uniques, context);
+    const primaryKey = (0, constraint_meta_builders_1.buildPrimaryKey)(codec, attributes, uniques, context);
+    const uniqueConstraints = (0, constraint_meta_builders_1.buildUniqueConstraints)(codec, attributes, uniques, context);
+    const foreignKeyConstraints = (0, constraint_meta_builders_1.buildForeignKeyConstraints)(codec, attributes, relations, context);
+    const constraints = {
+        primaryKey,
+        unique: uniqueConstraints,
+        foreignKey: foreignKeyConstraints,
+    };
+    const belongsTo = (0, relation_meta_builders_1.buildBelongsToRelations)(codec, attributes, uniques, relations, context);
+    const { hasOne, hasMany } = (0, relation_meta_builders_1.buildReverseRelations)(codec, attributes, relations, context);
+    const manyToMany = (0, relation_meta_builders_1.buildManyToManyRelations)(resource, codec, context);
+    const relationsMeta = {
+        belongsTo,
+        has: [...hasOne, ...hasMany],
+        hasOne,
+        hasMany,
+        manyToMany,
+    };
+    const tableType = (0, name_meta_builders_1.resolveTableType)(context.build, codec);
+    return {
+        name: tableType,
+        schemaName,
+        fields,
+        indexes,
+        constraints,
+        foreignKeyConstraints,
+        primaryKeyConstraints: primaryKey ? [primaryKey] : [],
+        uniqueConstraints,
+        relations: relationsMeta,
+        inflection: (0, name_meta_builders_1.buildInflectionMeta)(resource, tableType, context.build),
+        query: (0, name_meta_builders_1.buildQueryMeta)(resource, uniques, tableType, context.build),
+    };
+}
+function collectTablesMeta(build) {
+    const configuredSchemas = (0, table_resource_utils_1.getConfiguredSchemas)(build);
+    const context = (0, table_meta_context_1.createBuildContext)(build);
+    const seenCodecs = new Set();
+    const tablesMeta = [];
+    for (const resource of Object.values(build.input.pgRegistry.pgResources || {})) {
+        if (!(0, table_resource_utils_1.isTableResource)(resource))
+            continue;
+        const codec = resource.codec;
+        if (seenCodecs.has(codec))
+            continue;
+        seenCodecs.add(codec);
+        const schemaName = (0, table_resource_utils_1.getSchemaName)(resource);
+        if (!schemaName)
+            continue;
+        if (configuredSchemas.length > 0 &&
+            !configuredSchemas.includes(schemaName)) {
+            continue;
+        }
+        tablesMeta.push(buildTableMeta(resource, schemaName, context));
+    }
+    return tablesMeta;
+}

package/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/plugins/meta-schema/table-meta-context.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuildContext = createBuildContext;
+exports.buildFieldList = buildFieldList;
+const inflection_utils_1 = require("./inflection-utils");
+const type_mappings_1 = require("./type-mappings");
+function createBuildContext(build) {
+    return {
+        build,
+        inflectAttr: (0, inflection_utils_1.createAttributeInflector)(build.inflection),
+    };
+}
+function buildFieldList(attrNames, codec, attributes, context) {
+    return attrNames.map((attrName) => (0, type_mappings_1.buildFieldMeta)(context.inflectAttr(attrName, codec), attributes[attrName], context.build));
+}

package/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/plugins/meta-schema/table-resource-utils.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTableResource = isTableResource;
+exports.getSchemaName = getSchemaName;
+exports.getUniques = getUniques;
+exports.getRelations = getRelations;
+exports.getRelation = getRelation;
+exports.sameAttributes = sameAttributes;
+exports.getConfiguredSchemas = getConfiguredSchemas;
+exports.getResourceCodec = getResourceCodec;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isTableResource(resource) {
+    return (!!resource.codec &&
+        !resource.codec.isAnonymous &&
+        isRecord(resource.codec.attributes) &&
+        !resource.parameters &&
+        !resource.isVirtual &&
+        !resource.isUnique);
+}
+function getSchemaName(resource) {
+    const schemaName = resource.codec?.extensions?.pg?.schemaName;
+    if (typeof schemaName !== 'string' || schemaName.length === 0)
+        return null;
+    return schemaName;
+}
+function getUniques(resource) {
+    return Array.isArray(resource.uniques) ? resource.uniques : [];
+}
+function getRelations(resource) {
+    return resource.relations || resource.getRelations?.() || {};
+}
+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;
+}
+function sameAttributes(uniqueAttributes, relationAttributes) {
+    if (!uniqueAttributes || !relationAttributes)
+        return false;
+    return (uniqueAttributes.length === relationAttributes.length &&
+        uniqueAttributes.every((attrName) => relationAttributes.includes(attrName)));
+}
+function getConfiguredSchemas(build) {
+    const pgSchemas = build.options?.pgSchemas;
+    if (!Array.isArray(pgSchemas))
+        return [];
+    return pgSchemas.filter((schemaName) => typeof schemaName === 'string');
+}
+function getResourceCodec(resource) {
+    const codec = resource.codec;
+    if (!codec?.attributes)
+        return null;
+    return codec;
+}

package/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;