appwrite-utils-cli 0.10.86 → 1.0.1

package/dist/main.js

@@ -6,29 +6,31 @@ import { InteractiveCLI } from "./interactiveCLI.js";
 import { UtilsController } from "./utilsController.js";
 import { Databases, Storage } from "node-appwrite";
 import { getClient } from "./utils/getClientFromConfig.js";
-import { fetchAllDatabases } from "./migrations/databases.js";
+import { fetchAllDatabases } from "./databases/methods.js";
 import { setupDirsFiles } from "./utils/setupFiles.js";
 import { fetchAllCollections } from "./collections/methods.js";
 import chalk from "chalk";
 import { listSpecifications } from "./functions/methods.js";
+import { MessageFormatter } from "./shared/messageFormatter.js";
+import { ConfirmationDialogs } from "./shared/confirmationDialogs.js";
 const argv = yargs(hideBin(process.argv))
     .option("config", {
     type: "string",
-    description: "Appwrite Config file name",
+    description: "Path to Appwrite configuration file (appwriteConfig.ts)",
 })
     .option("it", {
     alias: ["interactive", "i"],
     type: "boolean",
-    description: "Run in interactive mode",
+    description: "Launch interactive CLI mode with guided prompts",
 })
     .option("dbIds", {
     type: "string",
-    description: "Comma-separated list of database IDs to operate on",
+    description: "Comma-separated list of database IDs to target (e.g., 'db1,db2,db3')",
 })
     .option("collectionIds", {
     alias: ["collIds"],
     type: "string",
-    description: "Comma-separated list of collection IDs to operate on",
+    description: "Comma-separated list of collection IDs to target (e.g., 'users,posts')",
 })
     .option("bucketIds", {
     type: "string",
@@ -36,11 +38,11 @@ const argv = yargs(hideBin(process.argv))
 })
     .option("wipe", {
     choices: ["all", "docs", "users"],
-    description: "Wipe data (all: everything, docs: only documents, users: only user data)",
+    description: "⚠️  DESTRUCTIVE: Wipe data (all: databases+storage+users, docs: documents only, users: user accounts only)",
 })
     .option("wipeCollections", {
     type: "boolean",
-    description: "Wipe collections, uses collectionIds option to get the collections to wipe",
+    description: "⚠️  DESTRUCTIVE: Wipe specific collections (requires --collectionIds)",
 })
     .option("transferUsers", {
     type: "boolean",
@@ -48,27 +50,27 @@ const argv = yargs(hideBin(process.argv))
 })
     .option("generate", {
     type: "boolean",
-    description: "Generate TypeScript schemas from database schemas",
+    description: "Generate TypeScript schemas and types from your Appwrite database schemas",
 })
     .option("import", {
     type: "boolean",
-    description: "Import data into your databases",
+    description: "Import data from importData/ directory into your Appwrite databases",
 })
     .option("backup", {
     type: "boolean",
-    description: "Perform a backup of your databases",
+    description: "Create a complete backup of your databases and collections",
 })
     .option("writeData", {
     type: "boolean",
-    description: "Write converted imported data to file",
+    description: "Output converted import data to files for validation before importing",
 })
     .option("push", {
     type: "boolean",
-    description: "Push your local Appwrite config to your configured Appwrite Project",
+    description: "Deploy your local configuration (collections, attributes, indexes) to Appwrite",
 })
     .option("sync", {
     type: "boolean",
-    description: "Synchronize by pulling your Appwrite config from your configured Appwrite Project",
+    description: "Pull and synchronize your local config with the remote Appwrite project schema",
 })
     .option("endpoint", {
     type: "string",
@@ -84,17 +86,17 @@ const argv = yargs(hideBin(process.argv))
 })
     .option("transfer", {
     type: "boolean",
-    description: "Transfer data between databases or collections",
+    description: "Transfer documents and files between databases, collections, or projects",
 })
     .option("fromDbId", {
     alias: ["fromDb", "sourceDbId", "sourceDb"],
     type: "string",
-    description: "Set the source database ID for transfer",
+    description: "Source database ID for transfer operations",
 })
     .option("toDbId", {
     alias: ["toDb", "targetDbId", "targetDb"],
     type: "string",
-    description: "Set the destination database ID for transfer",
+    description: "Target database ID for transfer operations",
 })
     .option("fromCollectionId", {
     alias: ["fromCollId", "fromColl"],
@@ -128,7 +130,7 @@ const argv = yargs(hideBin(process.argv))
 })
     .option("setup", {
     type: "boolean",
-    description: "Setup directories and files",
+    description: "Initialize project with configuration files and directory structure",
 })
     .option("updateFunctionSpec", {
     type: "boolean",
@@ -151,9 +153,16 @@ const argv = yargs(hideBin(process.argv))
         "s-8vcpu-4gb",
         "s-8vcpu-8gb",
     ],
+})
+    .option("migrateConfig", {
+    alias: ["migrate"],
+    type: "boolean",
+    description: "Migrate appwriteConfig.ts to .appwrite structure with YAML configuration",
 })
     .parse();
 async function main() {
+    const startTime = Date.now();
+    const operationStats = {};
     if (argv.it) {
         const cli = new InteractiveCLI(process.cwd());
         await cli.run();
@@ -172,8 +181,13 @@ async function main() {
             await setupDirsFiles(false, process.cwd());
             return;
         }
+        if (argv.migrateConfig) {
+            const { migrateConfig } = await import("./utils/configMigration.js");
+            await migrateConfig(process.cwd());
+            return;
+        }
         if (!controller.config) {
-            console.log(chalk.red("No Appwrite connection found"));
+            MessageFormatter.error("No Appwrite connection found", undefined, { prefix: "CLI" });
             return;
         }
         const parsedArgv = argv;
@@ -196,10 +210,10 @@ async function main() {
             if (!parsedArgv.functionId || !parsedArgv.specification) {
                 throw new Error("Function ID and specification are required for updating function specs");
             }
-            console.log(chalk.yellow(`Updating function specification for ${parsedArgv.functionId} to ${parsedArgv.specification}, checking if specification exists...`));
+            MessageFormatter.info(`Updating function specification for ${parsedArgv.functionId} to ${parsedArgv.specification}`, { prefix: "Functions" });
             const specifications = await listSpecifications(controller.appwriteServer);
             if (!specifications.specifications.some((s) => s.slug === parsedArgv.specification)) {
-                console.log(chalk.red(`Specification ${parsedArgv.specification} not found`));
+                MessageFormatter.error(`Specification ${parsedArgv.specification} not found`, undefined, { prefix: "Functions" });
                 return;
             }
             await controller.updateFunctionSpecifications(parsedArgv.functionId, parsedArgv.specification);
@@ -207,7 +221,10 @@ async function main() {
         // Add default databases if not specified
         if (!options.databases || options.databases.length === 0) {
             const allDatabases = await fetchAllDatabases(controller.database);
-            options.databases = allDatabases.filter((db) => db.name.toLowerCase() !== "migrations");
+            options.databases = allDatabases.filter((db) => {
+                const useMigrations = controller.config?.useMigrations ?? true;
+                return useMigrations || db.name.toLowerCase() !== "migrations";
+            });
         }
         // Add default collections if not specified
         if (!options.collections || options.collections.length === 0) {
@@ -219,47 +236,80 @@ async function main() {
             }
         }
         if (options.doBackup && options.databases) {
+            MessageFormatter.info(`Creating backups for ${options.databases.length} database(s)`, { prefix: "Backup" });
             for (const db of options.databases) {
                 await controller.backupDatabase(db);
             }
+            operationStats.backups = options.databases.length;
+            MessageFormatter.success(`Backup completed for ${options.databases.length} database(s)`, { prefix: "Backup" });
         }
         if (options.wipeDatabase ||
             options.wipeDocumentStorage ||
             options.wipeUsers ||
             options.wipeCollections) {
+            // Confirm destructive operations
+            const databaseNames = options.databases?.map(db => db.name) || [];
+            const confirmed = await ConfirmationDialogs.confirmDatabaseWipe(databaseNames, {
+                includeStorage: options.wipeDocumentStorage,
+                includeUsers: options.wipeUsers
+            });
+            if (!confirmed) {
+                MessageFormatter.info("Operation cancelled by user", { prefix: "CLI" });
+                return;
+            }
+            let wipeStats = { databases: 0, collections: 0, users: 0, buckets: 0 };
             if (parsedArgv.wipe === "all") {
                 if (options.databases) {
                     for (const db of options.databases) {
                         await controller.wipeDatabase(db, true); // true to wipe associated buckets
                     }
+                    wipeStats.databases = options.databases.length;
                 }
                 await controller.wipeUsers();
+                wipeStats.users = 1;
             }
             else if (parsedArgv.wipe === "docs") {
                 if (options.databases) {
                     for (const db of options.databases) {
                         await controller.wipeBucketFromDatabase(db);
                     }
+                    wipeStats.databases = options.databases.length;
                 }
                 if (parsedArgv.bucketIds) {
-                    for (const bucketId of parsedArgv.bucketIds.split(",")) {
+                    const bucketIds = parsedArgv.bucketIds.split(",");
+                    for (const bucketId of bucketIds) {
                         await controller.wipeDocumentStorage(bucketId);
                     }
+                    wipeStats.buckets = bucketIds.length;
                 }
             }
             else if (parsedArgv.wipe === "users") {
                 await controller.wipeUsers();
+                wipeStats.users = 1;
             }
             // Handle specific collection wipes
             if (options.wipeCollections && options.databases) {
                 for (const db of options.databases) {
                     const dbCollections = await fetchAllCollections(db.$id, controller.database);
                     const collectionsToWipe = dbCollections.filter((c) => options.collections.includes(c.$id));
-                    for (const collection of collectionsToWipe) {
-                        await controller.wipeCollection(db, collection);
+                    // Confirm collection wipe
+                    const collectionNames = collectionsToWipe.map(c => c.name);
+                    const collectionConfirmed = await ConfirmationDialogs.confirmCollectionWipe(db.name, collectionNames);
+                    if (collectionConfirmed) {
+                        for (const collection of collectionsToWipe) {
+                            await controller.wipeCollection(db, collection);
+                        }
+                        wipeStats.collections += collectionsToWipe.length;
                     }
                 }
             }
+            // Show wipe operation summary
+            if (wipeStats.databases > 0 || wipeStats.collections > 0 || wipeStats.users > 0 || wipeStats.buckets > 0) {
+                operationStats.wipedDatabases = wipeStats.databases;
+                operationStats.wipedCollections = wipeStats.collections;
+                operationStats.wipedUsers = wipeStats.users;
+                operationStats.wipedBuckets = wipeStats.buckets;
+            }
         }
         if (parsedArgv.push || parsedArgv.sync) {
             const databases = options.databases || (await fetchAllDatabases(controller.database));
@@ -272,16 +322,21 @@ async function main() {
             }
             if (parsedArgv.push) {
                 await controller.syncDb(databases, collections);
+                operationStats.pushedDatabases = databases.length;
+                operationStats.pushedCollections = collections.length;
             }
             else if (parsedArgv.sync) {
                 await controller.synchronizeConfigurations(databases);
+                operationStats.syncedDatabases = databases.length;
             }
         }
         if (options.generateSchemas) {
             await controller.generateSchemas();
+            operationStats.generatedSchemas = 1;
         }
         if (options.importData) {
             await controller.importData(options);
+            operationStats.importCompleted = 1;
         }
         if (parsedArgv.transfer) {
             const isRemote = !!parsedArgv.remoteEndpoint;
@@ -290,10 +345,10 @@ async function main() {
             let targetStorage;
             // Only fetch databases if database IDs are provided
             if (parsedArgv.fromDbId && parsedArgv.toDbId) {
-                console.log(chalk.blue(`Starting database transfer from ${parsedArgv.fromDbId} to ${parsedArgv.toDbId}`));
+                MessageFormatter.info(`Starting database transfer from ${parsedArgv.fromDbId} to ${parsedArgv.toDbId}`, { prefix: "Transfer" });
                 fromDb = (await controller.getDatabasesByIds([parsedArgv.fromDbId]))?.[0];
                 if (!fromDb) {
-                    console.log(chalk.red("Source database not found"));
+                    MessageFormatter.error("Source database not found", undefined, { prefix: "Transfer" });
                     return;
                 }
                 if (isRemote) {
@@ -308,19 +363,19 @@ async function main() {
                     const remoteDbs = await fetchAllDatabases(targetDatabases);
                     toDb = remoteDbs.find((db) => db.$id === parsedArgv.toDbId);
                     if (!toDb) {
-                        console.log(chalk.red("Target database not found"));
+                        MessageFormatter.error("Target database not found", undefined, { prefix: "Transfer" });
                         return;
                     }
                 }
                 else {
                     toDb = (await controller.getDatabasesByIds([parsedArgv.toDbId]))?.[0];
                     if (!toDb) {
-                        console.log(chalk.red("Target database not found"));
+                        MessageFormatter.error("Target database not found", undefined, { prefix: "Transfer" });
                         return;
                     }
                 }
                 if (!fromDb || !toDb) {
-                    console.log(chalk.red("Source or target database not found"));
+                    MessageFormatter.error("Source or target database not found", undefined, { prefix: "Transfer" });
                     return;
                 }
             }
@@ -357,10 +412,16 @@ async function main() {
                 transferUsers: options.transferUsers,
             };
             await controller.transferData(transferOptions);
+            operationStats.transfers = 1;
+        }
+        // Show final operation summary if any operations were performed
+        if (Object.keys(operationStats).length > 0) {
+            const duration = Date.now() - startTime;
+            MessageFormatter.operationSummary("CLI Operations", operationStats, duration);
         }
     }
 }
 main().catch((error) => {
-    console.error("An error occurred:", error);
+    MessageFormatter.error("CLI execution failed", error, { prefix: "CLI" });
     process.exit(1);
 });

package/dist/migrations/afterImportActions.js

@@ -3,7 +3,7 @@ import { InputFile } from "node-appwrite/file";
 import path from "path";
 import fs from "fs";
 import os from "os";
-import { logger } from "./logging.js";
+import { logger } from "../shared/logging.js";
 import { tryAwaitWithRetry, } from "appwrite-utils";
 export const getDatabaseFromConfig = (config) => {
     if (!config.appwriteClient) {
@@ -264,7 +264,7 @@ export const afterImportActions = {
                 // Use arrayBuffer if buffer is not available
                 const arrayBuffer = await response.arrayBuffer();
                 const buffer = Buffer.from(arrayBuffer);
-                fs.writeFileSync(tempFilePath, buffer);
+                fs.writeFileSync(tempFilePath, new Uint8Array(buffer));
                 // Create InputFile from the downloaded file
                 const inputFile = InputFile.fromPath(tempFilePath, fileName);
                 // Use the full file name (with extension) for creating the file

package/dist/migrations/appwriteToX.d.ts

@@ -25,6 +25,16 @@ export declare class AppwriteToX {
         xdefault?: number | null | undefined;
         min?: number | undefined;
         max?: number | undefined;
+    } | {
+        type: "double";
+        key: string;
+        description?: string | Record<string, string> | null | undefined;
+        required?: boolean | undefined;
+        array?: boolean | undefined;
+        error?: string | undefined;
+        xdefault?: number | null | undefined;
+        min?: number | undefined;
+        max?: number | undefined;
     } | {
         type: "float";
         key: string;

package/dist/migrations/appwriteToX.js

@@ -1,7 +1,8 @@
-import { SchemaGenerator } from "./schemaStrings.js";
+import { SchemaGenerator } from "../shared/schemaGenerator.js";
+import { findYamlConfig } from "../config/yamlConfig.js";
 import { Client, Compression, Databases, Query, Storage, } from "node-appwrite";
 import { fetchAllCollections } from "../collections/methods.js";
-import { fetchAllDatabases } from "./databases.js";
+import { fetchAllDatabases } from "../databases/methods.js";
 import { CollectionSchema, attributeSchema, AppwriteConfigSchema, permissionsSchema, attributesSchema, indexesSchema, parseAttribute, } from "appwrite-utils";
 import { getDatabaseFromConfig } from "./afterImportActions.js";
 import { listBuckets } from "../storage/methods.js";
@@ -57,7 +58,7 @@ export class AppwriteToX {
         const allBuckets = await listBuckets(this.storage);
         // Loop through each database
         for (const database of databases) {
-            if (database.name.toLowerCase() === "migrations") {
+            if (!this.config.useMigrations && database.name.toLowerCase() === "migrations") {
                 continue;
             }
             // Match bucket to database
@@ -189,7 +190,17 @@ export class AppwriteToX {
     async toSchemas(databases) {
         await this.appwriteSync(this.config, databases);
         const generator = new SchemaGenerator(this.updatedConfig, this.appwriteFolderPath);
-        generator.updateTsSchemas();
+        // Check if this is a YAML-based project
+        const yamlConfigPath = findYamlConfig(this.appwriteFolderPath);
+        const isYamlProject = !!yamlConfigPath;
+        if (isYamlProject) {
+            console.log("📄 Detected YAML configuration - generating YAML collection definitions");
+            generator.updateYamlCollections();
+        }
+        else {
+            console.log("📝 Generating TypeScript collection definitions");
+            generator.updateTsSchemas();
+        }
         generator.generateSchemas();
     }
 }

package/dist/migrations/backup.d.ts

@@ -9,31 +9,31 @@ export declare const BackupSchema: z.ZodObject<{
         collectionId: z.ZodString;
         data: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        collectionId: string;
         data: string;
-    }, {
         collectionId: string;
+    }, {
         data: string;
+        collectionId: string;
     }>, "many">>;
 }, "strip", z.ZodTypeAny, {
-    collections: string[];
     documents: {
-        collectionId: string;
         data: string;
+        collectionId: string;
     }[];
     $id: string;
+    collections: string[];
     $createdAt: string;
     $updatedAt: string;
     database: string;
 }, {
-    collections: string[];
     $id: string;
+    collections: string[];
     $createdAt: string;
     $updatedAt: string;
     database: string;
     documents?: {
-        collectionId: string;
         data: string;
+        collectionId: string;
     }[] | undefined;
 }>;
 export type Backup = z.infer<typeof BackupSchema>;
@@ -47,25 +47,25 @@ export declare const BackupCreateSchema: z.ZodObject<Omit<{
         collectionId: z.ZodString;
         data: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        collectionId: string;
         data: string;
-    }, {
         collectionId: string;
+    }, {
         data: string;
+        collectionId: string;
     }>, "many">>;
 }, "$id" | "$createdAt" | "$updatedAt">, "strip", z.ZodTypeAny, {
-    collections: string[];
     documents: {
-        collectionId: string;
         data: string;
+        collectionId: string;
     }[];
+    collections: string[];
     database: string;
 }, {
     collections: string[];
     database: string;
     documents?: {
-        collectionId: string;
         data: string;
+        collectionId: string;
     }[] | undefined;
 }>;
 export type BackupCreate = z.infer<typeof BackupCreateSchema>;
@@ -76,16 +76,16 @@ export declare const BatchSchema: z.ZodObject<{
     data: z.ZodString;
     processed: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
+    data: string;
     $id: string;
     $createdAt: string;
     $updatedAt: string;
-    data: string;
     processed: boolean;
 }, {
+    data: string;
     $id: string;
     $createdAt: string;
     $updatedAt: string;
-    data: string;
     processed?: boolean | undefined;
 }>;
 export type Batch = z.infer<typeof BatchSchema>;
@@ -116,11 +116,11 @@ export declare const OperationSchema: z.ZodObject<{
     error: z.ZodString;
     status: z.ZodDefault<z.ZodEnum<["pending", "ready", "in_progress", "completed", "error", "cancelled"]>>;
 }, "strip", z.ZodTypeAny, {
+    status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
+    error: string;
     $id: string;
     $createdAt: string;
     $updatedAt: string;
-    status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
-    error: string;
     collectionId: string;
     operationType: string;
     progress: number;
@@ -128,10 +128,10 @@ export declare const OperationSchema: z.ZodObject<{
     data?: any;
     batches?: string[] | undefined;
 }, {
+    error: string;
     $id: string;
     $createdAt: string;
     $updatedAt: string;
-    error: string;
     collectionId: string;
     operationType: string;
     progress: number;

package/dist/migrations/dataLoader.d.ts

@@ -87,7 +87,6 @@ export declare const CollectionImportDataSchema: z.ZodObject<{
             max?: number | undefined;
         }>, z.ZodObject<{
             key: z.ZodString;
-            type: z.ZodDefault<z.ZodLiteral<"float">>;
             error: z.ZodOptional<z.ZodDefault<z.ZodString>>;
             required: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             array: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
@@ -95,6 +94,39 @@ export declare const CollectionImportDataSchema: z.ZodObject<{
             max: z.ZodOptional<z.ZodNumber>;
             xdefault: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
             description: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+        } & {
+            type: z.ZodDefault<z.ZodLiteral<"double">>;
+        }, "strip", z.ZodTypeAny, {
+            type: "double";
+            key: string;
+            description?: string | Record<string, string> | null | undefined;
+            required?: boolean | undefined;
+            array?: boolean | undefined;
+            error?: string | undefined;
+            xdefault?: number | null | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+        }, {
+            key: string;
+            type?: "double" | undefined;
+            description?: string | Record<string, string> | null | undefined;
+            required?: boolean | undefined;
+            array?: boolean | undefined;
+            error?: string | undefined;
+            xdefault?: number | null | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+        }>, z.ZodObject<{
+            key: z.ZodString;
+            error: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+            required: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            array: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            xdefault: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+        } & {
+            type: z.ZodDefault<z.ZodLiteral<"float">>;
         }, "strip", z.ZodTypeAny, {
             type: "float";
             key: string;
@@ -561,6 +593,16 @@ export declare const CollectionImportDataSchema: z.ZodObject<{
             xdefault?: number | null | undefined;
             min?: number | undefined;
             max?: number | undefined;
+        } | {
+            type: "double";
+            key: string;
+            description?: string | Record<string, string> | null | undefined;
+            required?: boolean | undefined;
+            array?: boolean | undefined;
+            error?: string | undefined;
+            xdefault?: number | null | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
         } | {
             type: "float";
             key: string;
@@ -716,6 +758,16 @@ export declare const CollectionImportDataSchema: z.ZodObject<{
             xdefault?: number | null | undefined;
             min?: number | undefined;
             max?: number | undefined;
+        } | {
+            key: string;
+            type?: "double" | undefined;
+            description?: string | Record<string, string> | null | undefined;
+            required?: boolean | undefined;
+            array?: boolean | undefined;
+            error?: string | undefined;
+            xdefault?: number | null | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
         } | {
             key: string;
             type?: "float" | undefined;
@@ -1181,6 +1233,16 @@ export declare const CollectionImportDataSchema: z.ZodObject<{
             xdefault?: number | null | undefined;
             min?: number | undefined;
             max?: number | undefined;
+        } | {
+            type: "double";
+            key: string;
+            description?: string | Record<string, string> | null | undefined;
+            required?: boolean | undefined;
+            array?: boolean | undefined;
+            error?: string | undefined;
+            xdefault?: number | null | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
         } | {
             type: "float";
             key: string;
@@ -1380,6 +1442,16 @@ export declare const CollectionImportDataSchema: z.ZodObject<{
             xdefault?: number | null | undefined;
             min?: number | undefined;
             max?: number | undefined;
+        } | {
+            key: string;
+            type?: "double" | undefined;
+            description?: string | Record<string, string> | null | undefined;
+            required?: boolean | undefined;
+            array?: boolean | undefined;
+            error?: string | undefined;
+            xdefault?: number | null | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
         } | {
             key: string;
             type?: "float" | undefined;
@@ -1585,6 +1657,16 @@ export declare class DataLoader {
                 xdefault?: number | null | undefined;
                 min?: number | undefined;
                 max?: number | undefined;
+            } | {
+                type: "double";
+                key: string;
+                description?: string | Record<string, string> | null | undefined;
+                required?: boolean | undefined;
+                array?: boolean | undefined;
+                error?: string | undefined;
+                xdefault?: number | null | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
             } | {
                 type: "float";
                 key: string;

package/dist/migrations/dataLoader.js

@@ -1,14 +1,14 @@
 import { AttributeMappingsSchema, CollectionCreateSchema, importDefSchema, } from "appwrite-utils";
 import path from "path";
 import fs from "fs";
-import { convertObjectByAttributeMappings } from "./converters.js";
+import { convertObjectByAttributeMappings } from "../utils/dataConverters.js";
 import { z } from "zod";
 import { checkForCollection } from "../collections/methods.js";
 import { ID, Users } from "node-appwrite";
-import { logger } from "./logging.js";
-import { findOrCreateOperation, updateOperation } from "./migrationHelper.js";
+import { logger } from "../shared/logging.js";
+import { findOrCreateOperation, updateOperation } from "../shared/migrationHelpers.js";
 import { AuthUserCreateSchema } from "../schemas/authUser.js";
-import { UsersController } from "./users.js";
+import { UsersController } from "../users/methods.js";
 import { finalizeByAttributeMap } from "../utils/helperFunctions.js";
 import { isEmpty } from "es-toolkit/compat";
 // Define a schema for the structure of collection import data using Zod for validation