appwrite-utils-cli 0.0.262 → 0.0.264

package/dist/migrations/schemaStrings.js

@@ -2,6 +2,8 @@ import { toCamelCase, toPascalCase } from "../utils/index.js";
 import { z } from "zod";
 import fs from "fs";
 import path from "path";
+import { dump } from "js-yaml";
+import { getDatabaseFromConfig } from "./afterImportActions.js";
 export class SchemaGenerator {
     relationshipMap = new Map();
     config;
@@ -11,6 +13,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) => {
@@ -39,6 +50,7 @@ export class SchemaGenerator {
                             break;
                     }
                     this.addRelationship(collection.name, relationshipAttr.relatedCollection, attr.key, relationshipAttr.twoWayKey, isArrayParent, isArrayChild);
+                    console.log(`Extracted relationship: ${attr.key}\n\t${collection.name} -> ${relationshipAttr.relatedCollection}, databaseId: ${collection.databaseId}`);
                 }
             });
         });
@@ -79,7 +91,14 @@ export class SchemaGenerator {
         let imports = `import { z } from "zod";\n`;
         // Use the relationshipMap to find related collections
         const relationshipDetails = this.relationshipMap.get(name) || [];
-        const relatedCollections = relationshipDetails.map((detail) => {
+        const relatedCollections = relationshipDetails
+            .filter((detail, index, self) => {
+            const uniqueKey = `${detail.parentCollection}-${detail.childCollection}-${detail.parentKey}-${detail.childKey}`;
+            return (index ===
+                self.findIndex((obj) => `${obj.parentCollection}-${obj.childCollection}-${obj.parentKey}-${obj.childKey}` ===
+                    uniqueKey));
+        })
+            .map((detail) => {
             const relatedCollectionName = detail.isChild
                 ? detail.parentCollection
                 : detail.childCollection;
@@ -92,8 +111,9 @@ export class SchemaGenerator {
         let curNum = 0;
         let maxNum = relatedCollections.length;
         relatedCollections.forEach((relatedCollection) => {
-            const relatedPascalName = toPascalCase(relatedCollection[0]);
-            const relatedCamelName = toCamelCase(relatedCollection[0]);
+            console.log(relatedCollection);
+            let relatedPascalName = toPascalCase(relatedCollection[0]);
+            let relatedCamelName = toCamelCase(relatedCollection[0]);
             curNum++;
             let endNameTypes = relatedPascalName;
             let endNameLazy = `${relatedPascalName}Schema`;
@@ -162,10 +182,20 @@ export class SchemaGenerator {
             case "integer":
                 baseSchemaCode = "z.number().int()";
                 if (attribute.min !== undefined) {
-                    baseSchemaCode += `.min(${attribute.min}, "Minimum value of ${attribute.min} not met")`;
+                    if (BigInt(attribute.min) === BigInt(-9223372036854776000)) {
+                        delete attribute.min;
+                    }
+                    else {
+                        baseSchemaCode += `.min(${attribute.min}, "Minimum value of ${attribute.min} not met")`;
+                    }
                 }
                 if (attribute.max !== undefined) {
-                    baseSchemaCode += `.max(${attribute.max}, "Maximum value of ${attribute.max} exceeded")`;
+                    if (BigInt(attribute.max) === BigInt(9223372036854776000)) {
+                        delete attribute.max;
+                    }
+                    else {
+                        baseSchemaCode += `.max(${attribute.max}, "Maximum value of ${attribute.max} exceeded")`;
+                    }
                 }
                 if (attribute.xdefault !== undefined) {
                     baseSchemaCode += `.default(${attribute.xdefault})`;

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.262",
+  "version": "0.0.264",
   "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,156 @@
+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) {
+      if (database.name.toLowerCase() === "migrations") {
+        continue;
+      }
+      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)
+          .filter((attribute) =>
+            attribute.type === "relationship"
+              ? attribute.side !== "child"
+              : true
+          );
+        for (const attribute of collAttributes) {
+          if (
+            attribute.type === "relationship" &&
+            attribute.relatedCollection
+          ) {
+            console.log(
+              `Fetching related collection for ID: ${attribute.relatedCollection}`
+            );
+            try {
+              const relatedCollectionPulled = await db.getCollection(
+                database.$id,
+                attribute.relatedCollection
+              );
+              console.log(
+                `Fetched Collection Name: ${relatedCollectionPulled.name}`
+              );
+              attribute.relatedCollection = relatedCollectionPulled.name;
+              console.log(
+                `Updated attribute.relatedCollection to: ${attribute.relatedCollection}`
+              );
+            } catch (error) {
+              console.log("Error fetching related collection:", error);
+            }
+          }
+        }
+        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/dataLoader.ts

@@ -133,7 +133,7 @@ export class DataLoader {
   }
 
   // Method to load data from a file specified in the import definition
-  async loadData(importDef: ImportDef): Promise<any[]> {
+  loadData(importDef: ImportDef): any[] {
     // Resolve the file path and check if the file exists
     const filePath = path.resolve(this.appwriteFolderPath, importDef.filePath);
     if (!fs.existsSync(filePath)) {
@@ -194,10 +194,7 @@ export class DataLoader {
    * @param attributeMappings - The mappings that define how each attribute should be transformed.
    * @returns The transformed item.
    */
-  async transformData(
-    item: any,
-    attributeMappings: AttributeMappings
-  ): Promise<any> {
+  transformData(item: any, attributeMappings: AttributeMappings): any {
     // Convert the item using the attribute mappings provided
     const convertedItem = convertObjectByAttributeMappings(
       item,
@@ -345,107 +342,111 @@ export class DataLoader {
   async updateReferencesInRelatedCollections() {
     // Iterate over each collection configuration
     for (const collectionConfig of this.config.collections) {
-      const collectionKey = this.getCollectionKey(collectionConfig.name);
-      const collectionData = this.importMap.get(collectionKey);
+        const collectionKey = this.getCollectionKey(collectionConfig.name);
+        const collectionData = this.importMap.get(collectionKey);
 
-      if (!collectionData || !collectionData.data) continue;
+        if (!collectionData || !collectionData.data) continue;
 
-      console.log(
-        `Updating references for collection: ${collectionConfig.name}`
-      );
+        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;
+        // Iterate over each data item in the current collection
+        for (const item of collectionData.data) {
+            let needsUpdate = false;
 
-        // Check if the current collection has import definitions with idMappings
-        if (collectionConfig.importDefs) {
-          for (const importDef of collectionConfig.importDefs) {
-            if (importDef.idMappings) {
-              // Iterate over each idMapping defined for the current import definition
-              for (const idMapping of importDef.idMappings) {
-                const oldIds = Array.isArray(
-                  item.context[idMapping.sourceField]
-                )
-                  ? item.context[idMapping.sourceField]
-                  : [item.context[idMapping.sourceField]];
+            // Check if the current collection has import definitions with idMappings
+            if (collectionConfig.importDefs) {
+                for (const importDef of collectionConfig.importDefs) {
+                    if (importDef.idMappings) {
+                        // Iterate over each idMapping defined for the current import definition
+                        for (const idMapping of importDef.idMappings) {
+                            const oldIds = Array.isArray(item.context[idMapping.sourceField])
+                                ? item.context[idMapping.sourceField]
+                                : [item.context[idMapping.sourceField]];
+                            const resolvedNewIds: string[] = [];
 
-                oldIds.forEach((oldId: any) => {
-                  let newIdForOldId;
+                            oldIds.forEach((oldId: any) => {
+                                // Attempt to find a new ID for the old ID
+                                let newIdForOldId = this.findNewIdForOldId(
+                                    oldId,
+                                    idMapping,
+                                    importDef
+                                );
 
-                  // Handling users merged into a new ID
-                  newIdForOldId = this.findNewIdForOldId(oldId, idMapping);
+                                if (newIdForOldId && !resolvedNewIds.includes(newIdForOldId)) {
+                                    resolvedNewIds.push(newIdForOldId);
+                                } else {
+                                    logger.error(`No new ID found for old ID ${oldId} in collection ${collectionConfig.name}`);
+                                }
+                            });
 
-                  if (newIdForOldId) {
-                    const targetField =
-                      idMapping.fieldToSet || idMapping.targetField;
-                    const isArray = collectionConfig.attributes.some(
-                      (attribute) =>
-                        attribute.key === targetField && attribute.array
-                    );
+                            if (resolvedNewIds.length) {
+                                const targetField = idMapping.fieldToSet || idMapping.targetField;
+                                const isArray = collectionConfig.attributes.some(
+                                    attribute => attribute.key === targetField && attribute.array
+                                );
 
-                    // Properly update the target field based on whether it should be an array
-                    if (isArray) {
-                      if (!Array.isArray(item.finalData[targetField])) {
-                        item.finalData[targetField] = [newIdForOldId];
-                      } else if (
-                        !item.finalData[targetField].includes(newIdForOldId)
-                      ) {
-                        item.finalData[targetField].push(newIdForOldId);
-                      }
-                    } else {
-                      item.finalData[targetField] = newIdForOldId;
+                                // Set the target field based on whether it's an array or single value
+                                item.finalData[targetField] = isArray ? resolvedNewIds : resolvedNewIds[0];
+                                needsUpdate = true;
+                            }
+                        }
                     }
-                    needsUpdate = true;
-                  }
-                });
-              }
+                }
             }
-          }
-        }
 
-        // Update the importMap if changes were made to the item
-        if (needsUpdate) {
-          this.importMap.set(collectionKey, collectionData);
-          logger.info(
-            `Updated item: ${JSON.stringify(item.finalData, undefined, 2)}`
-          );
+            // Update the importMap if changes were made to the item
+            if (needsUpdate) {
+                this.importMap.set(collectionKey, collectionData);
+                logger.info(`Updated item: ${JSON.stringify(item.finalData, undefined, 2)}`);
+            }
         }
-      }
     }
+}
+
+findNewIdForOldId(oldId: string, idMapping: IdMapping, importDef: ImportDef) {
+  // First, check if this ID mapping is related to the users collection.
+  const targetCollectionKey = this.getCollectionKey(idMapping.targetCollection);
+  const isUsersCollection = targetCollectionKey === this.getCollectionKey(this.config.usersCollectionName);
+
+  // If handling users, check the mergedUserMap for any existing new ID.
+  if (isUsersCollection) {
+      for (const [newUserId, oldIds] of this.mergedUserMap.entries()) {
+          if (oldIds.includes(oldId)) {
+              return newUserId;
+          }
+      }
   }
 
-  findNewIdForOldId(oldId: string, idMapping: IdMapping) {
-    // Check merged users first for any corresponding new ID
-    let newIdForOldId;
-    for (const [newUserId, oldIds] of this.mergedUserMap.entries()) {
-      if (oldIds.includes(oldId)) {
-        newIdForOldId = newUserId;
-        break;
+  // If not a user or no merged ID found, check the regular ID mapping from old to new.
+  const targetCollectionData = this.importMap.get(targetCollectionKey);
+  if (targetCollectionData) {
+      const foundEntry = targetCollectionData.data.find(entry => entry.context[importDef.primaryKeyField] === oldId);
+      if (foundEntry) {
+          return foundEntry.context.docId;  // Assuming `docId` stores the new ID after import
       }
-    }
+  }
 
-    // If no new ID found in merged users, check the old-to-new ID map for the target collection
-    if (!newIdForOldId) {
-      const targetCollectionKey = this.getCollectionKey(
-        idMapping.targetCollection
-      );
-      const targetOldIdToNewIdMap =
-        this.oldIdToNewIdPerCollectionMap.get(targetCollectionKey);
+  logger.error(`No corresponding new ID found for ${oldId} in ${targetCollectionKey}`);
+  return null; // Return null if no new ID is found
+}
 
-      if (targetOldIdToNewIdMap && targetOldIdToNewIdMap.has(oldId)) {
-        newIdForOldId = targetOldIdToNewIdMap.get(oldId);
-      }
-    }
 
-    return newIdForOldId;
-  }
 
   private writeMapsToJsonFile() {
     const outputDir = path.resolve(process.cwd());
     const outputFile = path.join(outputDir, "dataLoaderOutput.json");
 
     const dataToWrite = {
+      // Convert Maps to arrays of entries for serialization
+      oldIdToNewIdPerCollectionMap: Array.from(
+        this.oldIdToNewIdPerCollectionMap.entries()
+      ).map(([key, value]) => {
+        return {
+          collection: key,
+          data: Array.from(value.entries()),
+        };
+      }),
+      mergedUserMap: Array.from(this.mergedUserMap.entries()),
       dataFromCollections: Array.from(this.importMap.entries()).map(
         ([key, value]) => {
           return {
@@ -454,8 +455,6 @@ export class DataLoader {
           };
         }
       ),
-      // Convert Maps to arrays of entries for serialization
-      mergedUserMap: Array.from(this.mergedUserMap.entries()),
       // emailToUserIdMap: Array.from(this.emailToUserIdMap.entries()),
       // phoneToUserIdMap: Array.from(this.phoneToUserIdMap.entries()),
     };
@@ -497,7 +496,7 @@ export class DataLoader {
     newId: string
   ): Promise<any> {
     // Transform the item data based on the attribute mappings
-    let transformedItem = await this.transformData(item, attributeMappings);
+    let transformedItem = this.transformData(item, attributeMappings);
     const userData = AuthUserCreateSchema.safeParse(transformedItem);
     if (!userData.success) {
       logger.error(
@@ -577,7 +576,7 @@ export class DataLoader {
     importDef: ImportDef
   ): Promise<void> {
     // Load the raw data based on the import definition
-    const rawData = await this.loadData(importDef);
+    const rawData = this.loadData(importDef);
     const operationId = this.collectionImportOperations.get(
       this.getCollectionKey(collection.name)
     );
@@ -762,7 +761,7 @@ export class DataLoader {
     importDef: ImportDef
   ): Promise<void> {
     // Load the raw data based on the import definition
-    const rawData = await this.loadData(importDef);
+    const rawData = this.loadData(importDef);
     const operationId = this.collectionImportOperations.get(
       this.getCollectionKey(collection.name)
     );
@@ -801,7 +800,7 @@ export class DataLoader {
       // Create a context object for the item, including the new ID
       let context = this.createContext(db, collection, item, itemIdNew);
       // Transform the item data based on the attribute mappings
-      const transformedData = await this.transformData(
+      const transformedData = this.transformData(
         item,
         importDef.attributeMappings
       );
@@ -892,7 +891,7 @@ export class DataLoader {
       return;
     }
     // Load the raw data based on the import definition
-    const rawData = await this.loadData(importDef);
+    const rawData = this.loadData(importDef);
     const operationId = this.collectionImportOperations.get(
       this.getCollectionKey(collection.name)
     );
@@ -903,7 +902,7 @@ export class DataLoader {
     }
     for (const item of rawData) {
       // Transform the item data based on the attribute mappings
-      let transformedData = await this.transformData(
+      let transformedData = this.transformData(
         item,
         importDef.attributeMappings
       );

package/src/migrations/databases.ts

@@ -0,0 +1,25 @@
+import { Databases, Query, type Models } from "node-appwrite";
+
+export const fetchAllDatabases = async (
+  database: Databases
+): Promise<Models.Database[]> => {
+  const databases = await database.list([Query.limit(25)]);
+  const allDatabases = databases.databases;
+  let lastDatabaseId = allDatabases[allDatabases.length - 1].$id;
+  if (databases.databases.length < 25) {
+    return allDatabases;
+  } else {
+    while (lastDatabaseId) {
+      const databases = await database.list([
+        Query.limit(25),
+        Query.cursorAfter(lastDatabaseId),
+      ]);
+      allDatabases.push(...databases.databases);
+      if (databases.databases.length < 25) {
+        break;
+      }
+      lastDatabaseId = databases.databases[databases.databases.length - 1].$id;
+    }
+  }
+  return allDatabases;
+};

package/src/migrations/indexes.ts

@@ -14,6 +14,14 @@ export const createOrUpdateIndex = async (
   if (existingIndex.total > 0) {
     await db.deleteIndex(dbId, collectionId, existingIndex.indexes[0].key);
   }
+  if (index.type === "fulltext" && index.attributes.length > 1) {
+    throw new Error(
+      `Fulltext index can only be created on a single attribute. Index: ${index.key}`
+    );
+  } else if (index.type === "fulltext") {
+    // @ts-ignore
+    index.attributes = index.attributes[0];
+  }
   const newIndex = await db.createIndex(
     dbId,
     collectionId,