graphile-settings 4.1.0 → 4.3.0

package/plugins/meta-schema/inflection-utils.d.ts

@@ -1,4 +0,0 @@
-import type { MetaInflection, PgCodec } from './types';
-export declare function safeInflection<T>(fn: () => T, fallback: T): T;
-export declare function createAttributeInflector(inflection: MetaInflection): (attrName: string, codec: PgCodec) => string;
-export declare function fallbackTableType(codecName: string): string;

package/plugins/meta-schema/inflection-utils.js

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

@@ -1,4 +0,0 @@
-import type { InflectionMeta, MetaBuild, PgCodec, PgTableResource, PgUnique, QueryMeta } from './types';
-export declare function resolveTableType(build: MetaBuild, codec: PgCodec): string;
-export declare function buildInflectionMeta(resource: PgTableResource, tableType: string, build: MetaBuild): InflectionMeta;
-export declare function buildQueryMeta(resource: PgTableResource, uniques: PgUnique[], tableType: string, build: MetaBuild): QueryMeta;

package/plugins/meta-schema/name-meta-builders.js

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

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

package/plugins/meta-schema/plugin.js

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

@@ -1,8 +0,0 @@
-import { type BuildContext } from './table-meta-context';
-import type { BelongsToRelation, HasRelation, ManyToManyRelation, PgAttribute, PgCodec, PgRelation, PgTableResource, PgUnique } from './types';
-export declare function buildBelongsToRelations(codec: PgCodec, attributes: Record<string, PgAttribute>, uniques: PgUnique[], relations: Record<string, PgRelation>, context: BuildContext): BelongsToRelation[];
-export declare function buildReverseRelations(codec: PgCodec, attributes: Record<string, PgAttribute>, relations: Record<string, PgRelation>, context: BuildContext): {
-    hasOne: HasRelation[];
-    hasMany: HasRelation[];
-};
-export declare function buildManyToManyRelations(resource: PgTableResource, codec: PgCodec, context: BuildContext): ManyToManyRelation[];

package/plugins/meta-schema/relation-meta-builders.js

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

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

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

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

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

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

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

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

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

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

@@ -1,3 +0,0 @@
-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/plugins/meta-schema/type-mappings.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pgTypeToGqlType = pgTypeToGqlType;
-exports.buildFieldMeta = buildFieldMeta;
-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',
-};
-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;
-}
-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,
-    };
-}