appwrite-utils-cli 0.10.86 → 1.0.1

package/dist/users/methods.js

@@ -0,0 +1,276 @@
+import { AppwriteException, Databases, ID, Query, Users, } from "node-appwrite";
+import { AuthUserSchema, } from "../schemas/authUser.js";
+import { logger } from "../shared/logging.js";
+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";
+export class UsersController {
+    config;
+    users;
+    static userFields = [
+        "email",
+        "name",
+        "password",
+        "phone",
+        "labels",
+        "prefs",
+        "userId",
+        "$createdAt",
+        "$updatedAt",
+    ];
+    constructor(config, db) {
+        this.config = config;
+        this.users = new Users(this.config.appwriteClient);
+    }
+    async wipeUsers() {
+        const allUsers = await this.getAllUsers();
+        console.log("Deleting all users...");
+        const createBatches = (finalData, batchSize) => {
+            const finalBatches = [];
+            for (let i = 0; i < finalData.length; i += batchSize) {
+                finalBatches.push(finalData.slice(i, i + batchSize));
+            }
+            return finalBatches;
+        };
+        let usersDeleted = 0;
+        if (allUsers.length > 0) {
+            const batchedUserPromises = createBatches(allUsers, 25); // Batch size of 25
+            for (const batch of batchedUserPromises) {
+                console.log(`Deleting ${batch.length} 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...`);
+                }
+            }
+        }
+        else {
+            console.log("No users to delete");
+        }
+    }
+    async getAllUsers() {
+        const allUsers = [];
+        const users = await tryAwaitWithRetry(async () => await this.users.list([Query.limit(200)]));
+        if (users.users.length === 0) {
+            return [];
+        }
+        if (users.users.length === 200) {
+            let lastDocumentId = users.users[users.users.length - 1].$id;
+            allUsers.push(...users.users);
+            while (lastDocumentId) {
+                const moreUsers = await tryAwaitWithRetry(async () => await this.users.list([
+                    Query.limit(200),
+                    Query.cursorAfter(lastDocumentId),
+                ]));
+                allUsers.push(...moreUsers.users);
+                if (moreUsers.users.length < 200) {
+                    break;
+                }
+                lastDocumentId = moreUsers.users[moreUsers.users.length - 1].$id;
+            }
+        }
+        else {
+            allUsers.push(...users.users);
+        }
+        return allUsers;
+    }
+    async createUsersAndReturn(items) {
+        const users = await Promise.all(items.map((item) => this.createUserAndReturn(item)));
+        return users;
+    }
+    async createUserAndReturn(item) {
+        try {
+            const user = await tryAwaitWithRetry(async () => {
+                const createdUser = await this.users.create(item.userId || ID.unique(), item.email || undefined, item.phone && item.phone.length < 15 && item.phone.startsWith("+")
+                    ? item.phone
+                    : undefined, `changeMe${item.email?.toLowerCase()}` || `changeMePlease`, item.name || undefined);
+                if (item.labels) {
+                    await this.users.updateLabels(createdUser.$id, item.labels);
+                }
+                if (item.prefs) {
+                    await this.users.updatePrefs(createdUser.$id, item.prefs);
+                }
+                return createdUser;
+            }); // Set throwError to true since we want to handle errors
+            return user;
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                logger.error("FAILED CREATING USER: ", e.message, item);
+            }
+        }
+    }
+    async createAndCheckForUserAndReturn(item) {
+        let userToReturn = undefined;
+        try {
+            // Attempt to find an existing user by email or phone.
+            let foundUsers = [];
+            if (item.email) {
+                const foundUsersByEmail = await this.users.list([
+                    Query.equal("email", item.email),
+                ]);
+                foundUsers = foundUsersByEmail.users;
+            }
+            if (item.phone) {
+                const foundUsersByPhone = await this.users.list([
+                    Query.equal("phone", item.phone),
+                ]);
+                foundUsers = foundUsers.length
+                    ? foundUsers.concat(foundUsersByPhone.users)
+                    : foundUsersByPhone.users;
+            }
+            userToReturn = foundUsers[0] || undefined;
+            if (!userToReturn) {
+                userToReturn = await this.users.create(item.userId || ID.unique(), item.email || undefined, item.phone && item.phone.length < 15 && item.phone.startsWith("+")
+                    ? item.phone
+                    : undefined, item.password?.toLowerCase() ||
+                    `changeMe${item.email?.toLowerCase()}` ||
+                    `changeMePlease`, item.name || undefined);
+            }
+            else {
+                // Update user details as necessary, ensuring email uniqueness if attempting an update.
+                if (item.email &&
+                    item.email !== userToReturn.email &&
+                    !isEmpty(item.email) &&
+                    !isUndefined(item.email)) {
+                    const emailExists = await this.users.list([
+                        Query.equal("email", item.email),
+                    ]);
+                    if (emailExists.users.length === 0) {
+                        userToReturn = await this.users.updateEmail(userToReturn.$id, item.email);
+                    }
+                    else {
+                        console.log("Email update skipped: Email already exists.");
+                    }
+                }
+                if (item.password) {
+                    userToReturn = await this.users.updatePassword(userToReturn.$id, item.password.toLowerCase());
+                }
+                if (item.name && item.name !== userToReturn.name) {
+                    userToReturn = await this.users.updateName(userToReturn.$id, item.name);
+                }
+                if (item.phone &&
+                    item.phone !== userToReturn.phone &&
+                    item.phone.length < 15 &&
+                    item.phone.startsWith("+") &&
+                    (isUndefined(userToReturn.phone) || isEmpty(userToReturn.phone))) {
+                    const userFoundWithPhone = await this.users.list([
+                        Query.equal("phone", item.phone),
+                    ]);
+                    if (userFoundWithPhone.total === 0) {
+                        userToReturn = await this.users.updatePhone(userToReturn.$id, item.phone);
+                    }
+                }
+            }
+            if (item.$createdAt && item.$updatedAt) {
+                console.log("$createdAt and $updatedAt are not yet supported, sorry about that!");
+            }
+            if (item.labels && item.labels.length) {
+                userToReturn = await this.users.updateLabels(userToReturn.$id, item.labels);
+            }
+            if (item.prefs && Object.keys(item.prefs).length) {
+                await this.users.updatePrefs(userToReturn.$id, item.prefs);
+                userToReturn.prefs = item.prefs;
+            }
+            return userToReturn;
+        }
+        catch (error) {
+            return userToReturn;
+        }
+    }
+    async getUserIdByEmailOrPhone(email, phone) {
+        if (!email && !phone) {
+            return undefined;
+        }
+        if (email && phone) {
+            const foundUsersByEmail = await this.users.list([
+                // @ts-ignore
+                Query.or([Query.equal("email", email), Query.equal("phone", phone)]),
+            ]);
+            if (foundUsersByEmail.users.length > 0) {
+                return foundUsersByEmail.users[0]?.$id;
+            }
+        }
+        else if (email) {
+            const foundUsersByEmail = await this.users.list([
+                Query.equal("email", email),
+            ]);
+            if (foundUsersByEmail.users.length > 0) {
+                return foundUsersByEmail.users[0]?.$id;
+            }
+            else {
+                if (!phone) {
+                    return undefined;
+                }
+                else {
+                    const foundUsersByPhone = await this.users.list([
+                        Query.equal("phone", phone),
+                    ]);
+                    if (foundUsersByPhone.users.length > 0) {
+                        return foundUsersByPhone.users[0]?.$id;
+                    }
+                    else {
+                        return undefined;
+                    }
+                }
+            }
+        }
+        if (phone) {
+            const foundUsersByPhone = await this.users.list([
+                Query.equal("phone", phone),
+            ]);
+            if (foundUsersByPhone.users.length > 0) {
+                return foundUsersByPhone.users[0]?.$id;
+            }
+            else {
+                return undefined;
+            }
+        }
+    }
+    transferUsersBetweenDbsLocalToRemote = async (endpoint, projectId, apiKey) => {
+        const localUsers = this.users;
+        const client = getAppwriteClient(endpoint, projectId, apiKey);
+        const remoteUsers = new Users(client);
+        let fromUsers = await localUsers.list([Query.limit(50)]);
+        if (fromUsers.users.length === 0) {
+            console.log(`No users found`);
+            return;
+        }
+        else if (fromUsers.users.length < 50) {
+            console.log(`Transferring ${fromUsers.users.length} users to remote`);
+            const batchedPromises = fromUsers.users.map((user) => {
+                return tryAwaitWithRetry(async () => {
+                    const toCreateObject = {
+                        ...user,
+                    };
+                    delete toCreateObject.$id;
+                    delete toCreateObject.$createdAt;
+                    delete toCreateObject.$updatedAt;
+                    await remoteUsers.create(user.$id, user.email, user.phone, user.password, user.name);
+                });
+            });
+            await Promise.all(batchedPromises);
+        }
+        else {
+            while (fromUsers.users.length === 50) {
+                fromUsers = await localUsers.list([
+                    Query.limit(50),
+                    Query.cursorAfter(fromUsers.users[fromUsers.users.length - 1].$id),
+                ]);
+                const batchedPromises = fromUsers.users.map((user) => {
+                    return tryAwaitWithRetry(async () => {
+                        const toCreateObject = {
+                            ...user,
+                        };
+                        delete toCreateObject.$id;
+                        delete toCreateObject.$createdAt;
+                        delete toCreateObject.$updatedAt;
+                        await remoteUsers.create(user.$id, user.email, user.phone, user.password, user.name);
+                    });
+                });
+                await Promise.all(batchedPromises);
+            }
+        }
+    };
+}

package/dist/utils/configMigration.d.ts

@@ -0,0 +1 @@
+export declare function migrateConfig(workingDir: string): Promise<void>;

package/dist/utils/configMigration.js

@@ -0,0 +1,156 @@
+import { promises as fs } from "fs";
+import path from "path";
+import { existsSync } from "fs";
+import { MessageFormatter } from "../shared/messageFormatter.js";
+import { ConfirmationDialogs } from "../shared/confirmationDialogs.js";
+import yaml from "js-yaml";
+export async function migrateConfig(workingDir) {
+    try {
+        // Look for appwriteConfig.ts files in the working directory and subdirectories
+        const configFiles = await findAppwriteConfigFiles(workingDir);
+        if (configFiles.length === 0) {
+            MessageFormatter.info("No appwriteConfig.ts files found to migrate", { prefix: "Migration" });
+            return;
+        }
+        MessageFormatter.info(`Found ${configFiles.length} appwriteConfig.ts file(s) to migrate`, { prefix: "Migration" });
+        for (const configFile of configFiles) {
+            await migrateConfigFile(configFile, workingDir);
+        }
+        MessageFormatter.success("Migration completed successfully", { prefix: "Migration" });
+    }
+    catch (error) {
+        MessageFormatter.error("Migration failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Migration" });
+        throw error;
+    }
+}
+async function findAppwriteConfigFiles(dir) {
+    const configFiles = [];
+    const checkDir = async (currentDir) => {
+        try {
+            const entries = await fs.readdir(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(currentDir, entry.name);
+                if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+                    await checkDir(fullPath);
+                }
+                else if (entry.isFile() && entry.name === 'appwriteConfig.ts') {
+                    configFiles.push(fullPath);
+                }
+            }
+        }
+        catch (error) {
+            // Ignore directory access errors
+        }
+    };
+    await checkDir(dir);
+    return configFiles;
+}
+async function migrateConfigFile(configFilePath, workingDir) {
+    const configDir = path.dirname(configFilePath);
+    const appwriteDir = path.join(configDir, '.appwrite');
+    MessageFormatter.info(`Migrating ${path.relative(workingDir, configFilePath)}`, { prefix: "Migration" });
+    // Check if .appwrite directory already exists
+    if (existsSync(appwriteDir)) {
+        const shouldOverwrite = await ConfirmationDialogs.confirmOverwrite(`.appwrite directory already exists at ${path.relative(workingDir, appwriteDir)}`);
+        if (!shouldOverwrite) {
+            MessageFormatter.info("Skipping migration for this config", { prefix: "Migration" });
+            return;
+        }
+    }
+    // Read and parse the TypeScript config
+    const configContent = await fs.readFile(configFilePath, 'utf8');
+    const config = await parseTypeScriptConfig(configContent);
+    // Create .appwrite directory
+    await fs.mkdir(appwriteDir, { recursive: true });
+    // Convert config to YAML and save
+    const yamlConfig = convertToYAMLConfig(config);
+    const yamlContent = yaml.dump(yamlConfig, {
+        indent: 2,
+        lineWidth: 120,
+        noRefs: true
+    });
+    await fs.writeFile(path.join(appwriteDir, 'appwriteConfig.yaml'), yamlContent);
+    // Move related directories
+    const foldersToMove = ['collections', 'schemas', 'importData', 'functions'];
+    for (const folder of foldersToMove) {
+        const sourcePath = path.join(configDir, folder);
+        const targetPath = path.join(appwriteDir, folder);
+        if (existsSync(sourcePath)) {
+            await fs.rename(sourcePath, targetPath);
+            MessageFormatter.info(`Moved ${folder}/ to .appwrite/${folder}/`, { prefix: "Migration" });
+        }
+    }
+    // Backup original config file
+    const backupPath = configFilePath + '.backup';
+    await fs.copyFile(configFilePath, backupPath);
+    MessageFormatter.info(`Created backup at ${path.relative(workingDir, backupPath)}`, { prefix: "Migration" });
+    // Optionally remove original config file
+    const shouldRemoveOriginal = await ConfirmationDialogs.confirmRemoval(`Remove original ${path.relative(workingDir, configFilePath)}?`);
+    if (shouldRemoveOriginal) {
+        await fs.unlink(configFilePath);
+        MessageFormatter.info(`Removed original ${path.relative(workingDir, configFilePath)}`, { prefix: "Migration" });
+    }
+    MessageFormatter.success(`Migration completed for ${path.relative(workingDir, configFilePath)}`, { prefix: "Migration" });
+}
+async function parseTypeScriptConfig(content) {
+    // This is a simplified parser - in a real implementation, you might want to use a proper TypeScript parser
+    // For now, we'll use a regex-based approach to extract the config object
+    try {
+        // Remove comments and imports
+        const cleanContent = content
+            .replace(/\/\*[\s\S]*?\*\//g, '') // Remove block comments
+            .replace(/\/\/.*$/gm, '') // Remove line comments
+            .replace(/^import.*$/gm, '') // Remove imports
+            .replace(/^export.*$/gm, ''); // Remove exports
+        // Find the config object
+        const configMatch = cleanContent.match(/const\s+\w+\s*:\s*\w+\s*=\s*({[\s\S]*?});/);
+        if (!configMatch) {
+            throw new Error('Could not find config object in TypeScript file');
+        }
+        // Convert to JSON-like format and parse
+        let configStr = configMatch[1];
+        // Replace TypeScript-specific syntax
+        configStr = configStr
+            .replace(/(\w+):/g, '"$1":') // Quote property names
+            .replace(/'/g, '"') // Convert single quotes to double quotes
+            .replace(/,(\s*[}\]])/g, '$1'); // Remove trailing commas
+        const config = JSON.parse(configStr);
+        return config;
+    }
+    catch (error) {
+        MessageFormatter.error("Could not parse TypeScript config", error instanceof Error ? error : new Error(String(error)), { prefix: "Migration" });
+        throw new Error('Failed to parse TypeScript configuration file. Please ensure it follows standard format.');
+    }
+}
+function convertToYAMLConfig(config) {
+    // Convert the config to YAML-friendly format
+    const yamlConfig = {
+        appwriteEndpoint: config.appwriteEndpoint,
+        appwriteProject: config.appwriteProject,
+        appwriteKey: config.appwriteKey,
+        databases: config.databases || [],
+        buckets: config.buckets || [],
+    };
+    // Add optional properties if they exist
+    if (config.enableBackups !== undefined)
+        yamlConfig.enableBackups = config.enableBackups;
+    if (config.backupInterval !== undefined)
+        yamlConfig.backupInterval = config.backupInterval;
+    if (config.backupRetention !== undefined)
+        yamlConfig.backupRetention = config.backupRetention;
+    if (config.enableBackupCleanup !== undefined)
+        yamlConfig.enableBackupCleanup = config.enableBackupCleanup;
+    if (config.enableMockData !== undefined)
+        yamlConfig.enableMockData = config.enableMockData;
+    if (config.documentBucketId !== undefined)
+        yamlConfig.documentBucketId = config.documentBucketId;
+    if (config.usersCollectionName !== undefined)
+        yamlConfig.usersCollectionName = config.usersCollectionName;
+    // Copy any additional properties
+    for (const [key, value] of Object.entries(config)) {
+        if (!(key in yamlConfig)) {
+            yamlConfig[key] = value;
+        }
+    }
+    return yamlConfig;
+}

package/dist/utils/dataConverters.d.ts

@@ -0,0 +1,46 @@
+import { type AttributeMappings } from "appwrite-utils";
+/**
+ * Deeply converts all properties of an object (or array) to strings.
+ * @param data The input data to convert.
+ * @returns The data with all its properties converted to strings.
+ */
+export declare const deepAnyToString: (data: any) => any;
+/**
+ * Performs a deep conversion of all values in a nested structure to the specified type.
+ * Uses a conversion function like anyToString, anyToNumber, etc.
+ * @param data The data to convert.
+ * @param convertFn The conversion function to apply.
+ * @returns The converted data.
+ */
+export declare const deepConvert: <T>(data: any, convertFn: (value: any) => T) => any;
+/**
+ * Converts an entire object's properties to different types based on a provided schema.
+ * @param obj The object to convert.
+ * @param schema A mapping of object keys to conversion functions.
+ * @returns The converted object.
+ */
+export declare const convertObjectBySchema: (obj: Record<string, any>, schema: Record<string, (value: any) => any>) => Record<string, any>;
+/**
+ * Converts the keys of an object based on a provided attributeMappings.
+ * Each key in the object is checked against attributeMappings; if a matching entry is found,
+ * the key is renamed to the targetKey specified in attributeMappings.
+ *
+ * @param obj The object to convert.
+ * @param attributeMappings The attributeMappings defining how keys in the object should be converted.
+ * @returns The converted object with keys renamed according to attributeMappings.
+ */
+export declare const convertObjectByAttributeMappings: (obj: Record<string, any>, attributeMappings: AttributeMappings) => Record<string, any>;
+/**
+ * Ensures data conversion without mutating the original input.
+ * @param data The data to convert.
+ * @param convertFn The conversion function to apply.
+ * @returns The converted data.
+ */
+export declare const immutableConvert: <T>(data: any, convertFn: (value: any) => T) => T;
+/**
+ * Validates a string against a regular expression and returns the string if valid, or null.
+ * @param value The string to validate.
+ * @param pattern The regex pattern to validate against.
+ * @returns The original string if valid, otherwise null.
+ */
+export declare const validateString: (value: string, pattern: RegExp) => string | null;

package/dist/utils/dataConverters.js

@@ -0,0 +1,139 @@
+import { converterFunctions } from "appwrite-utils";
+import { cloneDeep, isPlainObject } from "es-toolkit";
+/**
+ * Deeply converts all properties of an object (or array) to strings.
+ * @param data The input data to convert.
+ * @returns The data with all its properties converted to strings.
+ */
+export const deepAnyToString = (data) => {
+    if (Array.isArray(data)) {
+        return data.map((item) => deepAnyToString(item));
+    }
+    else if (isPlainObject(data)) {
+        return Object.keys(data).reduce((acc, key) => {
+            acc[key] = deepAnyToString(data[key]);
+            return acc;
+        }, {});
+    }
+    else {
+        return converterFunctions.anyToString(data);
+    }
+};
+/**
+ * Performs a deep conversion of all values in a nested structure to the specified type.
+ * Uses a conversion function like anyToString, anyToNumber, etc.
+ * @param data The data to convert.
+ * @param convertFn The conversion function to apply.
+ * @returns The converted data.
+ */
+export const deepConvert = (data, convertFn) => {
+    if (Array.isArray(data)) {
+        return data.map((item) => deepConvert(item, convertFn));
+    }
+    else if (isPlainObject(data)) {
+        return Object.keys(data).reduce((acc, key) => {
+            acc[key] = deepConvert(data[key], convertFn);
+            return acc;
+        }, {});
+    }
+    else {
+        return convertFn(data);
+    }
+};
+/**
+ * Converts an entire object's properties to different types based on a provided schema.
+ * @param obj The object to convert.
+ * @param schema A mapping of object keys to conversion functions.
+ * @returns The converted object.
+ */
+export const convertObjectBySchema = (obj, schema) => {
+    return Object.keys(obj).reduce((acc, key) => {
+        const convertFn = schema[key];
+        acc[key] = convertFn ? convertFn(obj[key]) : obj[key];
+        return acc;
+    }, {});
+};
+/**
+ * Converts the keys of an object based on a provided attributeMappings.
+ * Each key in the object is checked against attributeMappings; if a matching entry is found,
+ * the key is renamed to the targetKey specified in attributeMappings.
+ *
+ * @param obj The object to convert.
+ * @param attributeMappings The attributeMappings defining how keys in the object should be converted.
+ * @returns The converted object with keys renamed according to attributeMappings.
+ */
+export const convertObjectByAttributeMappings = (obj, attributeMappings) => {
+    const result = {};
+    // Correctly handle [any] notation by mapping or aggregating over all elements or keys
+    const resolveValue = (obj, path) => {
+        const parts = path.split(".");
+        let current = obj;
+        for (let i = 0; i < parts.length; i++) {
+            if (parts[i] === "[any]") {
+                if (Array.isArray(current)) {
+                    // If current is an array, apply resolution to each item
+                    return current.map((item) => resolveValue(item, parts.slice(i + 1).join(".")));
+                }
+                else if (typeof current === "object" && current !== null) {
+                    // If current is an object, aggregate values from all keys
+                    return Object.values(current).map((value) => resolveValue(value, parts.slice(i + 1).join(".")));
+                }
+            }
+            else {
+                current = current[parts[i]];
+                if (current === undefined)
+                    return undefined;
+            }
+        }
+        return current;
+    };
+    for (const mapping of attributeMappings) {
+        if (mapping.valueToSet !== undefined) {
+            result[mapping.targetKey] = mapping.valueToSet;
+        }
+        else if (Array.isArray(mapping.oldKeys)) {
+            // Collect and flatten values from multiple oldKeys
+            const values = mapping.oldKeys
+                .map((oldKey) => resolveValue(obj, oldKey))
+                .flat(Infinity);
+            if (values.length > 0) {
+                result[mapping.targetKey] = values.filter((value) => value !== undefined);
+            }
+            else {
+                result[mapping.targetKey] = null;
+            }
+        }
+        else if (mapping.oldKey) {
+            // Resolve single oldKey
+            const value = resolveValue(obj, mapping.oldKey);
+            if (value !== undefined) {
+                result[mapping.targetKey] = Array.isArray(value)
+                    ? value.flat(Infinity)
+                    : value;
+            }
+            else {
+                result[mapping.targetKey] = value ? value : null;
+            }
+        }
+    }
+    return result;
+};
+/**
+ * Ensures data conversion without mutating the original input.
+ * @param data The data to convert.
+ * @param convertFn The conversion function to apply.
+ * @returns The converted data.
+ */
+export const immutableConvert = (data, convertFn) => {
+    const clonedData = cloneDeep(data);
+    return convertFn(clonedData);
+};
+/**
+ * Validates a string against a regular expression and returns the string if valid, or null.
+ * @param value The string to validate.
+ * @param pattern The regex pattern to validate against.
+ * @returns The original string if valid, otherwise null.
+ */
+export const validateString = (value, pattern) => {
+    return pattern.test(value) ? value : null;
+};

package/dist/utils/loadConfigs.d.ts

@@ -1,14 +1,25 @@
 import { type AppwriteConfig } from "appwrite-utils";
 /**
- * Recursively searches for a file named 'appwriteConfig.ts' starting from the given directory.
+ * 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 path to the file if found, or null if not found.
+ * @returns The directory path where the config was found, suitable for passing to loadConfig().
  */
 export declare const findAppwriteConfig: (dir: string) => string | null;
+/**
+ * Loads the Appwrite configuration and returns both config and the path where it was found.
+ * @param configDir The directory to search for config files.
+ * @returns Object containing the config and the actual path where it was found.
+ */
+export declare const loadConfigWithPath: (configDir: string) => Promise<{
+    config: AppwriteConfig;
+    actualConfigPath: string;
+}>;
 /**
  * Loads the Appwrite configuration and all collection configurations from a specified directory.
- * @param configDir The directory containing the appwriteConfig.ts and collections folder.
+ * Supports both YAML and TypeScript config formats with backward compatibility.
+ * @param configDir The directory containing the config file and collections folder.
  * @returns The loaded Appwrite configuration including collections.
  */
 export declare const loadConfig: (configDir: string) => Promise<AppwriteConfig>;
-export declare const findFunctionsDir: (dir: string) => string | null;
+export declare const findFunctionsDir: (dir: string, depth?: number) => string | null;