appwrite-utils-cli 0.0.261 → 0.0.263

package/dist/migrations/schema.js

@@ -1,4 +1,4 @@
-import { ID, IndexType } from "node-appwrite";
+import { ID, IndexType, Permission } from "node-appwrite";
 import { z } from "zod";
 const stringAttributeSchema = z.object({
     key: z.string().describe("The key of the attribute"),
@@ -324,6 +324,7 @@ export const indexSchema = z.object({
     attributes: z.array(z.string()),
     orders: z.array(z.string()).optional(),
 });
+export const indexesSchema = z.array(indexSchema);
 export const AttributeMappingsSchema = z.array(z.object({
     oldKey: z
         .string()
@@ -366,6 +367,19 @@ export const AttributeMappingsSchema = z.array(z.object({
         .describe("The after import actions and parameter placeholders (they'll be replaced with the actual data) to use for the import")
         .default([]),
 }));
+export const idMappingSchema = z.array(z.object({
+    sourceField: z
+        .string()
+        .describe("The key of the data in the import data to match in the current data"),
+    fieldToSet: z
+        .string()
+        .optional()
+        .describe("The field to set in the target collection, if different from sourceField"),
+    targetField: z
+        .string()
+        .describe("The field in the target collection to match with sourceField that will then be updated"),
+    targetCollection: z.string().describe("The collection to search"),
+}));
 export const importDefSchema = z
     .object({
     type: z
@@ -382,20 +396,7 @@ export const importDefSchema = z
         .string()
         .default("id")
         .describe("The field in the import data representing the primary key for this import data (if any)"),
-    idMappings: z
-        .array(z.object({
-        sourceField: z
-            .string()
-            .describe("The key of the data in the import data to match in the current data"),
-        fieldToSet: z
-            .string()
-            .optional()
-            .describe("The field to set in the target collection, if different from sourceField"),
-        targetField: z
-            .string()
-            .describe("The field in the target collection to match with sourceField that will then be updated"),
-        targetCollection: z.string().describe("The collection to search"),
-    }))
+    idMappings: idMappingSchema
         .optional()
         .describe("The id mappings for the attribute to map ID's to"),
     updateMapping: z
@@ -416,12 +417,40 @@ export const importDefSchemas = z
     .array(importDefSchema)
     .default([])
     .describe("The import definitions for the database");
+export const permissionSchema = z
+    .object({
+    permission: z.string(),
+    target: z.string(),
+})
+    .or(z.string().transform((val) => {
+    const trimmedVal = val.trim();
+    // Adjusted regex to match double quotes
+    const match = trimmedVal.match(/^(\w+)\("([^"]+)"\)$/);
+    if (!match) {
+        throw new Error(`Invalid permission format: ${trimmedVal}`);
+    }
+    return {
+        permission: match[1],
+        target: match[2],
+    };
+}));
+export const permissionsSchema = z.array(permissionSchema).optional();
+export const attributesSchema = z.array(attributeSchema).default([]);
 export const collectionSchema = z.object({
+    name: z.string().describe("The name of the collection"),
     $id: z
         .string()
         .optional()
         .default(ID.unique())
         .describe("The ID of the collection, auto generated if not provided"),
+    enabled: z
+        .boolean()
+        .default(true)
+        .describe("Whether the collection is enabled or not"),
+    documentSecurity: z
+        .boolean()
+        .default(false)
+        .describe("Whether document security is enabled or not"),
     $createdAt: z.string(),
     $updatedAt: z.string(),
     $permissions: z
@@ -431,19 +460,6 @@ export const collectionSchema = z.object({
     }))
         .default([])
         .describe("The permissions of the collection"),
-    databaseId: z
-        .string()
-        .optional()
-        .describe("The ID of the database the collection belongs to"),
-    name: z.string().describe("The name of the collection"),
-    enabled: z
-        .boolean()
-        .default(true)
-        .describe("Whether the collection is enabled or not"),
-    documentSecurity: z
-        .boolean()
-        .default(false)
-        .describe("Whether document security is enabled or not"),
     attributes: z
         .array(attributeSchema)
         .default([])
@@ -453,6 +469,10 @@ export const collectionSchema = z.object({
         .default([])
         .describe("The indexes of the collection"),
     importDefs: importDefSchemas,
+    databaseId: z
+        .string()
+        .optional()
+        .describe("The ID of the database the collection belongs to"),
 });
 export const CollectionCreateSchema = collectionSchema.omit({
     $createdAt: true,

package/dist/migrations/schemaStrings.d.ts

@@ -4,6 +4,7 @@ export declare class SchemaGenerator {
     private config;
     private appwriteFolderPath;
     constructor(config: AppwriteConfig, appwriteFolderPath: string);
+    updateYamlSchemas(): void;
     private extractRelationships;
     private addRelationship;
     generateSchemas(): void;

package/dist/migrations/schemaStrings.js

@@ -2,6 +2,7 @@ import { toCamelCase, toPascalCase } from "../utils/index.js";
 import { z } from "zod";
 import fs from "fs";
 import path from "path";
+import { dump } from "js-yaml";
 export class SchemaGenerator {
     relationshipMap = new Map();
     config;
@@ -11,6 +12,15 @@ export class SchemaGenerator {
         this.appwriteFolderPath = appwriteFolderPath;
         this.extractRelationships();
     }
+    updateYamlSchemas() {
+        // Output this.config to a YAML file at appwriteFolderPath/appwriteConfig.yaml
+        let finalConfig = this.config;
+        finalConfig.appwriteClient = null;
+        const yamlConfig = finalConfig;
+        const yamlPath = path.join(this.appwriteFolderPath, "appwriteConfig.yaml");
+        fs.writeFileSync(yamlPath, dump(yamlConfig), { encoding: "utf-8" });
+        console.log(`YAML written to ${yamlPath}`);
+    }
     extractRelationships() {
         this.config.collections.forEach((collection) => {
             collection.attributes.forEach((attr) => {

package/dist/utils/helperFunctions.d.ts

@@ -1,4 +1,6 @@
 import type { Models } from "node-appwrite";
+import type { CollectionImportData } from "src/migrations/dataLoader.js";
+import type { ConfigCollection } from "src/migrations/schema.js";
 export declare const toPascalCase: (str: string) => string;
 export declare const toCamelCase: (str: string) => string;
 export declare const ensureDirectoryExistence: (filePath: string) => true | undefined;
@@ -32,3 +34,4 @@ export declare const getFileViewUrl: (endpoint: string, projectId: string, bucke
  * @return {string} The complete download URL for the file.
  */
 export declare const getFileDownloadUrl: (endpoint: string, projectId: string, bucketId: string, fileId: string, jwt?: Models.Jwt) => string;
+export declare const finalizeByAttributeMap: (appwriteFolderPath: string, collection: ConfigCollection, item: CollectionImportData["data"][number]) => Promise<any>;

package/dist/utils/helperFunctions.js

@@ -70,3 +70,11 @@ export const getFileViewUrl = (endpoint, projectId, bucketId, fileId, jwt) => {
 export const getFileDownloadUrl = (endpoint, projectId, bucketId, fileId, jwt) => {
     return `${endpoint}/storage/buckets/${bucketId}/files/${fileId}/download?project=${projectId}${jwt ? `&jwt=${jwt.jwt}` : ""}`;
 };
+export const finalizeByAttributeMap = async (appwriteFolderPath, collection, item) => {
+    const schemaFolderPath = path.join(appwriteFolderPath, "schemas");
+    const zodSchema = await import(`${schemaFolderPath}/${toCamelCase(collection.name)}.ts`);
+    return zodSchema.parse({
+        ...item.context,
+        ...item.finalData,
+    });
+};

package/dist/utilsController.d.ts

@@ -2,6 +2,7 @@ import { type ConverterFunctions } from "./migrations/converters.js";
 import { type AfterImportActions } from "./migrations/afterImportActions.js";
 import { type ValidationRules } from "./migrations/validationRules.js";
 export interface SetupOptions {
+    sync: boolean;
     runProd: boolean;
     runStaging: boolean;
     runDev: boolean;

package/dist/utilsController.js

@@ -11,6 +11,7 @@ import { afterImportActions, } from "./migrations/afterImportActions.js";
 import { validationRules, } from "./migrations/validationRules.js";
 import { ImportController } from "./migrations/importController.js";
 import _ from "lodash";
+import { AppwriteToX } from "./migrations/appwriteToX.js";
 async function loadConfig(configPath) {
     if (!fs.existsSync(configPath)) {
         throw new Error(`Configuration file not found at ${configPath}`);
@@ -84,6 +85,12 @@ export class UtilsController {
         if (!this.database || !this.storage || !this.config) {
             throw new Error("Database or storage not initialized");
         }
+        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");
+        }
         // 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);

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

package/src/main.ts

@@ -7,6 +7,7 @@ async function main() {
   const controller = new UtilsController();
   await controller.init();
 
+  let sync = false;
   let runProd = false;
   let runStaging = false;
   let runDev = false;
@@ -17,6 +18,9 @@ async function main() {
   let importData = false;
   let wipeDocuments = false;
   let shouldWriteFile = false;
+  if (args.includes("--sync")) {
+    sync = true;
+  }
   if (args.includes("--prod")) {
     runProd = true;
   }
@@ -49,6 +53,7 @@ async function main() {
   }
   if (args.includes("--init")) {
     await controller.run({
+      sync: sync,
       runProd: runProd,
       runStaging: runStaging,
       runDev: runDev,
@@ -64,6 +69,7 @@ async function main() {
     });
   } else {
     await controller.run({
+      sync: sync,
       runProd: runProd,
       runStaging: runStaging,
       runDev: runDev,

package/src/migrations/afterImportActions.ts

@@ -13,7 +13,7 @@ import fs from "fs";
 import os from "os";
 import { logger } from "./logging.js";
 
-const getDatabaseFromConfig = (config: AppwriteConfig) => {
+export const getDatabaseFromConfig = (config: AppwriteConfig) => {
   if (!config.appwriteClient) {
     config.appwriteClient = new Client()
       .setEndpoint(config.appwriteEndpoint)
@@ -23,7 +23,7 @@ const getDatabaseFromConfig = (config: AppwriteConfig) => {
   return new Databases(config.appwriteClient!);
 };
 
-const getStorageFromConfig = (config: AppwriteConfig) => {
+export const getStorageFromConfig = (config: AppwriteConfig) => {
   if (!config.appwriteClient) {
     config.appwriteClient = new Client()
       .setEndpoint(config.appwriteEndpoint)

package/src/migrations/appwriteToX.ts

@@ -0,0 +1,122 @@
+import { SchemaGenerator } from "./schemaStrings.js";
+import { Databases, Query, type Models, type Permission } from "node-appwrite";
+import { fetchAllCollections } from "./collections.js";
+import { fetchAllDatabases } from "./databases.js";
+import {
+  collectionSchema,
+  attributeSchema,
+  type AppwriteConfig,
+  AppwriteConfigSchema,
+  type ConfigDatabases,
+  type Attribute,
+  permissionsSchema,
+  attributesSchema,
+  indexesSchema,
+} from "./schema.js";
+import { getDatabaseFromConfig } from "./afterImportActions.js";
+
+export class AppwriteToX {
+  config: AppwriteConfig;
+  updatedConfig: AppwriteConfig;
+  collToAttributeMap = new Map<string, Attribute[]>();
+  appwriteFolderPath: string;
+
+  constructor(config: AppwriteConfig, appwriteFolderPath: string) {
+    this.config = config;
+    this.updatedConfig = config;
+    this.appwriteFolderPath = appwriteFolderPath;
+  }
+
+  // Function to parse a single permission string
+  parsePermissionString = (permissionString: string) => {
+    const match = permissionString.match(/^(\w+)\('([^']+)'\)$/);
+    if (!match) {
+      throw new Error(`Invalid permission format: ${permissionString}`);
+    }
+    return {
+      permission: match[1],
+      target: match[2],
+    };
+  };
+
+  // Function to parse an array of permission strings
+  parsePermissionsArray = (permissions: string[]) => {
+    const parsedPermissions = permissionsSchema.parse(permissions);
+    // Validate the parsed permissions using Zod
+    return parsedPermissions ?? [];
+  };
+
+  updateCollectionConfigAttributes = (collection: Models.Collection) => {
+    for (const attribute of collection.attributes) {
+      const attributeMap = this.collToAttributeMap.get(
+        collection.name as string
+      );
+      const attributeParsed = attributeSchema.parse(attribute);
+      this.collToAttributeMap
+        .get(collection.name as string)
+        ?.push(attributeParsed);
+    }
+  };
+
+  async appwriteSync(config: AppwriteConfig) {
+    const db = getDatabaseFromConfig(config);
+    const databases = await fetchAllDatabases(db);
+    let updatedConfig: AppwriteConfig = { ...config };
+
+    // Loop through each database
+    for (const database of databases) {
+      const collections = await fetchAllCollections(database.$id, db);
+
+      // Loop through each collection in the current database
+      for (const collection of collections) {
+        const existingCollectionIndex = updatedConfig.collections.findIndex(
+          (c) => c.name === collection.name
+        );
+
+        // Parse the collection permissions and attributes
+        const collPermissions = this.parsePermissionsArray(
+          collection.$permissions
+        );
+        const collAttributes = attributesSchema.parse(collection.attributes);
+        this.collToAttributeMap.set(collection.name, collAttributes);
+        const collIndexes = indexesSchema.parse(collection.indexes);
+
+        // Prepare the collection object to be added or updated
+        const collToPush = collectionSchema.parse({
+          name: collection.name,
+          enabled: collection.enabled,
+          documentSecurity: collection.documentSecurity,
+          $createdAt: collection.$createdAt,
+          $updatedAt: collection.$updatedAt,
+          $permissions:
+            collPermissions.length > 0 ? collPermissions : undefined,
+          indexes: collIndexes.length > 0 ? collIndexes : undefined,
+          attributes: collAttributes.length > 0 ? collAttributes : undefined,
+        });
+
+        if (existingCollectionIndex !== -1) {
+          // Update existing collection
+          updatedConfig.collections[existingCollectionIndex] = collToPush;
+        } else {
+          // Add new collection
+          updatedConfig.collections.push(collToPush);
+        }
+      }
+
+      console.log(
+        `Processed ${collections.length} collections in ${database.name}`
+      );
+    }
+    this.updatedConfig = updatedConfig;
+  }
+
+  async toSchemas() {
+    await this.appwriteSync(this.config);
+    const generator = new SchemaGenerator(
+      this.updatedConfig,
+      this.appwriteFolderPath
+    );
+    generator.updateYamlSchemas();
+    generator.generateSchemas();
+  }
+}

package/src/migrations/converters.ts

@@ -1,6 +1,6 @@
 import { DateTime } from "luxon";
 import _ from "lodash";
-import type { AppwriteConfig } from "./schema.js";
+import type { AppwriteConfig, ConfigCollection } from "./schema.js";
 
 const { cloneDeep, isObject } = _;
 
@@ -16,7 +16,7 @@ export const converterFunctions = {
    */
   anyToString(value: any): string | null {
     if (value == null) return null;
-    return typeof value === "string" ? value : JSON.stringify(value);
+    return typeof value === "string" ? value : `${value}`;
   },
 
   /**

package/src/migrations/dataLoader.ts

@@ -7,6 +7,7 @@ import {
   type AttributeMappings,
   type ConfigCollection,
   type ConfigDatabase,
+  type IdMapping,
   type ImportDef,
   type ImportDefs,
   type RelationshipAttribute,
@@ -22,6 +23,7 @@ import { findOrCreateOperation, updateOperation } from "./migrationHelper.js";
 import { AuthUserCreateSchema } from "../schemas/authUser.js";
 import _ from "lodash";
 import { UsersController } from "./users.js";
+import { finalizeByAttributeMap } from "../utils/helperFunctions.js";
 // Define a schema for the structure of collection import data using Zod for validation
 export const CollectionImportDataSchema = z.object({
   // Optional collection creation schema
@@ -96,22 +98,38 @@ export class DataLoader {
    * @param target - The target object with values to update the source object.
    * @returns The updated source object.
    */
-  mergeObjects(
-    source: Record<string, any>,
-    target: Record<string, any>
-  ): Record<string, any> {
-    Object.keys(target).forEach((key) => {
-      const targetValue = target[key];
-      if (
-        source.hasOwnProperty(key) &&
-        targetValue !== null &&
-        targetValue !== undefined &&
-        targetValue !== ""
+  mergeObjects(source: any, update: any): any {
+    // Create a new object to hold the merged result
+    const result = { ...source };
+
+    Object.keys(update).forEach((key) => {
+      const sourceValue = source[key];
+      const updateValue = update[key];
+
+      // If the update value is an array, concatenate and remove duplicates
+      if (Array.isArray(updateValue)) {
+        const sourceArray = Array.isArray(sourceValue) ? sourceValue : [];
+        result[key] = [...new Set([...sourceArray, ...updateValue])];
+      }
+      // If the update value is an object, recursively merge
+      else if (
+        updateValue !== null &&
+        typeof updateValue === "object" &&
+        !(updateValue instanceof Date)
       ) {
-        source[key] = targetValue;
+        result[key] = this.mergeObjects(sourceValue, updateValue);
+      }
+      // If the update value is not nullish, overwrite the source value
+      else if (updateValue !== null && updateValue !== undefined) {
+        result[key] = updateValue;
+      }
+      // If the update value is nullish, keep the original value unless it doesn't exist
+      else if (sourceValue === undefined) {
+        result[key] = updateValue;
       }
     });
-    return source;
+
+    return result;
   }
 
   // Method to load data from a file specified in the import definition
@@ -332,6 +350,10 @@ export class DataLoader {
 
       if (!collectionData || !collectionData.data) continue;
 
+      console.log(
+        `Updating references for collection: ${collectionConfig.name}`
+      );
+
       // Iterate over each data item in the current collection
       for (const item of collectionData.data) {
         let needsUpdate = false;
@@ -342,102 +364,74 @@ export class DataLoader {
             if (importDef.idMappings) {
               // Iterate over each idMapping defined for the current import definition
               for (const idMapping of importDef.idMappings) {
-                const oldId = item.context[idMapping.sourceField];
-                if (oldId) {
-                  let newIdForOldId: string | undefined;
-                  // Your existing logic to resolve newIdForOldId here...
+                const oldIds = Array.isArray(
+                  item.context[idMapping.sourceField]
+                )
+                  ? item.context[idMapping.sourceField]
+                  : [item.context[idMapping.sourceField]];
+                const resolvedNewIds: string[] = [];
+
+                oldIds.forEach((oldId: any) => {
+                  // Attempt to find a new ID for the old ID
+                  let newIdForOldId = this.findNewIdForOldId(oldId, idMapping);
+
+                  // Check if a new ID was found and it's not already included
+                  if (
+                    newIdForOldId &&
+                    !resolvedNewIds.includes(newIdForOldId)
+                  ) {
+                    resolvedNewIds.push(newIdForOldId);
+                  }
+                });
+                if (resolvedNewIds.length) {
+                  const targetField =
+                    idMapping.fieldToSet || idMapping.targetField;
+                  const isArray = collectionConfig.attributes.some(
+                    (attribute) =>
+                      attribute.key === targetField && attribute.array
+                  );
 
-                  if (newIdForOldId) {
-                    // Determine the field to update, handling arrays appropriately
-                    const fieldToUpdate =
-                      idMapping.fieldToSet || idMapping.targetField;
-                    if (Array.isArray(item.finalData[fieldToUpdate])) {
-                      // If the target field is an array, append the new ID
-                      item.finalData[fieldToUpdate].push(newIdForOldId);
-                    } else {
-                      // Otherwise, directly set the new ID
-                      item.finalData[fieldToUpdate] = newIdForOldId;
-                    }
-                    console.log(`Updated ${oldId} to ${newIdForOldId}`);
-                    needsUpdate = true;
+                  // Set the target field based on whether it's an array or single value
+                  if (isArray) {
+                    item.finalData[targetField] = resolvedNewIds;
+                  } else {
+                    // In case of a single value, use the first resolved ID
+                    item.finalData[targetField] = resolvedNewIds[0];
                   }
+                  needsUpdate = true;
                 }
               }
             }
           }
         }
 
+        // Update the importMap if changes were made to the item
         if (needsUpdate) {
-          // Re-transform the item's finalData using its attribute mappings
-          const importDef = item.importDef; // Assuming importDef is available in the item
-          if (importDef && importDef.attributeMappings) {
-            item.finalData = await this.transformData(
-              item.finalData,
-              importDef.attributeMappings
-            );
-          }
           this.importMap.set(collectionKey, collectionData);
+          logger.info(
+            `Updated item: ${JSON.stringify(item.finalData, undefined, 2)}`
+          );
         }
       }
     }
   }
 
-  // async updateReferencesInRelatedCollections() {
-  //   // Process each collection defined in the config
-  //   for (const collection of this.config.collections) {
-  //     // Ensure we handle only those definitions with idMappings and a primaryKeyField defined
-  //     for (const importDef of collection.importDefs) {
-  //       if (!importDef.idMappings || !importDef.primaryKeyField) continue;
-
-  //       // Load data for this particular import definition
-  //       const collectionData = this.importMap.get(
-  //         this.getCollectionKey(collection.name)
-  //       )?.data;
-  //       if (!collectionData) continue;
-
-  //       // Iterate over each item in the collection data
-  //       for (const item of collectionData) {
-  //         let needsUpdate = false;
-
-  //         // Go through each idMapping defined for the collection
-  //         for (const mapping of importDef.idMappings) {
-  //           const oldReferenceId =
-  //             item[mapping.targetField as keyof typeof item]; // Get the current reference ID from the item
-  //           const referenceCollectionMap =
-  //             this.oldIdToNewIdPerCollectionMap.get(
-  //               this.getCollectionKey(mapping.targetCollection)
-  //             );
-
-  //           if (
-  //             referenceCollectionMap &&
-  //             referenceCollectionMap.has(oldReferenceId)
-  //           ) {
-  //             // Update the target field with the new reference ID from the mapped collection
-  //             item[mapping.sourceField as keyof typeof item] =
-  //               referenceCollectionMap.get(oldReferenceId);
-  //             needsUpdate = true;
-  //             console.log(
-  //               `Updated item with ${mapping.sourceField} = ${JSON.stringify(
-  //                 item,
-  //                 null,
-  //                 undefined
-  //               )}.`
-  //             );
-  //           }
-  //         }
+  findNewIdForOldId(oldId: string, idMapping: IdMapping) {
+    // First, check if the old ID has been merged into a new one
+    for (const [newUserId, oldIds] of this.mergedUserMap.entries()) {
+      if (oldIds.includes(oldId)) {
+        return newUserId;
+      }
+    }
 
-  //         // Save changes if any reference was updated
-  //         if (needsUpdate) {
-  //           await this.saveUpdatedItem(
-  //             collection.name,
-  //             item,
-  //             importDef.primaryKeyField
-  //           );
-  //         }
-  //       }
-  //     }
-  //   }
-  // }
+    // If not merged, look for a direct mapping from old to new ID
+    const targetCollectionKey = this.getCollectionKey(
+      idMapping.targetCollection
+    );
+    const targetOldIdToNewIdMap =
+      this.oldIdToNewIdPerCollectionMap.get(targetCollectionKey);
+    return targetOldIdToNewIdMap?.get(oldId);
+  }
 
   private writeMapsToJsonFile() {
     const outputDir = path.resolve(process.cwd());
@@ -514,7 +508,6 @@ export class DataLoader {
     // Check for duplicate email and add to emailToUserIdMap if not found
     if (email && email.length > 0) {
       if (this.emailToUserIdMap.has(email)) {
-        logger.error(`Duplicate email found or user exists already: ${email}`);
         existingId = this.emailToUserIdMap.get(email);
       } else {
         this.emailToUserIdMap.set(email, newId);
@@ -524,7 +517,6 @@ export class DataLoader {
     // Check for duplicate phone and add to phoneToUserIdMap if not found
     if (phone && phone.length > 0) {
       if (this.phoneToUserIdMap.has(phone)) {
-        logger.error(`Duplicate phone found: ${phone}`);
         existingId = this.phoneToUserIdMap.get(phone);
       } else {
         this.phoneToUserIdMap.set(phone, newId);