appwrite-utils-cli 0.0.285 → 0.9.0

package/dist/utilsController.d.ts

@@ -1,33 +1,51 @@
+import { Client, Databases, Storage, type Models } from "node-appwrite";
+import { type AppwriteConfig } from "appwrite-utils";
 import { type AfterImportActions, type ConverterFunctions, type ValidationRules } from "appwrite-utils";
+import { type TransferOptions } from "./migrations/transfer.js";
 export interface SetupOptions {
-    sync: boolean;
-    runProd: boolean;
-    runStaging: boolean;
-    runDev: boolean;
-    doBackup: boolean;
-    wipeDatabases: boolean;
-    wipeDocumentStorage: boolean;
-    wipeUsers: boolean;
-    generateSchemas: boolean;
-    generateMockData: boolean;
-    importData: boolean;
-    checkDuplicates: boolean;
-    shouldWriteFile: boolean;
-    endpoint?: string;
-    project?: string;
-    key?: string;
+    databases?: Models.Database[];
+    collections?: string[];
+    doBackup?: boolean;
+    wipeDatabase?: boolean;
+    wipeDocumentStorage?: boolean;
+    wipeUsers?: boolean;
+    generateSchemas?: boolean;
+    importData?: boolean;
+    checkDuplicates?: boolean;
+    shouldWriteFile?: boolean;
 }
 export declare class UtilsController {
     private appwriteFolderPath;
     private appwriteConfigPath;
-    private config?;
-    private appwriteServer?;
-    private database?;
-    private storage?;
+    config?: AppwriteConfig;
+    appwriteServer?: Client;
+    database?: Databases;
+    storage?: Storage;
     converterDefinitions: ConverterFunctions;
     validityRuleDefinitions: ValidationRules;
     afterImportActionsDefinitions: AfterImportActions;
     constructor(currentUserDir: string);
-    init(setupOptions: SetupOptions): Promise<void>;
-    run(options: SetupOptions): Promise<void>;
+    init(): Promise<void>;
+    setupMigrationDatabase(): Promise<void>;
+    ensureDatabasesExist(databases?: Models.Database[]): Promise<void>;
+    getDatabasesByIds(ids: string[]): Promise<Models.Database[]>;
+    wipeOtherDatabases(databasesToKeep: Models.Database[]): Promise<void>;
+    wipeUsers(): Promise<void>;
+    backupDatabase(database: Models.Database): Promise<void>;
+    wipeDatabase(database: Models.Database): Promise<{
+        collectionId: string;
+        collectionName: string;
+    }[]>;
+    wipeDocumentStorage(bucketId: string): Promise<void>;
+    createOrUpdateCollectionsForDatabases(databases: Models.Database[]): Promise<void>;
+    createOrUpdateCollections(database: Models.Database, deletedCollections?: {
+        collectionId: string;
+        collectionName: string;
+    }[]): Promise<void>;
+    generateSchemas(): Promise<void>;
+    importData(options: SetupOptions): Promise<void>;
+    synchronizeConfigurations(databases?: Models.Database[], config?: AppwriteConfig): Promise<void>;
+    syncDb(): Promise<void>;
+    getAppwriteFolderPath(): string;
+    transferData(options: TransferOptions): Promise<void>;
 }

package/dist/utilsController.js

@@ -1,17 +1,19 @@
-import { Client, Databases, Storage } from "node-appwrite";
-import { startSetup } from "./migrations/setupDatabase.js";
-import path from "path";
-import fs from "fs";
-import { load } from "js-yaml";
+import { Client, Databases, Query, Storage } from "node-appwrite";
+import {} from "appwrite-utils";
+import { loadConfig, findAppwriteConfig } from "./utils/loadConfigs.js";
+import { UsersController } from "./migrations/users.js";
+import { AppwriteToX } from "./migrations/appwriteToX.js";
+import { ImportController } from "./migrations/importController.js";
 import { ImportDataActions } from "./migrations/importDataActions.js";
-import { readFileSync } from "./utils/helperFunctions.js";
+import { setupMigrationDatabase, ensureDatabasesExist, wipeOtherDatabases, } from "./migrations/setupDatabase.js";
+import { createOrUpdateCollections, wipeDatabase, generateSchemas, fetchAllCollections, } from "./collections/methods.js";
+import { backupDatabase, initOrGetBackupStorage, wipeDocumentStorage, } from "./storage/methods.js";
+import path from "path";
+import { converterFunctions, validationRules, } from "appwrite-utils";
 import { afterImportActions } from "./migrations/afterImportActions.js";
-import { converterFunctions, validationRules, AppwriteConfigSchema, } from "appwrite-utils";
-import { ImportController } from "./migrations/importController.js";
-import _ from "lodash";
-import { AppwriteToX } from "./migrations/appwriteToX.js";
-import { loadConfig as loadTsConfig } from "./utils/loadConfigs.js";
-import { findAppwriteConfig } from "./utils/loadConfigs.js";
+import { transferDatabaseLocalToLocal, transferDatabaseLocalToRemote, transferStorageLocalToLocal, transferStorageLocalToRemote, } from "./migrations/transfer.js";
+import { getClient } from "./utils/getClientFromConfig.js";
+import { fetchAllDatabases } from "./migrations/databases.js";
 export class UtilsController {
     appwriteFolderPath;
     appwriteConfigPath;
@@ -23,7 +25,7 @@ export class UtilsController {
     validityRuleDefinitions = validationRules;
     afterImportActionsDefinitions = afterImportActions;
     constructor(currentUserDir) {
-        const basePath = currentUserDir; // Gets the current working directory
+        const basePath = currentUserDir;
         const appwriteConfigFound = findAppwriteConfig(basePath);
         if (!appwriteConfigFound) {
             throw new Error("Failed to find appwriteConfig.ts");
@@ -34,91 +36,169 @@ export class UtilsController {
             throw new Error("Failed to get appwriteFolderPath");
         }
     }
-    // async loadCustomDefinitions(): Promise<void> {
-    //   try {
-    //     const customDefinitionsPath = path.join(
-    //       this.appwriteFolderPath,
-    //       "customDefinitions.ts"
-    //     );
-    //     if (fs.existsSync(customDefinitionsPath)) {
-    //       // Dynamically import custom definitions
-    //       const customDefinitions = (await import(
-    //         customDefinitionsPath
-    //       )) as typeof import("customDefinitions");
-    //       this.converterDefinitions = {
-    //         ...this.converterDefinitions,
-    //         ...customDefinitions.converterDefinitions,
-    //       };
-    //       this.validityRuleDefinitions = {
-    //         ...this.validityRuleDefinitions,
-    //         ...customDefinitions.validityRuleDefinitions,
-    //       };
-    //       this.afterImportActionsDefinitions = {
-    //         ...this.afterImportActionsDefinitions,
-    //         ...customDefinitions.afterImportActionsDefinitions,
-    //       };
-    //     }
-    //   } catch (error) {
-    //     console.error("Failed to load custom definitions:", error);
-    //   }
-    // }
-    async init(setupOptions) {
+    async init() {
         if (!this.config) {
             console.log("Initializing appwrite client & loading config...");
-            this.config = await loadTsConfig(this.appwriteFolderPath);
+            this.config = await loadConfig(this.appwriteFolderPath);
             if (!this.config) {
                 throw new Error("Failed to load config");
             }
             this.appwriteServer = new Client();
-            if (setupOptions.endpoint) {
-                if (!setupOptions.project || !setupOptions.key) {
-                    throw new Error("Project ID and API key required when setting endpoint");
-                }
-                this.appwriteServer
-                    .setEndpoint(setupOptions.endpoint)
-                    .setProject(setupOptions.project)
-                    .setKey(setupOptions.key);
-            }
-            else {
-                this.appwriteServer
-                    .setEndpoint(this.config.appwriteEndpoint)
-                    .setProject(this.config.appwriteProject)
-                    .setKey(this.config.appwriteKey);
-            }
+            this.appwriteServer
+                .setEndpoint(this.config.appwriteEndpoint)
+                .setProject(this.config.appwriteProject)
+                .setKey(this.config.appwriteKey);
             this.database = new Databases(this.appwriteServer);
             this.storage = new Storage(this.appwriteServer);
             this.config.appwriteClient = this.appwriteServer;
-            // await this.loadCustomDefinitions();
         }
     }
-    async run(options) {
-        await this.init(options); // Ensure initialization is done
-        if (!this.database || !this.storage || !this.config) {
-            throw new Error("Database or storage not initialized");
+    async setupMigrationDatabase() {
+        await this.init();
+        if (!this.config)
+            throw new Error("Config not initialized");
+        await setupMigrationDatabase(this.config);
+    }
+    async ensureDatabasesExist(databases) {
+        await this.init();
+        if (!this.config)
+            throw new Error("Config not initialized");
+        await this.setupMigrationDatabase();
+        await ensureDatabasesExist(this.config);
+    }
+    async getDatabasesByIds(ids) {
+        await this.init();
+        if (!this.database)
+            throw new Error("Database not initialized");
+        const dbs = await this.database.list([
+            Query.limit(500),
+            Query.equal("$id", ids),
+        ]);
+        return dbs.databases;
+    }
+    async wipeOtherDatabases(databasesToKeep) {
+        await this.init();
+        if (!this.database)
+            throw new Error("Database not initialized");
+        await wipeOtherDatabases(this.database, databasesToKeep);
+    }
+    async wipeUsers() {
+        await this.init();
+        if (!this.config || !this.database)
+            throw new Error("Config or database not initialized");
+        const usersController = new UsersController(this.config, this.database);
+        await usersController.wipeUsers();
+    }
+    async backupDatabase(database) {
+        await this.init();
+        if (!this.database || !this.storage || !this.config)
+            throw new Error("Database, storage, or config not initialized");
+        await backupDatabase(this.config, this.database, database.$id, this.storage);
+    }
+    async wipeDatabase(database) {
+        await this.init();
+        if (!this.database)
+            throw new Error("Database not initialized");
+        return await wipeDatabase(this.database, database.$id);
+    }
+    async wipeDocumentStorage(bucketId) {
+        await this.init();
+        if (!this.storage)
+            throw new Error("Storage not initialized");
+        await wipeDocumentStorage(this.storage, bucketId);
+    }
+    async createOrUpdateCollectionsForDatabases(databases) {
+        await this.init();
+        if (!this.database || !this.config)
+            throw new Error("Database or config not initialized");
+        for (const database of databases) {
+            await this.createOrUpdateCollections(database);
+        }
+    }
+    async createOrUpdateCollections(database, deletedCollections) {
+        await this.init();
+        if (!this.database || !this.config)
+            throw new Error("Database or config not initialized");
+        await createOrUpdateCollections(this.database, database.$id, this.config, deletedCollections);
+    }
+    async generateSchemas() {
+        await this.init();
+        if (!this.config)
+            throw new Error("Config not initialized");
+        await generateSchemas(this.config, this.appwriteFolderPath);
+    }
+    async importData(options) {
+        await this.init();
+        if (!this.config || !this.database || !this.storage)
+            throw new Error("Config, database, or storage not initialized");
+        const importDataActions = new ImportDataActions(this.database, this.storage, this.config, this.converterDefinitions, this.validityRuleDefinitions, this.afterImportActionsDefinitions);
+        const importController = new ImportController(this.config, this.database, this.storage, this.appwriteFolderPath, importDataActions, options);
+        await importController.run();
+    }
+    async synchronizeConfigurations(databases, config) {
+        await this.init();
+        if (!this.storage)
+            throw new Error("Storage not initialized");
+        const configToUse = config || this.config;
+        if (!configToUse)
+            throw new Error("Config not initialized");
+        const appwriteToX = new AppwriteToX(configToUse, this.appwriteFolderPath, this.storage);
+        await appwriteToX.toSchemas(databases);
+    }
+    async syncDb() {
+        await this.init();
+        if (!this.database)
+            throw new Error("Database not initialized");
+        const databases = await fetchAllDatabases(this.database);
+        await this.ensureDatabasesExist(databases);
+        await this.createOrUpdateCollectionsForDatabases(databases);
+    }
+    getAppwriteFolderPath() {
+        return this.appwriteFolderPath;
+    }
+    async transferData(options) {
+        if (!this.database) {
+            throw new Error("Database is not initialized, is the config file correct & created?");
+        }
+        let sourceClient = this.database;
+        let targetClient;
+        let sourceDatabases;
+        let targetDatabases;
+        if (options.isRemote) {
+            if (!options.transferEndpoint ||
+                !options.transferProject ||
+                !options.transferKey) {
+                throw new Error("Remote transfer options are missing");
+            }
+            const remoteClient = getClient(options.transferEndpoint, options.transferProject, options.transferKey);
+            targetClient = new Databases(remoteClient);
+            sourceDatabases = await fetchAllDatabases(sourceClient);
+            targetDatabases = await fetchAllDatabases(targetClient);
         }
-        if (options.sync) {
-            console.log("Starting synchronization with server...");
-            const appwriteToX = new AppwriteToX(this.config, this.appwriteFolderPath);
-            await appwriteToX.toSchemas();
-            console.log("Synchronization complete, YAML and Schemas updated");
+        else {
+            targetClient = sourceClient;
+            sourceDatabases = targetDatabases = await fetchAllDatabases(sourceClient);
         }
-        // Start the setup
-        console.log("Starting setup, this step sets up migrations, runs backup, wipes databases, and updates schemas (depending on your options)...");
-        await startSetup(this.database, this.storage, this.config, options, this.appwriteFolderPath);
-        console.log("Setup complete.");
-        if (options.generateMockData) {
-            // TODO: Figure out how to do this dynamically
-            // await this.generateMockData();
+        // Validate that the provided databases exist in the fetched lists
+        const fromDb = sourceDatabases.find((db) => db.$id === options.fromDb.$id);
+        const targetDb = targetDatabases.find((db) => db.$id === options.targetDb.$id);
+        if (!fromDb || !targetDb) {
+            throw new Error("Source or target database not found");
         }
-        if (options.importData) {
-            console.log("Starting import data...");
-            const importDataActions = new ImportDataActions(this.database, this.storage, this.config, this.converterDefinitions, this.validityRuleDefinitions, this.afterImportActionsDefinitions);
-            const importController = new ImportController(this.config, this.database, this.storage, this.appwriteFolderPath, importDataActions, options);
-            await importController.run();
-            console.log("Import data complete.");
+        if (options.isRemote) {
+            // Remote transfer
+            await transferDatabaseLocalToRemote(sourceClient, options.transferEndpoint, options.transferProject, options.transferKey, fromDb.$id, targetDb.$id);
+            if (this.storage && options.sourceBucket && options.targetBucket) {
+                await transferStorageLocalToRemote(this.storage, options.transferEndpoint, options.transferProject, options.transferKey, options.sourceBucket.$id, options.targetBucket.$id);
+            }
+        }
+        else {
+            // Local transfer
+            await transferDatabaseLocalToLocal(sourceClient, fromDb.$id, targetDb.$id);
+            if (this.storage && options.sourceBucket && options.targetBucket) {
+                await transferStorageLocalToLocal(this.storage, options.sourceBucket.$id, options.targetBucket.$id);
+            }
         }
-        // if (options.checkDuplicates) {
-        //   await this.checkDuplicates();
-        // }
+        console.log("Data transfer completed");
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "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": "0.0.285",
+  "version": "0.9.0",
   "main": "src/main.ts",
   "type": "module",
   "repository": {
@@ -21,35 +21,33 @@
     "utility"
   ],
   "bin": {
-    "appwrite-init": "./dist/init.js",
     "appwrite-migrate": "./dist/main.js"
   },
   "scripts": {
     "build": "bun run tsc",
-    "init": "tsx --no-cache src/init.ts",
-    "migrate": "tsx --no-cache src/main.ts",
+    "start": "tsx --no-cache src/main.ts migrate",
     "deploy": "bun run build && npm publish --access public",
     "postinstall": "echo 'This package is intended for CLI use only and should not be added as a dependency in other projects.'"
   },
   "dependencies": {
-    "@asteasolutions/zod-to-openapi": "^7.0.0",
     "@types/inquirer": "^9.0.7",
-    "appwrite-utils": "^0.2.1",
-    "commander": "^12.0.0",
-    "inquirer": "^9.2.20",
+    "appwrite-utils": "^0.3.8",
+    "commander": "^12.1.0",
+    "inquirer": "^9.3.6",
     "js-yaml": "^4.1.0",
     "lodash": "^4.17.21",
-    "luxon": "^3.4.4",
+    "luxon": "^3.5.0",
     "nanostores": "^0.10.3",
-    "node-appwrite": "^12.0.1",
-    "tsx": "^4.9.3",
-    "winston": "^3.13.0",
-    "zod": "^3.22.4"
+    "node-appwrite": "^13.0.0",
+    "tsx": "^4.17.0",
+    "ulidx": "^2.4.0",
+    "winston": "^3.14.1",
+    "zod": "^3.23.8"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
-    "@types/lodash": "^4.17.0",
+    "@types/lodash": "^4.17.7",
     "@types/luxon": "^3.4.2",
-    "typescript": "^5.0.0"
+    "typescript": "^5.5.4"
   }
 }