graphile-settings 6.5.2 → 6.5.3

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

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

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

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

@@ -1,100 +0,0 @@
-import { buildScalarEncoding } from './encoding-meta-builders';
-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 getGeometrySubtype(attr) {
-    const subtype = attr?.extensions?.geometrySubtype;
-    return typeof subtype === 'string' ? subtype : null;
-}
-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 extractEnumMeta(codec) {
-    if (!codec)
-        return null;
-    // Check the codec itself, or unwrap domain/array wrappers
-    const inner = codec.domainOfCodec ?? codec.arrayOfCodec ?? codec;
-    const values = inner.values;
-    if (!Array.isArray(values) || values.length === 0)
-        return null;
-    return {
-        name: inner.name || codec.name || 'unknown',
-        values: values.map((v) => (typeof v === 'string' ? v : v.value)),
-    };
-}
-export function buildFieldMeta(name, attr, build, options) {
-    const pgType = attr?.codec?.name || 'unknown';
-    const isNotNull = attr?.notNull || false;
-    const hasDefault = attr?.hasDefault || false;
-    const subtype = getGeometrySubtype(attr);
-    return {
-        name,
-        type: {
-            pgType,
-            gqlType: build ? resolveGqlTypeName(build, attr?.codec) : pgTypeToGqlType(pgType),
-            isArray: !!attr?.codec?.arrayOfCodec,
-            isNotNull,
-            hasDefault,
-            subtype,
-            encoding: buildScalarEncoding(attr),
-        },
-        isNotNull,
-        hasDefault,
-        isPrimaryKey: options?.isPrimaryKey ?? false,
-        isForeignKey: options?.isForeignKey ?? false,
-        description: attr?.description ?? null,
-        enumValues: extractEnumMeta(attr?.codec),
-    };
-}

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

@@ -1,325 +0,0 @@
-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;
-    storage: StorageMeta | null;
-    search: SearchMeta | null;
-    i18n: I18nMeta | null;
-    realtime: RealtimeMeta | null;
-    scope: ScopeMeta | null;
-}
-/** Coarse provisioning tier a table's scope belongs to. */
-export type ScopeTier = 'global' | 'database' | 'entity';
-export interface ScopeMeta {
-    /** The provisioning scope, e.g. 'platform', 'app', 'database', 'org', 'user' */
-    scope: string;
-    /** Coarse bucket: global (platform/app), database, or entity */
-    tier: ScopeTier;
-    /** Inflected scope key column (e.g. 'databaseId', 'orgId'), or null for global tiers */
-    keyColumn: string | null;
-    /** SQL name of the entity table for entity scopes, else null */
-    entityTable: string | null;
-    /** Provenance of the scope metadata. Always the @scope smart tag. */
-    source: 'smartTag';
-}
-export interface StorageMeta {
-    /** Whether this table is tagged as a storage files table */
-    isFilesTable: boolean;
-    /** Whether this table is tagged as a storage buckets table */
-    isBucketsTable: boolean;
-}
-export interface SearchColumnMeta {
-    /** Column name (camelCase inflected) */
-    name: string;
-    /** Search algorithm: 'tsvector', 'bm25', 'trgm', 'vector' */
-    algorithm: string;
-}
-export interface SearchMeta {
-    /** Which search algorithms are active on this table */
-    algorithms: string[];
-    /** Searchable columns with their algorithm */
-    columns: SearchColumnMeta[];
-    /** Whether unifiedSearch composite filter is available */
-    hasUnifiedSearch: boolean;
-    /** Per-table search config from @searchConfig smart tag */
-    config: SearchConfigMeta | null;
-}
-export interface SearchConfigMeta {
-    /** Per-adapter score weights */
-    weights: Record<string, number> | null;
-    /** Whether recency boosting is enabled */
-    boostRecent: boolean;
-    /** Field used for recency decay */
-    boostRecencyField: string | null;
-    /** Exponential decay factor per day */
-    boostRecencyDecay: number | null;
-}
-export interface I18nFieldMeta {
-    /** Inflected GraphQL field name */
-    name: string;
-    /** PostgreSQL column type (text, citext) */
-    type: string;
-}
-export interface I18nMeta {
-    /** Name of the translation table */
-    translationTable: string;
-    /** Fields that are translatable */
-    translatableFields: I18nFieldMeta[];
-}
-export interface RealtimeMeta {
-    /** The generated subscription field name (e.g. onPostChanged) */
-    subscriptionFieldName: string;
-}
-export interface EnumMeta {
-    /** The PostgreSQL enum type name */
-    name: string;
-    /** Allowed values for this enum */
-    values: string[];
-}
-export interface FieldMeta {
-    name: string;
-    type: TypeMeta;
-    isNotNull: boolean;
-    hasDefault: boolean;
-    isPrimaryKey: boolean;
-    isForeignKey: boolean;
-    description: string | null;
-    enumValues: EnumMeta | null;
-}
-export interface TypeMeta {
-    pgType: string;
-    gqlType: string;
-    isArray: boolean;
-    isNotNull?: boolean;
-    hasDefault?: boolean;
-    subtype?: string | null;
-    /**
-     * How the client must serialize/parse this scalar. `null` for plain scalars
-     * (String/Int/Float/Boolean/JSON/enum) whose wire format is obvious from
-     * `gqlType` — populated only for scalars introspection can't fully describe.
-     */
-    encoding?: ScalarEncodingMeta | null;
-}
-/** The machine kind a scalar marshals as on the client. */
-export type ScalarEncodingKind = 'bigint' | 'datetime' | 'date' | 'time' | 'interval' | 'uuid' | 'geojson' | 'point' | 'inet' | 'ltree' | 'vector' | 'bytea' | 'composite';
-export interface ScalarEncodingMeta {
-    /** Deterministic kind derived from the underlying (unwrapped) codec. */
-    kind: ScalarEncodingKind;
-    /** For 'vector': element scalar (e.g. 'float'), else null. */
-    elementType?: string | null;
-    /** For 'vector': declared length from typmod, else null. */
-    dimensions?: number | null;
-    /** For 'geojson': geometry subtype (Point/LineString/Polygon/…), else null. */
-    geometrySubtype?: string | null;
-    /** For 'geojson': spatial reference id, else null. */
-    srid?: number | null;
-    /** For 'ltree': values are dot-separated path strings ('a.b.c'). */
-    dotPath?: boolean;
-    /** For 'composite': nested attribute encodings. */
-    fields?: {
-        name: string;
-        type: TypeMeta;
-    }[] | null;
-}
-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;
-    domainOfCodec?: PgCodec | null;
-    isAnonymous?: boolean;
-    extensions?: {
-        pg?: {
-            schemaName?: string;
-        };
-    };
-}
-export interface PgAttributeExtensions extends Record<string, unknown> {
-    geometrySubtype?: string | null;
-    geometrySrid?: number | null;
-    vectorDimensions?: number | null;
-}
-export interface PgAttribute {
-    codec?: PgCodec | null;
-    notNull?: boolean;
-    hasDefault?: boolean;
-    description?: string | null;
-    extensions?: PgAttributeExtensions | null;
-}
-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>;
-}
-export interface PgCodecExtensions {
-    pg?: {
-        schemaName?: string;
-    };
-    tags?: Record<string, unknown>;
-}

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

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

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

@@ -1,4 +0,0 @@
-import type { TableMeta } from './types';
-export declare let cachedTablesMeta: TableMeta[];
-export declare function getCachedTablesMeta(): TableMeta[];
-export declare function setCachedTablesMeta(tablesMeta: TableMeta[]): void;

package/plugins/meta-schema/cache.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cachedTablesMeta = void 0;
-exports.getCachedTablesMeta = getCachedTablesMeta;
-exports.setCachedTablesMeta = setCachedTablesMeta;
-exports.cachedTablesMeta = [];
-function getCachedTablesMeta() {
-    return exports.cachedTablesMeta;
-}
-function setCachedTablesMeta(tablesMeta) {
-    exports.cachedTablesMeta = tablesMeta;
-}

package/plugins/meta-schema/constraint-meta-builders.d.ts

@@ -1,13 +0,0 @@
-import { type BuildContext } from './table-meta-context';
-import type { ForeignKeyConstraintMeta, PgAttribute, PgCodec, PgRelation, PgUnique, PrimaryKeyConstraintMeta, UniqueConstraintMeta } from './types';
-export declare function buildForeignKeyConstraint(constraintName: string, localCodec: PgCodec, localAttributes: Record<string, PgAttribute>, localAttributeNames: string[], remoteCodec: PgCodec | undefined, remoteAttributes: Record<string, PgAttribute>, remoteAttributeNames: string[], context: BuildContext): ForeignKeyConstraintMeta;
-export declare function buildIndexes(codec: PgCodec, attributes: Record<string, PgAttribute>, uniques: PgUnique[], context: BuildContext): {
-    name: string;
-    isUnique: boolean;
-    isPrimary: boolean;
-    columns: string[];
-    fields: import("./types").FieldMeta[];
-}[];
-export declare function buildPrimaryKey(codec: PgCodec, attributes: Record<string, PgAttribute>, uniques: PgUnique[], context: BuildContext): PrimaryKeyConstraintMeta | null;
-export declare function buildUniqueConstraints(codec: PgCodec, attributes: Record<string, PgAttribute>, uniques: PgUnique[], context: BuildContext): UniqueConstraintMeta[];
-export declare function buildForeignKeyConstraints(codec: PgCodec, attributes: Record<string, PgAttribute>, relations: Record<string, PgRelation>, context: BuildContext): ForeignKeyConstraintMeta[];

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

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildForeignKeyConstraint = buildForeignKeyConstraint;
-exports.buildIndexes = buildIndexes;
-exports.buildPrimaryKey = buildPrimaryKey;
-exports.buildUniqueConstraints = buildUniqueConstraints;
-exports.buildForeignKeyConstraints = buildForeignKeyConstraints;
-const type_mappings_1 = require("./type-mappings");
-const table_meta_context_1 = require("./table-meta-context");
-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: (0, table_meta_context_1.buildFieldList)(localAttributeNames, localCodec, localAttributes, context),
-        referencedTable,
-        referencedFields,
-        refFields: remoteAttributeNames.map((attrName) => (0, type_mappings_1.buildFieldMeta)(remoteCodec ? context.inflectAttr(attrName, remoteCodec) : attrName, remoteAttributes[attrName], context.build)),
-        refTable: { name: referencedTable },
-    };
-}
-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: (0, table_meta_context_1.buildFieldList)(unique.attributes, codec, attributes, context),
-    }));
-}
-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: (0, table_meta_context_1.buildFieldList)(primaryUnique.attributes, codec, attributes, context),
-    };
-}
-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: (0, table_meta_context_1.buildFieldList)(unique.attributes, codec, attributes, context),
-    }));
-}
-function buildForeignKeyConstraints(codec, attributes, relations, context) {
-    const constraints = [];
-    for (const [relationName, relation] of Object.entries(relations)) {
-        if (relation.isReferencee)
-            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/plugins/meta-schema/encoding-meta-builders.d.ts

@@ -1,2 +0,0 @@
-import type { PgAttribute, ScalarEncodingMeta } from './types';
-export declare function buildScalarEncoding(attr: PgAttribute | null | undefined): ScalarEncodingMeta | null;

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

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildScalarEncoding = buildScalarEncoding;
-/**
- * Scalar encoding contracts — the one piece of field metadata standard GraphQL
- * introspection can't provide.
- *
- * Introspection tells a client a field's scalar *name* (`GeoJSON`, `LTree`,
- * `Interval`, `BigInt`, `vector`, …) but not how to serialize/parse it or its
- * structural parameters (geometry subtype/SRID, vector dimensions, ltree
- * dot-path semantics). Without that, generated clients treat these as opaque
- * strings / `any` and mis-encode inputs or fail to parse outputs.
- *
- * `kind` is derived deterministically from the *underlying* codec (array and
- * domain wrappers unwrapped first, first match wins) so exactly one kind is
- * ever assigned and nothing can clobber it. Structural extras (subtype, SRID,
- * dimensions) are read verbatim from attribute extensions — never guessed, and
- * `null` when absent.
- */
-/** pg type name → encoding kind. Plain scalars are intentionally absent → null. */
-const KIND_BY_PG_TYPE = {
-    int8: 'bigint',
-    bigint: 'bigint',
-    numeric: 'bigint',
-    timestamptz: 'datetime',
-    timestamp: 'datetime',
-    date: 'date',
-    time: 'time',
-    timetz: 'time',
-    interval: 'interval',
-    uuid: 'uuid',
-    geometry: 'geojson',
-    geography: 'geojson',
-    point: 'point',
-    inet: 'inet',
-    cidr: 'inet',
-    ltree: 'ltree',
-    vector: 'vector',
-    bytea: 'bytea'
-};
-/** Unwrap array-of and domain-of wrappers to the underlying scalar/record codec. */
-function underlyingCodec(codec) {
-    let current = codec ?? null;
-    const seen = new Set();
-    while (current && !seen.has(current) && (current.arrayOfCodec || current.domainOfCodec)) {
-        seen.add(current);
-        current = current.arrayOfCodec || current.domainOfCodec || null;
-    }
-    return current;
-}
-/** True when a codec is a composite/record type (has named attributes). */
-function isCompositeCodec(codec) {
-    return !!codec?.attributes && Object.keys(codec.attributes).length > 0;
-}
-function buildScalarEncoding(attr) {
-    const codec = underlyingCodec(attr?.codec);
-    if (!codec)
-        return null;
-    const ext = attr?.extensions ?? undefined;
-    const kind = KIND_BY_PG_TYPE[codec.name];
-    if (!kind) {
-        // Composite/record types are the only non-mapped scalars worth describing;
-        // everything else (text, int, bool, json, enum, …) is fully covered by gqlType.
-        if (isCompositeCodec(codec)) {
-            return { kind: 'composite', fields: null };
-        }
-        return null;
-    }
-    switch (kind) {
-        case 'geojson':
-            return {
-                kind,
-                geometrySubtype: typeof ext?.geometrySubtype === 'string' ? ext.geometrySubtype : null,
-                srid: typeof ext?.geometrySrid === 'number' ? ext.geometrySrid : null
-            };
-        case 'vector':
-            return {
-                kind,
-                elementType: 'float',
-                dimensions: typeof ext?.vectorDimensions === 'number' ? ext.vectorDimensions : null
-            };
-        case 'ltree':
-            return { kind, dotPath: true };
-        default:
-            return { kind };
-    }
-}

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

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