@pgpmjs/export 0.20.0 → 0.20.2

package/esm/graphql-client.js

@@ -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 { unwrapGraphQLType } from './graphql-naming';
 export class GraphQLClient {
     endpoint;
     defaultHeaders;
@@ -136,4 +137,46 @@ export 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 = unwrapGraphQLType(field.type);
+                fields.set(field.name, typeInfo);
+            }
+        }
+        return fields;
+    }
 }

package/esm/graphql-naming.js

@@ -14,6 +14,7 @@
  *   column database_id -> databaseId
  */
 import { toCamelCase, toPascalCase, toSnakeCase, distinctPluralize, singularizeLast } from 'inflekt';
+import { lookupByGqlType } from './type-map';
 /**
  * Get the GraphQL query field name for a given Postgres table name.
  * Mirrors the PostGraphile InflektPlugin's allRowsConnection inflector:
@@ -36,28 +37,7 @@ export const graphqlRowToPostgresRow = (row) => {
     }
     return result;
 };
-/**
- * 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 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';
-};
+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.
@@ -74,3 +54,54 @@ export const buildFieldsFragment = (pgFieldNames, fieldTypes) => {
         return camel;
     }).join('\n      ');
 };
+/**
+ * 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 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 unwrapGraphQLType(typeRef.ofType, typeRef.kind ?? undefined);
+    }
+    return { typeName: 'Unknown', kind: 'UNKNOWN', nonNull: false, list: false };
+};
+/**
+ * Map GraphQL scalar/type names to FieldType values.
+ * Delegates to the canonical PG_TYPE_MAP in type-map.ts.
+ */
+export const mapGraphQLTypeToFieldType = (gqlTypeName, isList = false) => {
+    // Handle list types — map to the array variants that exist in FieldType
+    if (isList) {
+        const inner = 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 = lookupByGqlType(gqlTypeName);
+    return entry?.fieldType ?? 'text';
+};
+/**
+ * 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 const getGraphQLTypeName = (pgTableName) => {
+    return singularizeLast(toPascalCase(pgTableName));
+};

package/esm/index.js

@@ -3,5 +3,7 @@ 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 } 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 { PG_TYPE_MAP, lookupByPgUdt, lookupByGqlType } from './type-map';
+export { intervalToPostgres, parsePgInterval } from './interval-utils';

package/esm/interval-utils.js

@@ -0,0 +1,70 @@
+/**
+ * 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).
+ */
+/**
+ * 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 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';
+};
+/**
+ * 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 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;
+};

package/esm/type-map.js

@@ -0,0 +1,52 @@
+/**
+ * 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 const 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 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 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').
+ */
+export const lookupByPgUdt = (udtName) => pgUdtIndex.get(udtName);
+/**
+ * Look up a TypeMapEntry by GraphQL type name.
+ * Returns undefined for unknown types (callers should fall back to 'text').
+ */
+export const lookupByGqlType = (gqlTypeName) => gqlTypeIndex.get(gqlTypeName);

package/export-graphql-meta.js

@@ -9,8 +9,70 @@ exports.exportGraphQLMeta = void 0;
  * generate SQL INSERT statements.
  */
 const csv_to_pg_1 = require("csv-to-pg");
+const inflekt_1 = require("inflekt");
 const export_utils_1 = require("./export-utils");
 const graphql_naming_1 = require("./graphql-naming");
+const type_map_1 = require("./type-map");
+/**
+ * Discover fields dynamically from a GraphQL type via introspection.
+ * Queries `__type` to enumerate fields and infer their `FieldType` via
+ * `mapGraphQLTypeToFieldType`. Tracks ENUM fields separately so callers
+ * can normalize their CONSTANT_CASE values back to lowercase.
+ *
+ * `typeOverrides` from the config are applied on top for special types
+ * (image, upload, url) that cannot be inferred from the GraphQL type alone.
+ */
+const buildDynamicFieldsFromGraphQL = async (client, tableConfig) => {
+    const emptyResult = { fields: {}, enumFields: new Set() };
+    const typeName = tableConfig.gqlTypeName || (0, graphql_naming_1.getGraphQLTypeName)(tableConfig.table);
+    try {
+        const introspectedFields = await client.introspectType(typeName);
+        const dynamicFields = {};
+        const enumFields = new Set();
+        for (const [camelName, typeInfo] of introspectedFields) {
+            const snakeName = (0, inflekt_1.toSnakeCase)(camelName);
+            // Skip internal GraphQL fields
+            if (camelName.startsWith('__'))
+                continue;
+            // Track enum fields for lowercase normalization (custom inflector uppercases them)
+            if (typeInfo.kind === 'ENUM') {
+                enumFields.add(snakeName);
+            }
+            // Skip non-scalar fields (relations/computed columns like "database" of type Database)
+            // Only SCALAR and ENUM kinds can be selected without sub-field selections
+            // EXCEPTION: types registered as non-SCALAR in PG_TYPE_MAP (e.g. Interval=OBJECT)
+            // are handled via buildFieldsFragment sub-selections and intervalToPostgres conversion
+            if (typeInfo.kind !== 'SCALAR' && typeInfo.kind !== 'ENUM') {
+                const mapEntry = (0, type_map_1.lookupByGqlType)(typeInfo.typeName);
+                if (mapEntry && mapEntry.gqlKind !== 'SCALAR') {
+                    dynamicFields[snakeName] = mapEntry.fieldType;
+                    continue;
+                }
+                continue;
+            }
+            dynamicFields[snakeName] = (0, graphql_naming_1.mapGraphQLTypeToFieldType)(typeInfo.typeName, typeInfo.list);
+        }
+        // Apply type overrides (e.g., image, upload, url)
+        if (tableConfig.typeOverrides) {
+            for (const [fieldName, fieldType] of Object.entries(tableConfig.typeOverrides)) {
+                if (dynamicFields[fieldName]) {
+                    dynamicFields[fieldName] = fieldType;
+                }
+            }
+        }
+        return { fields: dynamicFields, enumFields };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes('Cannot query field') ||
+            message.includes('is not defined by type') ||
+            message.includes('Unknown field')) {
+            // Type not available in the GraphQL schema — return empty
+            return emptyResult;
+        }
+        throw err;
+    }
+};
 /**
  * Fetch metadata via GraphQL and generate SQL INSERT statements.
  * This is the GraphQL equivalent of exportMeta() in export-meta.ts.
@@ -21,8 +83,12 @@ const exportGraphQLMeta = async ({ client, database_id }) => {
         const tableConfig = export_utils_1.META_TABLE_CONFIG[key];
         if (!tableConfig)
             return;
-        const pgFieldNames = Object.keys(tableConfig.fields);
-        const graphqlFieldsFragment = (0, graphql_naming_1.buildFieldsFragment)(pgFieldNames, tableConfig.fields);
+        // Build fields dynamically: either from hardcoded config or via introspection
+        const { fields: configFields, enumFields } = await buildDynamicFieldsFromGraphQL(client, tableConfig);
+        if (Object.keys(configFields).length === 0)
+            return;
+        const pgFieldNames = Object.keys(configFields);
+        const graphqlFieldsFragment = (0, graphql_naming_1.buildFieldsFragment)(pgFieldNames, configFields);
         const graphqlQueryName = (0, graphql_naming_1.getGraphQLQueryName)(tableConfig.table);
         // The 'database' table is fetched by id, not by database_id
         const condition = key === 'database'
@@ -33,13 +99,30 @@ const exportGraphQLMeta = async ({ client, database_id }) => {
             if (rows.length > 0) {
                 // Convert camelCase GraphQL keys back to snake_case for the Parser
                 // Also convert interval objects back to Postgres interval strings
+                // and normalize enum values from CONSTANT_CASE back to lowercase
                 const pgRows = rows.map(row => {
                     const pgRow = (0, graphql_naming_1.graphqlRowToPostgresRow)(row);
-                    // Convert any interval fields from {seconds, minutes, ...} objects to strings
-                    for (const [fieldName, fieldType] of Object.entries(tableConfig.fields)) {
+                    for (const [fieldName, fieldType] of Object.entries(configFields)) {
+                        // Convert interval fields from {seconds, minutes, ...} objects to strings
                         if (fieldType === 'interval' && pgRow[fieldName] && typeof pgRow[fieldName] === 'object') {
                             pgRow[fieldName] = (0, graphql_naming_1.intervalToPostgres)(pgRow[fieldName]);
                         }
+                        // Truncate timestamptz to second precision for parity with SQL flow
+                        // PostGraphile's Datetime scalar preserves full millisecond precision,
+                        // but the pg driver + our SQL flow truncates to .000Z via Date rounding
+                        if (fieldType === 'timestamptz' && typeof pgRow[fieldName] === 'string') {
+                            const d = new Date(pgRow[fieldName]);
+                            if (!isNaN(d.getTime())) {
+                                pgRow[fieldName] = new Date(Math.floor(d.getTime() / 1000) * 1000).toISOString();
+                            }
+                        }
+                    }
+                    // Normalize enum values: custom inflector uppercases them to CONSTANT_CASE,
+                    // but PostgreSQL stores them in lowercase — convert back for parity with SQL flow
+                    for (const fieldName of enumFields) {
+                        if (typeof pgRow[fieldName] === 'string') {
+                            pgRow[fieldName] = pgRow[fieldName].toLowerCase();
+                        }
                     }
                     return pgRow;
                 });
@@ -52,7 +135,7 @@ const exportGraphQLMeta = async ({ client, database_id }) => {
                     }
                 }
                 const dynamicFields = {};
-                for (const [fieldName, fieldType] of Object.entries(tableConfig.fields)) {
+                for (const [fieldName, fieldType] of Object.entries(configFields)) {
                     if (returnedKeys.has(fieldName)) {
                         dynamicFields[fieldName] = fieldType;
                     }
@@ -136,6 +219,7 @@ const exportGraphQLMeta = async ({ client, database_id }) => {
         queryAndParse('permissions_module'),
         queryAndParse('limits_module'),
         queryAndParse('levels_module'),
+        queryAndParse('events_module'),
         queryAndParse('users_module'),
         queryAndParse('hierarchy_module'),
         queryAndParse('membership_types_module'),
@@ -145,13 +229,14 @@ const exportGraphQLMeta = async ({ client, database_id }) => {
         queryAndParse('user_state_module'),
         queryAndParse('profiles_module'),
         queryAndParse('config_secrets_user_module'),
+        queryAndParse('user_credentials_module'),
+        queryAndParse('user_settings_module'),
         queryAndParse('connected_accounts_module'),
         queryAndParse('phone_numbers_module'),
         queryAndParse('crypto_addresses_module'),
         queryAndParse('crypto_auth_module'),
         queryAndParse('field_module'),
         queryAndParse('table_module'),
-        queryAndParse('table_template_module'),
         queryAndParse('secure_table_provision'),
         queryAndParse('uuid_module'),
         queryAndParse('default_ids_module'),
@@ -169,8 +254,21 @@ const exportGraphQLMeta = async ({ client, database_id }) => {
         queryAndParse('realtime_module'),
         queryAndParse('session_secrets_module'),
         queryAndParse('config_secrets_org_module'),
+        queryAndParse('config_secrets_module'),
+        queryAndParse('i18n_module'),
+        queryAndParse('agent_module'),
+        queryAndParse('function_module'),
+        queryAndParse('namespace_module'),
+        queryAndParse('merkle_store_module'),
+        queryAndParse('graph_module'),
+        queryAndParse('compute_log_module'),
+        queryAndParse('db_usage_module'),
+        queryAndParse('storage_log_module'),
+        queryAndParse('transfer_log_module'),
         queryAndParse('webauthn_auth_module'),
-        queryAndParse('webauthn_credentials_module')
+        queryAndParse('webauthn_credentials_module'),
+        queryAndParse('inference_log_module'),
+        queryAndParse('rate_limit_meters_module')
     ]);
     return sql;
 };

package/export-meta.js

@@ -22,10 +22,10 @@ const getTableColumns = async (pool, schemaName, tableName) => {
     return columns;
 };
 /**
- * Build dynamic fields config by intersecting the hardcoded config with actual database columns.
- * - Only includes columns that exist in the database
- * - Preserves special type hints from config (image, upload, url) for columns that exist
- * - Infers types from PostgreSQL for columns not in config
+ * Build dynamic fields config from the database via information_schema.
+ * - All fields are derived from `information_schema.columns` + `mapPgTypeToFieldType`.
+ * - `typeOverrides` from the config are applied on top for special types
+ *   (image, upload, url) that cannot be inferred from PG types alone.
  */
 const buildDynamicFields = async (pool, tableConfig) => {
     const actualColumns = await getTableColumns(pool, tableConfig.schema, tableConfig.table);
@@ -34,13 +34,17 @@ const buildDynamicFields = async (pool, tableConfig) => {
         return {};
     }
     const dynamicFields = {};
-    // For each column in the hardcoded config, check if it exists in the database
-    for (const [fieldName, fieldType] of Object.entries(tableConfig.fields)) {
-        if (actualColumns.has(fieldName)) {
-            // Column exists - use the config's type hint (preserves special types like 'image', 'upload', 'url')
-            dynamicFields[fieldName] = fieldType;
+    // Derive all fields from information_schema
+    for (const [columnName, udtName] of actualColumns) {
+        dynamicFields[columnName] = (0, export_utils_1.mapPgTypeToFieldType)(udtName);
+    }
+    // Apply type overrides (image, upload, url)
+    if (tableConfig.typeOverrides) {
+        for (const [fieldName, fieldType] of Object.entries(tableConfig.typeOverrides)) {
+            if (dynamicFields[fieldName]) {
+                dynamicFields[fieldName] = fieldType;
+            }
         }
-        // If column doesn't exist in database, skip it (this fixes the bug)
     }
     return dynamicFields;
 };
@@ -50,8 +54,9 @@ const exportMeta = async ({ opts, dbname, database_id }) => {
         database: dbname
     });
     const sql = {};
-    // Cache for dynamically built parsers
+    // Cache for dynamically built parsers and their field configs
     const parsers = {};
+    const parserFields = {};
     // Build parser dynamically by querying actual columns from the database
     const getParser = async (key) => {
         if (parsers[key]) {
@@ -67,6 +72,7 @@ const exportMeta = async ({ opts, dbname, database_id }) => {
             // No columns found (table doesn't exist or no matching columns)
             return null;
         }
+        parserFields[key] = dynamicFields;
         const parser = new csv_to_pg_1.Parser({
             schema: tableConfig.schema,
             table: tableConfig.table,
@@ -84,6 +90,23 @@ const exportMeta = async ({ opts, dbname, database_id }) => {
             }
             const result = await pool.query(query, [database_id]);
             if (result.rows.length) {
+                // Truncate timestamptz to second precision to match PostGraphile's Datetime scalar
+                // which truncates milliseconds in the GraphQL flow
+                const fields = parserFields[key];
+                if (fields) {
+                    for (const row of result.rows) {
+                        for (const [fieldName, fieldType] of Object.entries(fields)) {
+                            if (fieldType === 'timestamptz') {
+                                const val = row[fieldName];
+                                if (val instanceof Date) {
+                                    // Truncate to second precision and convert to ISO string
+                                    // so both SQL and GraphQL flows pass the same value type to the Parser
+                                    row[fieldName] = new Date(Math.floor(val.getTime() / 1000) * 1000).toISOString();
+                                }
+                            }
+                        }
+                    }
+                }
                 const parsed = await parser.parse(result.rows);
                 if (parsed) {
                     sql[key] = parsed;
@@ -148,6 +171,7 @@ const exportMeta = async ({ opts, dbname, database_id }) => {
     await queryAndParse('permissions_module', `SELECT * FROM metaschema_modules_public.permissions_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('limits_module', `SELECT * FROM metaschema_modules_public.limits_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('levels_module', `SELECT * FROM metaschema_modules_public.levels_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('events_module', `SELECT * FROM metaschema_modules_public.events_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('users_module', `SELECT * FROM metaschema_modules_public.users_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('hierarchy_module', `SELECT * FROM metaschema_modules_public.hierarchy_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('membership_types_module', `SELECT * FROM metaschema_modules_public.membership_types_module WHERE database_id = $1 ORDER BY id`);
@@ -157,13 +181,14 @@ const exportMeta = async ({ opts, dbname, database_id }) => {
     await queryAndParse('user_state_module', `SELECT * FROM metaschema_modules_public.user_state_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('profiles_module', `SELECT * FROM metaschema_modules_public.profiles_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('config_secrets_user_module', `SELECT * FROM metaschema_modules_public.config_secrets_user_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('user_credentials_module', `SELECT * FROM metaschema_modules_public.user_credentials_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('user_settings_module', `SELECT * FROM metaschema_modules_public.user_settings_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('connected_accounts_module', `SELECT * FROM metaschema_modules_public.connected_accounts_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('phone_numbers_module', `SELECT * FROM metaschema_modules_public.phone_numbers_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('crypto_addresses_module', `SELECT * FROM metaschema_modules_public.crypto_addresses_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('crypto_auth_module', `SELECT * FROM metaschema_modules_public.crypto_auth_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('field_module', `SELECT * FROM metaschema_modules_public.field_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('table_module', `SELECT * FROM metaschema_modules_public.table_module WHERE database_id = $1 ORDER BY id`);
-    await queryAndParse('table_template_module', `SELECT * FROM metaschema_modules_public.table_template_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('secure_table_provision', `SELECT * FROM metaschema_modules_public.secure_table_provision WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('uuid_module', `SELECT * FROM metaschema_modules_public.uuid_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('default_ids_module', `SELECT * FROM metaschema_modules_public.default_ids_module WHERE database_id = $1 ORDER BY id`);
@@ -181,8 +206,21 @@ const exportMeta = async ({ opts, dbname, database_id }) => {
     await queryAndParse('realtime_module', `SELECT * FROM metaschema_modules_public.realtime_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('session_secrets_module', `SELECT * FROM metaschema_modules_public.session_secrets_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('config_secrets_org_module', `SELECT * FROM metaschema_modules_public.config_secrets_org_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('config_secrets_module', `SELECT * FROM metaschema_modules_public.config_secrets_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('i18n_module', `SELECT * FROM metaschema_modules_public.i18n_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('agent_module', `SELECT * FROM metaschema_modules_public.agent_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('function_module', `SELECT * FROM metaschema_modules_public.function_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('namespace_module', `SELECT * FROM metaschema_modules_public.namespace_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('merkle_store_module', `SELECT * FROM metaschema_modules_public.merkle_store_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('graph_module', `SELECT * FROM metaschema_modules_public.graph_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('compute_log_module', `SELECT * FROM metaschema_modules_public.compute_log_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('db_usage_module', `SELECT * FROM metaschema_modules_public.db_usage_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('storage_log_module', `SELECT * FROM metaschema_modules_public.storage_log_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('transfer_log_module', `SELECT * FROM metaschema_modules_public.transfer_log_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('webauthn_auth_module', `SELECT * FROM metaschema_modules_public.webauthn_auth_module WHERE database_id = $1 ORDER BY id`);
     await queryAndParse('webauthn_credentials_module', `SELECT * FROM metaschema_modules_public.webauthn_credentials_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('inference_log_module', `SELECT * FROM metaschema_modules_public.inference_log_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('rate_limit_meters_module', `SELECT * FROM metaschema_modules_public.rate_limit_meters_module WHERE database_id = $1 ORDER BY id`);
     return sql;
 };
 exports.exportMeta = exportMeta;

package/export-utils.d.ts

@@ -4,7 +4,13 @@ import { PgpmPackage } from '@pgpmjs/core';
  * Required extensions for database schema exports.
  * Includes native PostgreSQL extensions and pgpm modules.
  */
-export declare const DB_REQUIRED_EXTENSIONS: readonly ["plpgsql", "uuid-ossp", "citext", "pgcrypto", "btree_gin", "btree_gist", "pg_textsearch", "pg_trgm", "postgis", "hstore", "vector", "ltree", "metaschema-schema", "pgpm-inflection", "pgpm-utils", "pgpm-database-jobs", "pgpm-jwt-claims", "pgpm-stamps", "pgpm-base32", "pgpm-totp", "pgpm-types", "pgpm-ltree-helpers", "pgpm-partman"];
+export declare const DB_REQUIRED_EXTENSIONS: readonly ["plpgsql", "uuid-ossp", "citext", "pgcrypto", "btree_gin", "btree_gist", "pg_textsearch", "pg_trgm", "postgis", "hstore", "vector", "ltree", "metaschema-schema", "pgpm-inflection", "pgpm-uuid", "pgpm-utils", "pgpm-database-jobs", "pgpm-jwt-claims", "pgpm-stamps", "pgpm-base32", "pgpm-totp", "pgpm-types", "pgpm-ltree-helpers", "pgpm-partman"];
+/**
+ * Map PostgreSQL data types to FieldType values.
+ * Uses udt_name from information_schema which gives the base type name.
+ * Delegates to the canonical PG_TYPE_MAP in type-map.ts.
+ */
+export declare const mapPgTypeToFieldType: (udtName: string) => FieldType;
 /**
  * Required extensions for service/meta exports.
  * Includes native PostgreSQL extensions and pgpm modules for metadata management.
@@ -23,24 +29,25 @@ export declare const META_COMMON_FOOTER = "\nSET session_replication_role TO DEF
  * Ordered list of meta tables for export.
  * Tables are processed in this order to satisfy foreign key dependencies.
  */
-export declare const META_TABLE_ORDER: readonly ["database", "schema", "function", "table", "field", "spatial_relation", "policy", "index", "trigger", "trigger_function", "rls_function", "foreign_key_constraint", "primary_key_constraint", "unique_constraint", "check_constraint", "full_text_search", "schema_grant", "table_grant", "default_privilege", "domains", "sites", "apis", "apps", "site_modules", "site_themes", "site_metadata", "api_modules", "api_extensions", "api_schemas", "database_settings", "api_settings", "rls_settings", "cors_settings", "pubkey_settings", "webauthn_settings", "rls_module", "user_auth_module", "memberships_module", "permissions_module", "limits_module", "events_module", "users_module", "hierarchy_module", "membership_types_module", "invites_module", "emails_module", "sessions_module", "user_state_module", "profiles_module", "config_secrets_user_module", "connected_accounts_module", "phone_numbers_module", "crypto_addresses_module", "crypto_auth_module", "field_module", "table_module", "secure_table_provision", "uuid_module", "default_ids_module", "denormalized_table_field", "relation_provision", "entity_type_provision", "rate_limits_module", "storage_module", "billing_module", "billing_provider_module", "devices_module", "identity_providers_module", "notifications_module", "plans_module", "realtime_module", "session_secrets_module", "config_secrets_org_module", "webauthn_auth_module", "webauthn_credentials_module", "inference_log_module", "rate_limit_meters_module"];
+export declare const META_TABLE_ORDER: readonly ["database", "schema", "function", "table", "field", "spatial_relation", "policy", "index", "trigger", "trigger_function", "rls_function", "foreign_key_constraint", "primary_key_constraint", "unique_constraint", "check_constraint", "full_text_search", "schema_grant", "table_grant", "default_privilege", "domains", "sites", "apis", "apps", "site_modules", "site_themes", "site_metadata", "api_modules", "api_extensions", "api_schemas", "database_settings", "api_settings", "rls_settings", "cors_settings", "pubkey_settings", "webauthn_settings", "rls_module", "user_auth_module", "memberships_module", "permissions_module", "limits_module", "levels_module", "events_module", "users_module", "hierarchy_module", "membership_types_module", "invites_module", "emails_module", "sessions_module", "user_state_module", "profiles_module", "config_secrets_user_module", "user_credentials_module", "user_settings_module", "connected_accounts_module", "phone_numbers_module", "crypto_addresses_module", "crypto_auth_module", "field_module", "table_module", "secure_table_provision", "uuid_module", "default_ids_module", "denormalized_table_field", "relation_provision", "entity_type_provision", "rate_limits_module", "storage_module", "billing_module", "billing_provider_module", "devices_module", "identity_providers_module", "notifications_module", "plans_module", "realtime_module", "session_secrets_module", "config_secrets_org_module", "config_secrets_module", "i18n_module", "agent_module", "function_module", "namespace_module", "merkle_store_module", "graph_module", "compute_log_module", "db_usage_module", "storage_log_module", "transfer_log_module", "webauthn_auth_module", "webauthn_credentials_module", "inference_log_module", "rate_limit_meters_module"];
 export type FieldType = 'uuid' | 'uuid[]' | 'text' | 'text[]' | 'boolean' | 'image' | 'upload' | 'url' | 'jsonb' | 'jsonb[]' | 'int' | 'interval' | 'timestamptz';
 export interface TableConfig {
     schema: string;
     table: string;
     conflictDoNothing?: boolean;
-    fields: Record<string, FieldType>;
+    typeOverrides?: Record<string, FieldType>;
+    gqlTypeName?: string;
 }
 /**
  * Shared metadata table configuration.
  *
- * This is the **superset** of fields needed by both the SQL export flow
- * (export-meta.ts) and the GraphQL export flow (export-graphql-meta.ts).
- * Each flow dynamically filters to only the fields that actually exist:
- * - SQL flow: uses buildDynamicFields() to intersect with information_schema
- * - GraphQL flow: filters to fields present in the returned data
+ * Fields are discovered dynamically at runtime via introspection:
+ * - SQL flow: uses information_schema.columns + mapPgTypeToFieldType()
+ * - GraphQL flow: uses __type introspection + mapGraphQLTypeToFieldType()
+ *
+ * Only `typeOverrides` are hardcoded for special types (image, upload, url)
+ * that cannot be inferred from database/GraphQL types alone.
  *
- * Adding a field here that doesn't exist in a particular environment is safe.
  */
 export declare const META_TABLE_CONFIG: Record<string, TableConfig>;
 export interface Schema {