appwrite-ctl 1.0.0

package/dist/lib/cli.js

@@ -0,0 +1,136 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+const execAsync = promisify(exec);
+const SNAPSHOT_FILENAME = 'appwrite.config.json';
+/**
+ * Configure the Appwrite CLI client for non-interactive use via API key.
+ */
+export const configureClient = async (config) => {
+    const args = [
+        `--endpoint ${config.endpoint}`,
+        `--project-id ${config.projectId}`,
+        `--key ${config.apiKey}`,
+    ];
+    try {
+        await execAsync(`appwrite client ${args.join(' ')}`);
+        console.log(chalk.green('Appwrite CLI configured successfully.'));
+    }
+    catch (error) {
+        throw new Error(`Failed to configure Appwrite CLI: ${error.message}. Ensure 'appwrite-cli' is installed.`, { cause: error });
+    }
+};
+// Resource types to sync (excludes 'settings' which requires interactive login).
+const RESOURCES = ['tables', 'buckets', 'teams', 'topics'];
+/**
+ * Pull a full snapshot from Appwrite into a target directory.
+ * Uses individual `appwrite pull <resource>` commands for non-interactive operation.
+ *
+ * The operation works in the project root (where appwrite.config.json lives).
+ * If a targetDir is provided, it copies the resulting file to the target directory and cleans up the root.
+ */
+export const pullSnapshot = async (targetDir) => {
+    const rootDir = process.cwd();
+    const rootConfig = path.join(rootDir, SNAPSHOT_FILENAME);
+    for (const resource of RESOURCES) {
+        console.log(chalk.blue(`Pulling ${resource}...`));
+        try {
+            await execAsync(`appwrite pull ${resource}`, { cwd: rootDir, timeout: 120_000 });
+            console.log(chalk.green(`  ✓ ${resource}`));
+        }
+        catch (error) {
+            console.warn(chalk.yellow(`  ⚠ Failed to pull ${resource}: ${error.message}`));
+        }
+    }
+    if (!fs.existsSync(rootConfig)) {
+        throw new Error(`appwrite.config.json not found at project root after pull. ` +
+            `Ensure the CLI is configured correctly.`);
+    }
+    if (targetDir && targetDir !== rootDir) {
+        // Copy the updated root config into the target version directory
+        const targetPath = path.join(targetDir, SNAPSHOT_FILENAME);
+        fs.copyFileSync(rootConfig, targetPath);
+        console.log(chalk.green(`Snapshot saved to ${targetPath}`));
+        // Cleanup: Remove the root appwrite.config.json created by the pull command.
+        if (fs.existsSync(rootConfig)) {
+            fs.unlinkSync(rootConfig);
+        }
+        return targetPath;
+    }
+    console.log(chalk.green(`Snapshot saved to ${rootConfig}`));
+    return rootConfig;
+};
+/**
+ * Push a snapshot from a version directory to the Appwrite project.
+ * Copies the version's appwrite.config.json to the project root,
+ * then runs individual `appwrite push <resource> --all --force` commands.
+ *
+ * The `projectId` in the snapshot is rewritten to match the current config,
+ * allowing the same snapshot to be pushed to any environment.
+ *
+ * `--all` auto-selects all resources, `--force` auto-confirms changes.
+ */
+export const pushSnapshot = async (snapshotPath, config) => {
+    const rootDir = process.cwd();
+    const rootConfig = path.join(rootDir, SNAPSHOT_FILENAME);
+    if (!fs.existsSync(snapshotPath)) {
+        throw new Error(`Snapshot not found: ${snapshotPath}`);
+    }
+    // Backup current root config before overwriting.
+    const backupPath = rootConfig + '.bak';
+    const originalExists = fs.existsSync(rootConfig);
+    if (originalExists) {
+        fs.copyFileSync(rootConfig, backupPath);
+    }
+    // Copy snapshot to root and rewrite projectId to match current environment.
+    const snapshotData = JSON.parse(fs.readFileSync(snapshotPath, 'utf8'));
+    snapshotData.projectId = config.projectId;
+    fs.writeFileSync(rootConfig, JSON.stringify(snapshotData, null, 2));
+    console.log(chalk.blue(`Snapshot copied to project root (projectId: ${config.projectId}).`));
+    try {
+        for (const resource of RESOURCES) {
+            console.log(chalk.blue(`Pushing ${resource}...`));
+            try {
+                const extraFlags = resource === 'tables' ? '--attempts 60' : '';
+                await execAsync(`appwrite push ${resource} --all --force ${extraFlags}`.trim(), {
+                    cwd: rootDir,
+                    timeout: 300_000,
+                });
+                console.log(chalk.green(`  ✓ ${resource}`));
+            }
+            catch (error) {
+                console.error(chalk.red(`  ✗ Failed to push ${resource}: ${error.message}`));
+                throw error;
+            }
+        }
+    }
+    catch (error) {
+        // Restore backup if push fails.
+        if (originalExists && fs.existsSync(backupPath)) {
+            fs.copyFileSync(backupPath, rootConfig);
+            console.log(chalk.yellow('Root config restored from backup after push failure.'));
+        }
+        throw error;
+    }
+    finally {
+        // Restore original state.
+        if (originalExists) {
+            if (fs.existsSync(backupPath)) {
+                fs.copyFileSync(backupPath, rootConfig);
+                fs.unlinkSync(backupPath);
+            }
+        }
+        else {
+            // If it didn't exist before, delete the one we created.
+            if (fs.existsSync(rootConfig)) {
+                fs.unlinkSync(rootConfig);
+            }
+        }
+    }
+};
+/**
+ * Get the snapshot filename used for versioned snapshots.
+ */
+export const getSnapshotFilename = () => SNAPSHOT_FILENAME;

package/dist/lib/config.d.ts

@@ -0,0 +1,12 @@
+export interface AppConfig {
+    endpoint: string;
+    projectId: string;
+    apiKey: string;
+    migrationCollectionId: string;
+    database: string;
+    backupCommand?: string;
+}
+/**
+ * Load configuration from environment variables or .env file.
+ */
+export declare const loadConfig: (envPath?: string) => AppConfig;

package/dist/lib/config.js

@@ -0,0 +1,48 @@
+import dotenv from 'dotenv';
+import fs from 'fs';
+import path from 'path';
+/**
+ * Load configuration from environment variables or .env file.
+ */
+export const loadConfig = (envPath = '.env') => {
+    // Load environment variables.
+    dotenv.config({ path: path.resolve(process.cwd(), envPath), override: true });
+    const endpoint = process.env.APPWRITE_ENDPOINT;
+    const projectId = process.env.APPWRITE_PROJECT_ID;
+    const apiKey = process.env.APPWRITE_API_KEY;
+    const backupCommand = process.env.BACKUP_COMMAND;
+    if (!endpoint || !projectId || !apiKey) {
+        throw new Error('Missing required environment variables: APPWRITE_ENDPOINT, APPWRITE_PROJECT_ID, APPWRITE_API_KEY');
+    }
+    // Find root directory.
+    const rootDir = process.cwd();
+    const configPath = path.join(rootDir, 'appwrite', 'migration', 'config.json');
+    let migrationCollectionId = 'migrations';
+    let database = 'system';
+    if (fs.existsSync(configPath)) {
+        try {
+            const fileConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            if (fileConfig.collection) {
+                migrationCollectionId = fileConfig.collection;
+            }
+            if (fileConfig.database) {
+                database = fileConfig.database;
+            }
+            else if (fileConfig.databaseId) {
+                // Backward compatibility.
+                database = fileConfig.databaseId;
+            }
+        }
+        catch (error) {
+            console.warn('Could not parse config.json, using defaults.');
+        }
+    }
+    return {
+        endpoint,
+        projectId,
+        apiKey,
+        migrationCollectionId,
+        database,
+        backupCommand,
+    };
+};

package/dist/lib/diagram.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generate the full schema documentation markdown from a snapshot.
+ */
+export declare const generateSchemaDoc: (snapshotPath: string, version: string) => string;

package/dist/lib/diagram.js

@@ -0,0 +1,222 @@
+import fs from 'fs';
+import path from 'path';
+const MERMAID_CARDINALITY = {
+    oneToOne: '||--||',
+    oneToMany: '||--o{',
+    manyToOne: '}o--||',
+    manyToMany: '}o--o{',
+};
+/**
+ * Map Appwrite column types to concise display types for the ER diagram.
+ */
+const mapColumnType = (col) => {
+    if (col.type === 'string' && col.format === 'enum')
+        return 'enum';
+    if (col.type === 'relationship')
+        return 'relationship';
+    // Sanitize types that conflict with Mermaid reserved words
+    const safeTypes = {
+        text: 'longtext',
+        point: 'geopoint',
+        polygon: 'geopolygon',
+    };
+    return safeTypes[col.type] ?? col.type;
+};
+/**
+ * Format a human-readable file size string.
+ */
+const formatFileSize = (bytes) => {
+    if (bytes >= 1_000_000_000)
+        return `${(bytes / 1_000_000_000).toFixed(1)} GB`;
+    if (bytes >= 1_000_000)
+        return `${(bytes / 1_000_000).toFixed(0)} MB`;
+    if (bytes >= 1_000)
+        return `${(bytes / 1_000).toFixed(0)} KB`;
+    return `${bytes} B`;
+};
+/**
+ * Build the Mermaid erDiagram block for a set of tables.
+ */
+const buildErDiagram = (tables) => {
+    const lines = ['```mermaid', 'erDiagram'];
+    const relationships = [];
+    const renderedPairs = new Set();
+    for (const table of tables) {
+        const entityName = table.name;
+        lines.push(`    ${entityName} {`);
+        // Always add implicit id primary key
+        lines.push(`        string id PK`);
+        for (const col of table.columns) {
+            if (col.type === 'relationship') {
+                // Only emit from the parent side, and skip if pair already rendered
+                if (col.side === 'parent' && col.relatedTable) {
+                    const pairKey = [entityName, col.relatedTable].sort().join(':');
+                    if (!renderedPairs.has(pairKey)) {
+                        renderedPairs.add(pairKey);
+                        const cardinality = MERMAID_CARDINALITY[col.relationType ?? 'oneToMany'] ?? '||--||';
+                        const label = `"${col.key}"`;
+                        relationships.push(`    ${entityName} ${cardinality} ${col.relatedTable} : ${label}`);
+                    }
+                }
+                continue;
+            }
+            const type = mapColumnType(col);
+            const comment = col.required ? '"NOT NULL"' : '';
+            lines.push(`        ${type} ${col.key} ${comment}`.trimEnd());
+        }
+        lines.push(`    }`);
+    }
+    if (relationships.length > 0) {
+        lines.push('');
+        lines.push(...relationships);
+    }
+    lines.push('```');
+    return lines.join('\n');
+};
+/**
+ * Build markdown documentation for a single collection.
+ */
+const buildCollectionDoc = (table) => {
+    const sections = [];
+    const status = table.enabled ? '🟢 Enabled' : '🔴 Disabled';
+    sections.push(`#### ${table.name} (\`${table.$id}\`)`);
+    sections.push('');
+    sections.push(`- **Status:** ${status}`);
+    sections.push(`- **Row-level Security:** ${table.rowSecurity ? 'Yes' : 'No'}`);
+    // Permissions
+    if (table.$permissions.length > 0) {
+        sections.push('');
+        sections.push('**Permissions:**');
+        sections.push('');
+        sections.push('| Permission |');
+        sections.push('| --- |');
+        for (const perm of table.$permissions) {
+            sections.push(`| \`${perm}\` |`);
+        }
+    }
+    // Columns (non-relationship)
+    const dataCols = table.columns.filter((c) => c.type !== 'relationship');
+    if (dataCols.length > 0) {
+        sections.push('');
+        sections.push('**Columns:**');
+        sections.push('');
+        sections.push('| Key | Type | Required | Default | Details |');
+        sections.push('| --- | --- | --- | --- | --- |');
+        for (const col of dataCols) {
+            const type = mapColumnType(col);
+            const required = col.required ? '✅' : '—';
+            const def = col.default !== null && col.default !== undefined ? `\`${col.default}\`` : '—';
+            const details = [];
+            if (col.size)
+                details.push(`size: ${col.size}`);
+            if (col.min !== undefined && col.min !== null)
+                details.push(`min: ${col.min}`);
+            if (col.max !== undefined && col.max !== null)
+                details.push(`max: ${col.max}`);
+            if (col.format === 'enum' && col.elements) {
+                details.push(`values: ${col.elements.map((e) => `\`${e}\``).join(', ')}`);
+            }
+            if (col.array)
+                details.push('array');
+            if (col.encrypt)
+                details.push('encrypted');
+            sections.push(`| \`${col.key}\` | ${type} | ${required} | ${def} | ${details.join('; ') || '—'} |`);
+        }
+    }
+    // Relationships
+    const relCols = table.columns.filter((c) => c.type === 'relationship');
+    if (relCols.length > 0) {
+        sections.push('');
+        sections.push('**Relationships:**');
+        sections.push('');
+        sections.push('| Key | Related Collection | Type | Side | On Delete | Two-way |');
+        sections.push('| --- | --- | --- | --- | --- | --- |');
+        for (const col of relCols) {
+            sections.push(`| \`${col.key}\` | ${col.relatedTable} | ${col.relationType} | ${col.side} | ${col.onDelete ?? '—'} | ${col.twoWay ? 'Yes' : 'No'} |`);
+        }
+    }
+    // Indexes
+    if (table.indexes.length > 0) {
+        sections.push('');
+        sections.push('**Indexes:**');
+        sections.push('');
+        sections.push('| Key | Type | Columns | Orders |');
+        sections.push('| --- | --- | --- | --- |');
+        for (const idx of table.indexes) {
+            sections.push(`| \`${idx.key}\` | ${idx.type} | ${idx.columns.join(', ')} | ${idx.orders.join(', ')} |`);
+        }
+    }
+    return sections.join('\n');
+};
+/**
+ * Build the buckets documentation section.
+ */
+const buildBucketsDoc = (buckets) => {
+    if (buckets.length === 0)
+        return '';
+    const lines = [];
+    lines.push('## Buckets');
+    lines.push('');
+    lines.push('| Name | ID | Max Size | Extensions | Compression | Encryption | Antivirus | Enabled |');
+    lines.push('| --- | --- | --- | --- | --- | --- | --- | --- |');
+    for (const b of buckets) {
+        const extensions = b.allowedFileExtensions.length > 0 ? b.allowedFileExtensions.join(', ') : 'any';
+        lines.push(`| ${b.name} | \`${b.$id}\` | ${formatFileSize(b.maximumFileSize)} | ${extensions} | ${b.compression} | ${b.encryption ? '✅' : '—'} | ${b.antivirus ? '✅' : '—'} | ${b.enabled ? '✅' : '—'} |`);
+    }
+    return lines.join('\n');
+};
+/**
+ * Generate the full schema documentation markdown from a snapshot.
+ */
+export const generateSchemaDoc = (snapshotPath, version) => {
+    const raw = fs.readFileSync(snapshotPath, 'utf-8');
+    const snapshot = JSON.parse(raw);
+    // Load migration config to discover the system database name
+    const configPath = path.join(process.cwd(), 'appwrite', 'migration', 'config.json');
+    let systemDbName = 'system';
+    if (fs.existsSync(configPath)) {
+        try {
+            const cfg = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            if (cfg.database)
+                systemDbName = cfg.database;
+        }
+        catch {
+            // Ignore parse errors, keep default
+        }
+    }
+    const sections = [];
+    sections.push(`# Schema — ${version}`);
+    sections.push('');
+    sections.push(`> Auto-generated from \`appwrite.config.json\` (${version})`);
+    // Filter out system database
+    const userDatabases = snapshot.tablesDB.filter((db) => db.$id !== systemDbName);
+    for (const db of userDatabases) {
+        const dbTables = snapshot.tables.filter((t) => t.databaseId === db.$id);
+        if (dbTables.length === 0)
+            continue;
+        const dbStatus = db.enabled ? '🟢 Enabled' : '🔴 Disabled';
+        sections.push('');
+        sections.push(`## Database: ${db.name} (\`${db.$id}\`)`);
+        sections.push('');
+        sections.push(`- **Status:** ${dbStatus}`);
+        sections.push(`- **Collections:** ${dbTables.length}`);
+        // ER Diagram for this database
+        sections.push('');
+        sections.push('### ER Diagram');
+        sections.push('');
+        sections.push(buildErDiagram(dbTables));
+        // Collection details
+        sections.push('');
+        sections.push('### Collections');
+        for (const table of dbTables) {
+            sections.push('');
+            sections.push(buildCollectionDoc(table));
+        }
+    }
+    // Buckets section
+    if (snapshot.buckets.length > 0) {
+        sections.push('');
+        sections.push(buildBucketsDoc(snapshot.buckets));
+    }
+    return sections.join('\n') + '\n';
+};

package/dist/lib/runner.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Run pending migrations.
+ */
+export declare const runMigrations: (envPath?: string) => Promise<void>;

package/dist/lib/runner.js

@@ -0,0 +1,183 @@
+import fs from 'fs';
+import path from 'path';
+import { createJiti } from 'jiti';
+import { loadConfig } from './config.js';
+import { createAppwriteClient, getAppliedMigrations, recordMigration } from './appwrite.js';
+import { configureClient, pushSnapshot, getSnapshotFilename } from './cli.js';
+import chalk from 'chalk';
+const jiti = createJiti(import.meta.url);
+/**
+ * Run pending migrations.
+ */
+export const runMigrations = async (envPath = '.env') => {
+    const config = loadConfig(envPath);
+    const { client, databases } = createAppwriteClient(config);
+    console.log('Starting migration process...');
+    // 0. Configure CLI with API key (non-interactive auth).
+    console.log('Configuring Appwrite CLI...');
+    await configureClient(config);
+    // 1. Discovery.
+    const migrationsDir = path.join(process.cwd(), 'appwrite', 'migration');
+    if (!fs.existsSync(migrationsDir)) {
+        console.error(`Migrations directory not found at ${migrationsDir}`);
+        process.exit(1);
+    }
+    const versionDirs = fs
+        .readdirSync(migrationsDir)
+        .filter((dir) => dir.startsWith('v') && fs.statSync(path.join(migrationsDir, dir)).isDirectory())
+        .sort((a, b) => {
+        const numA = parseInt(a.substring(1));
+        const numB = parseInt(b.substring(1));
+        return numA - numB;
+    });
+    console.log(`Found ${versionDirs.length} versions.`);
+    // 2. State Check.
+    const appliedMigrationIds = await getAppliedMigrations(databases, config);
+    const appliedSet = new Set(appliedMigrationIds);
+    const snapshotFilename = getSnapshotFilename();
+    for (const version of versionDirs) {
+        const versionPath = path.join(migrationsDir, version);
+        const indexFile = path.join(versionPath, 'index.ts');
+        const indexFileJs = path.join(versionPath, 'index.js');
+        const validIndexFile = fs.existsSync(indexFile)
+            ? indexFile
+            : fs.existsSync(indexFileJs)
+                ? indexFileJs
+                : null;
+        if (!validIndexFile) {
+            console.warn(`Skipping ${version}: No index.ts or index.js found.`);
+            continue;
+        }
+        // Load migration file using jiti.
+        let migrationModule;
+        try {
+            migrationModule = await jiti.import(validIndexFile);
+        }
+        catch (e) {
+            console.error(`Failed to load migration file ${validIndexFile}:`, e);
+            process.exit(1);
+        }
+        const migration = migrationModule.default;
+        if (!migration || !migration.id) {
+            console.error(`Invalid migration file in ${version}: Missing default export or id.`);
+            process.exit(1);
+        }
+        if (appliedSet.has(migration.id)) {
+            console.log(`Version ${version} (${migration.id}) already applied. Skipping.`);
+            continue;
+        }
+        console.log(`Applying version ${version} (${migration.id})...`);
+        // 3. Backup hook.
+        if (migration.requiresBackup && config.backupCommand) {
+            console.log('Running backup command...');
+            try {
+                const { exec } = await import('child_process');
+                const { promisify } = await import('util');
+                const execAsync = promisify(exec);
+                await execAsync(config.backupCommand);
+            }
+            catch (error) {
+                console.error('Backup failed:', error);
+                process.exit(1);
+            }
+        }
+        else if (migration.requiresBackup && !config.backupCommand) {
+            console.warn('Migration requires backup but BACKUP_COMMAND is not set. Proceeding with caution...');
+        }
+        // 4. Schema sync via CLI push.
+        const snapshotPath = path.join(versionPath, snapshotFilename);
+        if (fs.existsSync(snapshotPath)) {
+            console.log(`Pushing schema snapshot for ${version}...`);
+            try {
+                await pushSnapshot(snapshotPath, config);
+            }
+            catch (error) {
+                console.error('Schema push failed:', error.message);
+                console.error("Ensure 'appwrite-cli' is installed and accessible.");
+                process.exit(1);
+            }
+        }
+        else {
+            console.warn(`No ${snapshotFilename} found in ${version}. Skipping schema sync.`);
+        }
+        // 5. Attribute polling.
+        if (fs.existsSync(snapshotPath)) {
+            await waitForAttributes(databases, snapshotPath);
+        }
+        // 6. Data execution.
+        console.log('Executing migration script...');
+        const context = {
+            client,
+            databases,
+            log: (msg) => console.log(`[${version}] ${msg}`),
+            error: (msg) => console.error(`[${version}] ${msg}`),
+        };
+        if (migration.up) {
+            try {
+                await migration.up(context);
+            }
+            catch (error) {
+                console.error('Migration script failed:', error);
+                process.exit(1);
+            }
+        }
+        // 7. Finalization.
+        console.log('Finalizing...');
+        await recordMigration(databases, config, migration.id, version);
+        console.log(`Version ${version} applied successfully.`);
+    }
+    console.log('All migrations applied.');
+};
+async function waitForAttributes(databases, snapshotPath) {
+    console.log('Polling attribute status...');
+    let schema;
+    try {
+        schema = JSON.parse(fs.readFileSync(snapshotPath, 'utf8'));
+    }
+    catch (e) {
+        console.error('Failed to parse snapshot for attribute polling');
+        return;
+    }
+    // appwrite.config.json format: tables[] with databaseId from tablesDB[].
+    const tables = schema.tables || [];
+    const tablesDB = schema.tablesDB || [];
+    // Build a map of database $id -> database info.
+    const dbMap = new Map();
+    for (const db of tablesDB) {
+        dbMap.set(db.$id, db);
+    }
+    for (const table of tables) {
+        const collectionId = table.$id;
+        const databaseId = table.databaseId;
+        if (!databaseId) {
+            console.warn(`Table ${table.name} (${collectionId}) has no databaseId. Skipping polling.`);
+            continue;
+        }
+        console.log(`Checking attributes for table ${table.name} (${collectionId})...`);
+        let allAvailable = false;
+        while (!allAvailable) {
+            try {
+                const response = await databases.listAttributes(databaseId, collectionId);
+                const attributes = response.attributes;
+                const pending = attributes.filter((attr) => attr.status !== 'available');
+                if (pending.length === 0) {
+                    allAvailable = true;
+                }
+                else {
+                    console.log(`Waiting for ${pending.length} attributes to be available...`);
+                    await new Promise((resolve) => setTimeout(resolve, 2000));
+                }
+            }
+            catch (e) {
+                if (e.code === 500) {
+                    console.warn(chalk.red(`  ⚠ Failed to list attributes for ${collectionId} in DB ${databaseId}: Server Error. Skipping polling for this collection.`));
+                    allAvailable = true; // Force exit loop
+                }
+                else {
+                    console.warn(`Failed to list attributes for ${collectionId} in DB ${databaseId}: ${e.message}. Retrying...`);
+                    await new Promise((resolve) => setTimeout(resolve, 2000));
+                }
+            }
+        }
+    }
+}

package/dist/lib/schema.d.ts

@@ -0,0 +1,6 @@
+import { AppConfig } from './config.js';
+export declare const fetchProjectSchema: (config: AppConfig) => Promise<{
+    projectId: string;
+    projectName: string;
+    collections: any[];
+}>;

package/dist/lib/schema.js

@@ -0,0 +1,57 @@
+import { Client, Databases, Query } from 'node-appwrite';
+import chalk from 'chalk';
+export const fetchProjectSchema = async (config) => {
+    const client = new Client()
+        .setEndpoint(config.endpoint)
+        .setProject(config.projectId)
+        .setKey(config.apiKey);
+    const databases = new Databases(client);
+    // 1. Fetch all databases
+    const dbsList = await databases.list([Query.limit(100)]);
+    const allCollections = [];
+    console.log(`Found ${dbsList.databases.length} databases.`);
+    for (const db of dbsList.databases) {
+        if (db.$id === 'system')
+            continue; // Skip internal system DB if strictly internal
+        console.log(`Fetching collections for database ${db.$id}...`);
+        try {
+            // 2. Fetch all collections for this DB
+            const colsList = await databases.listCollections(db.$id, [Query.limit(100)]);
+            console.log(`Found ${colsList.collections.length} collections in ${db.$id}.`);
+            for (const col of colsList.collections) {
+                try {
+                    // 3. For each collection, we need full details (attributes, indexes).
+                    const collectionData = {
+                        ...col,
+                        databaseId: db.$id, // Important for deployment
+                    };
+                    allCollections.push(collectionData);
+                }
+                catch (innerErr) {
+                    console.warn(`Skipping collection processing due to error: ${innerErr.message}`);
+                }
+            }
+        }
+        catch (err) {
+            console.error(`Error fetching collections for DB ${db.$id}:`, err.message);
+            // Attempt to identify which collection is broken if we have a hint
+            if (config.knownCollectionIds && config.knownCollectionIds.length > 0) {
+                console.log(chalk.yellow('Attempting to diagnose problematic collections...'));
+                for (const colId of config.knownCollectionIds) {
+                    try {
+                        await databases.getCollection(db.$id, colId);
+                    }
+                    catch (innerErr) {
+                        console.error(chalk.red(`  - Collection '${colId}' failed to load: ${innerErr.message}`));
+                    }
+                }
+            }
+            throw err;
+        }
+    }
+    return {
+        projectId: config.projectId,
+        projectName: config.projectId,
+        collections: allCollections,
+    };
+};