appwrite-utils-cli 0.0.16 → 0.0.18

package/dist/migrations/importController.d.ts

@@ -11,6 +11,7 @@ export declare class ImportController {
     private setupOptions;
     private documentCache;
     private batchLimit;
+    private postImportActionsQueue;
     constructor(config: AppwriteConfig, database: Databases, storage: Storage, appwriteFolderPath: string, importDataActions: ImportDataActions, setupOptions: SetupOptions);
     run(): Promise<void>;
     importCollections(db: ConfigDatabase): Promise<void>;

package/dist/migrations/importController.js

@@ -21,11 +21,7 @@ export class ImportController {
     setupOptions;
     documentCache;
     batchLimit = 25; // Define batch size limit
-    // private postImportActionsQueue: {
-    //   context: any;
-    //   finalItem: any;
-    //   attributeMappings: AttributeMappings;
-    // }[] = [];
+    postImportActionsQueue = [];
     constructor(config, database, storage, appwriteFolderPath, importDataActions, setupOptions) {
         this.config = config;
         this.database = database;
@@ -168,6 +164,10 @@ export class ImportController {
                         return;
                     }
                     const user = await usersController.createUserAndReturn(userToCreate.data);
+                    if (!user) {
+                        logger.error(`Skipping user & contact creation for ${item} because of an error...`);
+                        return;
+                    }
                     createIdToUse = user.$id;
                     context.docId = createIdToUse;
                     context = { ...context, ...user };
@@ -207,19 +207,23 @@ export class ImportController {
                 const attributeMappingsWithActions = this.getAttributeMappingsWithActions(importDef.attributeMappings, afterImportActionContext, finalItem);
                 if (attributeMappingsWithActions.some((m) => m.postImportActions)) {
                     logger.info(`Pushing to post-import actions queue for ${context.docId}`);
-                    const afterImportOperationContext = ContextObject.parse({
-                        dbId: db.$id,
-                        collectionId: collection.$id,
-                        finalItem: finalItem,
-                        attributeMappings: attributeMappingsWithActions,
-                        context: afterImportActionContext,
-                    });
-                    await createOrFindAfterImportOperation(this.database, context.collId, afterImportOperationContext);
-                    // this.postImportActionsQueue.push({
-                    //   context: afterImportActionContext,
+                    // const afterImportOperationContext = ContextObject.parse({
+                    //   dbId: db.$id,
+                    //   collectionId: collection.$id,
                     //   finalItem: finalItem,
                     //   attributeMappings: attributeMappingsWithActions,
+                    //   context: afterImportActionContext,
                     // });
+                    // await createOrFindAfterImportOperation(
+                    //   this.database,
+                    //   context.collId,
+                    //   afterImportOperationContext
+                    // );
+                    this.postImportActionsQueue.push({
+                        context: afterImportActionContext,
+                        finalItem: finalItem,
+                        attributeMappings: attributeMappingsWithActions,
+                    });
                 }
             }));
             results.forEach((result) => {
@@ -314,16 +318,29 @@ export class ImportController {
         });
     }
     async executePostImportActions(dbId) {
-        const collectionActionsPromises = [];
-        for (const collection of this.config.collections) {
-            collectionActionsPromises.push(this.executeActionsInParallel(dbId, collection));
+        let actionQueue = [];
+        for (const action of this.postImportActionsQueue) {
+            actionQueue.push(this.importDataActions.executeAfterImportActions(action.finalItem, action.attributeMappings, action.context));
         }
-        const results = await Promise.allSettled(collectionActionsPromises);
+        const results = await Promise.allSettled(actionQueue);
         results.forEach((result) => {
             if (result.status === "rejected") {
-                console.error("A process batch promise was rejected:", result.reason);
+                console.error("An action promise was rejected:", result.reason);
+                logger.error(`An action promise was rejected: ${result.reason} -- ${JSON.stringify(result)}`);
             }
         });
+        // const collectionActionsPromises = [];
+        // for (const collection of this.config.collections) {
+        //   collectionActionsPromises.push(
+        //     this.executeActionsInParallel(dbId, collection)
+        //   );
+        // }
+        // const results = await Promise.allSettled(collectionActionsPromises);
+        // results.forEach((result) => {
+        //   if (result.status === "rejected") {
+        //     console.error("A process batch promise was rejected:", result.reason);
+        //   }
+        // });
     }
     async executeActionsInParallel(dbId, collection) {
         const collectionExists = await checkForCollection(this.database, dbId, collection);

package/dist/migrations/importDataActions.js

@@ -193,7 +193,7 @@ export class ImportDataActions {
                     resolvedString = resolvedString.replace(match[0], value);
                 }
                 else {
-                    logger.warn(`Failed to resolve ${template} in context: `, context);
+                    logger.warn(`Failed to resolve ${template} in context: `, JSON.stringify({ ...context, ...item }, null, 2));
                 }
             }
             // console.log(`Resolved string: ${resolvedString}`);

package/dist/migrations/users.d.ts

@@ -7,5 +7,5 @@ export declare class UsersController {
     static userFields: string[];
     constructor(config: AppwriteConfig, db: Databases);
     wipeUsers(): Promise<void>;
-    createUserAndReturn(item: AuthUserCreate): Promise<Models.User<Models.Preferences>>;
+    createUserAndReturn(item: AuthUserCreate): Promise<Models.User<Models.Preferences> | undefined>;
 }

package/dist/migrations/users.js

@@ -40,72 +40,79 @@ export class UsersController {
         }
     }
     async createUserAndReturn(item) {
-        // Attempt to find an existing user by email or phone.
-        let foundUsers = [];
-        if (item.email) {
-            const foundUsersByEmail = await this.users.list([
-                Query.equal("email", item.email),
-            ]);
-            foundUsers = foundUsersByEmail.users;
-        }
-        if (item.phone) {
-            const foundUsersByPhone = await this.users.list([
-                Query.equal("phone", item.phone),
-            ]);
-            foundUsers = foundUsers.length
-                ? foundUsers.concat(foundUsersByPhone.users)
-                : foundUsersByPhone.users;
-        }
-        let userToReturn = foundUsers[0] || undefined;
-        if (!userToReturn) {
-            userToReturn = await this.users.create(item.userId || ID.unique(), item.email || undefined, item.phone && item.phone.length < 15 && item.phone.startsWith("+")
-                ? item.phone
-                : undefined, item.password?.toLowerCase() || `changeMe${item.email}`.toLowerCase(), item.name || undefined);
-        }
-        else {
-            // Update user details as necessary, ensuring email uniqueness if attempting an update.
-            if (item.email &&
-                item.email !== userToReturn.email &&
-                !_.isEmpty(item.email) &&
-                !_.isUndefined(item.email)) {
-                const emailExists = await this.users.list([
+        let userToReturn = undefined;
+        try {
+            // Attempt to find an existing user by email or phone.
+            let foundUsers = [];
+            if (item.email) {
+                const foundUsersByEmail = await this.users.list([
                     Query.equal("email", item.email),
                 ]);
-                if (emailExists.users.length === 0) {
-                    userToReturn = await this.users.updateEmail(userToReturn.$id, item.email);
+                foundUsers = foundUsersByEmail.users;
+            }
+            if (item.phone) {
+                const foundUsersByPhone = await this.users.list([
+                    Query.equal("phone", item.phone),
+                ]);
+                foundUsers = foundUsers.length
+                    ? foundUsers.concat(foundUsersByPhone.users)
+                    : foundUsersByPhone.users;
+            }
+            userToReturn = foundUsers[0] || undefined;
+            if (!userToReturn) {
+                userToReturn = await this.users.create(item.userId || ID.unique(), item.email || undefined, item.phone && item.phone.length < 15 && item.phone.startsWith("+")
+                    ? item.phone
+                    : undefined, item.password?.toLowerCase() || `changeMe${item.email}`.toLowerCase(), item.name || undefined);
+            }
+            else {
+                // Update user details as necessary, ensuring email uniqueness if attempting an update.
+                if (item.email &&
+                    item.email !== userToReturn.email &&
+                    !_.isEmpty(item.email) &&
+                    !_.isUndefined(item.email)) {
+                    const emailExists = await this.users.list([
+                        Query.equal("email", item.email),
+                    ]);
+                    if (emailExists.users.length === 0) {
+                        userToReturn = await this.users.updateEmail(userToReturn.$id, item.email);
+                    }
+                    else {
+                        console.log("Email update skipped: Email already exists.");
+                    }
+                }
+                if (item.password) {
+                    userToReturn = await this.users.updatePassword(userToReturn.$id, item.password.toLowerCase());
                 }
-                else {
-                    console.log("Email update skipped: Email already exists.");
+                if (item.name && item.name !== userToReturn.name) {
+                    userToReturn = await this.users.updateName(userToReturn.$id, item.name);
+                }
+                if (item.phone &&
+                    item.phone !== userToReturn.phone &&
+                    item.phone.length < 15 &&
+                    item.phone.startsWith("+") &&
+                    (_.isUndefined(userToReturn.phone) || _.isEmpty(userToReturn.phone))) {
+                    const userFoundWithPhone = await this.users.list([
+                        Query.equal("phone", item.phone),
+                    ]);
+                    if (userFoundWithPhone.total === 0) {
+                        userToReturn = await this.users.updatePhone(userToReturn.$id, item.phone);
+                    }
                 }
             }
-            if (item.password) {
-                userToReturn = await this.users.updatePassword(userToReturn.$id, item.password.toLowerCase());
+            if (item.$createdAt && item.$updatedAt) {
+                console.log("$createdAt and $updatedAt are not yet supported, sorry about that!");
             }
-            if (item.name && item.name !== userToReturn.name) {
-                userToReturn = await this.users.updateName(userToReturn.$id, item.name);
+            if (item.labels && item.labels.length) {
+                userToReturn = await this.users.updateLabels(userToReturn.$id, item.labels);
             }
-            if (item.phone &&
-                item.phone !== userToReturn.phone &&
-                item.phone.length < 15 &&
-                item.phone.startsWith("+") &&
-                (_.isUndefined(userToReturn.phone) || _.isEmpty(userToReturn.phone))) {
-                const userFoundWithPhone = await this.users.list([
-                    Query.equal("phone", item.phone),
-                ]);
-                if (userFoundWithPhone.total === 0) {
-                    userToReturn = await this.users.updatePhone(userToReturn.$id, item.phone);
-                }
+            if (item.prefs && Object.keys(item.prefs).length) {
+                await this.users.updatePrefs(userToReturn.$id, item.prefs);
+                userToReturn.prefs = item.prefs;
             }
+            return userToReturn;
         }
-        if (item.$createdAt && item.$updatedAt) {
-            console.log("$createdAt and $updatedAt are not yet supported, sorry about that!");
-        }
-        if (item.labels && item.labels.length) {
-            userToReturn = await this.users.updateLabels(userToReturn.$id, item.labels);
-        }
-        if (item.prefs && Object.keys(item.prefs).length) {
-            userToReturn = await this.users.updatePrefs(userToReturn.$id, item.prefs);
+        catch (error) {
+            return userToReturn;
         }
-        return userToReturn;
     }
 }

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

package/src/migrations/importController.ts

@@ -47,11 +47,11 @@ export class ImportController {
   private setupOptions: SetupOptions;
   private documentCache: Map<string, any>;
   private batchLimit: number = 25; // Define batch size limit
-  // private postImportActionsQueue: {
-  //   context: any;
-  //   finalItem: any;
-  //   attributeMappings: AttributeMappings;
-  // }[] = [];
+  private postImportActionsQueue: {
+    context: any;
+    finalItem: any;
+    attributeMappings: AttributeMappings;
+  }[] = [];
 
   constructor(
     config: AppwriteConfig,
@@ -284,6 +284,12 @@ export class ImportController {
             const user = await usersController.createUserAndReturn(
               userToCreate.data
             );
+            if (!user) {
+              logger.error(
+                `Skipping user & contact creation for ${item} because of an error...`
+              );
+              return;
+            }
             createIdToUse = user.$id;
             context.docId = createIdToUse;
             context = { ...context, ...user };
@@ -351,23 +357,23 @@ export class ImportController {
             logger.info(
               `Pushing to post-import actions queue for ${context.docId}`
             );
-            const afterImportOperationContext = ContextObject.parse({
-              dbId: db.$id,
-              collectionId: collection.$id,
-              finalItem: finalItem,
-              attributeMappings: attributeMappingsWithActions,
-              context: afterImportActionContext,
-            });
-            await createOrFindAfterImportOperation(
-              this.database,
-              context.collId,
-              afterImportOperationContext
-            );
-            // this.postImportActionsQueue.push({
-            //   context: afterImportActionContext,
+            // const afterImportOperationContext = ContextObject.parse({
+            //   dbId: db.$id,
+            //   collectionId: collection.$id,
             //   finalItem: finalItem,
             //   attributeMappings: attributeMappingsWithActions,
+            //   context: afterImportActionContext,
             // });
+            // await createOrFindAfterImportOperation(
+            //   this.database,
+            //   context.collId,
+            //   afterImportOperationContext
+            // );
+            this.postImportActionsQueue.push({
+              context: afterImportActionContext,
+              finalItem: finalItem,
+              attributeMappings: attributeMappingsWithActions,
+            });
           }
         })
       );
@@ -506,18 +512,39 @@ export class ImportController {
   }
 
   async executePostImportActions(dbId: string) {
-    const collectionActionsPromises = [];
-    for (const collection of this.config.collections) {
-      collectionActionsPromises.push(
-        this.executeActionsInParallel(dbId, collection)
+    let actionQueue: Promise<any>[] = [];
+    for (const action of this.postImportActionsQueue) {
+      actionQueue.push(
+        this.importDataActions.executeAfterImportActions(
+          action.finalItem,
+          action.attributeMappings,
+          action.context
+        )
       );
     }
-    const results = await Promise.allSettled(collectionActionsPromises);
+    const results = await Promise.allSettled(actionQueue);
     results.forEach((result) => {
       if (result.status === "rejected") {
-        console.error("A process batch promise was rejected:", result.reason);
+        console.error("An action promise was rejected:", result.reason);
+        logger.error(
+          `An action promise was rejected: ${result.reason} -- ${JSON.stringify(
+            result
+          )}`
+        );
       }
     });
+    // const collectionActionsPromises = [];
+    // for (const collection of this.config.collections) {
+    //   collectionActionsPromises.push(
+    //     this.executeActionsInParallel(dbId, collection)
+    //   );
+    // }
+    // const results = await Promise.allSettled(collectionActionsPromises);
+    // results.forEach((result) => {
+    //   if (result.status === "rejected") {
+    //     console.error("A process batch promise was rejected:", result.reason);
+    //   }
+    // });
   }
 
   async executeActionsInParallel(dbId: string, collection: ConfigCollection) {

package/src/migrations/importDataActions.ts

@@ -285,7 +285,10 @@ export class ImportDataActions {
             : resolvedValue;
           resolvedString = resolvedString.replace(match[0], value);
         } else {
-          logger.warn(`Failed to resolve ${template} in context: `, context);
+          logger.warn(
+            `Failed to resolve ${template} in context: `,
+            JSON.stringify({ ...context, ...item }, null, 2)
+          );
         }
       }
       // console.log(`Resolved string: ${resolvedString}`);

package/src/migrations/users.ts

@@ -49,96 +49,105 @@ export class UsersController {
   }
 
   async createUserAndReturn(item: AuthUserCreate) {
-    // Attempt to find an existing user by email or phone.
-    let foundUsers: Models.User<Models.Preferences>[] = [];
-    if (item.email) {
-      const foundUsersByEmail = await this.users.list([
-        Query.equal("email", item.email),
-      ]);
-      foundUsers = foundUsersByEmail.users;
-    }
-    if (item.phone) {
-      const foundUsersByPhone = await this.users.list([
-        Query.equal("phone", item.phone),
-      ]);
-      foundUsers = foundUsers.length
-        ? foundUsers.concat(foundUsersByPhone.users)
-        : foundUsersByPhone.users;
-    }
-
-    let userToReturn = foundUsers[0] || undefined;
-
-    if (!userToReturn) {
-      userToReturn = await this.users.create(
-        item.userId || ID.unique(),
-        item.email || undefined,
-        item.phone && item.phone.length < 15 && item.phone.startsWith("+")
-          ? item.phone
-          : undefined,
-        item.password?.toLowerCase() || `changeMe${item.email}`.toLowerCase(),
-        item.name || undefined
-      );
-    } else {
-      // Update user details as necessary, ensuring email uniqueness if attempting an update.
-      if (
-        item.email &&
-        item.email !== userToReturn.email &&
-        !_.isEmpty(item.email) &&
-        !_.isUndefined(item.email)
-      ) {
-        const emailExists = await this.users.list([
+    let userToReturn: Models.User<Models.Preferences> | undefined = undefined;
+    try {
+      // Attempt to find an existing user by email or phone.
+      let foundUsers: Models.User<Models.Preferences>[] = [];
+      if (item.email) {
+        const foundUsersByEmail = await this.users.list([
           Query.equal("email", item.email),
         ]);
-        if (emailExists.users.length === 0) {
-          userToReturn = await this.users.updateEmail(
+        foundUsers = foundUsersByEmail.users;
+      }
+      if (item.phone) {
+        const foundUsersByPhone = await this.users.list([
+          Query.equal("phone", item.phone),
+        ]);
+        foundUsers = foundUsers.length
+          ? foundUsers.concat(foundUsersByPhone.users)
+          : foundUsersByPhone.users;
+      }
+
+      userToReturn = foundUsers[0] || undefined;
+
+      if (!userToReturn) {
+        userToReturn = await this.users.create(
+          item.userId || ID.unique(),
+          item.email || undefined,
+          item.phone && item.phone.length < 15 && item.phone.startsWith("+")
+            ? item.phone
+            : undefined,
+          item.password?.toLowerCase() || `changeMe${item.email}`.toLowerCase(),
+          item.name || undefined
+        );
+      } else {
+        // Update user details as necessary, ensuring email uniqueness if attempting an update.
+        if (
+          item.email &&
+          item.email !== userToReturn.email &&
+          !_.isEmpty(item.email) &&
+          !_.isUndefined(item.email)
+        ) {
+          const emailExists = await this.users.list([
+            Query.equal("email", item.email),
+          ]);
+          if (emailExists.users.length === 0) {
+            userToReturn = await this.users.updateEmail(
+              userToReturn.$id,
+              item.email
+            );
+          } else {
+            console.log("Email update skipped: Email already exists.");
+          }
+        }
+        if (item.password) {
+          userToReturn = await this.users.updatePassword(
             userToReturn.$id,
-            item.email
+            item.password.toLowerCase()
           );
-        } else {
-          console.log("Email update skipped: Email already exists.");
+        }
+        if (item.name && item.name !== userToReturn.name) {
+          userToReturn = await this.users.updateName(
+            userToReturn.$id,
+            item.name
+          );
+        }
+        if (
+          item.phone &&
+          item.phone !== userToReturn.phone &&
+          item.phone.length < 15 &&
+          item.phone.startsWith("+") &&
+          (_.isUndefined(userToReturn.phone) || _.isEmpty(userToReturn.phone))
+        ) {
+          const userFoundWithPhone = await this.users.list([
+            Query.equal("phone", item.phone),
+          ]);
+          if (userFoundWithPhone.total === 0) {
+            userToReturn = await this.users.updatePhone(
+              userToReturn.$id,
+              item.phone
+            );
+          }
         }
       }
-      if (item.password) {
-        userToReturn = await this.users.updatePassword(
-          userToReturn.$id,
-          item.password.toLowerCase()
+      if (item.$createdAt && item.$updatedAt) {
+        console.log(
+          "$createdAt and $updatedAt are not yet supported, sorry about that!"
         );
       }
-      if (item.name && item.name !== userToReturn.name) {
-        userToReturn = await this.users.updateName(userToReturn.$id, item.name);
+      if (item.labels && item.labels.length) {
+        userToReturn = await this.users.updateLabels(
+          userToReturn.$id,
+          item.labels
+        );
       }
-      if (
-        item.phone &&
-        item.phone !== userToReturn.phone &&
-        item.phone.length < 15 &&
-        item.phone.startsWith("+") &&
-        (_.isUndefined(userToReturn.phone) || _.isEmpty(userToReturn.phone))
-      ) {
-        const userFoundWithPhone = await this.users.list([
-          Query.equal("phone", item.phone),
-        ]);
-        if (userFoundWithPhone.total === 0) {
-          userToReturn = await this.users.updatePhone(
-            userToReturn.$id,
-            item.phone
-          );
-        }
+      if (item.prefs && Object.keys(item.prefs).length) {
+        await this.users.updatePrefs(userToReturn.$id, item.prefs);
+        userToReturn.prefs = item.prefs;
       }
+      return userToReturn;
+    } catch (error) {
+      return userToReturn;
     }
-    if (item.$createdAt && item.$updatedAt) {
-      console.log(
-        "$createdAt and $updatedAt are not yet supported, sorry about that!"
-      );
-    }
-    if (item.labels && item.labels.length) {
-      userToReturn = await this.users.updateLabels(
-        userToReturn.$id,
-        item.labels
-      );
-    }
-    if (item.prefs && Object.keys(item.prefs).length) {
-      userToReturn = await this.users.updatePrefs(userToReturn.$id, item.prefs);
-    }
-    return userToReturn;
   }
 }