appwrite-utils-cli 1.5.2 → 1.6.0

package/dist/shared/schemaGenerator.js

@@ -1,4 +1,5 @@
 import { toCamelCase, toPascalCase } from "../utils/index.js";
+import { getVersionAwareDirectory, resolveDirectoryForApiMode, getDualDirectoryPaths } from "appwrite-utils";
 import { z } from "zod";
 import fs from "fs";
 import path from "path";
@@ -7,6 +8,9 @@ import { getDatabaseFromConfig } from "../migrations/afterImportActions.js";
 import { ulid } from "ulidx";
 import { JsonSchemaGenerator } from "./jsonSchemaGenerator.js";
 import { collectionToYaml, getCollectionYamlFilename } from "../utils/yamlConverter.js";
+import { extractTwoWayRelationships, resolveCollectionName } from "./relationshipExtractor.js";
+import { resolveSchemaDir } from "../utils/pathResolvers.js";
+import { MessageFormatter } from "./messageFormatter.js";
 export class SchemaGenerator {
     relationshipMap = new Map();
     config;
@@ -17,25 +21,34 @@ export class SchemaGenerator {
         this.extractRelationships();
     }
     resolveCollectionName = (idOrName) => {
-        const col = this.config.collections?.find((c) => c.$id === idOrName || c.name === idOrName);
-        return col?.name ?? idOrName;
+        return resolveCollectionName(this.config, idOrName);
     };
     updateYamlCollections() {
         const collections = this.config.collections;
         delete this.config.collections;
-        const collectionsDir = path.join(this.appwriteFolderPath, "collections");
+        // Determine output directory based on API mode/version detection
+        const outputDir = this.getVersionAwareCollectionsDirectory();
+        const collectionsDir = path.join(this.appwriteFolderPath, outputDir);
         if (!fs.existsSync(collectionsDir)) {
             fs.mkdirSync(collectionsDir, { recursive: true });
         }
         collections?.forEach((collection) => {
-            // Determine schema path based on config
+            // Determine schema path based on config and output directory
             const schemaDir = this.config.schemaConfig?.yamlSchemaDirectory || ".yaml_schemas";
-            const schemaPath = `../${schemaDir}/collection.schema.json`;
-            const yamlContent = collectionToYaml(collection, schemaPath);
+            const isTablesMode = outputDir === "tables";
+            const schemaPath = isTablesMode
+                ? `../${schemaDir}/table.schema.json`
+                : `../${schemaDir}/collection.schema.json`;
+            const yamlConfig = {
+                useTableTerminology: isTablesMode,
+                entityType: isTablesMode ? 'table' : 'collection',
+                schemaPath
+            };
+            const yamlContent = collectionToYaml(collection, yamlConfig);
             const filename = getCollectionYamlFilename(collection);
             const filePath = path.join(collectionsDir, filename);
             fs.writeFileSync(filePath, yamlContent, { encoding: "utf-8" });
-            console.log(`Collection YAML written to ${filePath}`);
+            MessageFormatter.success(`${outputDir === "tables" ? "Table" : "Collection"} YAML written to ${filePath}`, { prefix: "Schema" });
         });
     }
     updateTsSchemas() {
@@ -89,7 +102,9 @@ export class SchemaGenerator {
   export default appwriteConfig;
   `;
         fs.writeFileSync(configPath, configContent, { encoding: "utf-8" });
-        const collectionsFolderPath = path.join(this.appwriteFolderPath, "collections");
+        // Determine output directory based on API mode/version detection
+        const outputDir = this.getVersionAwareCollectionsDirectory();
+        const collectionsFolderPath = path.join(this.appwriteFolderPath, outputDir);
         if (!fs.existsSync(collectionsFolderPath)) {
             fs.mkdirSync(collectionsFolderPath, { recursive: true });
         }
@@ -155,9 +170,31 @@ export class SchemaGenerator {
             fs.writeFileSync(collectionFilePath, collectionContent, {
                 encoding: "utf-8",
             });
-            console.log(`Collection schema written to ${collectionFilePath}`);
+            MessageFormatter.success(`${outputDir === "tables" ? "Table" : "Collection"} schema written to ${collectionFilePath}`, { prefix: "Schema" });
         });
     }
+    /**
+     * Determines the appropriate directory for collections/tables based on API mode
+     * Uses version detection or config hints to choose between 'collections' and 'tables'
+     */
+    getVersionAwareCollectionsDirectory() {
+        return getVersionAwareDirectory(this.config, this.appwriteFolderPath);
+    }
+    /**
+     * Get directory for a specific API mode (legacy or tablesdb)
+     * @param apiMode - The API mode to get directory for
+     * @returns The directory name for the specified API mode
+     */
+    getDirectoryForApiMode(apiMode) {
+        return resolveDirectoryForApiMode(this.config, apiMode, this.appwriteFolderPath);
+    }
+    /**
+     * Get both directory paths for dual API support
+     * @returns Object with both collectionsDirectory and tablesDirectory paths
+     */
+    getDualDirectoryConfiguration() {
+        return getDualDirectoryPaths(this.config);
+    }
     async updateConfig(config, isYamlConfig = false) {
         if (isYamlConfig) {
             // User has YAML config - find the config file and update it + generate individual collection files
@@ -167,7 +204,7 @@ export class SchemaGenerator {
                 await this.updateYamlConfig(config, yamlConfigPath);
             }
             else {
-                console.warn("⚠️ YAML config expected but not found, falling back to TypeScript");
+                MessageFormatter.warning("YAML config expected but not found, falling back to TypeScript", { prefix: "Schema" });
                 this.updateTypeScriptConfig(config);
             }
         }
@@ -183,10 +220,10 @@ export class SchemaGenerator {
             await writeYamlConfig(yamlConfigPath, config);
             // Generate individual collection YAML files
             this.updateYamlCollections();
-            console.log("✅ Updated YAML configuration and collection files");
+            MessageFormatter.success("Updated YAML configuration and collection files", { prefix: "Schema" });
         }
         catch (error) {
-            console.error("❌ Error updating YAML config:", error instanceof Error ? error.message : error);
+            MessageFormatter.error("Error updating YAML config", error, { prefix: "Schema" });
             throw error;
         }
     }
@@ -234,68 +271,10 @@ const appwriteConfig: AppwriteConfig = {
 export default appwriteConfig;
 `;
         fs.writeFileSync(configPath, configContent, { encoding: "utf-8" });
-        console.log("✅ Updated TypeScript configuration file");
+        MessageFormatter.success("Updated TypeScript configuration file", { prefix: "Schema" });
     }
     extractRelationships() {
-        if (!this.config.collections) {
-            return;
-        }
-        this.config.collections.forEach((collection) => {
-            if (!collection.attributes) {
-                return;
-            }
-            collection.attributes.forEach((attr) => {
-                if (attr.type === "relationship" && attr.twoWay && attr.twoWayKey) {
-                    const relationshipAttr = attr;
-                    let isArrayParent = false;
-                    let isArrayChild = false;
-                    switch (relationshipAttr.relationType) {
-                        case "oneToMany":
-                            isArrayParent = true;
-                            isArrayChild = false;
-                            break;
-                        case "manyToMany":
-                            isArrayParent = true;
-                            isArrayChild = true;
-                            break;
-                        case "oneToOne":
-                            isArrayParent = false;
-                            isArrayChild = false;
-                            break;
-                        case "manyToOne":
-                            isArrayParent = false;
-                            isArrayChild = true;
-                            break;
-                        default:
-                            break;
-                    }
-                    this.addRelationship(collection.name, this.resolveCollectionName(relationshipAttr.relatedCollection), attr.key, relationshipAttr.twoWayKey, isArrayParent, isArrayChild);
-                    console.log(`Extracted relationship: ${attr.key}\n\t${collection.name} -> ${relationshipAttr.relatedCollection}, databaseId: ${collection.databaseId}`);
-                }
-            });
-        });
-    }
-    addRelationship(parentCollection, childCollection, parentKey, childKey, isArrayParent, isArrayChild) {
-        const relationshipsChild = this.relationshipMap.get(childCollection) || [];
-        const relationshipsParent = this.relationshipMap.get(parentCollection) || [];
-        relationshipsParent.push({
-            parentCollection,
-            childCollection,
-            parentKey,
-            childKey,
-            isArray: isArrayParent,
-            isChild: false,
-        });
-        relationshipsChild.push({
-            parentCollection,
-            childCollection,
-            parentKey,
-            childKey,
-            isArray: isArrayChild,
-            isChild: true,
-        });
-        this.relationshipMap.set(childCollection, relationshipsChild);
-        this.relationshipMap.set(parentCollection, relationshipsParent);
+        this.relationshipMap = extractTwoWayRelationships(this.config);
     }
     generateSchemas(options = {}) {
         const { format = "both", verbose = false } = options;
@@ -304,7 +283,9 @@ export default appwriteConfig;
         }
         // Create schemas directory using config setting
         const outputDir = this.config.schemaConfig?.outputDirectory || "schemas";
-        const schemasPath = path.join(this.appwriteFolderPath, outputDir);
+        const schemasPath = outputDir === "schemas"
+            ? resolveSchemaDir(this.appwriteFolderPath)
+            : path.join(this.appwriteFolderPath, outputDir);
         if (!fs.existsSync(schemasPath)) {
             fs.mkdirSync(schemasPath, { recursive: true });
         }
@@ -316,7 +297,7 @@ export default appwriteConfig;
                 const schemaPath = path.join(schemasPath, `${camelCaseName}.ts`);
                 fs.writeFileSync(schemaPath, schemaString, { encoding: "utf-8" });
                 if (verbose) {
-                    console.log(`Zod schema written to ${schemaPath}`);
+                    MessageFormatter.success(`Zod schema written to ${schemaPath}`, { prefix: "Schema" });
                 }
             });
         }
@@ -330,7 +311,7 @@ export default appwriteConfig;
             });
         }
         if (verbose) {
-            console.log(`✓ Schema generation completed (format: ${format})`);
+            MessageFormatter.success(`Schema generation completed (format: ${format})`, { prefix: "Schema" });
         }
     }
     // Zod v4 recursive getter-based schemas

package/dist/storage/backupCompression.d.ts

@@ -0,0 +1,20 @@
+import type { BackupCreate } from "./schemas.js";
+export interface BackupCompressionOptions {
+    includeFiles?: boolean;
+    compressionLevel?: number;
+}
+/**
+ * Creates a compressed ZIP backup from backup data
+ *
+ * Structure:
+ * - metadata.json (backup metadata)
+ * - database.json (database config)
+ * - collections/*.json (one file per collection)
+ * - documents/*.json (one file per collection's documents)
+ * - files/ (optional, if includeFiles is true)
+ */
+export declare function createBackupZip(backupData: BackupCreate, options?: BackupCompressionOptions): Promise<Buffer>;
+/**
+ * Estimates compression ratio for backup data
+ */
+export declare function estimateCompressedSize(uncompressedSize: number, format?: string): number;

package/dist/storage/backupCompression.js

@@ -0,0 +1,67 @@
+import JSZip from "jszip";
+/**
+ * Creates a compressed ZIP backup from backup data
+ *
+ * Structure:
+ * - metadata.json (backup metadata)
+ * - database.json (database config)
+ * - collections/*.json (one file per collection)
+ * - documents/*.json (one file per collection's documents)
+ * - files/ (optional, if includeFiles is true)
+ */
+export async function createBackupZip(backupData, options = {}) {
+    const zip = new JSZip();
+    const compressionLevel = options.compressionLevel ?? 6;
+    // Add metadata.json
+    const metadata = {
+        version: "1.0",
+        createdAt: new Date().toISOString(),
+        databaseId: JSON.parse(backupData.database).$id,
+        format: "zip",
+        includesFiles: options.includeFiles ?? false
+    };
+    zip.file("metadata.json", JSON.stringify(metadata, null, 2));
+    // Add database.json
+    zip.file("database.json", backupData.database);
+    // Add collections/*.json
+    const collectionsFolder = zip.folder("collections");
+    if (collectionsFolder) {
+        backupData.collections.forEach((collectionStr, index) => {
+            const collection = JSON.parse(collectionStr);
+            collectionsFolder.file(`${collection.$id || `collection_${index}`}.json`, collectionStr);
+        });
+    }
+    // Add documents/*.json
+    const documentsFolder = zip.folder("documents");
+    if (documentsFolder) {
+        backupData.documents.forEach((docBatch) => {
+            const collectionId = docBatch.collectionId;
+            documentsFolder.file(`${collectionId}.json`, docBatch.data);
+        });
+    }
+    // TODO: Add files support in future task (C3.5)
+    if (options.includeFiles) {
+        // Placeholder for file backup support
+        const filesFolder = zip.folder("files");
+        if (filesFolder) {
+            filesFolder.file("file-manifest.json", JSON.stringify({
+                note: "File backup not yet implemented"
+            }, null, 2));
+        }
+    }
+    // Generate ZIP buffer
+    const buffer = await zip.generateAsync({
+        type: "nodebuffer",
+        compression: "DEFLATE",
+        compressionOptions: { level: compressionLevel }
+    });
+    return buffer;
+}
+/**
+ * Estimates compression ratio for backup data
+ */
+export function estimateCompressedSize(uncompressedSize, format = "json") {
+    // JSON typically compresses to 20-30% of original size with gzip
+    const compressionRatio = format === "json" ? 0.25 : 0.5;
+    return Math.ceil(uncompressedSize * compressionRatio);
+}

package/dist/storage/methods.d.ts

@@ -14,5 +14,19 @@ export declare const wipeDocumentStorage: (storage: Storage, bucketId: string, o
     skipConfirmation?: boolean;
 }) => Promise<void>;
 export declare const initOrGetDocumentStorage: (storage: Storage, config: AppwriteConfig, dbId: string, bucketName?: string) => Promise<Models.Bucket>;
-export declare const initOrGetBackupStorage: (config: AppwriteConfig, storage: Storage) => Promise<Models.Bucket>;
-export declare const backupDatabase: (config: AppwriteConfig, database: Databases, databaseId: string, storage: Storage) => Promise<void>;
+/**
+ * Initializes or gets the centralized backup bucket
+ * All backups are stored in a single "appwrite-backups" bucket
+ */
+export declare const initBackupBucket: (storage: Storage) => Promise<Models.Bucket | undefined>;
+export interface DatabaseBackupResult {
+    backupFileId: string;
+    backupFileName: string;
+    backupSizeBytes: number;
+    databaseId: string;
+    databaseName: string;
+    collectionCount: number;
+    documentCount: number;
+    format: 'json' | 'zip';
+}
+export declare const backupDatabase: (config: AppwriteConfig, database: Databases, databaseId: string, storage: Storage, format?: "json" | "zip") => Promise<DatabaseBackupResult>;

package/dist/storage/methods.js

@@ -8,6 +8,9 @@ import { retryFailedPromises } from "../utils/retryFailedPromises.js";
 import { InputFile } from "node-appwrite/file";
 import { MessageFormatter, Messages } from "../shared/messageFormatter.js";
 import { ProgressManager } from "../shared/progressManager.js";
+import { recordBackup } from "../shared/backupTracking.js";
+import { AdapterFactory } from "../adapters/AdapterFactory.js";
+import { createBackupZip } from "./backupCompression.js";
 export const getStorage = (config) => {
     const client = getClientFromConfig(config);
     return new Storage(client);
@@ -165,15 +168,44 @@ export const initOrGetDocumentStorage = async (storage, config, dbId, bucketName
         ]));
     }
 };
-export const initOrGetBackupStorage = async (config, storage) => {
+/**
+ * Initializes or gets the centralized backup bucket
+ * All backups are stored in a single "appwrite-backups" bucket
+ */
+export const initBackupBucket = async (storage) => {
+    const BACKUP_BUCKET_ID = "appwrite-backups";
+    const BACKUP_BUCKET_NAME = "Backups";
     try {
-        return await tryAwaitWithRetry(async () => await storage.getBucket("backup"));
+        // Try to get existing bucket
+        const bucket = await storage.getBucket(BACKUP_BUCKET_ID);
+        return bucket;
     }
-    catch (e) {
-        return await initOrGetDocumentStorage(storage, config, "backups", "Database Backups");
+    catch (error) {
+        // Bucket doesn't exist, create it
+        try {
+            const bucket = await storage.createBucket(BACKUP_BUCKET_ID, BACKUP_BUCKET_NAME, [
+                Permission.read(Role.any()),
+                Permission.create(Role.users()),
+                Permission.update(Role.users()),
+                Permission.delete(Role.users())
+            ], false, // fileSecurity
+            true, // enabled
+            undefined, // maximumFileSize
+            undefined, // allowedFileExtensions
+            Compression.Gzip, // compression
+            false, // encryption
+            false // antivirus
+            );
+            MessageFormatter.success(`Created backup bucket: ${BACKUP_BUCKET_ID}`);
+            return bucket;
+        }
+        catch (createError) {
+            MessageFormatter.error("Failed to create backup bucket", createError instanceof Error ? createError : new Error(String(createError)));
+            return undefined;
+        }
     }
 };
-export const backupDatabase = async (config, database, databaseId, storage) => {
+export const backupDatabase = async (config, database, databaseId, storage, format = 'json') => {
     const startTime = Date.now();
     MessageFormatter.banner("Database Backup", `Backing up database: ${databaseId}`);
     MessageFormatter.info(Messages.BACKUP_STARTED(databaseId));
@@ -190,7 +222,7 @@ export const backupDatabase = async (config, database, databaseId, storage) => {
         total: 100,
         error: "",
         status: "in_progress",
-    }, undefined, config.useMigrations);
+    });
     let progress = null;
     let totalDocuments = 0;
     let processedDocuments = 0;
@@ -275,7 +307,7 @@ export const backupDatabase = async (config, database, databaseId, storage) => {
                                 total: totalDocuments,
                                 error: "",
                                 status: "in_progress",
-                            }, backupOperation.$id, config.useMigrations);
+                            }, backupOperation.$id);
                         }
                         moreDocuments = documentResponse.documents.length === 500;
                         if (moreDocuments) {
@@ -297,13 +329,53 @@ export const backupDatabase = async (config, database, databaseId, storage) => {
             }
         }
         MessageFormatter.step(3, 3, "Creating backup file");
-        const bucket = await initOrGetDocumentStorage(storage, config, databaseId);
-        const backupData = JSON.stringify(data);
-        const backupSize = Buffer.byteLength(backupData, 'utf8');
-        const fileName = `${new Date().toISOString()}-${databaseId}.json`;
-        const inputFile = InputFile.fromPlainText(backupData, fileName);
+        const bucket = await initBackupBucket(storage);
+        if (!bucket) {
+            throw new Error("Failed to initialize backup bucket");
+        }
+        let inputFile;
+        let fileName;
+        let backupSize;
+        if (format === 'zip') {
+            // Create compressed backup
+            const zipBuffer = await createBackupZip(data);
+            fileName = `${new Date().toISOString()}-${databaseId}.zip`;
+            backupSize = zipBuffer.length;
+            inputFile = InputFile.fromBuffer(new Uint8Array(zipBuffer), fileName);
+        }
+        else {
+            // Use JSON format (existing logic)
+            const backupData = JSON.stringify(data, null, 2);
+            fileName = `${new Date().toISOString()}-${databaseId}.json`;
+            backupSize = Buffer.byteLength(backupData, 'utf8');
+            inputFile = InputFile.fromPlainText(backupData, fileName);
+        }
         const fileCreated = await storage.createFile(bucket.$id, ulid(), inputFile);
         progress?.stop();
+        // Record backup metadata
+        try {
+            const { adapter } = await AdapterFactory.create({
+                appwriteEndpoint: config.appwriteEndpoint,
+                appwriteProject: config.appwriteProject,
+                appwriteKey: config.appwriteKey,
+                sessionCookie: config.sessionCookie
+            });
+            await recordBackup(adapter, databaseId, {
+                backupId: fileCreated.$id,
+                backupType: 'database',
+                databaseId: databaseId,
+                sizeBytes: backupSize,
+                collections: data.collections.length,
+                documents: processedDocuments,
+                format: format,
+                status: 'completed',
+                restorationStatus: 'not_restored'
+            });
+        }
+        catch (metadataError) {
+            // Don't fail backup if metadata recording fails
+            MessageFormatter.warning(`Failed to record backup metadata: ${metadataError instanceof Error ? metadataError.message : String(metadataError)}`);
+        }
         if (backupOperation) {
             await logOperation(database, databaseId, {
                 operationType: "backup",
@@ -313,7 +385,7 @@ export const backupDatabase = async (config, database, databaseId, storage) => {
                 total: totalItems,
                 error: "",
                 status: "completed",
-            }, backupOperation.$id, config.useMigrations);
+            }, backupOperation.$id);
         }
         const duration = Date.now() - startTime;
         MessageFormatter.operationSummary("Backup", {
@@ -325,6 +397,18 @@ export const backupDatabase = async (config, database, databaseId, storage) => {
             bucket: bucket.$id,
         }, duration);
         MessageFormatter.success(Messages.BACKUP_COMPLETED(databaseId, backupSize));
+        // Return backup result for tracking
+        const dbData = JSON.parse(data.database);
+        return {
+            backupFileId: fileCreated.$id,
+            backupFileName: fileName,
+            backupSizeBytes: backupSize,
+            databaseId: databaseId,
+            databaseName: dbData.name || databaseId,
+            collectionCount: data.collections.length,
+            documentCount: processedDocuments,
+            format: format
+        };
     }
     catch (error) {
         progress?.fail(error instanceof Error ? error.message : String(error));
@@ -338,7 +422,7 @@ export const backupDatabase = async (config, database, databaseId, storage) => {
                 total: totalDocuments,
                 error: String(error),
                 status: "error",
-            }, backupOperation.$id, config.useMigrations);
+            }, backupOperation.$id);
         }
         throw error;
     }

package/dist/users/methods.js

@@ -5,6 +5,7 @@ import { splitIntoBatches } from "../shared/migrationHelpers.js";
 import { getAppwriteClient, tryAwaitWithRetry, } from "../utils/helperFunctions.js";
 import { isUndefined } from "es-toolkit/compat";
 import { isEmpty } from "es-toolkit/compat";
+import { MessageFormatter } from "../shared/messageFormatter.js";
 export class UsersController {
     config;
     users;
@@ -25,7 +26,7 @@ export class UsersController {
     }
     async wipeUsers() {
         const allUsers = await this.getAllUsers();
-        console.log("Deleting all users...");
+        MessageFormatter.progress("Deleting all users...", { prefix: "Users" });
         const createBatches = (finalData, batchSize) => {
             const finalBatches = [];
             for (let i = 0; i < finalData.length; i += batchSize) {
@@ -37,16 +38,16 @@ export class UsersController {
         if (allUsers.length > 0) {
             const batchedUserPromises = createBatches(allUsers, 25); // Batch size of 25
             for (const batch of batchedUserPromises) {
-                console.log(`Deleting ${batch.length} users...`);
+                MessageFormatter.progress(`Deleting ${batch.length} users...`, { prefix: "Users" });
                 await Promise.all(batch.map((user) => tryAwaitWithRetry(async () => await this.users.delete(user.$id))));
                 usersDeleted += batch.length;
                 if (usersDeleted % 100 === 0) {
-                    console.log(`Deleted ${usersDeleted} users...`);
+                    MessageFormatter.progress(`Deleted ${usersDeleted} users...`, { prefix: "Users" });
                 }
             }
         }
         else {
-            console.log("No users to delete");
+            MessageFormatter.info("No users to delete", { prefix: "Users" });
         }
     }
     async getAllUsers() {
@@ -141,7 +142,7 @@ export class UsersController {
                         userToReturn = await this.users.updateEmail(userToReturn.$id, item.email);
                     }
                     else {
-                        console.log("Email update skipped: Email already exists.");
+                        MessageFormatter.warning("Email update skipped: Email already exists.", { prefix: "Users" });
                     }
                 }
                 if (item.password) {
@@ -164,7 +165,7 @@ export class UsersController {
                 }
             }
             if (item.$createdAt && item.$updatedAt) {
-                console.log("$createdAt and $updatedAt are not yet supported, sorry about that!");
+                MessageFormatter.warning("$createdAt and $updatedAt are not yet supported, sorry about that!", { prefix: "Users" });
             }
             if (item.labels && item.labels.length) {
                 userToReturn = await this.users.updateLabels(userToReturn.$id, item.labels);
@@ -234,11 +235,11 @@ export class UsersController {
         const remoteUsers = new Users(client);
         let fromUsers = await localUsers.list([Query.limit(50)]);
         if (fromUsers.users.length === 0) {
-            console.log(`No users found`);
+            MessageFormatter.info("No users found", { prefix: "Users" });
             return;
         }
         else if (fromUsers.users.length < 50) {
-            console.log(`Transferring ${fromUsers.users.length} users to remote`);
+            MessageFormatter.progress(`Transferring ${fromUsers.users.length} users to remote`, { prefix: "Users" });
             const batchedPromises = fromUsers.users.map((user) => {
                 return tryAwaitWithRetry(async () => {
                     const toCreateObject = {

package/dist/utils/configDiscovery.d.ts

@@ -0,0 +1,78 @@
+import { type CollectionCreate } from "appwrite-utils";
+/**
+ * Recursively searches for TypeScript configuration files (appwriteConfig.ts)
+ * @param dir The directory to start the search from
+ * @param depth Current search depth for recursion limiting
+ * @returns Path to the config file or null if not found
+ */
+export declare const findAppwriteConfigTS: (dir: string, depth?: number) => string | null;
+/**
+ * Recursively searches for configuration files starting from the given directory.
+ * Priority: 1) YAML configs in .appwrite directories, 2) appwriteConfig.ts files in subdirectories
+ * @param dir The directory to start the search from
+ * @returns The directory path where the config was found, suitable for passing to loadConfig()
+ */
+export declare const findAppwriteConfig: (dir: string) => string | null;
+/**
+ * Recursively searches for the functions directory
+ * @param dir The directory to start searching from
+ * @param depth Current search depth for recursion limiting
+ * @returns Path to the functions directory or null if not found
+ */
+export declare const findFunctionsDir: (dir: string, depth?: number) => string | null;
+/**
+ * Loads a YAML collection file and converts it to CollectionCreate format
+ * @param filePath Path to the YAML collection file
+ * @returns CollectionCreate object or null if loading fails
+ */
+export declare const loadYamlCollection: (filePath: string) => CollectionCreate | null;
+/**
+ * Loads a YAML table file and converts it to table format
+ * @param filePath Path to the YAML table file
+ * @returns Table object or null if loading fails
+ */
+export declare const loadYamlTable: (filePath: string) => any | null;
+/**
+ * Result of discovering collections from a directory
+ */
+export interface CollectionDiscoveryResult {
+    collections: CollectionCreate[];
+    loadedNames: Set<string>;
+    conflicts: Array<{
+        name: string;
+        source1: string;
+        source2: string;
+    }>;
+}
+/**
+ * Discovers and loads collections from a collections/ directory
+ * @param collectionsDir Path to the collections directory
+ * @returns Discovery result with loaded collections and metadata
+ */
+export declare const discoverCollections: (collectionsDir: string) => Promise<CollectionDiscoveryResult>;
+/**
+ * Result of discovering tables from a directory
+ */
+export interface TableDiscoveryResult {
+    tables: any[];
+    loadedNames: Set<string>;
+    conflicts: Array<{
+        name: string;
+        source1: string;
+        source2: string;
+    }>;
+}
+/**
+ * Discovers and loads tables from a tables/ directory
+ * @param tablesDir Path to the tables directory
+ * @param existingNames Set of already-loaded collection names to check for conflicts
+ * @returns Discovery result with loaded tables and metadata
+ */
+export declare const discoverTables: (tablesDir: string, existingNames?: Set<string>) => Promise<TableDiscoveryResult>;
+/**
+ * Discovers and loads collections/tables from legacy single directory structure
+ * @param configFileDir Directory containing the config file
+ * @param dirName Directory name to search for ('collections' or 'tables')
+ * @returns Array of discovered collections/tables
+ */
+export declare const discoverLegacyDirectory: (configFileDir: string, dirName: "collections" | "tables") => Promise<CollectionCreate[]>;