appwrite-utils-cli 0.9.3 → 0.9.5

package/README.md

@@ -124,6 +124,8 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+- 0.9.5: Fixed not checking for storage bucket for each database (checking the creation status) when importing data
+- 0.9.4: Fixed migrations database ensuring it has the required collections
 - 0.9.3: Fixed deployment error && fix lack of existing `appwriteConfig.ts` file from causing error (you want to be able to setup yeah? haha)
 - 0.9.2: Added changelog back, whoops
 - 0.0.90: Updated README with new command-line options and fixed alias issues

package/dist/interactiveCLI.js

@@ -91,10 +91,6 @@ export class InteractiveCLI {
     }
     async selectDatabases(databases, message, multiSelect = true) {
         const choices = databases.map((db) => ({ name: db.name, value: db }));
-        if (multiSelect) {
-            choices.unshift({ name: "Select All", value: "ALL" });
-            choices.push({ name: "Clear Selection", value: "CLEAR" });
-        }
         const { selectedDatabases } = await inquirer.prompt([
             {
                 type: multiSelect ? "checkbox" : "list",
@@ -105,15 +101,7 @@ export class InteractiveCLI {
                 pageSize: 10,
             },
         ]);
-        if (multiSelect) {
-            if (selectedDatabases.includes("ALL")) {
-                return databases;
-            }
-            else if (selectedDatabases.includes("CLEAR")) {
-                return [];
-            }
-        }
-        return selectedDatabases.filter((db) => typeof db !== "string");
+        return selectedDatabases;
     }
     async selectCollections(database, databasesClient, message, multiSelect = true) {
         const collections = await fetchAllCollections(database.$id, databasesClient);
@@ -121,10 +109,6 @@ export class InteractiveCLI {
             name: collection.name,
             value: collection,
         }));
-        if (multiSelect) {
-            choices.unshift({ name: "Select All", value: "ALL" });
-            choices.push({ name: "Clear Selection", value: "CLEAR" });
-        }
         const { selectedCollections } = await inquirer.prompt([
             {
                 type: multiSelect ? "checkbox" : "list",
@@ -135,25 +119,13 @@ export class InteractiveCLI {
                 pageSize: 10,
             },
         ]);
-        if (multiSelect) {
-            if (selectedCollections.includes("ALL")) {
-                return collections;
-            }
-            else if (selectedCollections.includes("CLEAR")) {
-                return [];
-            }
-        }
-        return selectedCollections.filter((collection) => typeof collection !== "string");
+        return selectedCollections;
     }
     async selectBuckets(buckets, message, multiSelect = true) {
         const choices = buckets.map((bucket) => ({
             name: bucket.name,
-            value: bucket.$id,
+            value: bucket,
         }));
-        if (multiSelect) {
-            choices.unshift({ name: "Select All", value: "ALL" });
-            choices.push({ name: "Clear Selection", value: "CLEAR" });
-        }
         const { selectedBuckets } = await inquirer.prompt([
             {
                 type: multiSelect ? "checkbox" : "list",
@@ -164,15 +136,7 @@ export class InteractiveCLI {
                 pageSize: 10,
             },
         ]);
-        if (multiSelect) {
-            if (selectedBuckets.includes("ALL")) {
-                return buckets;
-            }
-            else if (selectedBuckets.includes("CLEAR")) {
-                return [];
-            }
-        }
-        return selectedBuckets.map((id) => buckets.find((bucket) => bucket.$id === id));
+        return selectedBuckets;
     }
     async createCollectionConfig() {
         const { collectionName } = await inquirer.prompt([
@@ -365,7 +329,7 @@ export class InteractiveCLI {
             throw new Error("Database is not initialized. Is the config file correct and created?");
         }
         const databases = await fetchAllDatabases(this.controller.database);
-        const selectedDatabases = await this.selectDatabases(databases, "Select databases to synchronize (or select none to synchronize all):");
+        const selectedDatabases = await this.selectDatabases(databases, "Select databases to synchronize:");
         console.log("Configuring storage buckets...");
         const updatedConfig = await this.configureBuckets(this.controller.config, selectedDatabases);
         console.log("Synchronizing configurations...");
@@ -376,7 +340,7 @@ export class InteractiveCLI {
             throw new Error("Database is not initialized, is the config file correct & created?");
         }
         const databases = await fetchAllDatabases(this.controller.database);
-        const selectedDatabases = await this.selectDatabases(databases, "Select databases to backup (or select none to backup all):");
+        const selectedDatabases = await this.selectDatabases(databases, "Select databases to backup:");
         for (const db of selectedDatabases) {
             console.log(`Backing up database: ${db.name}`);
             await this.controller.backupDatabase(db);
@@ -388,12 +352,12 @@ export class InteractiveCLI {
         }
         const databases = await fetchAllDatabases(this.controller.database);
         const storage = await listBuckets(this.controller.storage);
-        const selectedDatabases = await this.selectDatabases(databases, "Select databases to wipe (or select none to skip database wipe):");
+        const selectedDatabases = await this.selectDatabases(databases, "Select databases to wipe:");
         const { selectedStorage } = await inquirer.prompt([
             {
                 type: "checkbox",
                 name: "selectedStorage",
-                message: "Select storage buckets to wipe (or select none to skip storage wipe):",
+                message: "Select storage buckets to wipe:",
                 choices: storage.buckets.map((s) => ({ name: s.name, value: s.$id })),
             },
         ]);
@@ -441,7 +405,7 @@ export class InteractiveCLI {
         const selectedDatabases = await this.selectDatabases(databases, "Select the database(s) to import data into:");
         let selectedCollections = [];
         for (const db of selectedDatabases) {
-            const dbCollections = await this.selectCollections(db, this.controller.database, `Select collections to import data into for database ${db.name} (or select none to import into all):`, true);
+            const dbCollections = await this.selectCollections(db, this.controller.database, `Select collections to import data into for database ${db.name}:`, true);
             selectedCollections = [...selectedCollections, ...dbCollections];
         }
         const { shouldWriteFile } = await inquirer.prompt([
@@ -516,7 +480,7 @@ export class InteractiveCLI {
         }
         const [fromDb] = await this.selectDatabases(sourceDatabases, "Select the source database:", false);
         const [targetDb] = await this.selectDatabases(targetDatabases.filter((db) => db.$id !== fromDb.$id), "Select the target database:", false);
-        const selectedCollections = await this.selectCollections(fromDb, sourceClient, "Select collections to transfer (or select none to transfer all):");
+        const selectedCollections = await this.selectCollections(fromDb, sourceClient, "Select collections to transfer):");
         const { transferStorage } = await inquirer.prompt([
             {
                 type: "confirm",

package/dist/migrations/setupDatabase.js

@@ -9,7 +9,7 @@ export const setupMigrationDatabase = async (config) => {
     console.log("Starting Migrations Setup");
     console.log("---------------------------------");
     const database = new Databases(config.appwriteClient);
-    let db = null;
+    let db;
     const migrationCollectionsSetup = getMigrationCollectionSchemas();
     try {
         db = await tryAwaitWithRetry(async () => await database.get("migrations"), undefined, true);
@@ -19,18 +19,40 @@ export const setupMigrationDatabase = async (config) => {
         db = await tryAwaitWithRetry(async () => await database.create("migrations", "Migrations", true));
         console.log("Migrations database created");
     }
+    if (!db) {
+        console.error("Failed to create or retrieve the migrations database");
+        return;
+    }
     for (const [collectionName, { collection, attributes }] of Object.entries(migrationCollectionsSetup)) {
         const collectionId = toCamelCase(collectionName);
-        let collectionFound = null;
+        let collectionFound;
         try {
-            collectionFound = await tryAwaitWithRetry(async () => await database.getCollection(db.$id, collectionId));
+            collectionFound = await tryAwaitWithRetry(async () => await database.getCollection(db.$id, collectionId), undefined, true);
+            console.log(`Collection found: ${collectionId}`);
         }
         catch (e) {
             console.log(`Collection not found: ${collectionId}`);
-            collectionFound = await tryAwaitWithRetry(async () => await database.createCollection(db.$id, collectionId, collectionName, undefined, collection.documentSecurity, collection.enabled));
+            try {
+                collectionFound = await tryAwaitWithRetry(async () => await database.createCollection(db.$id, collectionId, collectionName, undefined, collection.documentSecurity, collection.enabled), undefined, true);
+                console.log(`Collection created: ${collectionId}`);
+            }
+            catch (createError) {
+                console.error(`Failed to create collection: ${collectionId}`, createError);
+                continue;
+            }
+        }
+        if (!collectionFound) {
+            console.error(`Failed to create or retrieve collection: ${collectionId}`);
+            continue;
         }
         for (const attribute of attributes) {
-            await createOrUpdateAttribute(database, db.$id, collectionFound, attribute);
+            try {
+                await createOrUpdateAttribute(database, db.$id, collectionFound, attribute);
+                console.log(`Attribute created/updated: ${attribute.key}`);
+            }
+            catch (attrError) {
+                console.error(`Failed to create/update attribute: ${attribute.key}`, attrError);
+            }
         }
     }
     console.log("---------------------------------");
@@ -43,7 +65,7 @@ export const ensureDatabasesExist = async (config) => {
     const existingDatabases = await tryAwaitWithRetry(async () => await database.list([Query.limit(500)]));
     const migrationsDatabase = existingDatabases.databases.find((d) => d.name.toLowerCase().trim().replace(" ", "") === "migrations");
     if (existingDatabases.databases.length !== 0 && migrationsDatabase) {
-        console.log("Wiping all databases except migrations");
+        console.log("Creating all databases except migrations");
         databasesToEnsure.push(migrationsDatabase);
     }
     for (const db of databasesToEnsure) {

package/dist/setupController.d.ts

@@ -0,0 +1,6 @@
+export declare class SetupController {
+    private currentDir;
+    constructor(currentDir: string);
+    runSetup(withExampleData?: boolean): Promise<void>;
+    hasExistingConfig(): boolean;
+}

package/dist/setupController.js

@@ -0,0 +1,17 @@
+import { setupDirsFiles } from "./utils/setupFiles.js";
+import path from "path";
+import fs from "fs";
+export class SetupController {
+    currentDir;
+    constructor(currentDir) {
+        this.currentDir = currentDir;
+    }
+    async runSetup(withExampleData = false) {
+        await setupDirsFiles(withExampleData, this.currentDir);
+        console.log("Setup completed successfully.");
+    }
+    hasExistingConfig() {
+        const configPath = path.join(this.currentDir, "appwrite", "appwriteConfig.ts");
+        return fs.existsSync(configPath);
+    }
+}

package/dist/storage/methods.d.ts

@@ -9,6 +9,7 @@ export declare const deleteBucket: (storage: Storage, bucketId: string) => Promi
 export declare const getFile: (storage: Storage, bucketId: string, fileId: string) => Promise<Models.File>;
 export declare const listFiles: (storage: Storage, bucketId: string, queries?: string[], search?: string) => Promise<Models.FileList>;
 export declare const deleteFile: (storage: Storage, bucketId: string, fileId: string) => Promise<{}>;
+export declare const ensureDatabaseConfigBucketsExist: (storage: Storage, config: AppwriteConfig, databases?: Models.Database[]) => Promise<void>;
 export declare const wipeDocumentStorage: (storage: Storage, bucketId: string) => Promise<void>;
 export declare const initOrGetDocumentStorage: (storage: Storage, config: AppwriteConfig, dbId: string, bucketName?: string) => Promise<Models.Bucket>;
 export declare const initOrGetBackupStorage: (config: AppwriteConfig, storage: Storage) => Promise<Models.Bucket>;

package/dist/storage/methods.js

@@ -34,6 +34,52 @@ export const listFiles = async (storage, bucketId, queries, search) => {
 export const deleteFile = async (storage, bucketId, fileId) => {
     return await storage.deleteFile(bucketId, fileId);
 };
+export const ensureDatabaseConfigBucketsExist = async (storage, config, databases = []) => {
+    for (const db of databases) {
+        const database = config.databases?.find((d) => d.$id === db.$id);
+        if (database?.bucket) {
+            try {
+                await storage.getBucket(database.bucket.$id);
+                console.log(`Bucket ${database.bucket.$id} already exists.`);
+            }
+            catch (e) {
+                const permissions = [];
+                if (database.bucket.permissions &&
+                    database.bucket.permissions.length > 0) {
+                    for (const permission of database.bucket.permissions) {
+                        switch (permission.permission) {
+                            case "read":
+                                permissions.push(Permission.read(permission.target));
+                                break;
+                            case "create":
+                                permissions.push(Permission.create(permission.target));
+                                break;
+                            case "update":
+                                permissions.push(Permission.update(permission.target));
+                                break;
+                            case "delete":
+                                permissions.push(Permission.delete(permission.target));
+                                break;
+                            case "write":
+                                permissions.push(Permission.write(permission.target));
+                                break;
+                            default:
+                                console.warn(`Unknown permission: ${permission.permission}`);
+                                break;
+                        }
+                    }
+                }
+                try {
+                    await storage.createBucket(database.bucket.$id, database.bucket.name, permissions, database.bucket.fileSecurity, database.bucket.enabled, database.bucket.maximumFileSize, database.bucket.allowedFileExtensions, database.bucket.compression, database.bucket.encryption, database.bucket.antivirus);
+                    console.log(`Bucket ${database.bucket.$id} created successfully.`);
+                }
+                catch (createError) {
+                    console.error(`Failed to create bucket ${database.bucket.$id}:`, createError);
+                }
+            }
+        }
+    }
+};
 export const wipeDocumentStorage = async (storage, bucketId) => {
     console.log(`Wiping storage for bucket ID: ${bucketId}`);
     let moreFiles = true;

package/dist/utilsController.d.ts

@@ -27,6 +27,7 @@ export declare class UtilsController {
     constructor(currentUserDir: string);
     init(): Promise<void>;
     setupMigrationDatabase(): Promise<void>;
+    ensureDatabaseConfigBucketsExist(databases?: Models.Database[]): Promise<void>;
     ensureDatabasesExist(databases?: Models.Database[]): Promise<void>;
     getDatabasesByIds(ids: string[]): Promise<Models.Database[]>;
     wipeOtherDatabases(databasesToKeep: Models.Database[]): Promise<void>;

package/dist/utilsController.js

@@ -7,7 +7,7 @@ import { ImportController } from "./migrations/importController.js";
 import { ImportDataActions } from "./migrations/importDataActions.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 { backupDatabase, ensureDatabaseConfigBucketsExist, initOrGetBackupStorage, wipeDocumentStorage, } from "./storage/methods.js";
 import path from "path";
 import { converterFunctions, validationRules, } from "appwrite-utils";
 import { afterImportActions } from "./migrations/afterImportActions.js";
@@ -59,11 +59,20 @@ export class UtilsController {
             throw new Error("Config not initialized");
         await setupMigrationDatabase(this.config);
     }
+    async ensureDatabaseConfigBucketsExist(databases = []) {
+        await this.init();
+        if (!this.storage)
+            throw new Error("Storage not initialized");
+        if (!this.config)
+            throw new Error("Config not initialized");
+        await ensureDatabaseConfigBucketsExist(this.storage, this.config, databases);
+    }
     async ensureDatabasesExist(databases) {
         await this.init();
         if (!this.config)
             throw new Error("Config not initialized");
         await this.setupMigrationDatabase();
+        await this.ensureDatabaseConfigBucketsExist(databases);
         await ensureDatabasesExist(this.config);
     }
     async getDatabasesByIds(ids) {
@@ -112,6 +121,8 @@ export class UtilsController {
         if (!this.database || !this.config)
             throw new Error("Database or config not initialized");
         for (const database of databases) {
+            if (database.$id === "migrations")
+                continue;
             await this.createOrUpdateCollections(database);
         }
     }
@@ -151,6 +162,7 @@ export class UtilsController {
             throw new Error("Database not initialized");
         const databases = await fetchAllDatabases(this.database);
         await this.ensureDatabasesExist(databases);
+        await this.ensureDatabaseConfigBucketsExist(databases);
         await this.createOrUpdateCollectionsForDatabases(databases);
     }
     getAppwriteFolderPath() {

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.9.3",
+  "version": "0.9.5",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/interactiveCLI.ts

@@ -110,11 +110,6 @@ export class InteractiveCLI {
   ): Promise<Models.Database[]> {
     const choices = databases.map((db) => ({ name: db.name, value: db }));
 
-    if (multiSelect) {
-      choices.unshift({ name: "Select All", value: "ALL" as any });
-      choices.push({ name: "Clear Selection", value: "CLEAR" as any });
-    }
-
     const { selectedDatabases } = await inquirer.prompt([
       {
         type: multiSelect ? "checkbox" : "list",
@@ -126,18 +121,7 @@ export class InteractiveCLI {
       },
     ]);
 
-    if (multiSelect) {
-      if (selectedDatabases.includes("ALL")) {
-        return databases;
-      } else if (selectedDatabases.includes("CLEAR")) {
-        return [];
-      }
-    }
-
-    return selectedDatabases.filter(
-      (db: Models.Database | string): db is Models.Database =>
-        typeof db !== "string"
-    );
+    return selectedDatabases;
   }
 
   private async selectCollections(
@@ -155,11 +139,6 @@ export class InteractiveCLI {
       value: collection,
     }));
 
-    if (multiSelect) {
-      choices.unshift({ name: "Select All", value: "ALL" as any });
-      choices.push({ name: "Clear Selection", value: "CLEAR" as any });
-    }
-
     const { selectedCollections } = await inquirer.prompt([
       {
         type: multiSelect ? "checkbox" : "list",
@@ -171,19 +150,7 @@ export class InteractiveCLI {
       },
     ]);
 
-    if (multiSelect) {
-      if (selectedCollections.includes("ALL")) {
-        return collections;
-      } else if (selectedCollections.includes("CLEAR")) {
-        return [];
-      }
-    }
-
-    return selectedCollections.filter(
-      (
-        collection: Models.Collection | string
-      ): collection is Models.Collection => typeof collection !== "string"
-    );
+    return selectedCollections;
   }
 
   private async selectBuckets(
@@ -193,14 +160,9 @@ export class InteractiveCLI {
   ): Promise<Models.Bucket[]> {
     const choices = buckets.map((bucket) => ({
       name: bucket.name,
-      value: bucket.$id,
+      value: bucket,
     }));
 
-    if (multiSelect) {
-      choices.unshift({ name: "Select All", value: "ALL" });
-      choices.push({ name: "Clear Selection", value: "CLEAR" });
-    }
-
     const { selectedBuckets } = await inquirer.prompt([
       {
         type: multiSelect ? "checkbox" : "list",
@@ -212,17 +174,7 @@ export class InteractiveCLI {
       },
     ]);
 
-    if (multiSelect) {
-      if (selectedBuckets.includes("ALL")) {
-        return buckets;
-      } else if (selectedBuckets.includes("CLEAR")) {
-        return [];
-      }
-    }
-
-    return selectedBuckets.map(
-      (id: string) => buckets.find((bucket) => bucket.$id === id)!
-    );
+    return selectedBuckets;
   }
 
   private async createCollectionConfig(): Promise<void> {
@@ -475,7 +427,7 @@ export class InteractiveCLI {
 
     const selectedDatabases = await this.selectDatabases(
       databases,
-      "Select databases to synchronize (or select none to synchronize all):"
+      "Select databases to synchronize:"
     );
 
     console.log("Configuring storage buckets...");
@@ -501,7 +453,7 @@ export class InteractiveCLI {
 
     const selectedDatabases = await this.selectDatabases(
       databases,
-      "Select databases to backup (or select none to backup all):"
+      "Select databases to backup:"
     );
 
     for (const db of selectedDatabases) {
@@ -521,15 +473,14 @@ export class InteractiveCLI {
 
     const selectedDatabases = await this.selectDatabases(
       databases,
-      "Select databases to wipe (or select none to skip database wipe):"
+      "Select databases to wipe:"
     );
 
     const { selectedStorage } = await inquirer.prompt([
       {
         type: "checkbox",
         name: "selectedStorage",
-        message:
-          "Select storage buckets to wipe (or select none to skip storage wipe):",
+        message: "Select storage buckets to wipe:",
         choices: storage.buckets.map((s) => ({ name: s.name, value: s.$id })),
       },
     ]);
@@ -592,7 +543,7 @@ export class InteractiveCLI {
       const dbCollections = await this.selectCollections(
         db,
         this.controller!.database,
-        `Select collections to import data into for database ${db.name} (or select none to import into all):`,
+        `Select collections to import data into for database ${db.name}:`,
         true
       );
       selectedCollections = [...selectedCollections, ...dbCollections];
@@ -703,7 +654,7 @@ export class InteractiveCLI {
     const selectedCollections = await this.selectCollections(
       fromDb,
       sourceClient,
-      "Select collections to transfer (or select none to transfer all):"
+      "Select collections to transfer):"
     );
 
     const { transferStorage } = await inquirer.prompt([

package/src/migrations/setupDatabase.ts

@@ -14,7 +14,7 @@ export const setupMigrationDatabase = async (config: AppwriteConfig) => {
   console.log("Starting Migrations Setup");
   console.log("---------------------------------");
   const database = new Databases(config.appwriteClient!);
-  let db: Models.Database | null = null;
+  let db: Models.Database | undefined;
   const migrationCollectionsSetup = getMigrationCollectionSchemas();
 
   try {
@@ -31,36 +31,69 @@ export const setupMigrationDatabase = async (config: AppwriteConfig) => {
     console.log("Migrations database created");
   }
 
+  if (!db) {
+    console.error("Failed to create or retrieve the migrations database");
+    return;
+  }
+
   for (const [collectionName, { collection, attributes }] of Object.entries(
     migrationCollectionsSetup
   )) {
     const collectionId = toCamelCase(collectionName);
-    let collectionFound: Models.Collection | null = null;
+    let collectionFound: Models.Collection | undefined;
     try {
       collectionFound = await tryAwaitWithRetry(
-        async () => await database.getCollection(db!.$id, collectionId)
+        async () => await database.getCollection(db.$id, collectionId),
+        undefined,
+        true
       );
+      console.log(`Collection found: ${collectionId}`);
     } catch (e) {
       console.log(`Collection not found: ${collectionId}`);
-      collectionFound = await tryAwaitWithRetry(
-        async () =>
-          await database.createCollection(
-            db!.$id,
-            collectionId,
-            collectionName,
-            undefined,
-            collection.documentSecurity,
-            collection.enabled
-          )
-      );
+      try {
+        collectionFound = await tryAwaitWithRetry(
+          async () =>
+            await database.createCollection(
+              db.$id,
+              collectionId,
+              collectionName,
+              undefined,
+              collection.documentSecurity,
+              collection.enabled
+            ),
+          undefined,
+          true
+        );
+        console.log(`Collection created: ${collectionId}`);
+      } catch (createError) {
+        console.error(
+          `Failed to create collection: ${collectionId}`,
+          createError
+        );
+        continue;
+      }
     }
+
+    if (!collectionFound) {
+      console.error(`Failed to create or retrieve collection: ${collectionId}`);
+      continue;
+    }
+
     for (const attribute of attributes) {
-      await createOrUpdateAttribute(
-        database,
-        db!.$id,
-        collectionFound!,
-        attribute
-      );
+      try {
+        await createOrUpdateAttribute(
+          database,
+          db.$id,
+          collectionFound,
+          attribute
+        );
+        console.log(`Attribute created/updated: ${attribute.key}`);
+      } catch (attrError) {
+        console.error(
+          `Failed to create/update attribute: ${attribute.key}`,
+          attrError
+        );
+      }
     }
   }
   console.log("---------------------------------");
@@ -80,7 +113,7 @@ export const ensureDatabasesExist = async (config: AppwriteConfig) => {
     (d) => d.name.toLowerCase().trim().replace(" ", "") === "migrations"
   );
   if (existingDatabases.databases.length !== 0 && migrationsDatabase) {
-    console.log("Wiping all databases except migrations");
+    console.log("Creating all databases except migrations");
     databasesToEnsure.push(migrationsDatabase);
   }
 

package/src/setupController.ts

@@ -0,0 +1,25 @@
+import { setupDirsFiles } from "./utils/setupFiles.js";
+import path from "path";
+import fs from "fs";
+
+export class SetupController {
+  private currentDir: string;
+
+  constructor(currentDir: string) {
+    this.currentDir = currentDir;
+  }
+
+  async runSetup(withExampleData: boolean = false): Promise<void> {
+    await setupDirsFiles(withExampleData, this.currentDir);
+    console.log("Setup completed successfully.");
+  }
+
+  hasExistingConfig(): boolean {
+    const configPath = path.join(
+      this.currentDir,
+      "appwrite",
+      "appwriteConfig.ts"
+    );
+    return fs.existsSync(configPath);
+  }
+}

package/src/storage/methods.ts

@@ -100,6 +100,71 @@ export const deleteFile = async (
   return await storage.deleteFile(bucketId, fileId);
 };
 
+export const ensureDatabaseConfigBucketsExist = async (
+  storage: Storage,
+  config: AppwriteConfig,
+  databases: Models.Database[] = []
+) => {
+  for (const db of databases) {
+    const database = config.databases?.find((d) => d.$id === db.$id);
+    if (database?.bucket) {
+      try {
+        await storage.getBucket(database.bucket.$id);
+        console.log(`Bucket ${database.bucket.$id} already exists.`);
+      } catch (e) {
+        const permissions: string[] = [];
+        if (
+          database.bucket.permissions &&
+          database.bucket.permissions.length > 0
+        ) {
+          for (const permission of database.bucket.permissions) {
+            switch (permission.permission) {
+              case "read":
+                permissions.push(Permission.read(permission.target));
+                break;
+              case "create":
+                permissions.push(Permission.create(permission.target));
+                break;
+              case "update":
+                permissions.push(Permission.update(permission.target));
+                break;
+              case "delete":
+                permissions.push(Permission.delete(permission.target));
+                break;
+              case "write":
+                permissions.push(Permission.write(permission.target));
+                break;
+              default:
+                console.warn(`Unknown permission: ${permission.permission}`);
+                break;
+            }
+          }
+        }
+        try {
+          await storage.createBucket(
+            database.bucket.$id,
+            database.bucket.name,
+            permissions,
+            database.bucket.fileSecurity,
+            database.bucket.enabled,
+            database.bucket.maximumFileSize,
+            database.bucket.allowedFileExtensions,
+            database.bucket.compression as Compression,
+            database.bucket.encryption,
+            database.bucket.antivirus
+          );
+          console.log(`Bucket ${database.bucket.$id} created successfully.`);
+        } catch (createError) {
+          console.error(
+            `Failed to create bucket ${database.bucket.$id}:`,
+            createError
+          );
+        }
+      }
+    }
+  }
+};
+
 export const wipeDocumentStorage = async (
   storage: Storage,
   bucketId: string

package/src/utilsController.ts

@@ -18,6 +18,7 @@ import {
 } from "./collections/methods.js";
 import {
   backupDatabase,
+  ensureDatabaseConfigBucketsExist,
   initOrGetBackupStorage,
   wipeDocumentStorage,
 } from "./storage/methods.js";
@@ -101,10 +102,22 @@ export class UtilsController {
     await setupMigrationDatabase(this.config);
   }
 
+  async ensureDatabaseConfigBucketsExist(databases: Models.Database[] = []) {
+    await this.init();
+    if (!this.storage) throw new Error("Storage not initialized");
+    if (!this.config) throw new Error("Config not initialized");
+    await ensureDatabaseConfigBucketsExist(
+      this.storage,
+      this.config,
+      databases
+    );
+  }
+
   async ensureDatabasesExist(databases?: Models.Database[]) {
     await this.init();
     if (!this.config) throw new Error("Config not initialized");
     await this.setupMigrationDatabase();
+    await this.ensureDatabaseConfigBucketsExist(databases);
     await ensureDatabasesExist(this.config);
   }
 
@@ -161,6 +174,7 @@ export class UtilsController {
     if (!this.database || !this.config)
       throw new Error("Database or config not initialized");
     for (const database of databases) {
+      if (database.$id === "migrations") continue;
       await this.createOrUpdateCollections(database);
     }
   }
@@ -230,6 +244,7 @@ export class UtilsController {
     if (!this.database) throw new Error("Database not initialized");
     const databases = await fetchAllDatabases(this.database);
     await this.ensureDatabasesExist(databases);
+    await this.ensureDatabaseConfigBucketsExist(databases);
     await this.createOrUpdateCollectionsForDatabases(databases);
   }