appwrite-utils-cli 1.3.4 → 1.4.0

package/src/collections/methods.ts

@@ -7,7 +7,9 @@ import {
   type Models,
 } from "node-appwrite";
 import type { AppwriteConfig, CollectionCreate, Indexes } from "appwrite-utils";
-import { nameToIdMapping, processQueue } from "../shared/operationQueue.js";
+import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import { getAdapterFromConfig } from "../utils/getClientFromConfig.js";
+import { nameToIdMapping, processQueue, queuedOperations } from "../shared/operationQueue.js";
 import { createUpdateCollectionAttributes, createUpdateCollectionAttributesWithStatusCheck } from "./attributes.js";
 import { createOrUpdateIndexes, createOrUpdateIndexesWithStatusCheck } from "./indexes.js";
 import { SchemaGenerator } from "../shared/schemaGenerator.js";
@@ -26,13 +28,15 @@ import { ProgressManager } from "../shared/progressManager.js";
 import chalk from "chalk";
 
 export const documentExists = async (
-  db: Databases,
+  db: Databases | DatabaseAdapter,
   dbId: string,
   targetCollectionId: string,
   toCreateObject: any
 ): Promise<Models.Document | null> => {
-  const collection = await db.getCollection(dbId, targetCollectionId);
-  const attributes = collection.attributes as any[];
+  const collection = await (db instanceof Databases ? 
+    db.getCollection(dbId, targetCollectionId) :
+    db.getTable({ databaseId: dbId, tableId: targetCollectionId }));
+  const attributes = (collection as any).attributes as any[];
   let arrayTypeAttributes = attributes
     .filter((attribute: any) => attribute.array === true)
     .map((attribute: any) => attribute.key);
@@ -77,28 +81,30 @@ export const documentExists = async (
   );
 
   // Execute the query with the validated and prepared parameters
-  const result = await db.listDocuments(
-    dbId,
-    targetCollectionId,
-    validQueryParams
-  );
-  return result.documents[0] || null;
+  const result = await (db instanceof Databases ?
+    db.listDocuments(dbId, targetCollectionId, validQueryParams) :
+    db.listRows({ databaseId: dbId, tableId: targetCollectionId, queries: validQueryParams }));
+  
+  const items = db instanceof Databases ? result.documents : ((result as any).rows || result.documents);
+  return items?.[0] || null;
 };
 
 export const checkForCollection = async (
-  db: Databases,
+  db: Databases | DatabaseAdapter,
   dbId: string,
   collection: Partial<CollectionCreate>
 ): Promise<Models.Collection | null> => {
   try {
     MessageFormatter.progress(`Checking for collection with name: ${collection.name}`, { prefix: "Collections" });
     const response = await tryAwaitWithRetry(
-      async () =>
-        await db.listCollections(dbId, [Query.equal("name", collection.name!)])
+      async () => db instanceof Databases ?
+        await db.listCollections(dbId, [Query.equal("name", collection.name!)]) :
+        await db.listTables({ databaseId: dbId, queries: [Query.equal("name", collection.name!)] })
     );
-    if (response.collections.length > 0) {
-      MessageFormatter.info(`Collection found: ${response.collections[0].$id}`, { prefix: "Collections" });
-      return { ...collection, ...response.collections[0] };
+    const items = db instanceof Databases ? response.collections : ((response as any).tables || response.collections);
+    if (items && items.length > 0) {
+      MessageFormatter.info(`Collection found: ${items[0].$id}`, { prefix: "Collections" });
+      return { ...collection, ...items[0] } as Models.Collection;
     } else {
       MessageFormatter.info(`No collection found with name: ${collection.name}`, { prefix: "Collections" });
       return null;
@@ -111,7 +117,7 @@ export const checkForCollection = async (
 
 // Helper function to fetch and cache collection by name
 export const fetchAndCacheCollectionByName = async (
-  db: Databases,
+  db: Databases | DatabaseAdapter,
   dbId: string,
   collectionName: string
 ): Promise<Models.Collection | undefined> => {
@@ -119,16 +125,20 @@ export const fetchAndCacheCollectionByName = async (
     const collectionId = nameToIdMapping.get(collectionName);
     MessageFormatter.debug(`Collection found in cache: ${collectionId}`, undefined, { prefix: "Collections" });
     return await tryAwaitWithRetry(
-      async () => await db.getCollection(dbId, collectionId!)
-    );
+      async () => db instanceof Databases ?
+        await db.getCollection(dbId, collectionId!) :
+        await db.getTable({ databaseId: dbId, tableId: collectionId! })
+    ) as Models.Collection;
   } else {
     MessageFormatter.progress(`Fetching collection by name: ${collectionName}`, { prefix: "Collections" });
     const collectionsPulled = await tryAwaitWithRetry(
-      async () =>
-        await db.listCollections(dbId, [Query.equal("name", collectionName)])
+      async () => db instanceof Databases ?
+        await db.listCollections(dbId, [Query.equal("name", collectionName)]) :
+        await db.listTables({ databaseId: dbId, queries: [Query.equal("name", collectionName)] })
     );
-    if (collectionsPulled.total > 0) {
-      const collection = collectionsPulled.collections[0];
+    const items = db instanceof Databases ? collectionsPulled.collections : ((collectionsPulled as any).tables || collectionsPulled.collections);
+    if ((collectionsPulled.total || items?.length) > 0) {
+      const collection = items[0];
       MessageFormatter.info(`Collection found: ${collection.$id}`, { prefix: "Collections" });
       nameToIdMapping.set(collectionName, collection.$id);
       return collection;
@@ -455,8 +465,13 @@ export const createOrUpdateCollections = async (
     // Add delay after creating indexes
     await delay(250);
   }
-  // Process any remaining tasks in the queue
-  await processQueue(database, databaseId);
+  // Process any remaining tasks in the queue (only if there are operations to process)
+  if (queuedOperations.length > 0) {
+    MessageFormatter.info(`Processing ${queuedOperations.length} queued operations (relationship dependencies)`, { prefix: "Collections" });
+    await processQueue(database, databaseId);
+  } else {
+    MessageFormatter.info("No queued operations to process", { prefix: "Collections" });
+  }
 };
 
 export const generateMockData = async (
@@ -530,7 +545,7 @@ export const transferDocumentsBetweenDbsLocalToLocal = async (
     return;
   } else if (fromCollDocs.documents.length < 50) {
     const batchedPromises = fromCollDocs.documents.map((doc) => {
-      const toCreateObject: Partial<typeof doc> = {
+      const toCreateObject: any = {
         ...doc,
       };
       delete toCreateObject.$databaseId;
@@ -554,7 +569,7 @@ export const transferDocumentsBetweenDbsLocalToLocal = async (
     totalDocumentsTransferred += fromCollDocs.documents.length;
   } else {
     const batchedPromises = fromCollDocs.documents.map((doc) => {
-      const toCreateObject: Partial<typeof doc> = {
+      const toCreateObject: any = {
         ...doc,
       };
       delete toCreateObject.$databaseId;
@@ -586,7 +601,7 @@ export const transferDocumentsBetweenDbsLocalToLocal = async (
           ])
       );
       const batchedPromises = fromCollDocs.documents.map((doc) => {
-        const toCreateObject: Partial<typeof doc> = {
+        const toCreateObject: any = {
           ...doc,
         };
         delete toCreateObject.$databaseId;

package/src/config/yamlConfig.ts

@@ -46,15 +46,17 @@ const YamlConfigSchema = z.object({
     .object({
       outputDirectory: z.string().default("schemas"),
       yamlSchemaDirectory: z.string().default(".yaml_schemas"),
+      collectionsDirectory: z.string().default("collections"),
     })
     .optional()
     .default({
       outputDirectory: "schemas",
       yamlSchemaDirectory: ".yaml_schemas",
+      collectionsDirectory: "collections",
     }),
   migrations: z
     .object({
-      enabled: z.boolean().default(true),
+      enabled: z.boolean().default(false),
     })
     .optional()
     .default({
@@ -148,6 +150,7 @@ export const convertYamlToAppwriteConfig = (yamlConfig: YamlConfig): AppwriteCon
     appwriteEndpoint: yamlConfig.appwrite.endpoint,
     appwriteProject: yamlConfig.appwrite.project,
     appwriteKey: yamlConfig.appwrite.key,
+    apiMode: "auto", // Default to auto-detect for dual API support
     appwriteClient: null,
     logging: {
       enabled: yamlConfig.logging.enabled,
@@ -167,6 +170,7 @@ export const convertYamlToAppwriteConfig = (yamlConfig: YamlConfig): AppwriteCon
       outputDirectory: yamlConfig.schemas.outputDirectory,
       yamlSchemaDirectory: yamlConfig.schemas.yamlSchemaDirectory,
       importDirectory: yamlConfig.data.importDirectory,
+      collectionsDirectory: yamlConfig.schemas.collectionsDirectory || "collections",
     },
     databases: yamlConfig.databases.map((db) => ({
       $id: db.id,
@@ -244,7 +248,7 @@ export const loadYamlConfig = async (configPath: string): Promise<AppwriteConfig
   } catch (error) {
     if (error instanceof z.ZodError) {
       console.error("❌ YAML config validation failed:");
-      error.errors.forEach((err) => {
+      error.issues.forEach((err) => {
         console.error(`  ${err.path.join('.')} → ${err.message}`);
       });
     } else {
@@ -415,6 +419,7 @@ export const generateYamlConfigTemplate = (outputPath: string) => {
     schemas: {
       outputDirectory: "schemas",
       yamlSchemaDirectory: ".yaml_schemas",
+      collectionsDirectory: "collections",
     },
     migrations: {
       enabled: true,
@@ -476,6 +481,7 @@ export const writeYamlConfig = async (configPath: string, config: AppwriteConfig
       schemas: {
         outputDirectory: config.schemaConfig?.outputDirectory || "schemas",
         yamlSchemaDirectory: config.schemaConfig?.yamlSchemaDirectory || ".yaml_schemas",
+        collectionsDirectory: config.schemaConfig?.collectionsDirectory || "collections",
       },
       migrations: {
         enabled: config.useMigrations !== false,

package/src/databases/setup.ts

@@ -1,5 +1,5 @@
 import { Databases, Query, type Models } from "node-appwrite";
-import { createOrUpdateAttribute } from "../collections/attributes.js";
+import { createOrUpdateAttributeWithStatusCheck } from "../collections/attributes.js";
 import { getMigrationCollectionSchemas } from "../storage/schemas.js";
 import {
   areCollectionNamesSame,
@@ -90,7 +90,7 @@ export const setupMigrationDatabase = async (config: AppwriteConfig) => {
 
     for (const attribute of attributes) {
       try {
-        await createOrUpdateAttribute(
+        await createOrUpdateAttributeWithStatusCheck(
           database,
           db.$id,
           collectionFound,

package/src/migrations/afterImportActions.ts

@@ -219,7 +219,7 @@ export const afterImportActions = {
         }
         const nextCursor = documents[documents.length - 1].$id;
         const nextBatch = await fetchAllMatchingDocuments(nextCursor);
-        return documents.concat(nextBatch);
+        return documents.concat(nextBatch as any);
       };
 
       const matchingDocuments = await fetchAllMatchingDocuments();
@@ -316,7 +316,7 @@ export const afterImportActions = {
         }
         const nextCursor = documents[documents.length - 1].$id;
         const nextBatch = await fetchAllMatchingDocuments(nextCursor);
-        return documents.concat(nextBatch);
+        return documents.concat(nextBatch as any);
       };
 
       const matchingDocuments = await fetchAllMatchingDocuments();

package/src/migrations/comprehensiveTransfer.ts

@@ -1682,6 +1682,7 @@ export class ComprehensiveTransfer {
         $permissions,
         $databaseId,
         $collectionId,
+        $sequence,
         ...docData
       } = doc;
       return {
@@ -1799,6 +1800,7 @@ export class ComprehensiveTransfer {
             $permissions,
             $databaseId,
             $collectionId,
+            $sequence,
             ...docData
           } = doc;
 
@@ -1827,6 +1829,7 @@ export class ComprehensiveTransfer {
                 $permissions,
                 $databaseId,
                 $collectionId,
+                $sequence,
                 ...docData
               } = doc;
               await tryAwaitWithRetry(async () =>
@@ -1889,6 +1892,7 @@ export class ComprehensiveTransfer {
             $permissions,
             $databaseId,
             $collectionId,
+            $sequence,
             ...docData
           } = doc;
 

package/src/migrations/dataLoader.ts

@@ -806,7 +806,7 @@ export class DataLoader {
     if (!userData.success || !(userData.data.email || userData.data.phone)) {
       logger.error(
         `Invalid user data: ${JSON.stringify(
-          userData.error?.errors,
+          userData.error?.issues,
           undefined,
           2
         )} or missing email/phone`
@@ -908,6 +908,7 @@ export class DataLoader {
     const userDataToAdd = {
       rawData: item,
       finalData: userData.data,
+      context: {},
     };
     this.importMap.set(this.getCollectionKey("users"), {
       data: [...(usersMap?.data || []), userDataToAdd],

package/src/migrations/relationships.ts

@@ -218,7 +218,7 @@ async function prepareDocumentUpdates(
         dbId,
         relatedCollection,
         targetField!,
-        originalId
+        String(originalId)
       );
 
       if (foundDocuments && foundDocuments.length > 0) {

package/src/migrations/services/UserMappingService.ts

@@ -138,7 +138,7 @@ export class UserMappingService {
     if (!userData.success || !(userData.data.email || userData.data.phone)) {
       logger.error(
         `Invalid user data: ${JSON.stringify(
-          userData.error?.errors,
+          userData.error?.issues,
           undefined,
           2
         )} or missing email/phone`

package/src/migrations/yaml/YamlImportConfigLoader.ts

@@ -70,7 +70,12 @@ export const YamlImportConfigSchema = z.object({
       originalIdField: z.string().describe("Field in source data for matching"),
       targetField: z.string().describe("Field in collection to match against"),
     }).optional().describe("Configuration for update operations"),
-  }).default({}),
+  }).default(() => ({
+    batchSize: 50,
+    skipValidation: false,
+    dryRun: false,
+    continueOnError: true
+  })),
 });
 
 export type YamlImportConfig = z.infer<typeof YamlImportConfigSchema>;
@@ -112,7 +117,7 @@ export class YamlImportConfigLoader {
       
     } catch (error) {
       if (error instanceof z.ZodError) {
-        const errorMessages = error.errors.map(err => `${err.path.join('.')}: ${err.message}`);
+        const errorMessages = error.issues.map(err => `${err.path.join('.')}: ${err.message}`);
         throw new Error(`Invalid import configuration in ${configPath}:\n${errorMessages.join('\n')}`);
       }
       throw new Error(`Failed to load import configuration ${configPath}: ${error}`);

package/src/schemas/authUser.ts

@@ -7,7 +7,7 @@ export const AuthUserSchema = z.object({
   name: z.string().nullish(),
   email: z.string().email("Invalid Email Address").nullish(),
   phone: z.string().nullish(),
-  prefs: z.record(z.string()).optional().default({}),
+  prefs: z.record(z.string(), z.string()).optional().default({}),
   labels: z.array(z.string()).optional().default([]),
 });
 

package/src/shared/jsonSchemaGenerator.ts

@@ -6,7 +6,6 @@ import chalk from "chalk";
 
 export interface JsonSchemaProperty {
   type: string | string[];
-  description?: string;
   format?: string;
   minimum?: number;
   maximum?: number;
@@ -27,7 +26,6 @@ export interface JsonSchema {
   $schema: string;
   $id: string;
   title: string;
-  description?: string;
   type: "object";
   properties: Record<string, JsonSchemaProperty>;
   required: string[];
@@ -72,12 +70,6 @@ export class JsonSchemaGenerator {
       type: "string" // Default type
     };
 
-    // Set description if available
-    if (attribute.description) {
-      property.description = typeof attribute.description === 'string' 
-        ? attribute.description 
-        : JSON.stringify(attribute.description);
-    }
 
     // Handle array attributes
     if (attribute.array) {
@@ -167,7 +159,6 @@ export class JsonSchemaGenerator {
           schema.$ref = `#/definitions/${toPascalCase(attribute.relatedCollection)}`;
         } else {
           schema.type = "string";
-          schema.description = "Document ID reference";
         }
         break;
 
@@ -184,31 +175,26 @@ export class JsonSchemaGenerator {
       $schema: "https://json-schema.org/draft/2020-12/schema",
       $id: `https://example.com/schemas/${toCamelCase(collection.name)}.json`,
       title: pascalName,
-      description: collection.description || `Schema for ${collection.name} collection`,
       type: "object",
       properties: {
         // Standard Appwrite document fields
         $id: {
           type: "string",
-          description: "Document ID",
           pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,35}$"
         },
         $createdAt: {
           type: "string",
-          format: "date-time",
-          description: "Document creation date"
+          format: "date-time"
         },
         $updatedAt: {
           type: "string", 
-          format: "date-time",
-          description: "Document last update date"
+          format: "date-time"
         },
         $permissions: {
           type: "array",
           items: {
             type: "string"
-          },
-          description: "Document permissions"
+          }
         }
       },
       required: ["$id", "$createdAt", "$updatedAt"],
@@ -244,8 +230,7 @@ export class JsonSchemaGenerator {
             $createdAt: { type: "string", format: "date-time" },
             $updatedAt: { type: "string", format: "date-time" }
           },
-          additionalProperties: true,
-          description: `Reference to ${rel.relatedCollection} document`
+          additionalProperties: true
         };
       });
     }

package/src/shared/operationQueue.ts

@@ -1,8 +1,9 @@
 import { Query, type Databases, type Models } from "node-appwrite";
 import type { Attribute } from "appwrite-utils";
-import { createOrUpdateAttribute } from "../collections/attributes.js";
+import { createOrUpdateAttributeWithStatusCheck } from "../collections/attributes.js";
 import { fetchAndCacheCollectionByName } from "../collections/methods.js";
 import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import chalk from "chalk";
 
 export interface QueuedOperation {
   type: "attribute";
@@ -81,24 +82,30 @@ export const processQueue = async (db: Databases, dbId: string) => {
 
       // Process the operation if the collection is found
       if (collectionFound && operation.attribute) {
-        console.log(
-          `\tProcessing attribute: ${operation.attribute.key} for collection ID: ${collectionFound.$id}`
-        );
-        await createOrUpdateAttribute(
+        console.log(chalk.cyan(
+          `\t📋 Queue processing relationship attribute: ${operation.attribute.key} for collection: ${collectionFound.name}`
+        ));
+        const success = await createOrUpdateAttributeWithStatusCheck(
           db,
           dbId,
           collectionFound,
           operation.attribute
         );
-        queuedOperations.splice(i, 1);
-        i--; // Adjust index since we're modifying the array
-        progress = true;
+        
+        if (success) {
+          console.log(chalk.green(`\t✅ Successfully processed queued attribute: ${operation.attribute.key}`));
+          queuedOperations.splice(i, 1);
+          i--; // Adjust index since we're modifying the array
+          progress = true;
+        } else {
+          console.log(chalk.red(`\t❌ Failed to process queued attribute: ${operation.attribute.key}, removing from queue`));
+          queuedOperations.splice(i, 1);
+          i--; // Adjust index since we're modifying the array
+        }
       } else {
-        console.error(
-          `\tCollection not found for operation, removing from queue: ${JSON.stringify(
-            operation
-          )}`
-        );
+        console.log(chalk.yellow(
+          `\t⚠️ Collection not found for queued operation, removing from queue: ${operation.attribute?.key || 'unknown'}`
+        ));
         queuedOperations.splice(i, 1);
         i--; // Adjust index since we're modifying the array
       }

package/src/shared/schemaGenerator.ts

@@ -414,11 +414,6 @@ export default appwriteConfig;
   createSchemaString = (name: string, attributes: Attribute[]): string => {
     const pascalName = toPascalCase(name);
     let imports = `import { z } from "zod";\n`;
-    const hasDescription = attributes.some((attr) => attr.description);
-    if (hasDescription) {
-      imports += `import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";\n`;
-      imports += `extendZodWithOpenApi(z);\n`;
-    }
 
     // Use the relationshipMap to find related collections
     const relationshipDetails = this.relationshipMap.get(name) || [];
@@ -555,14 +550,14 @@ export default appwriteConfig;
         baseSchemaCode = "z.number().int()";
         if (finalAttribute.min !== undefined) {
           if (BigInt(finalAttribute.min) === BigInt(-9223372036854776000)) {
-            delete finalAttribute.min;
+            finalAttribute.min = undefined;
           } else {
             baseSchemaCode += `.min(${finalAttribute.min}, "Minimum value of ${finalAttribute.min} not met")`;
           }
         }
         if (finalAttribute.max !== undefined) {
           if (BigInt(finalAttribute.max) === BigInt(9223372036854776000)) {
-            delete finalAttribute.max;
+            finalAttribute.max = undefined;
           } else {
             baseSchemaCode += `.max(${finalAttribute.max}, "Maximum value of ${finalAttribute.max} exceeded")`;
           }
@@ -659,15 +654,6 @@ export default appwriteConfig;
     if (attribute.array && !attribute.required) {
       baseSchemaCode += ".nullish()";
     }
-    if (attribute.description) {
-      if (typeof attribute.description === "string") {
-        baseSchemaCode += `.openapi({ description: "${attribute.description}" })`;
-      } else {
-        baseSchemaCode += `.openapi(${Object.entries(attribute.description)
-          .map(([key, value]) => `"${key}": ${value}`)
-          .join(", ")})`;
-      }
-    }
 
     return baseSchemaCode;
   };

package/src/types/node-appwrite-tablesdb.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Type declarations for optional node-appwrite-tablesdb module
+ * This allows compilation when the module is not installed
+ */
+
+declare module 'node-appwrite-tablesdb' {
+  export class Client {
+    setEndpoint(endpoint: string): this;
+    setProject(project: string): this;
+    setKey(key: string): this;
+  }
+  
+  export class TablesDB {
+    constructor(client: Client);
+    
+    // Core methods based on TablesDB API
+    listTables(databaseId: string, queries?: any[]): Promise<any>;
+    createTable(databaseId: string, id: string, name: string, permissions?: string[], documentSecurity?: boolean, enabled?: boolean): Promise<any>;
+    updateTable(databaseId: string, id: string, name: string, permissions?: string[], documentSecurity?: boolean, enabled?: boolean): Promise<any>;
+    deleteTable(databaseId: string, tableId: string): Promise<void>;
+    getTable(databaseId: string, tableId: string): Promise<any>;
+    
+    listRows(databaseId: string, tableId: string, queries?: any[]): Promise<any>;
+    createRow(databaseId: string, tableId: string, id: string, data: any, permissions?: string[]): Promise<any>;
+    updateRow(databaseId: string, tableId: string, id: string, data?: any, permissions?: string[]): Promise<any>;
+    deleteRow(databaseId: string, tableId: string, id: string): Promise<void>;
+    getRow(databaseId: string, tableId: string, id: string): Promise<any>;
+    
+    // Bulk operations (if supported)
+    bulkCreateRows?(databaseId: string, tableId: string, rows: any[]): Promise<any>;
+    bulkUpsertRows?(databaseId: string, tableId: string, rows: any[]): Promise<any>;
+    bulkDeleteRows?(databaseId: string, tableId: string, rowIds: string[]): Promise<any>;
+    
+    // Index operations
+    listIndexes(databaseId: string, tableId: string, queries?: any[]): Promise<any>;
+    createIndex(databaseId: string, tableId: string, key: string, type: string, attributes: string[], orders?: string[]): Promise<any>;
+    deleteIndex(databaseId: string, tableId: string, key: string): Promise<void>;
+    
+    // Attribute operations
+    createAttribute(databaseId: string, tableId: string, key: string, type: string, ...args: any[]): Promise<any>;
+    updateAttribute(databaseId: string, tableId: string, key: string, required?: boolean, defaultValue?: any): Promise<any>;
+    deleteAttribute(databaseId: string, tableId: string, key: string): Promise<void>;
+  }
+}

package/src/users/methods.ts

@@ -105,14 +105,14 @@ export class UsersController {
     return allUsers;
   }
 
-  async createUsersAndReturn(items: AuthUserCreate[]) {
+  async createUsersAndReturn(items: AuthUserCreate[]): Promise<any[]> {
     const users = await Promise.all(
       items.map((item) => this.createUserAndReturn(item))
     );
     return users;
   }
 
-  async createUserAndReturn(item: AuthUserCreate) {
+  async createUserAndReturn(item: AuthUserCreate): Promise<any> {
     try {
       const user = await tryAwaitWithRetry(async () => {
         const createdUser = await this.users.create(

package/src/utils/configMigration.ts

@@ -303,7 +303,6 @@ async function convertCollectionToYaml(tsFilePath: string, targetDir: string): P
           required: attr.required ?? false,
           array: attr.array,
           default: attr.xdefault || attr.default,
-          description: attr.description,
           min: attr.min,
           max: attr.max,
           elements: attr.elements,