appwrite-utils-cli 0.10.86 → 1.0.1

package/dist/utils/validationRules.d.ts

@@ -0,0 +1,43 @@
+export interface ValidationRules {
+    [key: string]: (value: any, ...args: any[]) => boolean;
+}
+export declare const validationRules: {
+    isNumber: (value: any) => boolean;
+    isString: (value: any) => boolean;
+    isBoolean: (value: any) => boolean;
+    isArray: (value: any) => boolean;
+    isObject: (value: any) => boolean;
+    isNull: (value: any) => boolean;
+    isValidEmail: (value: string) => boolean;
+    isValidPhone: (value: string) => boolean;
+    isValidPassword: (value: string) => boolean;
+    isValidUrl: (value: string) => boolean;
+    isValidHex: (value: string) => boolean;
+    isValidHexColor: (value: string) => boolean;
+    isValidHexAlpha: (value: string) => boolean;
+    isValidDate: (value: string) => boolean;
+    isValidTime: (value: string) => boolean;
+    isNullish: (value: any) => boolean;
+    isUndefined: (value: any) => boolean;
+    isDefined: (value: any) => boolean;
+    isDate: (value: any) => boolean;
+    isEmpty: (value: any) => boolean;
+    isInteger: (value: any) => boolean;
+    isFloat: (value: any) => boolean;
+    isArrayLike: (value: any) => boolean;
+    isArrayLikeObject: (value: any) => boolean;
+    isFunction: (value: any) => boolean;
+    isLength: (value: any) => boolean;
+    isMap: (value: any) => boolean;
+    isSet: (value: any) => boolean;
+    isRegExp: (value: any) => boolean;
+    isSymbol: (value: any) => boolean;
+    isObjectLike: (value: any) => boolean;
+    isPlainObject: (value: any) => boolean;
+    isSafeInteger: (value: any) => boolean;
+    isTypedArray: (value: any) => boolean;
+    isEqual: (value: any, other: any) => boolean;
+    isMatch: (object: any, source: any) => boolean;
+    has: (object: any, path: string) => boolean;
+    get: (object: any, path: string, defaultValue: any) => any;
+};

package/dist/utils/validationRules.js

@@ -0,0 +1,42 @@
+import { isNumber, isString, isBoolean, isArray, isPlainObject, isNull, isUndefined, isDate, isEmpty, isInteger, isArrayLike, isArrayLikeObject, isFunction, isLength, isMap, isSet, isRegExp, isSymbol, isObjectLike, isSafeInteger, isTypedArray, isEqual, isMatch, has, get, } from "es-toolkit/compat";
+export const validationRules = {
+    isNumber: (value) => isNumber(value),
+    isString: (value) => isString(value),
+    isBoolean: (value) => isBoolean(value),
+    isArray: (value) => isArray(value),
+    isObject: (value) => isPlainObject(value) && !isArray(value) && !isFunction(value),
+    isNull: (value) => isNull(value),
+    isValidEmail: (value) => value.match(/^[\w\-\.]+@([\w-]+\.)+[\w-]{2,}$/) !== null,
+    isValidPhone: (value) => value.match(/^[+]?[(]?[0-9]{3}[)]?[-\s.]?[0-9]{3}[-\s.]?[0-9]{4,6}$/im) !==
+        null,
+    isValidPassword: (value) => value.match(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!%*#?&]{8,}$/) !== null,
+    isValidUrl: (value) => value.match(/^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/) !== null,
+    isValidHex: (value) => value.match(/^#([a-f0-9]{6}|[a-f0-9]{3})$/i) !== null,
+    isValidHexColor: (value) => value.match(/^#([a-f0-9]{6}|[a-f0-9]{3})$/i) !== null,
+    isValidHexAlpha: (value) => value.match(/^#([a-f0-9]{8}|[a-f0-9]{4})$/i) !== null,
+    isValidDate: (value) => value.match(/^\d{4}-\d{2}-\d{2}$/) !== null,
+    isValidTime: (value) => value.match(/^\d{2}:\d{2}(:\d{2})?$/) !== null,
+    isNullish: (value) => isNull(value) || isUndefined(value),
+    isUndefined: (value) => isUndefined(value),
+    isDefined: (value) => !isUndefined(value) && !isNull(value) && !isEmpty(value),
+    isDate: (value) => isDate(value),
+    isEmpty: (value) => isEmpty(value),
+    isInteger: (value) => isInteger(value),
+    isFloat: (value) => isNumber(value) && !isInteger(value), // Note: Works for double precision numbers
+    isArrayLike: (value) => isArrayLike(value),
+    isArrayLikeObject: (value) => isArrayLikeObject(value),
+    isFunction: (value) => isFunction(value),
+    isLength: (value) => isLength(value),
+    isMap: (value) => isMap(value),
+    isSet: (value) => isSet(value),
+    isRegExp: (value) => isRegExp(value),
+    isSymbol: (value) => isSymbol(value),
+    isObjectLike: (value) => isObjectLike(value),
+    isPlainObject: (value) => isPlainObject(value),
+    isSafeInteger: (value) => isSafeInteger(value),
+    isTypedArray: (value) => isTypedArray(value),
+    isEqual: (value, other) => isEqual(value, other),
+    isMatch: (object, source) => isMatch(object, source),
+    has: (object, path) => has(object, path),
+    get: (object, path, defaultValue) => get(object, path, defaultValue),
+};

package/dist/utils/yamlConverter.d.ts

@@ -0,0 +1,48 @@
+import type { Collection, CollectionCreate } from "appwrite-utils";
+export interface YamlCollectionData {
+    name: string;
+    id?: string;
+    documentSecurity?: boolean;
+    enabled?: boolean;
+    permissions?: Array<{
+        permission: string;
+        target: string;
+    }>;
+    attributes?: Array<{
+        key: string;
+        type: string;
+        size?: number;
+        required?: boolean;
+        array?: boolean;
+        default?: any;
+        description?: string;
+        min?: number;
+        max?: number;
+        elements?: string[];
+        relatedCollection?: string;
+        relationType?: string;
+        twoWay?: boolean;
+        twoWayKey?: string;
+        onDelete?: string;
+        side?: string;
+    }>;
+    indexes?: Array<{
+        key: string;
+        type: string;
+        attributes: string[];
+        orders?: string[];
+    }>;
+    importDefs?: any[];
+}
+/**
+ * Converts a Collection object to YAML format with proper schema reference
+ */
+export declare function collectionToYaml(collection: Collection | CollectionCreate, schemaPath?: string): string;
+/**
+ * Sanitizes a collection name for use as a filename
+ */
+export declare function sanitizeFilename(name: string): string;
+/**
+ * Generates the filename for a collection YAML file
+ */
+export declare function getCollectionYamlFilename(collection: Collection | CollectionCreate): string;

package/dist/utils/yamlConverter.js

@@ -0,0 +1,98 @@
+import yaml from "js-yaml";
+/**
+ * Converts a Collection object to YAML format with proper schema reference
+ */
+export function collectionToYaml(collection, schemaPath = "../.yaml_schemas/collection.schema.json") {
+    // Convert Collection to YamlCollectionData format
+    const yamlData = {
+        name: collection.name,
+        id: collection.$id,
+        documentSecurity: collection.documentSecurity,
+        enabled: collection.enabled,
+    };
+    // Convert permissions
+    if (collection.$permissions && collection.$permissions.length > 0) {
+        yamlData.permissions = collection.$permissions.map(p => ({
+            permission: p.permission,
+            target: p.target
+        }));
+    }
+    // Convert attributes
+    if (collection.attributes && collection.attributes.length > 0) {
+        yamlData.attributes = collection.attributes.map(attr => {
+            const yamlAttr = {
+                key: attr.key,
+                type: attr.type,
+            };
+            // Add optional properties only if they exist (safely access with 'in' operator)
+            if ('size' in attr && attr.size !== undefined)
+                yamlAttr.size = attr.size;
+            if (attr.required !== undefined)
+                yamlAttr.required = attr.required;
+            if (attr.array !== undefined)
+                yamlAttr.array = attr.array;
+            if ('xdefault' in attr && attr.xdefault !== undefined)
+                yamlAttr.default = attr.xdefault;
+            if (attr.description !== undefined)
+                yamlAttr.description = attr.description;
+            if ('min' in attr && attr.min !== undefined)
+                yamlAttr.min = attr.min;
+            if ('max' in attr && attr.max !== undefined)
+                yamlAttr.max = attr.max;
+            if ('elements' in attr && attr.elements !== undefined)
+                yamlAttr.elements = attr.elements;
+            if ('relatedCollection' in attr && attr.relatedCollection !== undefined)
+                yamlAttr.relatedCollection = attr.relatedCollection;
+            if ('relationType' in attr && attr.relationType !== undefined)
+                yamlAttr.relationType = attr.relationType;
+            if ('twoWay' in attr && attr.twoWay !== undefined)
+                yamlAttr.twoWay = attr.twoWay;
+            if ('twoWayKey' in attr && attr.twoWayKey !== undefined)
+                yamlAttr.twoWayKey = attr.twoWayKey;
+            if ('onDelete' in attr && attr.onDelete !== undefined)
+                yamlAttr.onDelete = attr.onDelete;
+            if ('side' in attr && attr.side !== undefined)
+                yamlAttr.side = attr.side;
+            return yamlAttr;
+        });
+    }
+    // Convert indexes
+    if (collection.indexes && collection.indexes.length > 0) {
+        yamlData.indexes = collection.indexes.map(idx => ({
+            key: idx.key,
+            type: idx.type,
+            attributes: idx.attributes,
+            ...(idx.orders && idx.orders.length > 0 ? { orders: idx.orders } : {})
+        }));
+    }
+    // Add import definitions if they exist
+    if (collection.importDefs && collection.importDefs.length > 0) {
+        yamlData.importDefs = collection.importDefs;
+    }
+    else {
+        yamlData.importDefs = [];
+    }
+    // Generate YAML with schema reference
+    const yamlContent = yaml.dump(yamlData, {
+        indent: 2,
+        lineWidth: 120,
+        sortKeys: false,
+        quotingType: '"',
+        forceQuotes: false,
+    });
+    return `# yaml-language-server: $schema=${schemaPath}
+# Collection Definition: ${collection.name}
+${yamlContent}`;
+}
+/**
+ * Sanitizes a collection name for use as a filename
+ */
+export function sanitizeFilename(name) {
+    return name.replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+/**
+ * Generates the filename for a collection YAML file
+ */
+export function getCollectionYamlFilename(collection) {
+    return `${sanitizeFilename(collection.name)}.yaml`;
+}

package/dist/utilsController.js

@@ -1,11 +1,11 @@
 import { Client, Databases, Query, Storage, Users, } from "node-appwrite";
 import {} from "appwrite-utils";
-import { loadConfig, findAppwriteConfig, findFunctionsDir, } from "./utils/loadConfigs.js";
-import { UsersController } from "./migrations/users.js";
+import { loadConfig, loadConfigWithPath, findAppwriteConfig, findFunctionsDir, } from "./utils/loadConfigs.js";
+import { UsersController } from "./users/methods.js";
 import { AppwriteToX } from "./migrations/appwriteToX.js";
 import { ImportController } from "./migrations/importController.js";
 import { ImportDataActions } from "./migrations/importDataActions.js";
-import { setupMigrationDatabase, ensureDatabasesExist, wipeOtherDatabases, ensureCollectionsExist, } from "./migrations/setupDatabase.js";
+import { setupMigrationDatabase, ensureDatabasesExist, wipeOtherDatabases, ensureCollectionsExist, } from "./databases/setup.js";
 import { createOrUpdateCollections, wipeDatabase, generateSchemas, fetchAllCollections, wipeCollection, } from "./collections/methods.js";
 import { backupDatabase, ensureDatabaseConfigBucketsExist, initOrGetBackupStorage, wipeDocumentStorage, } from "./storage/methods.js";
 import path from "path";
@@ -13,11 +13,13 @@ import { converterFunctions, validationRules, } from "appwrite-utils";
 import { afterImportActions } from "./migrations/afterImportActions.js";
 import { transferDatabaseLocalToLocal, transferDatabaseLocalToRemote, transferStorageLocalToLocal, transferStorageLocalToRemote, transferUsersLocalToRemote, } from "./migrations/transfer.js";
 import { getClient } from "./utils/getClientFromConfig.js";
-import { fetchAllDatabases } from "./migrations/databases.js";
+import { fetchAllDatabases } from "./databases/methods.js";
 import { listFunctions, updateFunctionSpecifications, } from "./functions/methods.js";
 import chalk from "chalk";
 import { deployLocalFunction } from "./functions/deployments.js";
 import fs from "node:fs";
+import { configureLogging, updateLogger } from "./shared/logging.js";
+import { MessageFormatter, Messages } from "./shared/messageFormatter.js";
 export class UtilsController {
     appwriteFolderPath;
     appwriteConfigPath;
@@ -33,15 +35,15 @@ export class UtilsController {
         if (directConfig) {
             let hasErrors = false;
             if (!directConfig.appwriteEndpoint) {
-                console.log(chalk.red("Appwrite endpoint is required"));
+                MessageFormatter.error("Appwrite endpoint is required", undefined, { prefix: "Config" });
                 hasErrors = true;
             }
             if (!directConfig.appwriteProject) {
-                console.log(chalk.red("Appwrite project is required"));
+                MessageFormatter.error("Appwrite project is required", undefined, { prefix: "Config" });
                 hasErrors = true;
             }
             if (!directConfig.appwriteKey) {
-                console.log(chalk.red("Appwrite key is required"));
+                MessageFormatter.error("Appwrite key is required", undefined, { prefix: "Config" });
                 hasErrors = true;
             }
             if (!hasErrors) {
@@ -58,9 +60,15 @@ export class UtilsController {
                     enableMockData: false,
                     documentBucketId: "",
                     usersCollectionName: "",
+                    useMigrations: true,
                     databases: [],
                     buckets: [],
                     functions: [],
+                    logging: {
+                        enabled: false,
+                        level: "info",
+                        console: false,
+                    },
                 };
             }
         }
@@ -68,28 +76,37 @@ export class UtilsController {
             // Try to find config file
             const appwriteConfigFound = findAppwriteConfig(basePath);
             if (!appwriteConfigFound) {
-                console.log(chalk.yellow("No appwriteConfig.ts found and no direct configuration provided"));
+                MessageFormatter.warning("No appwriteConfig.ts found and no direct configuration provided", { prefix: "Config" });
                 return;
             }
             this.appwriteConfigPath = appwriteConfigFound;
-            this.appwriteFolderPath = path.dirname(appwriteConfigFound);
+            this.appwriteFolderPath = appwriteConfigFound; // For YAML configs, findAppwriteConfig already returns the correct directory
         }
     }
     async init() {
         if (!this.config) {
             if (this.appwriteFolderPath && this.appwriteConfigPath) {
-                console.log("Loading config from file...");
-                this.config = await loadConfig(this.appwriteFolderPath);
-                if (!this.config) {
-                    console.log(chalk.red("Failed to load config from file"));
+                MessageFormatter.progress("Loading config from file...", { prefix: "Config" });
+                try {
+                    const { config, actualConfigPath } = await loadConfigWithPath(this.appwriteFolderPath);
+                    this.config = config;
+                    MessageFormatter.info(`Loaded config from: ${actualConfigPath}`, { prefix: "Config" });
+                }
+                catch (error) {
+                    MessageFormatter.error("Failed to load config from file", undefined, { prefix: "Config" });
                     return;
                 }
             }
             else {
-                console.log(chalk.red("No configuration available"));
+                MessageFormatter.error("No configuration available", undefined, { prefix: "Config" });
                 return;
             }
         }
+        // Configure logging based on config
+        if (this.config.logging) {
+            configureLogging(this.config.logging);
+            updateLogger();
+        }
         this.appwriteServer = new Client();
         this.appwriteServer
             .setEndpoint(this.config.appwriteEndpoint)
@@ -101,7 +118,7 @@ export class UtilsController {
     }
     async reloadConfig() {
         if (!this.appwriteFolderPath) {
-            console.log(chalk.red("Failed to get appwriteFolderPath"));
+            MessageFormatter.error("Failed to get appwriteFolderPath", undefined, { prefix: "Controller" });
             return;
         }
         this.config = await loadConfig(this.appwriteFolderPath);
@@ -109,6 +126,11 @@ export class UtilsController {
             console.log(chalk.red("Failed to load config"));
             return;
         }
+        // Configure logging based on updated config
+        if (this.config.logging) {
+            configureLogging(this.config.logging);
+            updateLogger();
+        }
         this.appwriteServer = new Client();
         this.appwriteServer
             .setEndpoint(this.config.appwriteEndpoint)
@@ -121,7 +143,7 @@ export class UtilsController {
     async setupMigrationDatabase() {
         await this.init();
         if (!this.config) {
-            console.log(chalk.red("Config not initialized"));
+            MessageFormatter.error("Config not initialized", undefined, { prefix: "Controller" });
             return;
         }
         await setupMigrationDatabase(this.config);
@@ -129,11 +151,11 @@ export class UtilsController {
     async ensureDatabaseConfigBucketsExist(databases = []) {
         await this.init();
         if (!this.storage) {
-            console.log(chalk.red("Storage not initialized"));
+            MessageFormatter.error("Storage not initialized", undefined, { prefix: "Controller" });
             return;
         }
         if (!this.config) {
-            console.log(chalk.red("Config not initialized"));
+            MessageFormatter.error("Config not initialized", undefined, { prefix: "Controller" });
             return;
         }
         await ensureDatabaseConfigBucketsExist(this.storage, this.config, databases);
@@ -141,7 +163,7 @@ export class UtilsController {
     async ensureDatabasesExist(databases) {
         await this.init();
         if (!this.config) {
-            console.log(chalk.red("Config not initialized"));
+            MessageFormatter.error("Config not initialized", undefined, { prefix: "Controller" });
             return;
         }
         await this.setupMigrationDatabase();
@@ -151,7 +173,7 @@ export class UtilsController {
     async ensureCollectionsExist(database, collections) {
         await this.init();
         if (!this.config) {
-            console.log(chalk.red("Config not initialized"));
+            MessageFormatter.error("Config not initialized", undefined, { prefix: "Controller" });
             return;
         }
         await ensureCollectionsExist(this.config, database, collections);
@@ -159,7 +181,7 @@ export class UtilsController {
     async getDatabasesByIds(ids) {
         await this.init();
         if (!this.database) {
-            console.log(chalk.red("Database not initialized"));
+            MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
             return;
         }
         if (ids.length === 0)
@@ -173,10 +195,10 @@ export class UtilsController {
     async wipeOtherDatabases(databasesToKeep) {
         await this.init();
         if (!this.database) {
-            console.log(chalk.red("Database not initialized"));
+            MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
             return;
         }
-        await wipeOtherDatabases(this.database, databasesToKeep);
+        await wipeOtherDatabases(this.database, databasesToKeep, this.config?.useMigrations ?? true);
     }
     async wipeUsers() {
         await this.init();
@@ -208,7 +230,7 @@ export class UtilsController {
     }
     async findFunctionDirectories() {
         if (!this.appwriteFolderPath) {
-            console.log(chalk.red("Failed to get appwriteFolderPath"));
+            MessageFormatter.error("Failed to get appwriteFolderPath", undefined, { prefix: "Controller" });
             return new Map();
         }
         const functionsDir = findFunctionsDir(this.appwriteFolderPath);
@@ -258,10 +280,10 @@ export class UtilsController {
             Query.limit(1000),
         ]);
         for (const localFunction of localFunctions) {
-            console.log(chalk.blue(`Syncing function ${localFunction.name}...`));
+            MessageFormatter.progress(`Syncing function ${localFunction.name}...`, { prefix: "Functions" });
             await this.deployFunction(localFunction.name);
         }
-        console.log(chalk.green("✨ All functions synchronized successfully!"));
+        MessageFormatter.success("All functions synchronized successfully!", { prefix: "Functions" });
     }
     async wipeDatabase(database, wipeBucket = false) {
         await this.init();
@@ -312,7 +334,7 @@ export class UtilsController {
         if (!this.database || !this.config)
             throw new Error("Database or config not initialized");
         for (const database of databases) {
-            if (database.$id === "migrations")
+            if (!this.config.useMigrations && database.$id === "migrations")
                 continue;
             await this.createOrUpdateCollections(database, undefined, collections);
         }
@@ -326,11 +348,11 @@ export class UtilsController {
     async generateSchemas() {
         await this.init();
         if (!this.config) {
-            console.log(chalk.red("Config not initialized"));
+            MessageFormatter.error("Config not initialized", undefined, { prefix: "Controller" });
             return;
         }
         if (!this.appwriteFolderPath) {
-            console.log(chalk.red("Failed to get appwriteFolderPath"));
+            MessageFormatter.error("Failed to get appwriteFolderPath", undefined, { prefix: "Controller" });
             return;
         }
         await generateSchemas(this.config, this.appwriteFolderPath);
@@ -338,19 +360,19 @@ export class UtilsController {
     async importData(options = {}) {
         await this.init();
         if (!this.database) {
-            console.log(chalk.red("Database not initialized"));
+            MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
             return;
         }
         if (!this.storage) {
-            console.log(chalk.red("Storage not initialized"));
+            MessageFormatter.error("Storage not initialized", undefined, { prefix: "Controller" });
             return;
         }
         if (!this.config) {
-            console.log(chalk.red("Config not initialized"));
+            MessageFormatter.error("Config not initialized", undefined, { prefix: "Controller" });
             return;
         }
         if (!this.appwriteFolderPath) {
-            console.log(chalk.red("Failed to get appwriteFolderPath"));
+            MessageFormatter.error("Failed to get appwriteFolderPath", undefined, { prefix: "Controller" });
             return;
         }
         const importDataActions = new ImportDataActions(this.database, this.storage, this.config, this.converterDefinitions, this.validityRuleDefinitions, this.afterImportActionsDefinitions);
@@ -360,16 +382,16 @@ export class UtilsController {
     async synchronizeConfigurations(databases, config) {
         await this.init();
         if (!this.storage) {
-            console.log(chalk.red("Storage not initialized"));
+            MessageFormatter.error("Storage not initialized", undefined, { prefix: "Controller" });
             return;
         }
         const configToUse = config || this.config;
         if (!configToUse) {
-            console.log(chalk.red("Config not initialized"));
+            MessageFormatter.error("Config not initialized", undefined, { prefix: "Controller" });
             return;
         }
         if (!this.appwriteFolderPath) {
-            console.log(chalk.red("Failed to get appwriteFolderPath"));
+            MessageFormatter.error("Failed to get appwriteFolderPath", undefined, { prefix: "Controller" });
             return;
         }
         const appwriteToX = new AppwriteToX(configToUse, this.appwriteFolderPath, this.storage);
@@ -378,7 +400,7 @@ export class UtilsController {
     async syncDb(databases = [], collections = []) {
         await this.init();
         if (!this.database) {
-            console.log(chalk.red("Database not initialized"));
+            MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
             return;
         }
         if (databases.length === 0) {
@@ -441,10 +463,10 @@ export class UtilsController {
                 return;
             }
             else {
-                console.log(chalk.blue("Starting user transfer..."));
+                MessageFormatter.progress("Starting user transfer...", { prefix: "Transfer" });
                 const localUsers = new Users(this.appwriteServer);
                 await transferUsersLocalToRemote(localUsers, options.transferEndpoint, options.transferProject, options.transferKey);
-                console.log(chalk.green("User transfer completed"));
+                MessageFormatter.success("User transfer completed", { prefix: "Transfer" });
             }
         }
         // Handle storage transfer
@@ -464,7 +486,7 @@ export class UtilsController {
                         .trim()
                         .replace(/\s+/g, "")}`);
             if (sourceBucketId && targetBucketId) {
-                console.log(chalk.blue(`Starting storage transfer from ${sourceBucketId} to ${targetBucketId}`));
+                MessageFormatter.progress(`Starting storage transfer from ${sourceBucketId} to ${targetBucketId}`, { prefix: "Transfer" });
                 if (options.isRemote) {
                     await transferStorageLocalToRemote(this.storage, options.transferEndpoint, options.transferProject, options.transferKey, sourceBucketId, targetBucketId);
                 }
@@ -473,14 +495,14 @@ export class UtilsController {
                 }
             }
         }
-        console.log(chalk.green("Transfer completed"));
+        MessageFormatter.success("Transfer completed", { prefix: "Transfer" });
     }
     async updateFunctionSpecifications(functionId, specification) {
         await this.init();
         if (!this.appwriteServer)
             throw new Error("Appwrite server not initialized");
-        console.log(chalk.green(`Updating function specifications for ${functionId} to ${specification}`));
+        MessageFormatter.progress(`Updating function specifications for ${functionId} to ${specification}`, { prefix: "Functions" });
         await updateFunctionSpecifications(this.appwriteServer, functionId, specification);
-        console.log(chalk.green(`Successfully updated function specifications for ${functionId} to ${specification}`));
+        MessageFormatter.success(`Successfully updated function specifications for ${functionId} to ${specification}`, { prefix: "Functions" });
     }
 }

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.10.86",
+  "version": "1.0.1",
   "main": "src/main.ts",
   "type": "module",
   "repository": {
@@ -30,29 +30,33 @@
     "postinstall": "echo 'This package is intended for CLI use only and should not be added as a dependency in other projects.'"
   },
   "dependencies": {
-    "@types/inquirer": "^9.0.7",
-    "appwrite-utils": "^0.4.1",
-    "chalk": "^5.3.0",
+    "@types/inquirer": "^9.0.8",
+    "@types/json-schema": "^7.0.15",
+    "@types/yargs": "^17.0.33",
+    "appwrite-utils": "^1.0.0",
+    "chalk": "^5.4.1",
     "cli-progress": "^3.12.0",
     "commander": "^12.1.0",
-    "es-toolkit": "^1.32.0",
+    "es-toolkit": "^1.39.4",
     "ignore": "^6.0.2",
-    "inquirer": "^9.3.6",
+    "inquirer": "^9.3.7",
     "js-yaml": "^4.1.0",
-    "luxon": "^3.5.0",
+    "luxon": "^3.6.1",
     "nanostores": "^0.10.3",
-    "node-appwrite": "^14.1.0",
+    "node-appwrite": "^14.2.0",
+    "p-limit": "^6.2.0",
     "tar": "^7.4.3",
-    "tsx": "^4.17.0",
-    "ulidx": "^2.4.0",
-    "winston": "^3.14.2",
-    "zod": "^3.23.8"
+    "tsx": "^4.20.3",
+    "ulidx": "^2.4.1",
+    "winston": "^3.17.0",
+    "yargs": "^18.0.0",
+    "zod": "^3.25.67"
   },
   "devDependencies": {
     "@types/cli-progress": "^3.11.6",
     "@types/js-yaml": "^4.0.9",
-    "@types/lodash": "^4.17.7",
-    "@types/luxon": "^3.4.2",
-    "typescript": "^5.5.4"
+    "@types/lodash": "^4.17.18",
+    "@types/luxon": "^3.6.2",
+    "typescript": "^5.8.3"
   }
 }

package/src/collections/attributes.ts

@@ -4,7 +4,7 @@ import {
   parseAttribute,
   type Attribute,
 } from "appwrite-utils";
-import { nameToIdMapping, enqueueOperation } from "../migrations/queue.js";
+import { nameToIdMapping, enqueueOperation } from "../shared/operationQueue.js";
 import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
 import chalk from "chalk";
 
@@ -264,7 +264,8 @@ export const createOrUpdateAttribute = async (
         );
       }
       break;
-    case "float":
+    case "double":
+    case "float": // Backward compatibility
       if (action === "create") {
         await tryAwaitWithRetry(
           async () =>