@pgpmjs/export 0.1.0

package/graphql-client.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Simple GraphQL HTTP client with pagination and authentication support.
+ * Used by the GraphQL export flow to fetch data from the Constructive GraphQL API.
+ */
+interface GraphQLClientOptions {
+    endpoint: string;
+    token?: string;
+    headers?: Record<string, string>;
+}
+export declare class GraphQLClient {
+    private endpoint;
+    private defaultHeaders;
+    constructor({ endpoint, token, headers }: GraphQLClientOptions);
+    /**
+     * Execute a single GraphQL query with retry for transient network errors.
+     */
+    query<T = any>(queryString: string, variables?: Record<string, unknown>, retries?: number): Promise<T>;
+    /**
+     * Fetch all rows from a paginated GraphQL connection, handling cursor-based pagination.
+     * Returns all nodes across all pages.
+     */
+    fetchAllNodes<T = Record<string, unknown>>(queryFieldName: string, fieldsFragment: string, condition?: Record<string, unknown>, pageSize?: number, orderBy?: string): Promise<T[]>;
+    private buildConnectionArgs;
+}
+export {};

package/graphql-client.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Simple GraphQL HTTP client with pagination and authentication support.
+ * Used by the GraphQL export flow to fetch data from the Constructive GraphQL API.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLClient = void 0;
+class GraphQLClient {
+    endpoint;
+    defaultHeaders;
+    constructor({ endpoint, token, headers }) {
+        this.endpoint = endpoint;
+        this.defaultHeaders = {
+            'Content-Type': 'application/json',
+            ...(token ? { Authorization: `Bearer ${token}` } : {}),
+            ...headers
+        };
+    }
+    /**
+     * Execute a single GraphQL query with retry for transient network errors.
+     */
+    async query(queryString, variables, retries = 3) {
+        const body = { query: queryString };
+        if (variables) {
+            body.variables = variables;
+        }
+        let lastError;
+        for (let attempt = 0; attempt < retries; attempt++) {
+            try {
+                const response = await fetch(this.endpoint, {
+                    method: 'POST',
+                    headers: this.defaultHeaders,
+                    body: JSON.stringify(body)
+                });
+                // Try to parse JSON even on non-200 responses (GraphQL servers often
+                // return 400 with a JSON body containing error details)
+                let json;
+                try {
+                    json = (await response.json());
+                }
+                catch {
+                    if (!response.ok) {
+                        const hint = response.status === 404
+                            ? `\n  Hint: Check that the API is configured for this endpoint and required headers (e.g. X-Meta-Schema) are set.`
+                            : '';
+                        throw new Error(`GraphQL request failed: ${response.status} ${response.statusText} at ${this.endpoint}${hint}`);
+                    }
+                    throw new Error(`GraphQL response is not valid JSON (got ${response.headers.get('content-type') || 'unknown content-type'}) from ${this.endpoint}.\n  Hint: The endpoint may be serving a different app (e.g. Next.js dashboard). Try using http://[::1]:<port>/graphql to target the GraphQL server directly.`);
+                }
+                if (json.errors?.length) {
+                    const messages = json.errors.map(e => e.message).join('; ');
+                    throw new Error(`GraphQL errors: ${messages}`);
+                }
+                if (!response.ok) {
+                    const hint = response.status === 404
+                        ? `\n  Hint: Check that the API is configured for this endpoint and required headers (e.g. X-Meta-Schema) are set.`
+                        : '';
+                    throw new Error(`GraphQL request failed: ${response.status} ${response.statusText} at ${this.endpoint}${hint}`);
+                }
+                if (!json.data) {
+                    throw new Error('GraphQL response missing data');
+                }
+                return json.data;
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+                const cause = lastError.cause;
+                const isTransient = cause?.code === 'ECONNRESET' ||
+                    cause?.code === 'ECONNREFUSED' ||
+                    cause?.code === 'UND_ERR_SOCKET' ||
+                    lastError.message.includes('fetch failed');
+                if (isTransient && attempt < retries - 1) {
+                    const delay = Math.min(1000 * Math.pow(2, attempt), 5000);
+                    console.warn(`  Retry ${attempt + 1}/${retries - 1}: ${cause?.code || lastError.message} — waiting ${delay}ms...`);
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    continue;
+                }
+                throw lastError;
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * Fetch all rows from a paginated GraphQL connection, handling cursor-based pagination.
+     * Returns all nodes across all pages.
+     */
+    async fetchAllNodes(queryFieldName, fieldsFragment, condition, pageSize = 100, orderBy = 'ID_ASC') {
+        const allNodes = [];
+        let hasNextPage = true;
+        let afterCursor = null;
+        while (hasNextPage) {
+            const args = this.buildConnectionArgs(condition, pageSize, afterCursor, orderBy);
+            const queryString = `{
+  ${queryFieldName}${args} {
+    nodes {
+      ${fieldsFragment}
+    }
+    pageInfo {
+      hasNextPage
+      endCursor
+    }
+  }
+}`;
+            const data = await this.query(queryString);
+            const connection = data[queryFieldName];
+            if (!connection?.nodes) {
+                break;
+            }
+            allNodes.push(...connection.nodes);
+            hasNextPage = connection.pageInfo?.hasNextPage ?? false;
+            afterCursor = connection.pageInfo?.endCursor ?? null;
+        }
+        return allNodes;
+    }
+    buildConnectionArgs(condition, first, after, orderBy) {
+        const parts = [];
+        if (first) {
+            parts.push(`first: ${first}`);
+        }
+        if (after) {
+            parts.push(`after: "${after}"`);
+        }
+        if (condition && Object.keys(condition).length > 0) {
+            const filterParts = Object.entries(condition)
+                .map(([k, v]) => {
+                if (typeof v === 'string')
+                    return `${k}: { equalTo: "${v}" }`;
+                if (typeof v === 'boolean')
+                    return `${k}: { equalTo: ${v} }`;
+                if (typeof v === 'number')
+                    return `${k}: { equalTo: ${v} }`;
+                return `${k}: { equalTo: "${v}" }`;
+            })
+                .join(', ');
+            parts.push(`where: { ${filterParts} }`);
+        }
+        if (orderBy) {
+            parts.push(`orderBy: ${orderBy}`);
+        }
+        return parts.length > 0 ? `(${parts.join(', ')})` : '';
+    }
+}
+exports.GraphQLClient = GraphQLClient;

package/graphql-naming.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Get the GraphQL query field name for a given Postgres table name.
+ * Mirrors the PostGraphile InflektPlugin's allRowsConnection inflector:
+ *   camelize(distinctPluralize(singularizeLast(camelize(pgTableName))), true)
+ */
+export declare const getGraphQLQueryName: (pgTableName: string) => string;
+/**
+ * Convert a row of GraphQL camelCase keys back to Postgres snake_case keys.
+ * This is needed because the csv-to-pg Parser expects snake_case column names.
+ * 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;
+/**
+ * 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.
+ * e.g. [['id', 'uuid'], ['sessions_default_expiration', 'interval']] ->
+ *   'id\nsessionsDefaultExpiration { seconds minutes hours days months years }'
+ */
+export declare const buildFieldsFragment: (pgFieldNames: string[], fieldTypes?: Record<string, string>) => string;

package/graphql-naming.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFieldsFragment = exports.intervalToPostgres = exports.graphqlRowToPostgresRow = exports.getGraphQLQueryName = void 0;
+/**
+ * Helpers for mapping between PostgreSQL names and PostGraphile GraphQL names.
+ *
+ * PostGraphile's inflection (with InflektPreset) transforms:
+ *   - Table names: snake_case -> camelCase (pluralized for collections)
+ *   - Column names: snake_case -> camelCase
+ *   - Schema prefix is stripped (tables are exposed without schema prefix)
+ *
+ * Examples:
+ *   metaschema_public.database -> databases (query), Database (type)
+ *   metaschema_public.foreign_key_constraint -> foreignKeyConstraints
+ *   services_public.api_schemas -> apiSchemas
+ *   db_migrate.sql_actions -> sqlActions
+ *   column database_id -> databaseId
+ */
+const inflekt_1 = require("inflekt");
+/**
+ * Get the GraphQL query field name for a given Postgres table name.
+ * Mirrors the PostGraphile InflektPlugin's allRowsConnection inflector:
+ *   camelize(distinctPluralize(singularizeLast(camelize(pgTableName))), true)
+ */
+const getGraphQLQueryName = (pgTableName) => {
+    const pascal = (0, inflekt_1.camelize)(pgTableName);
+    const singularized = (0, inflekt_1.singularizeLast)(pascal);
+    return (0, inflekt_1.camelize)((0, inflekt_1.distinctPluralize)(singularized), true);
+};
+exports.getGraphQLQueryName = getGraphQLQueryName;
+/**
+ * Convert a row of GraphQL camelCase keys back to Postgres snake_case keys.
+ * This is needed because the csv-to-pg Parser expects snake_case column names.
+ * Only transforms top-level keys — nested objects (e.g. JSONB values) are left intact.
+ */
+const graphqlRowToPostgresRow = (row) => {
+    const result = {};
+    for (const [key, value] of Object.entries(row)) {
+        result[(0, inflekt_1.underscore)(key)] = value;
+    }
+    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;
+/**
+ * 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.
+ * e.g. [['id', 'uuid'], ['sessions_default_expiration', 'interval']] ->
+ *   'id\nsessionsDefaultExpiration { seconds minutes hours days months years }'
+ */
+const buildFieldsFragment = (pgFieldNames, fieldTypes) => {
+    return pgFieldNames.map(name => {
+        const camel = (0, inflekt_1.camelize)(name, true);
+        const fieldType = fieldTypes?.[name];
+        if (fieldType === 'interval') {
+            return `${camel} { seconds minutes hours days months years }`;
+        }
+        return camel;
+    }).join('\n      ');
+};
+exports.buildFieldsFragment = buildFieldsFragment;

package/index.d.ts

@@ -0,0 +1,8 @@
+export * from './export-meta';
+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 type { FieldType, TableConfig, Schema, MakeReplacerOptions, ReplacerResult, PreparePackageOptions, MissingModulesResult } from './export-utils';

package/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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;
+__exportStar(require("./export-meta"), exports);
+__exportStar(require("./export-migrations"), exports);
+__exportStar(require("./export-graphql"), exports);
+__exportStar(require("./export-graphql-meta"), exports);
+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, "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; } });
+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; } });
+Object.defineProperty(exports, "META_COMMON_HEADER", { enumerable: true, get: function () { return export_utils_1.META_COMMON_HEADER; } });
+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, "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; } });

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@pgpmjs/export",
+  "version": "0.1.0",
+  "author": "Constructive <developers@constructive.io>",
+  "description": "PGPM export tools for SQL and GraphQL database migration extraction",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/constructive-io/constructive",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/constructive-io/constructive"
+  },
+  "bugs": {
+    "url": "https://github.com/constructive-io/constructive/issues"
+  },
+  "scripts": {
+    "clean": "makage clean",
+    "prepack": "npm run build",
+    "build": "makage build",
+    "build:dev": "makage build --dev",
+    "lint": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "keywords": [
+    "database",
+    "migration",
+    "export",
+    "postgresql",
+    "pgpm",
+    "pgpmjs",
+    "graphql"
+  ],
+  "devDependencies": {
+    "@pgsql/types": "^17.6.2",
+    "@types/pg": "^8.18.0",
+    "makage": "^0.1.12",
+    "pgsql-test": "^4.6.0"
+  },
+  "dependencies": {
+    "@pgpmjs/core": "^6.9.0",
+    "@pgpmjs/migrate-client": "^0.2.0",
+    "@pgpmjs/types": "^2.19.3",
+    "csv-to-pg": "^3.10.5",
+    "glob": "^13.0.6",
+    "inflekt": "^0.3.3",
+    "inquirerer": "^4.7.0",
+    "komoji": "^0.8.1",
+    "pg": "^8.20.0",
+    "pg-cache": "^3.3.4",
+    "pg-env": "^1.7.3"
+  },
+  "gitHead": "f42b4df50a1cdbcb03b3c52200d953b5e7b24507"
+}