appwrite-utils-cli 0.9.4 → 0.9.5

package/README.md

@@ -124,6 +124,7 @@ 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

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

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);
   }
 
@@ -231,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);
   }