@pgpmjs/export 0.1.0

package/esm/graphql-client.js

@@ -0,0 +1,139 @@
+/**
+ * Simple GraphQL HTTP client with pagination and authentication support.
+ * Used by the GraphQL export flow to fetch data from the Constructive GraphQL API.
+ */
+export 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(', ')})` : '';
+    }
+}

package/esm/graphql-naming.js

@@ -0,0 +1,76 @@
+/**
+ * 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
+ */
+import { camelize, distinctPluralize, singularizeLast, underscore } from '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)
+ */
+export const getGraphQLQueryName = (pgTableName) => {
+    const pascal = camelize(pgTableName);
+    const singularized = singularizeLast(pascal);
+    return camelize(distinctPluralize(singularized), true);
+};
+/**
+ * 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 const graphqlRowToPostgresRow = (row) => {
+    const result = {};
+    for (const [key, value] of Object.entries(row)) {
+        result[underscore(key)] = value;
+    }
+    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';
+};
+/**
+ * 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 const buildFieldsFragment = (pgFieldNames, fieldTypes) => {
+    return pgFieldNames.map(name => {
+        const camel = camelize(name, true);
+        const fieldType = fieldTypes?.[name];
+        if (fieldType === 'interval') {
+            return `${camel} { seconds minutes hours days months years }`;
+        }
+        return camel;
+    }).join('\n      ');
+};

package/esm/index.js

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

package/export-graphql-meta.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLClient } from './graphql-client';
+export interface ExportGraphQLMetaParams {
+    /** GraphQL client configured for the meta/services API endpoint */
+    client: GraphQLClient;
+    /** The database_id to filter by */
+    database_id: string;
+}
+export type ExportGraphQLMetaResult = Record<string, string>;
+/**
+ * Fetch metadata via GraphQL and generate SQL INSERT statements.
+ * This is the GraphQL equivalent of exportMeta() in export-meta.ts.
+ */
+export declare const exportGraphQLMeta: ({ client, database_id }: ExportGraphQLMetaParams) => Promise<ExportGraphQLMetaResult>;

package/export-graphql-meta.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportGraphQLMeta = void 0;
+/**
+ * GraphQL equivalent of export-meta.ts.
+ *
+ * Fetches metadata from metaschema_public, services_public, and metaschema_modules_public
+ * via GraphQL queries instead of direct SQL, then uses the same csv-to-pg Parser to
+ * generate SQL INSERT statements.
+ */
+const csv_to_pg_1 = require("csv-to-pg");
+const export_utils_1 = require("./export-utils");
+const graphql_naming_1 = require("./graphql-naming");
+/**
+ * Fetch metadata via GraphQL and generate SQL INSERT statements.
+ * This is the GraphQL equivalent of exportMeta() in export-meta.ts.
+ */
+const exportGraphQLMeta = async ({ client, database_id }) => {
+    const sql = {};
+    const queryAndParse = async (key) => {
+        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);
+        const graphqlQueryName = (0, graphql_naming_1.getGraphQLQueryName)(tableConfig.table);
+        // The 'database' table is fetched by id, not by database_id
+        const condition = key === 'database'
+            ? { id: database_id }
+            : { databaseId: database_id };
+        try {
+            const rows = await client.fetchAllNodes(graphqlQueryName, graphqlFieldsFragment, condition);
+            if (rows.length > 0) {
+                // Convert camelCase GraphQL keys back to snake_case for the Parser
+                // Also convert interval objects back to Postgres interval strings
+                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)) {
+                        if (fieldType === 'interval' && pgRow[fieldName] && typeof pgRow[fieldName] === 'object') {
+                            pgRow[fieldName] = (0, graphql_naming_1.intervalToPostgres)(pgRow[fieldName]);
+                        }
+                    }
+                    return pgRow;
+                });
+                // Filter fields to only those that exist in the returned data
+                // This mirrors the dynamic field building in the SQL version
+                const returnedKeys = new Set();
+                for (const row of pgRows) {
+                    for (const k of Object.keys(row)) {
+                        returnedKeys.add(k);
+                    }
+                }
+                const dynamicFields = {};
+                for (const [fieldName, fieldType] of Object.entries(tableConfig.fields)) {
+                    if (returnedKeys.has(fieldName)) {
+                        dynamicFields[fieldName] = fieldType;
+                    }
+                }
+                if (Object.keys(dynamicFields).length === 0)
+                    return;
+                const parser = new csv_to_pg_1.Parser({
+                    schema: tableConfig.schema,
+                    table: tableConfig.table,
+                    conflictDoNothing: tableConfig.conflictDoNothing,
+                    fields: dynamicFields
+                });
+                const parsed = await parser.parse(pgRows);
+                if (parsed) {
+                    sql[key] = parsed;
+                }
+            }
+        }
+        catch (err) {
+            // If the GraphQL query fails (e.g. table not exposed), skip silently
+            // similar to how the SQL version handles 42P01 (undefined_table)
+            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') ||
+                (message.includes('Field') && message.includes('not found'))) {
+                // Field/table not available in the GraphQL schema — skip
+                return;
+            }
+            throw err;
+        }
+    };
+    // Batch queries by schema group — independent HTTP requests run in parallel
+    // within each group for significant speedup over sequential awaits.
+    // metaschema_public tables
+    await Promise.all([
+        queryAndParse('database'),
+        queryAndParse('database_extension'),
+        queryAndParse('schema'),
+        queryAndParse('table'),
+        queryAndParse('field'),
+        queryAndParse('policy'),
+        queryAndParse('index'),
+        queryAndParse('trigger'),
+        queryAndParse('trigger_function'),
+        queryAndParse('rls_function'),
+        queryAndParse('foreign_key_constraint'),
+        queryAndParse('primary_key_constraint'),
+        queryAndParse('unique_constraint'),
+        queryAndParse('check_constraint'),
+        queryAndParse('full_text_search'),
+        queryAndParse('schema_grant'),
+        queryAndParse('table_grant'),
+        queryAndParse('default_privilege')
+    ]);
+    // services_public tables
+    await Promise.all([
+        queryAndParse('domains'),
+        queryAndParse('sites'),
+        queryAndParse('apis'),
+        queryAndParse('apps'),
+        queryAndParse('site_modules'),
+        queryAndParse('site_themes'),
+        queryAndParse('site_metadata'),
+        queryAndParse('api_modules'),
+        queryAndParse('api_extensions'),
+        queryAndParse('api_schemas')
+    ]);
+    // metaschema_modules_public tables
+    await Promise.all([
+        queryAndParse('rls_module'),
+        queryAndParse('user_auth_module'),
+        queryAndParse('memberships_module'),
+        queryAndParse('permissions_module'),
+        queryAndParse('limits_module'),
+        queryAndParse('levels_module'),
+        queryAndParse('users_module'),
+        queryAndParse('hierarchy_module'),
+        queryAndParse('membership_types_module'),
+        queryAndParse('invites_module'),
+        queryAndParse('emails_module'),
+        queryAndParse('sessions_module'),
+        queryAndParse('secrets_module'),
+        queryAndParse('profiles_module'),
+        queryAndParse('encrypted_secrets_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'),
+        queryAndParse('denormalized_table_field')
+    ]);
+    return sql;
+};
+exports.exportGraphQLMeta = exportGraphQLMeta;

package/export-graphql.d.ts

@@ -0,0 +1,52 @@
+/**
+ * GraphQL-based export orchestrator.
+ *
+ * This is a standalone GraphQL export flow that mirrors export-migrations.ts
+ * but fetches all data via GraphQL queries instead of direct SQL.
+ *
+ * Per Dan's guidance: "I would NOT do branching in those existing files.
+ * I would make the GraphQL flow its entire own flow at first."
+ */
+import { Inquirerer } from 'inquirerer';
+import { PgpmPackage } from '@pgpmjs/core';
+import { Schema } from './export-utils';
+export interface ExportGraphQLOptions {
+    project: PgpmPackage;
+    /** GraphQL endpoint for metaschema/services data (e.g. http://private.localhost:3002/graphql) */
+    metaEndpoint: string;
+    /** GraphQL endpoint for db_migrate data (e.g. http://db_migrate.localhost:3000/graphql) */
+    migrateEndpoint?: string;
+    /** Extra headers for the migrate endpoint (e.g. Host header for subdomain routing) */
+    migrateHeaders?: Record<string, string>;
+    /** Bearer token for authentication */
+    token?: string;
+    /** Extra headers to send with GraphQL requests (e.g. X-Meta-Schema) */
+    headers?: Record<string, string>;
+    /** Database ID to export */
+    databaseId: string;
+    /** Database display name */
+    databaseName: string;
+    /** Schema names selected for export */
+    schema_names: string[];
+    /** Schema rows (with name and schema_name) for the replacer */
+    schemas: Schema[];
+    /** Author string */
+    author: string;
+    /** Output directory for packages */
+    outdir: string;
+    /** Extension name for the DB module */
+    extensionName: string;
+    /** Description for the DB extension */
+    extensionDesc?: string;
+    /** Extension name for the service/meta module */
+    metaExtensionName: string;
+    /** Description for the service/meta extension */
+    metaExtensionDesc?: string;
+    prompter?: Inquirerer;
+    argv?: Record<string, any>;
+    repoName?: string;
+    username?: string;
+    serviceOutdir?: string;
+    skipSchemaRenaming?: boolean;
+}
+export declare const exportGraphQL: ({ project, metaEndpoint, migrateEndpoint, token, headers, migrateHeaders, databaseId, databaseName, schema_names, schemas, author, outdir, extensionName, extensionDesc, metaExtensionName, metaExtensionDesc, prompter, argv, repoName, username, serviceOutdir, skipSchemaRenaming }: ExportGraphQLOptions) => Promise<void>;

package/export-graphql.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportGraphQL = void 0;
+const core_1 = require("@pgpmjs/core");
+const migrate_client_1 = require("@pgpmjs/migrate-client");
+const graphql_client_1 = require("./graphql-client");
+const export_graphql_meta_1 = require("./export-graphql-meta");
+const graphql_naming_1 = require("./graphql-naming");
+const export_utils_1 = require("./export-utils");
+const exportGraphQL = async ({ project, metaEndpoint, migrateEndpoint, token, headers, migrateHeaders, databaseId, databaseName, schema_names, schemas, author, outdir, extensionName, extensionDesc, metaExtensionName, metaExtensionDesc, prompter, argv, repoName, username, serviceOutdir, skipSchemaRenaming = false }) => {
+    const normalizedOutdir = (0, export_utils_1.normalizeOutdir)(outdir);
+    const svcOutdir = (0, export_utils_1.normalizeOutdir)(serviceOutdir || outdir);
+    const name = extensionName;
+    const schemasForReplacement = skipSchemaRenaming
+        ? []
+        : schemas.filter((schema) => schema_names.includes(schema.schema_name));
+    const { replacer } = (0, export_utils_1.makeReplacer)({
+        schemas: schemasForReplacement,
+        name
+    });
+    // =========================================================================
+    // 1. Fetch sql_actions via @pgpmjs/migrate-client ORM (db_migrate endpoint)
+    // =========================================================================
+    let sqlActionRows = [];
+    if (migrateEndpoint) {
+        console.log(`Fetching sql_actions from ${migrateEndpoint}...`);
+        const db = (0, migrate_client_1.createClient)({
+            endpoint: migrateEndpoint,
+            headers: {
+                ...(token ? { Authorization: `Bearer ${token}` } : {}),
+                ...migrateHeaders
+            }
+        });
+        try {
+            // Paginate through all sql_actions for this database using the ORM.
+            // The ORM generates `where: SqlActionFilter` which uses the filter plugin's
+            // `equalTo` operator — the correct approach for Constructive's PostGraphile APIs.
+            let hasNextPage = true;
+            let afterCursor;
+            const PAGE_SIZE = 100;
+            while (hasNextPage) {
+                const result = await db.sqlAction.findMany({
+                    select: {
+                        id: true,
+                        databaseId: true,
+                        name: true,
+                        deploy: true,
+                        revert: true,
+                        verify: true,
+                        content: true,
+                        deps: true,
+                        action: true,
+                        actionId: true,
+                        actorId: true,
+                        payload: true
+                    },
+                    where: {
+                        databaseId: { equalTo: databaseId }
+                    },
+                    orderBy: ['ID_ASC'],
+                    first: PAGE_SIZE,
+                    ...(afterCursor ? { after: afterCursor } : {})
+                }).unwrap();
+                const connection = result.sqlActions;
+                for (const node of connection.nodes) {
+                    sqlActionRows.push((0, graphql_naming_1.graphqlRowToPostgresRow)(node));
+                }
+                hasNextPage = connection.pageInfo?.hasNextPage ?? false;
+                afterCursor = connection.pageInfo?.endCursor ?? undefined;
+            }
+            console.log(`  Found ${sqlActionRows.length} sql_actions`);
+        }
+        catch (err) {
+            console.warn(`  Warning: Could not fetch sql_actions: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    else {
+        console.log('No migrate endpoint provided, skipping sql_actions export.');
+    }
+    const opts = {
+        name,
+        replacer,
+        outdir: normalizedOutdir,
+        author
+    };
+    const dbExtensionDesc = extensionDesc || `${name} database schema for ${databaseName}`;
+    if (sqlActionRows.length > 0) {
+        const dbMissingResult = await (0, export_utils_1.detectMissingModules)(project, [...export_utils_1.DB_REQUIRED_EXTENSIONS], prompter, argv);
+        const dbModuleDir = await (0, export_utils_1.preparePackage)({
+            project,
+            author,
+            outdir: normalizedOutdir,
+            name,
+            description: dbExtensionDesc,
+            extensions: [...export_utils_1.DB_REQUIRED_EXTENSIONS],
+            prompter,
+            repoName,
+            username
+        });
+        if (dbMissingResult.shouldInstall) {
+            await (0, export_utils_1.installMissingModules)(dbModuleDir, dbMissingResult.missingModules);
+        }
+        (0, core_1.writePgpmPlan)(sqlActionRows, opts);
+        (0, core_1.writePgpmFiles)(sqlActionRows, opts);
+    }
+    else {
+        console.log('No sql_actions found. Skipping database module export.');
+    }
+    // =========================================================================
+    // 2. Fetch meta/services data via GraphQL
+    // =========================================================================
+    console.log(`Fetching metadata from ${metaEndpoint}...`);
+    const metaClient = new graphql_client_1.GraphQLClient({ endpoint: metaEndpoint, token, headers });
+    const metaResult = await (0, export_graphql_meta_1.exportGraphQLMeta)({
+        client: metaClient,
+        database_id: databaseId
+    });
+    const metaTableCount = Object.keys(metaResult).length;
+    console.log(`  Fetched ${metaTableCount} meta tables with data`);
+    if (metaTableCount > 0) {
+        const metaDesc = metaExtensionDesc || `${metaExtensionName} service utilities for managing domains, APIs, and services`;
+        const svcMissingResult = await (0, export_utils_1.detectMissingModules)(project, [...export_utils_1.SERVICE_REQUIRED_EXTENSIONS], prompter, argv);
+        const svcModuleDir = await (0, export_utils_1.preparePackage)({
+            project,
+            author,
+            outdir: svcOutdir,
+            name: metaExtensionName,
+            description: metaDesc,
+            extensions: [...export_utils_1.SERVICE_REQUIRED_EXTENSIONS],
+            prompter,
+            repoName,
+            username
+        });
+        if (svcMissingResult.shouldInstall) {
+            await (0, export_utils_1.installMissingModules)(svcModuleDir, svcMissingResult.missingModules);
+        }
+        const metaSchemasForReplacement = skipSchemaRenaming
+            ? []
+            : schemas.filter((schema) => schema_names.includes(schema.schema_name));
+        const metaReplacer = (0, export_utils_1.makeReplacer)({
+            schemas: metaSchemasForReplacement,
+            name: metaExtensionName,
+            // Use extensionName for schema prefix — the services metadata references
+            // schemas owned by the application package (e.g. agent_db_auth_public),
+            // not the services package (agent_db_services_auth_public)
+            schemaPrefix: name
+        });
+        const metaPackage = [];
+        const tablesWithContent = [];
+        for (const tableName of export_utils_1.META_TABLE_ORDER) {
+            const tableSql = metaResult[tableName];
+            if (tableSql) {
+                const replacedSql = metaReplacer.replacer(tableSql);
+                const deps = tableName === 'database'
+                    ? []
+                    : tablesWithContent.length > 0
+                        ? [`migrate/${tablesWithContent[tablesWithContent.length - 1]}`]
+                        : [];
+                metaPackage.push({
+                    deps,
+                    deploy: `migrate/${tableName}`,
+                    content: `${export_utils_1.META_COMMON_HEADER}
+
+${replacedSql}
+
+${export_utils_1.META_COMMON_FOOTER}
+`
+                });
+                tablesWithContent.push(tableName);
+            }
+        }
+        opts.replacer = metaReplacer.replacer;
+        opts.name = metaExtensionName;
+        opts.outdir = svcOutdir;
+        (0, core_1.writePgpmPlan)(metaPackage, opts);
+        (0, core_1.writePgpmFiles)(metaPackage, opts);
+    }
+    console.log('GraphQL export complete.');
+};
+exports.exportGraphQL = exportGraphQL;

package/export-meta.d.ts

@@ -0,0 +1,9 @@
+import { PgpmOptions } from '@pgpmjs/types';
+interface ExportMetaParams {
+    opts: PgpmOptions;
+    dbname: string;
+    database_id: string;
+}
+export type ExportMetaResult = Record<string, string>;
+export declare const exportMeta: ({ opts, dbname, database_id }: ExportMetaParams) => Promise<ExportMetaResult>;
+export {};