@pgpmjs/export 0.1.0

package/export-meta.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportMeta = void 0;
+const csv_to_pg_1 = require("csv-to-pg");
+const pg_cache_1 = require("pg-cache");
+const export_utils_1 = require("./export-utils");
+/**
+ * Query actual columns from information_schema for a given table.
+ * Returns a map of column_name -> udt_name (PostgreSQL type).
+ */
+const getTableColumns = async (pool, schemaName, tableName) => {
+    const result = await pool.query(`
+    SELECT column_name, udt_name
+    FROM information_schema.columns
+    WHERE table_schema = $1 AND table_name = $2
+    ORDER BY ordinal_position
+  `, [schemaName, tableName]);
+    const columns = new Map();
+    for (const row of result.rows) {
+        columns.set(row.column_name, row.udt_name);
+    }
+    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
+ */
+const buildDynamicFields = async (pool, tableConfig) => {
+    const actualColumns = await getTableColumns(pool, tableConfig.schema, tableConfig.table);
+    if (actualColumns.size === 0) {
+        // Table doesn't exist, return empty fields
+        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;
+        }
+        // If column doesn't exist in database, skip it (this fixes the bug)
+    }
+    return dynamicFields;
+};
+const exportMeta = async ({ opts, dbname, database_id }) => {
+    const pool = (0, pg_cache_1.getPgPool)({
+        ...opts.pg,
+        database: dbname
+    });
+    const sql = {};
+    // Cache for dynamically built parsers
+    const parsers = {};
+    // Build parser dynamically by querying actual columns from the database
+    const getParser = async (key) => {
+        if (parsers[key]) {
+            return parsers[key];
+        }
+        const tableConfig = export_utils_1.META_TABLE_CONFIG[key];
+        if (!tableConfig) {
+            return null;
+        }
+        // Build fields dynamically based on actual database columns
+        const dynamicFields = await buildDynamicFields(pool, tableConfig);
+        if (Object.keys(dynamicFields).length === 0) {
+            // No columns found (table doesn't exist or no matching columns)
+            return null;
+        }
+        const parser = new csv_to_pg_1.Parser({
+            schema: tableConfig.schema,
+            table: tableConfig.table,
+            conflictDoNothing: tableConfig.conflictDoNothing,
+            fields: dynamicFields
+        });
+        parsers[key] = parser;
+        return parser;
+    };
+    const queryAndParse = async (key, query) => {
+        try {
+            const parser = await getParser(key);
+            if (!parser) {
+                return;
+            }
+            const result = await pool.query(query, [database_id]);
+            if (result.rows.length) {
+                const parsed = await parser.parse(result.rows);
+                if (parsed) {
+                    sql[key] = parsed;
+                }
+            }
+        }
+        catch (err) {
+            const pgError = err;
+            if (pgError.code === '42P01') {
+                return;
+            }
+            throw err;
+        }
+    };
+    // =============================================================================
+    // metaschema_public tables
+    // =============================================================================
+    await queryAndParse('database', `SELECT * FROM metaschema_public.database WHERE id = $1 ORDER BY id`);
+    await queryAndParse('database_extension', `SELECT * FROM metaschema_public.database_extension WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('schema', `SELECT * FROM metaschema_public.schema WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('table', `SELECT * FROM metaschema_public.table WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('field', `SELECT * FROM metaschema_public.field WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('policy', `SELECT * FROM metaschema_public.policy WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('index', `SELECT * FROM metaschema_public.index WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('trigger', `SELECT * FROM metaschema_public.trigger WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('trigger_function', `SELECT * FROM metaschema_public.trigger_function WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('rls_function', `SELECT * FROM metaschema_public.rls_function WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('foreign_key_constraint', `SELECT * FROM metaschema_public.foreign_key_constraint WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('primary_key_constraint', `SELECT * FROM metaschema_public.primary_key_constraint WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('unique_constraint', `SELECT * FROM metaschema_public.unique_constraint WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('check_constraint', `SELECT * FROM metaschema_public.check_constraint WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('full_text_search', `SELECT * FROM metaschema_public.full_text_search WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('schema_grant', `SELECT * FROM metaschema_public.schema_grant WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('table_grant', `SELECT * FROM metaschema_public.table_grant WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('default_privilege', `SELECT * FROM metaschema_public.default_privilege WHERE database_id = $1 ORDER BY id`);
+    // =============================================================================
+    // services_public tables
+    // =============================================================================
+    await queryAndParse('domains', `SELECT * FROM services_public.domains WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('sites', `SELECT * FROM services_public.sites WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('apis', `SELECT * FROM services_public.apis WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('apps', `SELECT * FROM services_public.apps WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('site_modules', `SELECT * FROM services_public.site_modules WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('site_themes', `SELECT * FROM services_public.site_themes WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('site_metadata', `SELECT * FROM services_public.site_metadata WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('api_modules', `SELECT * FROM services_public.api_modules WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('api_extensions', `SELECT * FROM services_public.api_extensions WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('api_schemas', `SELECT * FROM services_public.api_schemas WHERE database_id = $1 ORDER BY id`);
+    // =============================================================================
+    // metaschema_modules_public tables
+    // =============================================================================
+    await queryAndParse('rls_module', `SELECT * FROM metaschema_modules_public.rls_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('user_auth_module', `SELECT * FROM metaschema_modules_public.user_auth_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('memberships_module', `SELECT * FROM metaschema_modules_public.memberships_module WHERE database_id = $1 ORDER BY 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('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`);
+    await queryAndParse('invites_module', `SELECT * FROM metaschema_modules_public.invites_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('emails_module', `SELECT * FROM metaschema_modules_public.emails_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('sessions_module', `SELECT * FROM metaschema_modules_public.sessions_module WHERE database_id = $1 ORDER BY id`);
+    await queryAndParse('secrets_module', `SELECT * FROM metaschema_modules_public.secrets_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('encrypted_secrets_module', `SELECT * FROM metaschema_modules_public.encrypted_secrets_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`);
+    await queryAndParse('denormalized_table_field', `SELECT * FROM metaschema_modules_public.denormalized_table_field WHERE database_id = $1 ORDER BY id`);
+    return sql;
+};
+exports.exportMeta = exportMeta;

package/export-migrations.d.ts

@@ -0,0 +1,35 @@
+import { PgpmOptions } from '@pgpmjs/types';
+import { Inquirerer } from 'inquirerer';
+import { PgpmPackage } from '@pgpmjs/core';
+interface ExportOptions {
+    project: PgpmPackage;
+    options: PgpmOptions;
+    dbInfo: {
+        dbname: string;
+        databaseName: string;
+        database_ids: string[];
+    };
+    author: string;
+    outdir: string;
+    schema_names: string[];
+    extensionName?: string;
+    extensionDesc?: string;
+    metaExtensionName: string;
+    metaExtensionDesc?: string;
+    prompter?: Inquirerer;
+    argv?: Record<string, any>;
+    /** Repository name for module scaffolding. Defaults to module name if not provided. */
+    repoName?: string;
+    /** GitHub username/org for module scaffolding. Required for non-interactive use. */
+    username?: string;
+    /** Output directory for service/meta module. Defaults to outdir if not provided. */
+    serviceOutdir?: string;
+    /**
+     * Skip schema name replacement for infrastructure schemas.
+     * When true, schema names like metaschema_public, services_public will not be renamed.
+     * Useful for self-referential introspection where you want to apply policies to real schemas.
+     */
+    skipSchemaRenaming?: boolean;
+}
+export declare const exportMigrations: ({ project, options, dbInfo, author, outdir, schema_names, extensionName, extensionDesc, metaExtensionName, metaExtensionDesc, prompter, argv, repoName, username, serviceOutdir, skipSchemaRenaming }: ExportOptions) => Promise<void>;
+export {};

package/export-migrations.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportMigrations = void 0;
+const pg_cache_1 = require("pg-cache");
+const core_1 = require("@pgpmjs/core");
+const export_meta_1 = require("./export-meta");
+const export_utils_1 = require("./export-utils");
+const exportMigrationsToDisk = async ({ project, options, database, databaseId, databaseName, author, outdir, schema_names, extensionName, extensionDesc, metaExtensionName, metaExtensionDesc, prompter, argv, repoName, username, serviceOutdir, skipSchemaRenaming = false }) => {
+    const normalizedOutdir = (0, export_utils_1.normalizeOutdir)(outdir);
+    // Use serviceOutdir for service module, defaulting to outdir if not provided
+    const svcOutdir = (0, export_utils_1.normalizeOutdir)(serviceOutdir || outdir);
+    const pgPool = (0, pg_cache_1.getPgPool)({
+        ...options.pg,
+        database
+    });
+    const db = await pgPool.query(`select * from metaschema_public.database where id=$1`, [databaseId]);
+    const schemas = await pgPool.query(`select * from metaschema_public.schema where database_id=$1`, [databaseId]);
+    if (!db?.rows?.length) {
+        console.log('NO DATABASES.');
+        return;
+    }
+    if (!schemas?.rows?.length) {
+        console.log('NO SCHEMAS.');
+        return;
+    }
+    const name = extensionName || db.rows[0].name;
+    // When skipSchemaRenaming is true, pass empty schemas array to avoid renaming
+    // This is useful for self-referential introspection where you want to apply
+    // policies to real infrastructure schemas (metaschema_public, services_public, etc.)
+    const schemasForReplacement = skipSchemaRenaming
+        ? []
+        : schemas.rows.filter((schema) => schema_names.includes(schema.schema_name));
+    const { replace, replacer } = (0, export_utils_1.makeReplacer)({
+        schemas: schemasForReplacement,
+        name
+    });
+    // Filter sql_actions by database_id to avoid cross-database pollution
+    // Previously this query had no WHERE clause, which could export actions
+    // from unrelated databases in a persistent database environment
+    const results = await pgPool.query(`select * from db_migrate.sql_actions where database_id = $1 order by id`, [databaseId]);
+    const opts = {
+        name,
+        replacer,
+        outdir: normalizedOutdir,
+        author
+    };
+    // Build description for the database extension package
+    const dbExtensionDesc = extensionDesc || `${name} database schema for ${databaseName}`;
+    if (results?.rows?.length > 0) {
+        // Detect missing modules at workspace level and prompt user
+        const dbMissingResult = await (0, export_utils_1.detectMissingModules)(project, [...export_utils_1.DB_REQUIRED_EXTENSIONS], prompter, argv);
+        // Create/prepare the module directory
+        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
+        });
+        // Install missing modules if user confirmed (now that module exists)
+        if (dbMissingResult.shouldInstall) {
+            await (0, export_utils_1.installMissingModules)(dbModuleDir, dbMissingResult.missingModules);
+        }
+        (0, core_1.writePgpmPlan)(results.rows, opts);
+        (0, core_1.writePgpmFiles)(results.rows, opts);
+    }
+    else {
+        console.log('No sql_actions found — skipping database module. Meta/service module will still be exported.');
+    }
+    // =========================================================================
+    // Meta/service module export — runs independently of sql_actions
+    // =========================================================================
+    const metaResult = await (0, export_meta_1.exportMeta)({
+        opts: options,
+        dbname: database,
+        database_id: databaseId
+    });
+    // Build description for the meta/service extension package
+    const metaDesc = metaExtensionDesc || `${metaExtensionName} service utilities for managing domains, APIs, and services`;
+    // Detect missing modules at workspace level and prompt user
+    const svcMissingResult = await (0, export_utils_1.detectMissingModules)(project, [...export_utils_1.SERVICE_REQUIRED_EXTENSIONS], prompter, argv);
+    // Create/prepare the module directory (use serviceOutdir if provided)
+    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
+    });
+    // Install missing modules if user confirmed (now that module exists)
+    if (svcMissingResult.shouldInstall) {
+        await (0, export_utils_1.installMissingModules)(svcModuleDir, svcMissingResult.missingModules);
+    }
+    // Use same skipSchemaRenaming logic for meta replacer
+    const metaSchemasForReplacement = skipSchemaRenaming
+        ? []
+        : schemas.rows.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
+    });
+    // Create separate files for each table type
+    const metaPackage = [];
+    // Track which tables have content for dependency resolution
+    const tablesWithContent = [];
+    // Create a file for each table type that has content
+    for (const tableName of export_utils_1.META_TABLE_ORDER) {
+        const tableSql = metaResult[tableName];
+        if (tableSql) {
+            const replacedSql = metaReplacer.replacer(tableSql);
+            // Determine dependencies - each table depends on the previous tables that have content
+            // This ensures proper ordering during deployment
+            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);
+    pgPool.end();
+};
+const exportMigrations = async ({ project, options, dbInfo, author, outdir, schema_names, extensionName, extensionDesc, metaExtensionName, metaExtensionDesc, prompter, argv, repoName, username, serviceOutdir, skipSchemaRenaming }) => {
+    for (let v = 0; v < dbInfo.database_ids.length; v++) {
+        const databaseId = dbInfo.database_ids[v];
+        await exportMigrationsToDisk({
+            project,
+            options,
+            extensionName,
+            extensionDesc,
+            metaExtensionName,
+            metaExtensionDesc,
+            database: dbInfo.dbname,
+            databaseName: dbInfo.databaseName,
+            databaseId,
+            schema_names,
+            author,
+            outdir,
+            prompter,
+            argv,
+            repoName,
+            username,
+            serviceOutdir,
+            skipSchemaRenaming
+        });
+    }
+};
+exports.exportMigrations = exportMigrations;

package/export-utils.d.ts

@@ -0,0 +1,127 @@
+import { Inquirerer } from 'inquirerer';
+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", "metaschema-schema", "pgpm-inflection", "pgpm-uuid", "pgpm-utils", "pgpm-database-jobs", "pgpm-jwt-claims", "pgpm-stamps", "pgpm-base32", "pgpm-totp", "pgpm-types"];
+/**
+ * Required extensions for service/meta exports.
+ * Includes native PostgreSQL extensions and pgpm modules for metadata management.
+ */
+export declare const SERVICE_REQUIRED_EXTENSIONS: readonly ["plpgsql", "metaschema-schema", "metaschema-modules", "services"];
+/**
+ * Common SQL header for meta export files.
+ * Sets session_replication_role and grants necessary permissions.
+ */
+export declare const META_COMMON_HEADER = "SET session_replication_role TO replica;\n-- using replica in case we are deploying triggers to metaschema_public\n\n-- unaccent, postgis affected and require grants\nGRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public to public;\n\nDO $LQLMIGRATION$\n  DECLARE\n  BEGIN\n\n    EXECUTE format('GRANT CONNECT ON DATABASE %I TO %I', current_database(), 'app_user');\n    EXECUTE format('GRANT CONNECT ON DATABASE %I TO %I', current_database(), 'app_admin');\n\n  END;\n$LQLMIGRATION$;";
+/**
+ * Common SQL footer for meta export files.
+ */
+export declare const META_COMMON_FOOTER = "\nSET session_replication_role TO DEFAULT;";
+/**
+ * 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", "table", "field", "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", "rls_module", "user_auth_module", "memberships_module", "permissions_module", "limits_module", "levels_module", "users_module", "hierarchy_module", "membership_types_module", "invites_module", "emails_module", "sessions_module", "secrets_module", "profiles_module", "encrypted_secrets_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", "table_template_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>;
+}
+/**
+ * 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
+ *
+ * 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 {
+    name: string;
+    schema_name: string;
+}
+export interface MakeReplacerOptions {
+    schemas: Schema[];
+    name: string;
+    /**
+     * Optional prefix for schema name replacement.
+     * When provided, schema names are replaced using this prefix instead of `name`.
+     * This is needed for the services/meta package where `name` is the services
+     * extension name (e.g. "agent-db-services") but schemas should use the
+     * application extension prefix (e.g. "agent-db" → "agent_db_auth_public").
+     */
+    schemaPrefix?: string;
+}
+export interface ReplacerResult {
+    replacer: (str: string, n?: number) => string;
+    replace: [RegExp, string][];
+}
+export interface PreparePackageOptions {
+    project: PgpmPackage;
+    author: string;
+    outdir: string;
+    name: string;
+    description: string;
+    extensions: string[];
+    prompter?: Inquirerer;
+    /** Repository name for module scaffolding. Defaults to module name if not provided. */
+    repoName?: string;
+    /** GitHub username/org for module scaffolding. Required for non-interactive use. */
+    username?: string;
+}
+/**
+ * Result of checking for missing modules at workspace level.
+ */
+export interface MissingModulesResult {
+    missingModules: {
+        controlName: string;
+        npmName: string;
+    }[];
+    shouldInstall: boolean;
+}
+/**
+ * Checks which pgpm modules from the extensions list are missing from the workspace
+ * and prompts the user if they want to install them.
+ *
+ * This function only does detection and prompting - it does NOT install.
+ * Use installMissingModules() after the module is created to do the actual installation.
+ *
+ * @param project - The PgpmPackage instance (only needs workspace context)
+ * @param extensions - List of extension names (control file names)
+ * @param prompter - Optional prompter for interactive confirmation
+ * @returns Object with missing modules and whether user wants to install them
+ */
+export declare const detectMissingModules: (project: PgpmPackage, extensions: string[], prompter?: Inquirerer, argv?: Record<string, any>) => Promise<MissingModulesResult>;
+/**
+ * Installs missing modules into a specific module directory.
+ * Must be called after the module has been created.
+ *
+ * @param moduleDir - The directory of the module to install into
+ * @param missingModules - Array of missing modules to install
+ */
+export declare const installMissingModules: (moduleDir: string, missingModules: {
+    controlName: string;
+    npmName: string;
+}[]) => Promise<void>;
+/**
+ * Generates a function for replacing schema names and extension names in strings.
+ */
+export declare const makeReplacer: ({ schemas, name, schemaPrefix }: MakeReplacerOptions) => ReplacerResult;
+/**
+ * Creates a PGPM package directory or resets the deploy/revert/verify directories if it exists.
+ * If the module already exists and a prompter is provided, prompts the user for confirmation.
+ *
+ * @returns The absolute path to the created/prepared module directory
+ */
+export declare const preparePackage: ({ project, author, outdir, name, description, extensions, prompter, repoName, username }: PreparePackageOptions) => Promise<string>;
+/**
+ * Normalizes an output directory path to ensure it ends with a path separator.
+ */
+export declare const normalizeOutdir: (outdir: string) => string;