appwrite-utils-cli 0.9.2 → 0.9.4

package/src/main.ts

@@ -33,6 +33,7 @@ interface CliOptions {
   remoteEndpoint?: string;
   remoteProjectId?: string;
   remoteApiKey?: string;
+  setup?: boolean;
 }
 
 type ParsedArgv = ArgumentsCamelCase<CliOptions>;
@@ -145,18 +146,34 @@ const argv = yargs(hideBin(process.argv))
     type: "string",
     description: "Set the remote Appwrite API key for transfers",
   })
+  .option("setup", {
+    type: "boolean",
+    description: "Setup the project with example data",
+  })
   .help()
   .parse();
 
 async function main() {
   const parsedArgv = (await argv) as ParsedArgv;
-  const controller = new UtilsController(process.cwd());
-  await controller.init();
+  let controller: UtilsController | undefined;
 
   if (parsedArgv.it) {
-    const cli = new InteractiveCLI(process.cwd(), controller);
+    try {
+      controller = new UtilsController(process.cwd());
+      await controller.init();
+    } catch (error: any) {
+      // If it fails, that means there's no config, more than likely
+      console.log(
+        "No config found, you probably need to create the setup files"
+      );
+    }
+    const cli = new InteractiveCLI(process.cwd());
     await cli.run();
   } else {
+    if (!controller) {
+      controller = new UtilsController(process.cwd());
+      await controller.init();
+    }
     // Handle non-interactive mode with the new options
     const options: SetupOptions = {
       databases: parsedArgv.dbIds

package/src/migrations/helper.ts

@@ -1,40 +1,40 @@
-import type { Databases, Models } from "node-appwrite";
-import type { OperationCreate } from "../storage/schemas.js";
-import { tryAwaitWithRetry } from "appwrite-utils";
-import { ulid } from "ulidx";
-
-export const logOperation = async (
-  db: Databases,
-  dbId: string,
-  operationDetails: OperationCreate,
-  operationId?: string
-): Promise<Models.Document> => {
-  try {
-    let operation;
-    if (operationId) {
-      // Update existing operation log
-      operation = await tryAwaitWithRetry(
-        async () =>
-          await db.updateDocument(
-            "migrations",
-            "currentOperations",
-            operationId,
-            operationDetails
-          )
-      );
-    } else {
-      // Create new operation log
-      operation = await db.createDocument(
-        "migrations",
-        "currentOperations",
-        ulid(),
-        operationDetails
-      );
-    }
-    console.log(`Operation logged: ${operation.$id}`);
-    return operation;
-  } catch (error) {
-    console.error(`Error logging operation: ${error}`);
-    throw error;
-  }
-};
+import type { Databases, Models } from "node-appwrite";
+import type { OperationCreate } from "../storage/schemas.js";
+import { tryAwaitWithRetry } from "appwrite-utils";
+import { ulid } from "ulidx";
+
+export const logOperation = async (
+  db: Databases,
+  dbId: string,
+  operationDetails: OperationCreate,
+  operationId?: string
+): Promise<Models.Document> => {
+  try {
+    let operation;
+    if (operationId) {
+      // Update existing operation log
+      operation = await tryAwaitWithRetry(
+        async () =>
+          await db.updateDocument(
+            "migrations",
+            "currentOperations",
+            operationId,
+            operationDetails
+          )
+      );
+    } else {
+      // Create new operation log
+      operation = await db.createDocument(
+        "migrations",
+        "currentOperations",
+        ulid(),
+        operationDetails
+      );
+    }
+    console.log(`Operation logged: ${operation.$id}`);
+    return operation;
+  } catch (error) {
+    console.error(`Error logging operation: ${error}`);
+    throw error;
+  }
+};

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);
   }