@pgpmjs/export 0.20.0 → 0.20.2

package/graphql-client.d.ts

@@ -2,6 +2,7 @@
  * Simple GraphQL HTTP client with pagination and authentication support.
  * Used by the GraphQL export flow to fetch data from the Constructive GraphQL API.
  */
+import { GraphQLTypeInfo } from './graphql-naming';
 interface GraphQLClientOptions {
     endpoint: string;
     token?: string;
@@ -21,5 +22,13 @@ export declare class GraphQLClient {
      */
     fetchAllNodes<T = Record<string, unknown>>(queryFieldName: string, fieldsFragment: string, condition?: Record<string, unknown>, pageSize?: number, orderBy?: string): Promise<T[]>;
     private buildConnectionArgs;
+    /**
+     * Introspect a GraphQL type to discover its fields and their types.
+     * Used by the dynamic export flow to discover what fields are available
+     * instead of hardcoding them in META_TABLE_CONFIG.
+     *
+     * Returns a Map of camelCase field name → { typeName, list, nonNull }.
+     */
+    introspectType(typeName: string): Promise<Map<string, GraphQLTypeInfo>>;
 }
 export {};

package/graphql-client.js

@@ -5,6 +5,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphQLClient = void 0;
+const graphql_naming_1 = require("./graphql-naming");
 class GraphQLClient {
     endpoint;
     defaultHeaders;
@@ -139,5 +140,47 @@ class GraphQLClient {
         }
         return parts.length > 0 ? `(${parts.join(', ')})` : '';
     }
+    /**
+     * Introspect a GraphQL type to discover its fields and their types.
+     * Used by the dynamic export flow to discover what fields are available
+     * instead of hardcoding them in META_TABLE_CONFIG.
+     *
+     * Returns a Map of camelCase field name → { typeName, list, nonNull }.
+     */
+    async introspectType(typeName) {
+        const result = await this.query(`
+      query IntrospectType($typeName: String!) {
+        __type(name: $typeName) {
+          fields {
+            name
+            type {
+              name
+              kind
+              ofType {
+                name
+                kind
+                ofType {
+                  name
+                  kind
+                  ofType {
+                    name
+                    kind
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    `, { typeName });
+        const fields = new Map();
+        if (result.__type?.fields) {
+            for (const field of result.__type.fields) {
+                const typeInfo = (0, graphql_naming_1.unwrapGraphQLType)(field.type);
+                fields.set(field.name, typeInfo);
+            }
+        }
+        return fields;
+    }
 }
 exports.GraphQLClient = GraphQLClient;

package/graphql-naming.d.ts

@@ -1,3 +1,4 @@
+import { FieldType } from './export-utils';
 /**
  * Get the GraphQL query field name for a given Postgres table name.
  * Mirrors the PostGraphile InflektPlugin's allRowsConnection inflector:
@@ -10,11 +11,7 @@ export declare const getGraphQLQueryName: (pgTableName: string) => string;
  * Only transforms top-level keys — nested objects (e.g. JSONB values) are left intact.
  */
 export declare const graphqlRowToPostgresRow: (row: Record<string, unknown>) => Record<string, unknown>;
-/**
- * Convert a PostgreSQL interval object (from GraphQL Interval type) back to a Postgres interval string.
- * e.g. { years: 0, months: 0, days: 0, hours: 1, minutes: 30, seconds: 0 } -> '1 hour 30 minutes'
- */
-export declare const intervalToPostgres: (interval: Record<string, number | null> | null) => string | null;
+export { intervalToPostgres } from './interval-utils';
 /**
  * Convert an array of Postgres field names (with optional type hints) to a GraphQL fields fragment.
  * Handles composite types like 'interval' by expanding them into subfield selections.
@@ -22,3 +19,39 @@ export declare const intervalToPostgres: (interval: Record<string, number | null
  *   'id\nsessionsDefaultExpiration { seconds minutes hours days months years }'
  */
 export declare const buildFieldsFragment: (pgFieldNames: string[], fieldTypes?: Record<string, string>) => string;
+/**
+ * Represents the unwrapped type info from a GraphQL introspection field.
+ * PostGraphile wraps types in NON_NULL and LIST layers via nested `ofType`.
+ */
+export interface GraphQLTypeInfo {
+    /** The leaf/nullable type name (e.g. "UUID", "String", "Interval") */
+    typeName: string;
+    /** The leaf type kind (e.g. "SCALAR", "OBJECT", "ENUM") */
+    kind: string;
+    /** Whether the outermost wrapper is NON_NULL */
+    nonNull: boolean;
+    /** Whether the type is a list */
+    list: boolean;
+}
+/**
+ * Unwrap a GraphQL introspection type reference into its leaf type name and list status.
+ * PostGraphile wraps types like: { kind: NON_NULL, name: null, ofType: { kind: LIST, name: null, ofType: { kind: SCALAR, name: "UUID" } } }
+ * This function recursively unwraps ofType layers, detecting LIST wrappers via the `kind` field.
+ */
+export declare const unwrapGraphQLType: (typeRef: {
+    name: string | null;
+    kind?: string;
+    ofType?: any;
+} | null, parentKind?: string) => GraphQLTypeInfo;
+/**
+ * Map GraphQL scalar/type names to FieldType values.
+ * Delegates to the canonical PG_TYPE_MAP in type-map.ts.
+ */
+export declare const mapGraphQLTypeToFieldType: (gqlTypeName: string, isList?: boolean) => FieldType;
+/**
+ * Derive the GraphQL type name (PascalCase singular) from a PostgreSQL table name.
+ * Mirrors PostGraphile's InflektPlugin type inflector:
+ *   singularizeLast(toPascalCase(pgTableName))
+ * e.g. "user_auth_module" → "UserAuthModule"
+ */
+export declare const getGraphQLTypeName: (pgTableName: string) => string;

package/graphql-naming.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildFieldsFragment = exports.intervalToPostgres = exports.graphqlRowToPostgresRow = exports.getGraphQLQueryName = void 0;
+exports.getGraphQLTypeName = exports.mapGraphQLTypeToFieldType = exports.unwrapGraphQLType = exports.buildFieldsFragment = exports.intervalToPostgres = exports.graphqlRowToPostgresRow = exports.getGraphQLQueryName = void 0;
 /**
  * Helpers for mapping between PostgreSQL names and PostGraphile GraphQL names.
  *
@@ -17,6 +17,7 @@ exports.buildFieldsFragment = exports.intervalToPostgres = exports.graphqlRowToP
  *   column database_id -> databaseId
  */
 const inflekt_1 = require("inflekt");
+const type_map_1 = require("./type-map");
 /**
  * Get the GraphQL query field name for a given Postgres table name.
  * Mirrors the PostGraphile InflektPlugin's allRowsConnection inflector:
@@ -41,29 +42,8 @@ const graphqlRowToPostgresRow = (row) => {
     return result;
 };
 exports.graphqlRowToPostgresRow = graphqlRowToPostgresRow;
-/**
- * Convert a PostgreSQL interval object (from GraphQL Interval type) back to a Postgres interval string.
- * e.g. { years: 0, months: 0, days: 0, hours: 1, minutes: 30, seconds: 0 } -> '1 hour 30 minutes'
- */
-const intervalToPostgres = (interval) => {
-    if (!interval)
-        return null;
-    const parts = [];
-    if (interval.years)
-        parts.push(`${interval.years} year${interval.years !== 1 ? 's' : ''}`);
-    if (interval.months)
-        parts.push(`${interval.months} mon${interval.months !== 1 ? 's' : ''}`);
-    if (interval.days)
-        parts.push(`${interval.days} day${interval.days !== 1 ? 's' : ''}`);
-    if (interval.hours)
-        parts.push(`${interval.hours}:${String(interval.minutes ?? 0).padStart(2, '0')}:${String(interval.seconds ?? 0).padStart(2, '0')}`);
-    else if (interval.minutes)
-        parts.push(`00:${String(interval.minutes).padStart(2, '0')}:${String(interval.seconds ?? 0).padStart(2, '0')}`);
-    else if (interval.seconds)
-        parts.push(`00:00:${String(interval.seconds).padStart(2, '0')}`);
-    return parts.length > 0 ? parts.join(' ') : '00:00:00';
-};
-exports.intervalToPostgres = intervalToPostgres;
+var interval_utils_1 = require("./interval-utils");
+Object.defineProperty(exports, "intervalToPostgres", { enumerable: true, get: function () { return interval_utils_1.intervalToPostgres; } });
 /**
  * Convert an array of Postgres field names (with optional type hints) to a GraphQL fields fragment.
  * Handles composite types like 'interval' by expanding them into subfield selections.
@@ -81,3 +61,57 @@ const buildFieldsFragment = (pgFieldNames, fieldTypes) => {
     }).join('\n      ');
 };
 exports.buildFieldsFragment = buildFieldsFragment;
+/**
+ * Unwrap a GraphQL introspection type reference into its leaf type name and list status.
+ * PostGraphile wraps types like: { kind: NON_NULL, name: null, ofType: { kind: LIST, name: null, ofType: { kind: SCALAR, name: "UUID" } } }
+ * This function recursively unwraps ofType layers, detecting LIST wrappers via the `kind` field.
+ */
+const unwrapGraphQLType = (typeRef, parentKind) => {
+    if (!typeRef)
+        return { typeName: 'Unknown', kind: 'UNKNOWN', nonNull: false, list: false };
+    // If the type has a name, it's the leaf type
+    if (typeRef.name) {
+        const isList = parentKind === 'LIST';
+        return { typeName: typeRef.name, kind: typeRef.kind ?? 'UNKNOWN', nonNull: parentKind === 'NON_NULL', list: isList };
+    }
+    // If it has ofType, it's a wrapper (NON_NULL or LIST)
+    if (typeRef.ofType) {
+        return (0, exports.unwrapGraphQLType)(typeRef.ofType, typeRef.kind ?? undefined);
+    }
+    return { typeName: 'Unknown', kind: 'UNKNOWN', nonNull: false, list: false };
+};
+exports.unwrapGraphQLType = unwrapGraphQLType;
+/**
+ * Map GraphQL scalar/type names to FieldType values.
+ * Delegates to the canonical PG_TYPE_MAP in type-map.ts.
+ */
+const mapGraphQLTypeToFieldType = (gqlTypeName, isList = false) => {
+    // Handle list types — map to the array variants that exist in FieldType
+    if (isList) {
+        const inner = (0, exports.mapGraphQLTypeToFieldType)(gqlTypeName, false);
+        // Only these array types exist in FieldType: uuid[], text[], jsonb[]
+        switch (inner) {
+            case 'uuid': return 'uuid[]';
+            case 'text': return 'text[]';
+            case 'jsonb': return 'jsonb[]';
+            default: return 'text'; // safe fallback for unsupported array types
+        }
+    }
+    // ID is a GraphQL-only type (relay-style) that maps to uuid;
+    // it has no direct PG udt_name counterpart in PG_TYPE_MAP.
+    if (gqlTypeName === 'ID')
+        return 'uuid';
+    const entry = (0, type_map_1.lookupByGqlType)(gqlTypeName);
+    return entry?.fieldType ?? 'text';
+};
+exports.mapGraphQLTypeToFieldType = mapGraphQLTypeToFieldType;
+/**
+ * Derive the GraphQL type name (PascalCase singular) from a PostgreSQL table name.
+ * Mirrors PostGraphile's InflektPlugin type inflector:
+ *   singularizeLast(toPascalCase(pgTableName))
+ * e.g. "user_auth_module" → "UserAuthModule"
+ */
+const getGraphQLTypeName = (pgTableName) => {
+    return (0, inflekt_1.singularizeLast)((0, inflekt_1.toPascalCase)(pgTableName));
+};
+exports.getGraphQLTypeName = getGraphQLTypeName;

package/index.d.ts

@@ -3,6 +3,8 @@ export * from './export-migrations';
 export * from './export-graphql';
 export * from './export-graphql-meta';
 export { GraphQLClient } from './graphql-client';
-export { getGraphQLQueryName, graphqlRowToPostgresRow, buildFieldsFragment, intervalToPostgres } from './graphql-naming';
-export { DB_REQUIRED_EXTENSIONS, SERVICE_REQUIRED_EXTENSIONS, META_COMMON_HEADER, META_COMMON_FOOTER, META_TABLE_ORDER, META_TABLE_CONFIG, makeReplacer, preparePackage, normalizeOutdir, detectMissingModules, installMissingModules } from './export-utils';
+export { getGraphQLQueryName, getGraphQLTypeName, graphqlRowToPostgresRow, buildFieldsFragment, mapGraphQLTypeToFieldType, unwrapGraphQLType, GraphQLTypeInfo } from './graphql-naming';
+export { DB_REQUIRED_EXTENSIONS, SERVICE_REQUIRED_EXTENSIONS, META_COMMON_HEADER, META_COMMON_FOOTER, META_TABLE_ORDER, META_TABLE_CONFIG, mapPgTypeToFieldType, makeReplacer, preparePackage, normalizeOutdir, detectMissingModules, installMissingModules } from './export-utils';
 export type { FieldType, TableConfig, Schema, MakeReplacerOptions, ReplacerResult, PreparePackageOptions, MissingModulesResult } from './export-utils';
+export { PG_TYPE_MAP, TypeMapEntry, lookupByPgUdt, lookupByGqlType } from './type-map';
+export { intervalToPostgres, parsePgInterval, PgInterval } from './interval-utils';

package/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.installMissingModules = exports.detectMissingModules = exports.normalizeOutdir = exports.preparePackage = exports.makeReplacer = exports.META_TABLE_CONFIG = exports.META_TABLE_ORDER = exports.META_COMMON_FOOTER = exports.META_COMMON_HEADER = exports.SERVICE_REQUIRED_EXTENSIONS = exports.DB_REQUIRED_EXTENSIONS = exports.intervalToPostgres = exports.buildFieldsFragment = exports.graphqlRowToPostgresRow = exports.getGraphQLQueryName = exports.GraphQLClient = void 0;
+exports.parsePgInterval = exports.intervalToPostgres = exports.lookupByGqlType = exports.lookupByPgUdt = exports.PG_TYPE_MAP = exports.installMissingModules = exports.detectMissingModules = exports.normalizeOutdir = exports.preparePackage = exports.makeReplacer = exports.mapPgTypeToFieldType = exports.META_TABLE_CONFIG = exports.META_TABLE_ORDER = exports.META_COMMON_FOOTER = exports.META_COMMON_HEADER = exports.SERVICE_REQUIRED_EXTENSIONS = exports.DB_REQUIRED_EXTENSIONS = exports.unwrapGraphQLType = exports.mapGraphQLTypeToFieldType = exports.buildFieldsFragment = exports.graphqlRowToPostgresRow = exports.getGraphQLTypeName = exports.getGraphQLQueryName = exports.GraphQLClient = void 0;
 __exportStar(require("./export-meta"), exports);
 __exportStar(require("./export-migrations"), exports);
 __exportStar(require("./export-graphql"), exports);
@@ -23,9 +23,11 @@ var graphql_client_1 = require("./graphql-client");
 Object.defineProperty(exports, "GraphQLClient", { enumerable: true, get: function () { return graphql_client_1.GraphQLClient; } });
 var graphql_naming_1 = require("./graphql-naming");
 Object.defineProperty(exports, "getGraphQLQueryName", { enumerable: true, get: function () { return graphql_naming_1.getGraphQLQueryName; } });
+Object.defineProperty(exports, "getGraphQLTypeName", { enumerable: true, get: function () { return graphql_naming_1.getGraphQLTypeName; } });
 Object.defineProperty(exports, "graphqlRowToPostgresRow", { enumerable: true, get: function () { return graphql_naming_1.graphqlRowToPostgresRow; } });
 Object.defineProperty(exports, "buildFieldsFragment", { enumerable: true, get: function () { return graphql_naming_1.buildFieldsFragment; } });
-Object.defineProperty(exports, "intervalToPostgres", { enumerable: true, get: function () { return graphql_naming_1.intervalToPostgres; } });
+Object.defineProperty(exports, "mapGraphQLTypeToFieldType", { enumerable: true, get: function () { return graphql_naming_1.mapGraphQLTypeToFieldType; } });
+Object.defineProperty(exports, "unwrapGraphQLType", { enumerable: true, get: function () { return graphql_naming_1.unwrapGraphQLType; } });
 var export_utils_1 = require("./export-utils");
 Object.defineProperty(exports, "DB_REQUIRED_EXTENSIONS", { enumerable: true, get: function () { return export_utils_1.DB_REQUIRED_EXTENSIONS; } });
 Object.defineProperty(exports, "SERVICE_REQUIRED_EXTENSIONS", { enumerable: true, get: function () { return export_utils_1.SERVICE_REQUIRED_EXTENSIONS; } });
@@ -33,8 +35,16 @@ Object.defineProperty(exports, "META_COMMON_HEADER", { enumerable: true, get: fu
 Object.defineProperty(exports, "META_COMMON_FOOTER", { enumerable: true, get: function () { return export_utils_1.META_COMMON_FOOTER; } });
 Object.defineProperty(exports, "META_TABLE_ORDER", { enumerable: true, get: function () { return export_utils_1.META_TABLE_ORDER; } });
 Object.defineProperty(exports, "META_TABLE_CONFIG", { enumerable: true, get: function () { return export_utils_1.META_TABLE_CONFIG; } });
+Object.defineProperty(exports, "mapPgTypeToFieldType", { enumerable: true, get: function () { return export_utils_1.mapPgTypeToFieldType; } });
 Object.defineProperty(exports, "makeReplacer", { enumerable: true, get: function () { return export_utils_1.makeReplacer; } });
 Object.defineProperty(exports, "preparePackage", { enumerable: true, get: function () { return export_utils_1.preparePackage; } });
 Object.defineProperty(exports, "normalizeOutdir", { enumerable: true, get: function () { return export_utils_1.normalizeOutdir; } });
 Object.defineProperty(exports, "detectMissingModules", { enumerable: true, get: function () { return export_utils_1.detectMissingModules; } });
 Object.defineProperty(exports, "installMissingModules", { enumerable: true, get: function () { return export_utils_1.installMissingModules; } });
+var type_map_1 = require("./type-map");
+Object.defineProperty(exports, "PG_TYPE_MAP", { enumerable: true, get: function () { return type_map_1.PG_TYPE_MAP; } });
+Object.defineProperty(exports, "lookupByPgUdt", { enumerable: true, get: function () { return type_map_1.lookupByPgUdt; } });
+Object.defineProperty(exports, "lookupByGqlType", { enumerable: true, get: function () { return type_map_1.lookupByGqlType; } });
+var interval_utils_1 = require("./interval-utils");
+Object.defineProperty(exports, "intervalToPostgres", { enumerable: true, get: function () { return interval_utils_1.intervalToPostgres; } });
+Object.defineProperty(exports, "parsePgInterval", { enumerable: true, get: function () { return interval_utils_1.parsePgInterval; } });

package/interval-utils.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Interval conversion utilities shared between graphql-naming.ts and tests.
+ *
+ * NOTE: @pgpmjs/csv-to-pg has its own formatInterval() in parse.ts which
+ * performs the same object→string conversion. That is a separate package with
+ * its own release cycle, so we do not cross-reference it here. If interval
+ * handling needs to be unified across packages, that would require an
+ * architectural change (shared dependency or monorepo util package).
+ */
+/** Shape of a PostGraphile Interval object (OBJECT type in introspection). */
+export interface PgInterval {
+    years: number | null;
+    months: number | null;
+    days: number | null;
+    hours: number | null;
+    minutes: number | null;
+    seconds: number | null;
+}
+/**
+ * Convert a PostgreSQL interval object (from GraphQL Interval type) back to a
+ * Postgres interval string.
+ * e.g. { years: 0, months: 0, days: 0, hours: 1, minutes: 30, seconds: 0 } → '1:30:00'
+ */
+export declare const intervalToPostgres: (interval: Record<string, number | null> | null) => string | null;
+/**
+ * Parse a PostgreSQL interval string into the object shape that PostGraphile's
+ * Interval type returns: { years, months, days, hours, minutes, seconds }.
+ *
+ * Handles formats like:
+ *   '30 days' → { years: 0, months: 0, days: 30, hours: 0, minutes: 0, seconds: 0 }
+ *   '1:30:00'  → { years: 0, months: 0, days: 0, hours: 1, minutes: 30, seconds: 0 }
+ */
+export declare const parsePgInterval: (value: string) => Record<string, number>;

package/interval-utils.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Interval conversion utilities shared between graphql-naming.ts and tests.
+ *
+ * NOTE: @pgpmjs/csv-to-pg has its own formatInterval() in parse.ts which
+ * performs the same object→string conversion. That is a separate package with
+ * its own release cycle, so we do not cross-reference it here. If interval
+ * handling needs to be unified across packages, that would require an
+ * architectural change (shared dependency or monorepo util package).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePgInterval = exports.intervalToPostgres = void 0;
+/**
+ * Convert a PostgreSQL interval object (from GraphQL Interval type) back to a
+ * Postgres interval string.
+ * e.g. { years: 0, months: 0, days: 0, hours: 1, minutes: 30, seconds: 0 } → '1:30:00'
+ */
+const intervalToPostgres = (interval) => {
+    if (!interval)
+        return null;
+    const parts = [];
+    if (interval.years)
+        parts.push(`${interval.years} year${interval.years !== 1 ? 's' : ''}`);
+    if (interval.months)
+        parts.push(`${interval.months} mon${interval.months !== 1 ? 's' : ''}`);
+    if (interval.days)
+        parts.push(`${interval.days} day${interval.days !== 1 ? 's' : ''}`);
+    if (interval.hours)
+        parts.push(`${interval.hours}:${String(interval.minutes ?? 0).padStart(2, '0')}:${String(interval.seconds ?? 0).padStart(2, '0')}`);
+    else if (interval.minutes)
+        parts.push(`00:${String(interval.minutes).padStart(2, '0')}:${String(interval.seconds ?? 0).padStart(2, '0')}`);
+    else if (interval.seconds)
+        parts.push(`00:00:${String(interval.seconds).padStart(2, '0')}`);
+    return parts.length > 0 ? parts.join(' ') : '00:00:00';
+};
+exports.intervalToPostgres = intervalToPostgres;
+/**
+ * Parse a PostgreSQL interval string into the object shape that PostGraphile's
+ * Interval type returns: { years, months, days, hours, minutes, seconds }.
+ *
+ * Handles formats like:
+ *   '30 days' → { years: 0, months: 0, days: 30, hours: 0, minutes: 0, seconds: 0 }
+ *   '1:30:00'  → { years: 0, months: 0, days: 0, hours: 1, minutes: 30, seconds: 0 }
+ */
+const parsePgInterval = (value) => {
+    const result = { years: 0, months: 0, days: 0, hours: 0, minutes: 0, seconds: 0 };
+    // Try HH:MM:SS format
+    const timeMatch = value.match(/^(\d+):(\d+):(\d+)/);
+    if (timeMatch) {
+        result.hours = parseInt(timeMatch[1], 10);
+        result.minutes = parseInt(timeMatch[2], 10);
+        result.seconds = parseInt(timeMatch[3], 10);
+        return result;
+    }
+    // Try descriptive format: 'N unit N unit ...'
+    const parts = value.trim().split(/\s+/);
+    for (let i = 0; i < parts.length - 1; i += 2) {
+        const num = parseInt(parts[i], 10);
+        const unit = parts[i + 1].toLowerCase();
+        if (unit.startsWith('year'))
+            result.years = num;
+        else if (unit.startsWith('mon'))
+            result.months = num;
+        else if (unit.startsWith('day'))
+            result.days = num;
+        else if (unit.startsWith('hour'))
+            result.hours = num;
+        else if (unit.startsWith('minute'))
+            result.minutes = num;
+        else if (unit.startsWith('second'))
+            result.seconds = num;
+    }
+    return result;
+};
+exports.parsePgInterval = parsePgInterval;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgpmjs/export",
-  "version": "0.20.0",
+  "version": "0.20.2",
   "author": "Constructive <developers@constructive.io>",
   "description": "PGPM export tools for SQL and GraphQL database migration extraction",
   "main": "index.js",
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@pgpmjs/core": "^6.21.0",
-    "@pgpmjs/migrate-client": "^0.15.0",
+    "@pgpmjs/migrate-client": "^0.15.1",
     "@pgpmjs/types": "^2.29.0",
     "csv-to-pg": "^3.18.0",
     "glob": "^13.0.6",
@@ -55,5 +55,5 @@
     "pg-cache": "^3.12.0",
     "pg-env": "^1.16.0"
   },
-  "gitHead": "0503916f414a3b8a6f6cbe46e03a59988b2f3cb5"
+  "gitHead": "8a39d7f293a1128aed84a3bc6a7a79c32d27759d"
 }

package/type-map.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Single-source type mapping between PostgreSQL, PostGraphile GraphQL, and FieldType.
+ *
+ * This is the canonical mapping table. All other mappers and tests derive from it:
+ * - `mapPgTypeToFieldType` in export-utils.ts
+ * - `mapGraphQLTypeToFieldType` in graphql-naming.ts
+ * - `pgUdtToGraphQLType` / `pgUdtToGraphQLKind` in cross-flow-parity test
+ * - parity table in dynamic-fields test
+ *
+ * When a new type needs to be supported, add it here and all consumers update automatically.
+ */
+import { FieldType } from './export-utils';
+export interface TypeMapEntry {
+    /** PostgreSQL udt_name values from information_schema (e.g. ['int4', 'int2']) */
+    pgUdtNames: string[];
+    /** PostGraphile v5 GraphQL type name (e.g. 'Int', 'BigInt', 'Datetime') */
+    gqlTypeName: string;
+    /** FieldType used by csv-to-pg Parser (e.g. 'int', 'timestamptz') */
+    fieldType: FieldType;
+    /** GraphQL kind that PostGraphile reports via introspection */
+    gqlKind: 'SCALAR' | 'OBJECT' | 'ENUM';
+    /** Whether this is a PostgreSQL array type (e.g. _uuid, _text, _jsonb) */
+    isArray?: boolean;
+}
+/**
+ * Canonical PG → GraphQL → FieldType mapping table.
+ * Aligned with PostGraphile v5's PgCodecsPlugin type assignments:
+ *   - int2, int4 → Int
+ *   - int8 (bigint) → BigInt
+ *   - numeric → BigFloat
+ *   - float4, float8 → Float
+ *   - interval → Interval (OBJECT kind, not SCALAR)
+ *   - timestamptz, timestamp → Datetime
+ */
+export declare const PG_TYPE_MAP: TypeMapEntry[];
+/**
+ * Look up a TypeMapEntry by PostgreSQL udt_name.
+ * Returns undefined for unknown types (callers should fall back to 'text').
+ */
+export declare const lookupByPgUdt: (udtName: string) => TypeMapEntry | undefined;
+/**
+ * Look up a TypeMapEntry by GraphQL type name.
+ * Returns undefined for unknown types (callers should fall back to 'text').
+ */
+export declare const lookupByGqlType: (gqlTypeName: string) => TypeMapEntry | undefined;

package/type-map.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookupByGqlType = exports.lookupByPgUdt = exports.PG_TYPE_MAP = void 0;
+/**
+ * Canonical PG → GraphQL → FieldType mapping table.
+ * Aligned with PostGraphile v5's PgCodecsPlugin type assignments:
+ *   - int2, int4 → Int
+ *   - int8 (bigint) → BigInt
+ *   - numeric → BigFloat
+ *   - float4, float8 → Float
+ *   - interval → Interval (OBJECT kind, not SCALAR)
+ *   - timestamptz, timestamp → Datetime
+ */
+exports.PG_TYPE_MAP = [
+    { pgUdtNames: ['uuid'], gqlTypeName: 'UUID', fieldType: 'uuid', gqlKind: 'SCALAR' },
+    { pgUdtNames: ['_uuid'], gqlTypeName: 'UUID', fieldType: 'uuid[]', gqlKind: 'SCALAR', isArray: true },
+    { pgUdtNames: ['text', 'varchar', 'bpchar', 'name', 'citext'], gqlTypeName: 'String', fieldType: 'text', gqlKind: 'SCALAR' },
+    { pgUdtNames: ['_text', '_varchar', '_citext'], gqlTypeName: 'String', fieldType: 'text[]', gqlKind: 'SCALAR', isArray: true },
+    { pgUdtNames: ['bool'], gqlTypeName: 'Boolean', fieldType: 'boolean', gqlKind: 'SCALAR' },
+    { pgUdtNames: ['jsonb', 'json'], gqlTypeName: 'JSON', fieldType: 'jsonb', gqlKind: 'SCALAR' },
+    { pgUdtNames: ['_jsonb'], gqlTypeName: 'JSON', fieldType: 'jsonb[]', gqlKind: 'SCALAR', isArray: true },
+    { pgUdtNames: ['int2', 'int4'], gqlTypeName: 'Int', fieldType: 'int', gqlKind: 'SCALAR' },
+    { pgUdtNames: ['int8'], gqlTypeName: 'BigInt', fieldType: 'int', gqlKind: 'SCALAR' },
+    { pgUdtNames: ['numeric'], gqlTypeName: 'BigFloat', fieldType: 'int', gqlKind: 'SCALAR' },
+    { pgUdtNames: ['float4', 'float8'], gqlTypeName: 'Float', fieldType: 'int', gqlKind: 'SCALAR' },
+    { pgUdtNames: ['interval'], gqlTypeName: 'Interval', fieldType: 'interval', gqlKind: 'OBJECT' },
+    { pgUdtNames: ['timestamptz', 'timestamp'], gqlTypeName: 'Datetime', fieldType: 'timestamptz', gqlKind: 'SCALAR' },
+];
+// =============================================================================
+// Lookup indices (built once at module load)
+// =============================================================================
+/** Reverse index: pgUdtName → TypeMapEntry */
+const pgUdtIndex = new Map();
+for (const entry of exports.PG_TYPE_MAP) {
+    for (const udt of entry.pgUdtNames) {
+        pgUdtIndex.set(udt, entry);
+    }
+}
+/** Reverse index: gqlTypeName → TypeMapEntry (first match wins) */
+const gqlTypeIndex = new Map();
+for (const entry of exports.PG_TYPE_MAP) {
+    if (!gqlTypeIndex.has(entry.gqlTypeName)) {
+        gqlTypeIndex.set(entry.gqlTypeName, entry);
+    }
+}
+/**
+ * Look up a TypeMapEntry by PostgreSQL udt_name.
+ * Returns undefined for unknown types (callers should fall back to 'text').
+ */
+const lookupByPgUdt = (udtName) => pgUdtIndex.get(udtName);
+exports.lookupByPgUdt = lookupByPgUdt;
+/**
+ * Look up a TypeMapEntry by GraphQL type name.
+ * Returns undefined for unknown types (callers should fall back to 'text').
+ */
+const lookupByGqlType = (gqlTypeName) => gqlTypeIndex.get(gqlTypeName);
+exports.lookupByGqlType = lookupByGqlType;