graphile-settings 3.1.1 → 4.0.0

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;

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

@@ -0,0 +1,75 @@
+const PG_TO_GQL_TYPE = {
+    text: 'String',
+    varchar: 'String',
+    char: 'String',
+    name: 'String',
+    bpchar: 'String',
+    uuid: 'UUID',
+    int2: 'Int',
+    int4: 'Int',
+    integer: 'Int',
+    int8: 'BigInt',
+    bigint: 'BigInt',
+    float4: 'Float',
+    float8: 'Float',
+    numeric: 'BigFloat',
+    bool: 'Boolean',
+    boolean: 'Boolean',
+    timestamptz: 'Datetime',
+    timestamp: 'Datetime',
+    date: 'Date',
+    time: 'Time',
+    timetz: 'Time',
+    json: 'JSON',
+    jsonb: 'JSON',
+    interval: 'Interval',
+    point: 'Point',
+    geometry: 'GeoJSON',
+    geography: 'GeoJSON',
+    inet: 'InternetAddress',
+    cidr: 'InternetAddress',
+    xml: 'String',
+    bytea: 'String',
+    macaddr: 'String',
+};
+export function pgTypeToGqlType(pgTypeName) {
+    return PG_TO_GQL_TYPE[pgTypeName] || pgTypeName;
+}
+function resolveGqlTypeName(build, codec) {
+    if (!codec)
+        return 'unknown';
+    try {
+        const codecForLookup = codec.arrayOfCodec || codec;
+        if (build?.hasGraphQLTypeForPgCodec?.(codecForLookup, 'output')) {
+            const resolved = build.getGraphQLTypeNameByPgCodec?.(codecForLookup, 'output');
+            if (resolved)
+                return resolved;
+        }
+    }
+    catch {
+        // Fall through to static fallback mapping.
+    }
+    const pgTypeName = codec.name || 'unknown';
+    const mapped = pgTypeToGqlType(pgTypeName);
+    if (mapped !== pgTypeName)
+        return mapped;
+    const nestedTypeName = codec.arrayOfCodec?.name;
+    return nestedTypeName ? pgTypeToGqlType(nestedTypeName) : pgTypeName;
+}
+export function buildFieldMeta(name, attr, build) {
+    const pgType = attr?.codec?.name || 'unknown';
+    const isNotNull = attr?.notNull || false;
+    const hasDefault = attr?.hasDefault || false;
+    return {
+        name,
+        type: {
+            pgType,
+            gqlType: build ? resolveGqlTypeName(build, attr?.codec) : pgTypeToGqlType(pgType),
+            isArray: !!attr?.codec?.arrayOfCodec,
+            isNotNull,
+            hasDefault,
+        },
+        isNotNull,
+        hasDefault,
+    };
+}

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

@@ -0,0 +1,206 @@
+export interface TableMeta {
+    name: string;
+    schemaName: string;
+    fields: FieldMeta[];
+    indexes: IndexMeta[];
+    constraints: ConstraintsMeta;
+    foreignKeyConstraints: ForeignKeyConstraintMeta[];
+    primaryKeyConstraints: PrimaryKeyConstraintMeta[];
+    uniqueConstraints: UniqueConstraintMeta[];
+    relations: RelationsMeta;
+    inflection: InflectionMeta;
+    query: QueryMeta;
+}
+export interface FieldMeta {
+    name: string;
+    type: TypeMeta;
+    isNotNull: boolean;
+    hasDefault: boolean;
+}
+export interface TypeMeta {
+    pgType: string;
+    gqlType: string;
+    isArray: boolean;
+    isNotNull?: boolean;
+    hasDefault?: boolean;
+}
+export interface IndexMeta {
+    name: string;
+    isUnique: boolean;
+    isPrimary: boolean;
+    columns: string[];
+    fields: FieldMeta[];
+}
+export interface ConstraintsMeta {
+    primaryKey: PrimaryKeyConstraintMeta | null;
+    unique: UniqueConstraintMeta[];
+    foreignKey: ForeignKeyConstraintMeta[];
+}
+export interface PrimaryKeyConstraintMeta {
+    name: string;
+    fields: FieldMeta[];
+}
+export interface UniqueConstraintMeta {
+    name: string;
+    fields: FieldMeta[];
+}
+export interface ForeignKeyConstraintMeta {
+    name: string;
+    fields: FieldMeta[];
+    referencedTable: string;
+    referencedFields: string[];
+    refFields: FieldMeta[];
+    refTable: {
+        name: string;
+    };
+}
+export interface RelationsMeta {
+    belongsTo: BelongsToRelation[];
+    has: HasRelation[];
+    hasOne: HasRelation[];
+    hasMany: HasRelation[];
+    manyToMany: ManyToManyRelation[];
+}
+export interface BelongsToRelation {
+    fieldName: string | null;
+    isUnique: boolean;
+    type: string | null;
+    keys: FieldMeta[];
+    references: {
+        name: string;
+    };
+}
+export interface HasRelation {
+    fieldName: string | null;
+    isUnique: boolean;
+    type: string | null;
+    keys: FieldMeta[];
+    referencedBy: {
+        name: string;
+    };
+}
+export interface ManyToManyRelation {
+    fieldName: string | null;
+    type: string | null;
+    junctionTable: {
+        name: string;
+    };
+    junctionLeftConstraint: ForeignKeyConstraintMeta;
+    junctionLeftKeyAttributes: FieldMeta[];
+    junctionRightConstraint: ForeignKeyConstraintMeta;
+    junctionRightKeyAttributes: FieldMeta[];
+    leftKeyAttributes: FieldMeta[];
+    rightKeyAttributes: FieldMeta[];
+    rightTable: {
+        name: string;
+    };
+}
+export interface InflectionMeta {
+    tableType: string;
+    allRows: string;
+    connection: string;
+    edge: string;
+    filterType: string | null;
+    orderByType: string;
+    conditionType: string;
+    patchType: string | null;
+    createInputType: string;
+    createPayloadType: string;
+    updatePayloadType: string | null;
+    deletePayloadType: string;
+}
+export interface QueryMeta {
+    all: string;
+    one: string | null;
+    create: string | null;
+    update: string | null;
+    delete: string | null;
+}
+export interface PgCodec {
+    name: string;
+    attributes?: Record<string, PgAttribute>;
+    arrayOfCodec?: PgCodec | null;
+    isAnonymous?: boolean;
+    extensions?: {
+        pg?: {
+            schemaName?: string;
+        };
+    };
+}
+export interface PgAttribute {
+    codec?: PgCodec | null;
+    notNull?: boolean;
+    hasDefault?: boolean;
+}
+export interface PgUnique {
+    attributes: string[];
+    isPrimary?: boolean;
+    tags?: {
+        name?: string;
+    };
+}
+export interface PgRelation {
+    isReferencee?: boolean;
+    localAttributes?: string[];
+    remoteAttributes?: string[];
+    remoteResource?: PgTableResource | null;
+}
+export interface PgTableResource {
+    codec?: PgCodec;
+    uniques?: PgUnique[];
+    relations?: Record<string, PgRelation>;
+    parameters?: unknown;
+    isVirtual?: boolean;
+    isUnique?: boolean;
+    getRelation?: (relationName: string) => PgRelation | undefined;
+    getRelations?: () => Record<string, PgRelation>;
+}
+export interface PgManyToManyRelationDetails {
+    leftTable: PgTableResource;
+    leftRelationName: string;
+    junctionTable: PgTableResource;
+    rightRelationName: string;
+    rightTable: PgTableResource;
+    allowsMultipleEdgesToNode?: boolean;
+}
+export interface MetaInflection {
+    tableType: (codec: PgCodec) => string;
+    _attributeName?: (input: {
+        attributeName: string;
+        codec: PgCodec;
+    }) => string;
+    camelCase?: (value: string) => string;
+    _manyToManyRelation?: (details: PgManyToManyRelationDetails) => string | null | undefined;
+    allRows?: (resource: PgTableResource) => string | null | undefined;
+    connectionType?: (tableType: string) => string | null | undefined;
+    edgeType?: (tableType: string) => string | null | undefined;
+    filterType?: (tableType: string) => string | null | undefined;
+    orderByType?: (tableType: string) => string | null | undefined;
+    conditionType?: (tableType: string) => string | null | undefined;
+    patchType?: (tableType: string) => string | null | undefined;
+    createInputType?: (resource: PgTableResource) => string | null | undefined;
+    createPayloadType?: (resource: PgTableResource) => string | null | undefined;
+    updatePayloadType?: (resource: PgTableResource) => string | null | undefined;
+    deletePayloadType?: (resource: PgTableResource) => string | null | undefined;
+    tableFieldName?: (resource: PgTableResource) => string | null | undefined;
+    createField?: (resource: PgTableResource) => string | null | undefined;
+    updateByKeys?: (resource: PgTableResource) => string | null | undefined;
+    deleteByKeys?: (resource: PgTableResource) => string | null | undefined;
+}
+export interface GqlTypeResolverBuild {
+    hasGraphQLTypeForPgCodec?: (codec: PgCodec, mode?: 'output' | 'input' | string) => boolean;
+    getGraphQLTypeNameByPgCodec?: (codec: PgCodec, mode?: 'output' | 'input' | string) => string | null | undefined;
+}
+export interface MetaBuild extends GqlTypeResolverBuild {
+    input: {
+        pgRegistry: {
+            pgResources: Record<string, PgTableResource>;
+        };
+    };
+    inflection: MetaInflection;
+    options?: {
+        pgSchemas?: string[];
+        [key: string]: unknown;
+    };
+    pgManyToManyRealtionshipsByResource?: Map<unknown, unknown>;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,19 @@
+/**
+ * PostGraphile v5 Meta Schema Plugin
+ *
+ * Exposes a `_meta` GraphQL query that provides metadata about tables, fields,
+ * constraints, indexes, and relations for code generation tooling.
+ */
+import type { GraphileConfig } from 'graphile-config';
+import { cachedTablesMeta } from './meta-schema/cache';
+import { MetaSchemaPlugin } from './meta-schema/plugin';
+import { buildFieldMeta, pgTypeToGqlType } from './meta-schema/type-mappings';
+export { MetaSchemaPlugin };
+export declare const MetaSchemaPreset: GraphileConfig.Preset;
+/** @internal Exported for testing only */
+export { pgTypeToGqlType as _pgTypeToGqlType };
+/** @internal Exported for testing only */
+export { buildFieldMeta as _buildFieldMeta };
+/** @internal Exported for testing only */
+export { cachedTablesMeta as _cachedTablesMeta };
+export default MetaSchemaPlugin;