appwrite-utils-cli 1.9.7 → 1.12.0

package/dist/utils/setupFiles.js

@@ -1,15 +1,13 @@
 import { mkdirSync, writeFileSync, existsSync } from "node:fs";
 import path from "node:path";
 import { findAppwriteConfig } from "./loadConfigs.js";
-import { loadYamlConfig } from "../config/yamlConfig.js";
-import { fetchServerVersion, isVersionAtLeast } from "./versionDetection.js";
-import { findYamlConfig } from "../config/yamlConfig.js";
+import { loadYamlConfig, findYamlConfig, generateYamlConfigTemplate } from "appwrite-utils-helpers";
+import { fetchServerVersion, isVersionAtLeast } from 'appwrite-utils-helpers';
 import { ID } from "node-appwrite";
 import { ulid } from "ulidx";
-import { generateYamlConfigTemplate } from "../config/yamlConfig.js";
-import { loadAppwriteProjectConfig, findAppwriteProjectConfig, getProjectDirectoryName, isTablesDBProject } from "./projectConfig.js";
-import { hasSessionAuth, getSessionAuth } from "./sessionAuth.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { loadAppwriteProjectConfig, findAppwriteProjectConfig, getProjectDirectoryName, isTablesDBProject } from 'appwrite-utils-helpers';
+import { hasSessionAuth, getSessionAuth } from 'appwrite-utils-helpers';
+import { MessageFormatter } from "appwrite-utils-helpers";
 // Example base configuration using types from appwrite-utils
 const baseConfig = {
     appwriteEndpoint: "https://cloud.appwrite.io/v1",
@@ -86,31 +84,31 @@ const baseConfig = {
 const collectionsConfig = [
     {
         name: "ExampleCollection",
-        content: `import type { CollectionCreate } from "appwrite-utils";
-    
-const ExampleCollection: Partial<CollectionCreate> = {
-  name: 'ExampleCollection',
-  $id: '${ulid()}',
-  documentSecurity: false,
-  enabled: true,
-  $permissions: [
-    { permission: 'read', target: 'any' },
-    { permission: 'create', target: 'users' },
-    { permission: 'update', target: 'users' },
-    { permission: 'delete', target: 'users' }
-  ],
-  attributes: [
-    { key: 'alterEgoName', type: 'string', size: 255, required: false },
-    // Add more attributes here
-  ],
-  indexes: [
-    { key: 'alterEgoName_search', type: 'fulltext', attributes: ['alterEgoName'] }
-  ],
-  importDefs: [
-    // Define import definitions here
-  ]
-};
-
+        content: `import type { CollectionCreate } from "appwrite-utils";
+    
+const ExampleCollection: Partial<CollectionCreate> = {
+  name: 'ExampleCollection',
+  $id: '${ulid()}',
+  documentSecurity: false,
+  enabled: true,
+  $permissions: [
+    { permission: 'read', target: 'any' },
+    { permission: 'create', target: 'users' },
+    { permission: 'update', target: 'users' },
+    { permission: 'delete', target: 'users' }
+  ],
+  attributes: [
+    { key: 'alterEgoName', type: 'string', size: 255, required: false },
+    // Add more attributes here
+  ],
+  indexes: [
+    { key: 'alterEgoName_search', type: 'fulltext', attributes: ['alterEgoName'] }
+  ],
+  importDefs: [
+    // Define import definitions here
+  ]
+};
+
 export default ExampleCollection;`,
     },
     // Add more collections here
@@ -118,16 +116,16 @@ export default ExampleCollection;`,
 // Define our YAML files
 // Define our YAML files
 const configFileExample = `d`;
-export const customDefinitionsFile = `import type { ConverterFunctions, ValidationRules, AfterImportActions } from "appwrite-utils";
-
-export const customConverterFunctions: ConverterFunctions = {
-  // Add your custom converter functions here
-}
-export const customValidationRules: ValidationRules = {
-  // Add your custom validation rules here
-}
-export const customAfterImportActions: AfterImportActions = {
-  // Add your custom after import actions here
+export const customDefinitionsFile = `import type { ConverterFunctions, ValidationRules, AfterImportActions } from "appwrite-utils";
+
+export const customConverterFunctions: ConverterFunctions = {
+  // Add your custom converter functions here
+}
+export const customValidationRules: ValidationRules = {
+  // Add your custom validation rules here
+}
+export const customAfterImportActions: AfterImportActions = {
+  // Add your custom after import actions here
 }`;
 export const createEmptyCollection = (collectionName) => {
     const currentDir = process.cwd();
@@ -159,37 +157,37 @@ export const createEmptyCollection = (collectionName) => {
     }
     if (isYamlProject) {
         // Create YAML collection
-        const yamlCollection = `# yaml-language-server: $schema=../.yaml_schemas/collection.schema.json
-# Collection Definition: ${collectionName}
-name: ${collectionName}
-id: ${ulid()}
-documentSecurity: false
-enabled: true
-permissions:
-  - permission: read
-    target: any
-  - permission: create
-    target: users
-  - permission: update
-    target: users
-  - permission: delete
-    target: users
-attributes:
-  # Add your attributes here
-  # Example:
-  # - key: title
-  #   type: string
-  #   size: 255
-  #   required: true
-  #   description: "The title of the item"
-indexes:
-  # Add your indexes here
-  # Example:
-  # - key: title_search
-  #   type: fulltext
-  #   attributes:
-  #     - title
-importDefs: []
+        const yamlCollection = `# yaml-language-server: $schema=../.yaml_schemas/collection.schema.json
+# Collection Definition: ${collectionName}
+name: ${collectionName}
+id: ${ulid()}
+documentSecurity: false
+enabled: true
+permissions:
+  - permission: read
+    target: any
+  - permission: create
+    target: users
+  - permission: update
+    target: users
+  - permission: delete
+    target: users
+attributes:
+  # Add your attributes here
+  # Example:
+  # - key: title
+  #   type: string
+  #   size: 255
+  #   required: true
+  #   description: "The title of the item"
+indexes:
+  # Add your indexes here
+  # Example:
+  # - key: title_search
+  #   type: fulltext
+  #   attributes:
+  #     - title
+importDefs: []
 `;
         const collectionFilePath = path.join(collectionsFolder, `${collectionName}.yaml`);
         writeFileSync(collectionFilePath, yamlCollection);
@@ -197,27 +195,27 @@ importDefs: []
     }
     else {
         // Create TypeScript collection
-        const emptyCollection = `import type { CollectionCreate } from "appwrite-utils";
-
-const ${collectionName}: Partial<CollectionCreate> = {
-  $id: '${ulid()}',
-  documentSecurity: false,
-  enabled: true,
-  name: '${collectionName}',
-  $permissions: [
-    { permission: 'read', target: 'any' },
-    { permission: 'create', target: 'users' },
-    { permission: 'update', target: 'users' },
-    { permission: 'delete', target: 'users' }
-  ],
-  attributes: [
-    // Add more attributes here
-  ],
-  indexes: [
-    // Add more indexes here
-  ],
-};
-
+        const emptyCollection = `import type { CollectionCreate } from "appwrite-utils";
+
+const ${collectionName}: Partial<CollectionCreate> = {
+  $id: '${ulid()}',
+  documentSecurity: false,
+  enabled: true,
+  name: '${collectionName}',
+  $permissions: [
+    { permission: 'read', target: 'any' },
+    { permission: 'create', target: 'users' },
+    { permission: 'update', target: 'users' },
+    { permission: 'delete', target: 'users' }
+  ],
+  attributes: [
+    // Add more attributes here
+  ],
+  indexes: [
+    // Add more indexes here
+  ],
+};
+
 export default ${collectionName};`;
         const collectionFilePath = path.join(collectionsFolder, `${collectionName}.ts`);
         writeFileSync(collectionFilePath, emptyCollection);
@@ -307,11 +305,11 @@ export const setupDirsFiles = async (example = false, currentDir, useYaml = true
             writeFileSync(appwriteConfigFile, configFileExample);
         }
         else {
-            const baseConfigContent = `import { type AppwriteConfig } from "appwrite-utils";
-
-const appwriteConfig: AppwriteConfig = ${JSON.stringify(baseConfig, null, 2)};
-
-export default appwriteConfig;
+            const baseConfigContent = `import { type AppwriteConfig } from "appwrite-utils";
+
+const appwriteConfig: AppwriteConfig = ${JSON.stringify(baseConfig, null, 2)};
+
+export default appwriteConfig;
 `;
             writeFileSync(appwriteConfigFile, baseConfigContent);
         }
@@ -342,48 +340,48 @@ export default appwriteConfig;
                 containerName: "Collection",
                 fieldName: "Attribute"
             };
-        const yamlExample = `# yaml-language-server: $schema=../.yaml_schemas/${terminology.schemaRef}
-# Example ${terminology.containerName} Definition
-name: Example${terminology.containerName}
-id: example_${terminology.container}_${Date.now()}
-${terminology.security}: false
-enabled: true
-permissions:
-  - permission: read
-    target: any
-  - permission: create
-    target: users
-  - permission: update
-    target: users
-  - permission: delete
-    target: users
-${terminology.fields}:
-  - key: title
-    type: string
-    size: 255
-    required: true
-    description: "The title of the item"
-  - key: description
-    type: string
-    size: 1000
-    required: false
-    description: "A longer description"
-  - key: isActive
-    type: boolean
-    required: false
-    default: true${useTables ? `
-  - key: uniqueCode
-    type: string
-    size: 50
-    required: false
-    unique: true
-    description: "Unique identifier code (TablesDB feature)"` : ''}
-indexes:
-  - key: title_search
-    type: fulltext
-    attributes:
-      - title
-importDefs: []
+        const yamlExample = `# yaml-language-server: $schema=../.yaml_schemas/${terminology.schemaRef}
+# Example ${terminology.containerName} Definition
+name: Example${terminology.containerName}
+id: example_${terminology.container}_${Date.now()}
+${terminology.security}: false
+enabled: true
+permissions:
+  - permission: read
+    target: any
+  - permission: create
+    target: users
+  - permission: update
+    target: users
+  - permission: delete
+    target: users
+${terminology.fields}:
+  - key: title
+    type: string
+    size: 255
+    required: true
+    description: "The title of the item"
+  - key: description
+    type: string
+    size: 1000
+    required: false
+    description: "A longer description"
+  - key: isActive
+    type: boolean
+    required: false
+    default: true${useTables ? `
+  - key: uniqueCode
+    type: string
+    size: 50
+    required: false
+    unique: true
+    description: "Unique identifier code (TablesDB feature)"` : ''}
+indexes:
+  - key: title_search
+    type: fulltext
+    attributes:
+      - title
+importDefs: []
 `;
         const yamlExamplePath = path.join(collectionsFolder, `Example${terminology.containerName}.yaml`);
         writeFileSync(yamlExamplePath, yamlExample);

package/dist/utilsController.d.ts

@@ -2,8 +2,8 @@ import { Client, Databases, Storage, type Models } from "node-appwrite";
 import { type AppwriteConfig, type AppwriteFunction, type Specification } from "appwrite-utils";
 import { type AfterImportActions, type ConverterFunctions, type ValidationRules } from "appwrite-utils";
 import { type TransferOptions } from "./migrations/transfer.js";
-import type { DatabaseAdapter } from './adapters/DatabaseAdapter.js';
-import { type ValidationResult } from "./config/configValidation.js";
+import type { DatabaseAdapter } from 'appwrite-utils-helpers';
+import { type ValidationResult } from "appwrite-utils-helpers";
 import type { DatabaseSelection, BucketSelection } from "./shared/selectionDialogs.js";
 export interface SetupOptions {
     databases?: Models.Database[];
@@ -19,6 +19,18 @@ export interface SetupOptions {
     checkDuplicates?: boolean;
     shouldWriteFile?: boolean;
 }
+export interface ControllerInitOptions {
+    validate?: boolean;
+    strictMode?: boolean;
+    useSession?: boolean;
+    sessionCookie?: string;
+    preferJson?: boolean;
+    overrides?: {
+        appwriteEndpoint?: string;
+        appwriteProject?: string;
+        appwriteKey?: string;
+    };
+}
 export declare class UtilsController {
     private static instance;
     private isInitialized;
@@ -50,15 +62,10 @@ export declare class UtilsController {
         appwriteProject?: string;
         appwriteKey?: string;
     });
-    init(options?: {
-        validate?: boolean;
-        strictMode?: boolean;
-        useSession?: boolean;
-        sessionCookie?: string;
-        preferJson?: boolean;
-    }): Promise<void>;
+    init(options?: ControllerInitOptions): Promise<void>;
     reloadConfig(): Promise<void>;
     ensureDatabaseConfigBucketsExist(databases?: Models.Database[]): Promise<void>;
+    pushGlobalBuckets(selectedBucketIds?: string[]): Promise<void>;
     ensureDatabasesExist(databases?: Models.Database[]): Promise<void>;
     ensureCollectionsExist(database: Models.Database, collections?: Models.Collection[]): Promise<void>;
     getDatabasesByIds(ids: string[]): Promise<Models.Database[] | undefined>;

package/dist/utilsController.js

@@ -1,7 +1,7 @@
 import { Client, Databases, Query, Storage, Users, } from "node-appwrite";
 import {} from "appwrite-utils";
 import { findAppwriteConfig, findFunctionsDir, } from "./utils/loadConfigs.js";
-import { normalizeFunctionName, validateFunctionDirectory } from './functions/pathResolution.js';
+import { normalizeFunctionName, validateFunctionDirectory } from 'appwrite-utils-helpers';
 import { UsersController } from "./users/methods.js";
 import { AppwriteToX } from "./migrations/appwriteToX.js";
 import { ImportController } from "./migrations/importController.js";
@@ -9,27 +9,22 @@ import { ImportDataActions } from "./migrations/importDataActions.js";
 import { ensureDatabasesExist, wipeOtherDatabases, ensureCollectionsExist, } from "./databases/setup.js";
 import { createOrUpdateCollections, createOrUpdateCollectionsViaAdapter, wipeDatabase, generateSchemas, fetchAllCollections, wipeCollection, } from "./collections/methods.js";
 import { wipeAllTables, wipeTableRows } from "./collections/methods.js";
-import { backupDatabase, ensureDatabaseConfigBucketsExist, wipeDocumentStorage, } from "./storage/methods.js";
+import { backupDatabase, ensureDatabaseConfigBucketsExist, ensureGlobalBucketsExist, wipeDocumentStorage, } from "./storage/methods.js";
 import path from "path";
 import { converterFunctions, validationRules, } from "appwrite-utils";
 import { afterImportActions } from "./migrations/afterImportActions.js";
 import { transferDatabaseLocalToLocal, transferDatabaseLocalToRemote, transferStorageLocalToLocal, transferStorageLocalToRemote, transferUsersLocalToRemote, } from "./migrations/transfer.js";
-import { getClient, getClientWithAuth } from "./utils/getClientFromConfig.js";
-import { getAdapterFromConfig } from "./utils/getClientFromConfig.js";
-import { hasSessionAuth, findSessionByEndpointAndProject, isValidSessionCookie } from "./utils/sessionAuth.js";
+import { getClient, getClientWithAuth } from "appwrite-utils-helpers";
+import { getAdapterFromConfig } from "appwrite-utils-helpers";
+import { hasSessionAuth, findSessionByEndpointAndProject, isValidSessionCookie } from "appwrite-utils-helpers";
 import { fetchAllDatabases } from "./databases/methods.js";
 import { listFunctions, updateFunctionSpecifications, } from "./functions/methods.js";
 import chalk from "chalk";
 import { deployLocalFunction } from "./functions/deployments.js";
 import fs from "node:fs";
-import { configureLogging, updateLogger, logger } from "./shared/logging.js";
-import { MessageFormatter, Messages } from "./shared/messageFormatter.js";
-import { SchemaGenerator } from "./shared/schemaGenerator.js";
-import { findYamlConfig } from "./config/yamlConfig.js";
+import { configureLogging, updateLogger, logger, MessageFormatter, Messages, SchemaGenerator, findYamlConfig, validateCollectionsTablesConfig, reportValidationResults, validateWithStrictMode, ConfigManager } from "appwrite-utils-helpers";
 import { createImportSchemas } from "./migrations/yaml/generateImportSchemas.js";
-import { validateCollectionsTablesConfig, reportValidationResults, validateWithStrictMode } from "./config/configValidation.js";
-import { ConfigManager } from "./config/ConfigManager.js";
-import { ClientFactory } from "./utils/ClientFactory.js";
+import { ClientFactory } from "appwrite-utils-helpers";
 import { clearProcessingState, processQueue } from "./shared/operationQueue.js";
 export class UtilsController {
     // ──────────────────────────────────────────────────
@@ -152,7 +147,7 @@ export class UtilsController {
         }
     }
     async init(options = {}) {
-        const { validate = false, strictMode = false, preferJson = false } = options;
+        const { validate = false, strictMode = false, preferJson = false, useSession, sessionCookie, overrides } = options;
         const configManager = ConfigManager.getInstance();
         // Load config if not already loaded
         if (!configManager.hasConfig()) {
@@ -161,6 +156,9 @@ export class UtilsController {
                 validate,
                 strictMode,
                 preferJson,
+                useSession,
+                explicitSessionCookie: sessionCookie,
+                overrides,
             });
         }
         const config = configManager.getConfig();
@@ -224,6 +222,18 @@ export class UtilsController {
         }
         await ensureDatabaseConfigBucketsExist(this.storage, this.config, databases);
     }
+    async pushGlobalBuckets(selectedBucketIds) {
+        await this.init();
+        if (!this.storage) {
+            MessageFormatter.error("Storage not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        if (!this.config) {
+            MessageFormatter.error("Config not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        await ensureGlobalBucketsExist(this.storage, this.config, selectedBucketIds);
+    }
     async ensureDatabasesExist(databases) {
         await this.init();
         if (!this.config) {
@@ -353,7 +363,7 @@ export class UtilsController {
             MessageFormatter.error(`Function ${functionName} not found in config`, undefined, { prefix: "Controller" });
             return;
         }
-        await deployLocalFunction(this.appwriteServer, functionName, functionConfig, functionPath);
+        await deployLocalFunction(this.appwriteServer, functionName, functionConfig, functionPath, this.appwriteFolderPath);
     }
     async syncFunctions() {
         await this.init();
@@ -648,72 +658,87 @@ export class UtilsController {
         MessageFormatter.progress("Starting selective push (local config → Appwrite)...", { prefix: "Controller" });
         // Convert database selections to Models.Database format
         const selectedDatabases = [];
+        const serverDatabases = await fetchAllDatabases(this.database);
+        const configuredDatabases = this.config?.databases || [];
         for (const dbSelection of databaseSelections) {
-            // Get the full database object from the controller
-            const databases = await fetchAllDatabases(this.database);
-            const database = databases.find(db => db.$id === dbSelection.databaseId);
-            if (database) {
-                selectedDatabases.push(database);
-                MessageFormatter.info(`Selected database: ${database.name} (${database.$id})`, { prefix: "Controller" });
-                // Log selected tables for this database
-                if (dbSelection.tableIds && dbSelection.tableIds.length > 0) {
-                    MessageFormatter.info(`  Tables: ${dbSelection.tableIds.join(', ')}`, { prefix: "Controller" });
-                }
+            // First try to find on server
+            const serverDb = serverDatabases.find(db => db.$id === dbSelection.databaseId);
+            if (serverDb) {
+                selectedDatabases.push(serverDb);
+                MessageFormatter.info(`Selected database: ${serverDb.name} (${serverDb.$id})`, { prefix: "Controller" });
             }
             else {
-                MessageFormatter.warning(`Database with ID ${dbSelection.databaseId} not found`, { prefix: "Controller" });
+                // Database doesn't exist on server - check if it's in local config
+                const configDb = configuredDatabases.find((db) => db.$id === dbSelection.databaseId);
+                if (configDb) {
+                    // Create a pseudo-database object that ensureDatabasesExist will create
+                    const dbId = configDb.$id;
+                    selectedDatabases.push({
+                        $id: dbId,
+                        name: configDb.name || dbId,
+                        $createdAt: new Date().toISOString(),
+                        $updatedAt: new Date().toISOString(),
+                        enabled: true,
+                    });
+                    MessageFormatter.info(`Selected database: ${configDb.name || dbId} (${dbId}) [will be created]`, { prefix: "Controller" });
+                }
+                else {
+                    MessageFormatter.warning(`Database with ID ${dbSelection.databaseId} not found in server or local config`, { prefix: "Controller" });
+                    continue;
+                }
+            }
+            // Log selected tables for this database
+            if (dbSelection.tableIds && dbSelection.tableIds.length > 0) {
+                MessageFormatter.info(`  Tables: ${dbSelection.tableIds.join(', ')}`, { prefix: "Controller" });
             }
         }
-        if (selectedDatabases.length === 0) {
-            MessageFormatter.warning("No valid databases selected for push", { prefix: "Controller" });
+        if (selectedDatabases.length === 0 && (!bucketSelections || bucketSelections.length === 0)) {
+            MessageFormatter.warning("No valid databases or buckets selected for push", { prefix: "Controller" });
             return;
         }
-        // Log bucket selections if provided
+        // Push global/root-level buckets if any were selected
         if (bucketSelections && bucketSelections.length > 0) {
             MessageFormatter.info(`Selected ${bucketSelections.length} buckets:`, { prefix: "Controller" });
             for (const bucketSelection of bucketSelections) {
                 const dbInfo = bucketSelection.databaseId ? ` (DB: ${bucketSelection.databaseId})` : '';
                 MessageFormatter.info(`  - ${bucketSelection.bucketName} (${bucketSelection.bucketId})${dbInfo}`, { prefix: "Controller" });
             }
-        }
-        // PUSH OPERATION: Push local configuration to Appwrite
-        // Build database-specific collection mappings from databaseSelections
-        const databaseCollectionsMap = new Map();
-        // Get all collections/tables from config (they're at the root level, not nested in databases)
-        const allCollections = this.config?.collections || this.config?.tables || [];
-        // Create database-specific collection mapping to preserve relationships
-        for (const dbSelection of databaseSelections) {
-            const collectionsForDatabase = [];
-            MessageFormatter.info(`Processing collections for database: ${dbSelection.databaseId}`, { prefix: "Controller" });
-            // Filter collections that were selected for THIS specific database
-            for (const collection of allCollections) {
-                const collectionId = collection.$id || collection.id;
-                // Check if this collection was selected for THIS database
-                if (dbSelection.tableIds.includes(collectionId)) {
-                    collectionsForDatabase.push(collection);
-                    const source = collection._isFromTablesDir ? 'tables/' : 'collections/';
-                    MessageFormatter.info(`  - Selected collection: ${collection.name || collectionId} for database ${dbSelection.databaseId} [source: ${source}]`, { prefix: "Controller" });
+            const selectedGlobalBucketIds = bucketSelections.map(bs => bs.bucketId);
+            await this.pushGlobalBuckets(selectedGlobalBucketIds);
+        }
+        // Database + tables push
+        if (selectedDatabases.length > 0) {
+            const databaseCollectionsMap = new Map();
+            const allCollections = [
+                ...(this.config?.collections || []),
+                ...(this.config?.tables || [])
+            ];
+            for (const dbSelection of databaseSelections) {
+                const collectionsForDatabase = [];
+                for (const collection of allCollections) {
+                    const collectionId = collection.$id || collection.id;
+                    if (dbSelection.tableIds.includes(collectionId)) {
+                        collectionsForDatabase.push(collection);
+                        const source = collection._isFromTablesDir ? 'tables/' : 'collections/';
+                        MessageFormatter.info(`  - Selected: ${collection.name || collectionId} → ${dbSelection.databaseId} [${source}]`, { prefix: "Controller" });
+                    }
+                }
+                databaseCollectionsMap.set(dbSelection.databaseId, collectionsForDatabase);
+            }
+            const totalSelectedCollections = Array.from(databaseCollectionsMap.values())
+                .reduce((total, collections) => total + collections.length, 0);
+            MessageFormatter.info(`Pushing ${totalSelectedCollections} selected tables to ${databaseCollectionsMap.size} databases`, { prefix: "Controller" });
+            await this.ensureDatabasesExist(selectedDatabases);
+            await this.ensureDatabaseConfigBucketsExist(selectedDatabases);
+            for (const database of selectedDatabases) {
+                const collectionsForThisDatabase = databaseCollectionsMap.get(database.$id) || [];
+                if (collectionsForThisDatabase.length > 0) {
+                    MessageFormatter.info(`Pushing ${collectionsForThisDatabase.length} tables to database ${database.$id} (${database.name})`, { prefix: "Controller" });
+                    await this.createOrUpdateCollections(database, undefined, collectionsForThisDatabase);
+                }
+                else {
+                    MessageFormatter.info(`No tables selected for database ${database.$id} (${database.name})`, { prefix: "Controller" });
                 }
-            }
-            databaseCollectionsMap.set(dbSelection.databaseId, collectionsForDatabase);
-            MessageFormatter.info(`Database ${dbSelection.databaseId}: ${collectionsForDatabase.length} collections selected`, { prefix: "Controller" });
-        }
-        // Calculate total collections for logging
-        const totalSelectedCollections = Array.from(databaseCollectionsMap.values())
-            .reduce((total, collections) => total + collections.length, 0);
-        MessageFormatter.info(`Pushing ${totalSelectedCollections} selected tables/collections to ${databaseCollectionsMap.size} databases`, { prefix: "Controller" });
-        // Ensure databases exist
-        await this.ensureDatabasesExist(selectedDatabases);
-        await this.ensureDatabaseConfigBucketsExist(selectedDatabases);
-        // Create/update collections with database-specific context
-        for (const database of selectedDatabases) {
-            const collectionsForThisDatabase = databaseCollectionsMap.get(database.$id) || [];
-            if (collectionsForThisDatabase.length > 0) {
-                MessageFormatter.info(`Pushing ${collectionsForThisDatabase.length} collections to database ${database.$id} (${database.name})`, { prefix: "Controller" });
-                await this.createOrUpdateCollections(database, undefined, collectionsForThisDatabase);
-            }
-            else {
-                MessageFormatter.info(`No collections selected for database ${database.$id} (${database.name})`, { prefix: "Controller" });
             }
         }
         MessageFormatter.success("Selective push completed successfully! Local config pushed to Appwrite.", { prefix: "Controller" });
@@ -770,10 +795,10 @@ export class UtilsController {
                 return;
             }
             if (options.isRemote && targetClient) {
-                await transferDatabaseLocalToRemote(sourceClient, options.transferEndpoint, options.transferProject, options.transferKey, fromDb.$id, targetDb.$id);
+                await transferDatabaseLocalToRemote(sourceClient, options.transferEndpoint, options.transferProject, options.transferKey, fromDb.$id, targetDb.$id, options.collections);
             }
             else {
-                await transferDatabaseLocalToLocal(sourceClient, fromDb.$id, targetDb.$id);
+                await transferDatabaseLocalToLocal(sourceClient, fromDb.$id, targetDb.$id, options.collections, this.adapter);
             }
         }
         if (options.transferUsers) {

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "1.9.7",
-  "main": "src/main.ts",
+  "version": "1.12.0",
+  "main": "dist/main.js",
   "type": "module",
+  "files": [
+    "dist"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/zachhandley/AppwriteUtils"
@@ -39,7 +42,8 @@
     "@types/inquirer": "^9.0.8",
     "@types/json-schema": "^7.0.15",
     "@types/yargs": "^17.0.33",
-    "appwrite-utils": "latest",
+    "appwrite-utils": "^1.9.0",
+    "appwrite-utils-helpers": "^0.3.0",
     "chalk": "^5.4.1",
     "cli-progress": "^3.12.0",
     "commander": "^12.1.0",
@@ -54,6 +58,7 @@
     "nanostores": "^0.10.3",
     "node-appwrite": "^20.2.1",
     "p-limit": "^6.2.0",
+    "papaparse": "^5.5.3",
     "tar": "^7.4.3",
     "tsx": "^4.20.3",
     "ulidx": "^2.4.1",
@@ -69,6 +74,7 @@
     "@types/jszip": "^3.4.1",
     "@types/lodash": "^4.17.18",
     "@types/luxon": "^3.6.2",
+    "@types/papaparse": "^5.5.2",
     "jest": "^29.7.0",
     "ts-jest": "^29.1.2",
     "typescript": "^5.8.3"