@njdamstra/appwrite-utils-cli 1.8.9

package/dist/migrations/importController.d.ts

@@ -0,0 +1,23 @@
+import { type Databases, type Models, type Storage } from "node-appwrite";
+import type { AppwriteConfig, ConfigDatabase } from "@njdamstra/appwrite-utils";
+import type { ImportDataActions } from "./importDataActions.js";
+import type { SetupOptions } from "../utilsController.js";
+import { DataLoader } from "./dataLoader.js";
+export declare class ImportController {
+    private config;
+    private database;
+    private storage;
+    private appwriteFolderPath;
+    private importDataActions;
+    private setupOptions;
+    private documentCache;
+    private batchLimit;
+    private hasImportedUsers;
+    private postImportActionsQueue;
+    private databasesToRun;
+    constructor(config: AppwriteConfig, database: Databases, storage: Storage, appwriteFolderPath: string, importDataActions: ImportDataActions, setupOptions: SetupOptions, databasesToRun?: Models.Database[]);
+    run(specificCollections?: string[]): Promise<void>;
+    updateOthersToFinalData(updatedDb: Models.Database, targetDb: Models.Database): Promise<void>;
+    importCollections(db: ConfigDatabase, dataLoader: DataLoader, specificCollections?: string[]): Promise<void>;
+    executePostImportActions(dbId: string, dataLoader: DataLoader, specificCollections?: string[]): Promise<void>;
+}

package/dist/migrations/importController.js

@@ -0,0 +1,268 @@
+import { AppwriteException, ID, Query, } from "node-appwrite";
+import { areCollectionNamesSame, tryAwaitWithRetry } from "../utils/index.js";
+import { resolveAndUpdateRelationships } from "./relationships.js";
+import { UsersController } from "../users/methods.js";
+import { logger } from "../shared/logging.js";
+import { updateOperation } from "../shared/migrationHelpers.js";
+import { LegacyAdapter } from "../adapters/LegacyAdapter.js";
+import { BatchSchema, OperationCreateSchema, OperationSchema, } from "../storage/schemas.js";
+import { DataLoader } from "./dataLoader.js";
+import { transferDatabaseLocalToLocal, transferStorageLocalToLocal, } from "./transfer.js";
+import { MessageFormatter } from "../shared/messageFormatter.js";
+import { ProgressManager } from "../shared/progressManager.js";
+export class ImportController {
+    config;
+    database;
+    storage;
+    appwriteFolderPath;
+    importDataActions;
+    setupOptions;
+    documentCache;
+    batchLimit = 25; // Define batch size limit
+    hasImportedUsers = false;
+    postImportActionsQueue = [];
+    databasesToRun;
+    constructor(config, database, storage, appwriteFolderPath, importDataActions, setupOptions, databasesToRun) {
+        this.config = config;
+        this.database = database;
+        this.storage = storage;
+        this.appwriteFolderPath = appwriteFolderPath;
+        this.importDataActions = importDataActions;
+        this.setupOptions = setupOptions;
+        this.documentCache = new Map();
+        this.databasesToRun = databasesToRun || [];
+    }
+    async run(specificCollections) {
+        let databasesToProcess;
+        if (this.databasesToRun.length > 0) {
+            // Use the provided databases
+            databasesToProcess = this.databasesToRun;
+        }
+        else {
+            // If no databases are specified, fetch all databases
+            const allDatabases = await this.database.list();
+            databasesToProcess = allDatabases.databases;
+        }
+        let dataLoader;
+        let databaseRan;
+        for (let db of databasesToProcess) {
+            MessageFormatter.banner(`Starting import data for database: ${db.name}`, "Database Import");
+            if (!databaseRan) {
+                databaseRan = db;
+                dataLoader = new DataLoader(this.appwriteFolderPath, this.importDataActions, this.database, this.config, this.setupOptions.shouldWriteFile);
+                await dataLoader.setupMaps(db.$id);
+                await dataLoader.start(db.$id);
+                await this.importCollections(db, dataLoader, specificCollections);
+                await resolveAndUpdateRelationships(db.$id, this.database, this.config);
+                await this.executePostImportActions(db.$id, dataLoader, specificCollections);
+            }
+            else if (databaseRan.$id !== db.$id) {
+                await this.updateOthersToFinalData(databaseRan, db);
+            }
+            MessageFormatter.divider();
+            MessageFormatter.success(`Finished import data for database: ${db.name}`, { prefix: "Import" });
+            MessageFormatter.divider();
+        }
+    }
+    async updateOthersToFinalData(updatedDb, targetDb) {
+        if (this.database) {
+            await transferDatabaseLocalToLocal(this.database, updatedDb.$id, targetDb.$id);
+        }
+        if (this.storage) {
+            // Find the corresponding database configs
+            const updatedDbConfig = this.config.databases.find((db) => db.$id === updatedDb.$id);
+            const targetDbConfig = this.config.databases.find((db) => db.$id === targetDb.$id);
+            const allBuckets = await this.storage.listBuckets([Query.limit(1000)]);
+            const bucketsWithDbIdInThem = allBuckets.buckets.filter((bucket) => bucket.name.toLowerCase().includes(updatedDb.$id.toLowerCase()));
+            const configuredUpdatedBucketId = `${this.config.documentBucketId}_${updatedDb.$id.toLowerCase().trim().replace(" ", "")}`;
+            const configuredTargetBucketId = `${this.config.documentBucketId}_${targetDb.$id.toLowerCase().trim().replace(" ", "")}`;
+            let sourceBucketId;
+            let targetBucketId;
+            if (bucketsWithDbIdInThem.find((bucket) => bucket.$id === configuredUpdatedBucketId)) {
+                sourceBucketId = configuredUpdatedBucketId;
+            }
+            else if (bucketsWithDbIdInThem.find((bucket) => bucket.$id === configuredTargetBucketId)) {
+                targetBucketId = configuredTargetBucketId;
+            }
+            if (!sourceBucketId) {
+                sourceBucketId =
+                    updatedDbConfig?.bucket?.$id || bucketsWithDbIdInThem[0]?.$id;
+            }
+            if (!targetBucketId) {
+                targetBucketId =
+                    targetDbConfig?.bucket?.$id || bucketsWithDbIdInThem[0]?.$id;
+            }
+            if (sourceBucketId && targetBucketId) {
+                await transferStorageLocalToLocal(this.storage, sourceBucketId, targetBucketId);
+            }
+        }
+    }
+    async importCollections(db, dataLoader, specificCollections) {
+        const collectionsToImport = specificCollections ||
+            (this.config.collections
+                ? this.config.collections.map((c) => c.name)
+                : []);
+        for (const collection of this.config.collections || []) {
+            if (collectionsToImport.includes(collection.name)) {
+                let isUsersCollection = this.config.usersCollectionName &&
+                    dataLoader.getCollectionKey(this.config.usersCollectionName) ===
+                        dataLoader.getCollectionKey(collection.name);
+                const importOperationId = dataLoader.collectionImportOperations.get(dataLoader.getCollectionKey(collection.name));
+                const createBatches = (finalData) => {
+                    let maxBatchLength = 50;
+                    const finalBatches = [];
+                    for (let i = 0; i < finalData.length; i++) {
+                        if (i % maxBatchLength === 0) {
+                            finalBatches.push([]);
+                        }
+                        finalBatches[finalBatches.length - 1].push(finalData[i]);
+                    }
+                    return finalBatches;
+                };
+                if (isUsersCollection && !this.hasImportedUsers) {
+                    const usersDataMap = dataLoader.importMap.get(dataLoader.getCollectionKey("users"));
+                    const usersData = usersDataMap?.data;
+                    const usersController = new UsersController(this.config, this.database);
+                    if (usersData) {
+                        console.log("Found users data", usersData.length);
+                        const userDataBatches = createBatches(usersData);
+                        for (const batch of userDataBatches) {
+                            console.log("Importing users batch", batch.length);
+                            const userBatchPromises = batch
+                                .filter((item) => {
+                                let itemId;
+                                if (item.finalData.userId) {
+                                    itemId = item.finalData.userId;
+                                }
+                                else if (item.finalData.docId) {
+                                    itemId = item.finalData.docId;
+                                }
+                                if (!itemId) {
+                                    return false;
+                                }
+                                return (item &&
+                                    item.finalData &&
+                                    !dataLoader.userExistsMap.has(itemId));
+                            })
+                                .map((item) => {
+                                dataLoader.userExistsMap.set(item.finalData.userId ||
+                                    item.finalData.docId ||
+                                    item.context.userId ||
+                                    item.context.docId, true);
+                                return usersController.createUserAndReturn(item.finalData);
+                            });
+                            const promiseResults = await Promise.allSettled(userBatchPromises);
+                            for (const item of batch) {
+                                if (item && item.finalData) {
+                                    dataLoader.userExistsMap.set(item.finalData.userId ||
+                                        item.finalData.docId ||
+                                        item.context.userId ||
+                                        item.context.docId, true);
+                                }
+                            }
+                            MessageFormatter.success("Finished importing users batch", { prefix: "Import" });
+                        }
+                        this.hasImportedUsers = true;
+                        MessageFormatter.success("Finished importing users", { prefix: "Import" });
+                    }
+                }
+                if (!importOperationId) {
+                    // Skip further processing if no import operation is found
+                    continue;
+                }
+                let importOperation = null;
+                importOperation = await this.database.getDocument("migrations", "currentOperations", importOperationId);
+                const adapter = new LegacyAdapter(this.database.client);
+                await updateOperation(adapter, db.$id, importOperation.$id, {
+                    status: "in_progress",
+                });
+                const collectionData = dataLoader.importMap.get(dataLoader.getCollectionKey(collection.name));
+                MessageFormatter.processing(`Processing collection: ${collection.name}...`, { prefix: "Import" });
+                if (!collectionData) {
+                    MessageFormatter.warning(`No collection data for ${collection.name}`, { prefix: "Import" });
+                    continue;
+                }
+                const dataSplit = createBatches(collectionData.data);
+                let processedItems = 0;
+                for (let i = 0; i < dataSplit.length; i++) {
+                    const batches = dataSplit[i];
+                    MessageFormatter.progress(`Processing batch ${i + 1} of ${dataSplit.length}`, { prefix: "Import" });
+                    const batchPromises = batches.map((item, index) => {
+                        try {
+                            const id = item.finalData.docId ||
+                                item.finalData.userId ||
+                                item.context.docId ||
+                                item.context.userId;
+                            if (item.finalData.hasOwnProperty("userId")) {
+                                delete item.finalData.userId;
+                            }
+                            if (item.finalData.hasOwnProperty("docId")) {
+                                delete item.finalData.docId;
+                            }
+                            if (!item.finalData) {
+                                return Promise.resolve();
+                            }
+                            return tryAwaitWithRetry(async () => await this.database.createDocument(db.$id, collection.$id, id, item.finalData));
+                        }
+                        catch (error) {
+                            MessageFormatter.error("Error creating document", error instanceof Error ? error : new Error(String(error)), { prefix: "Import" });
+                            return Promise.resolve();
+                        }
+                    });
+                    // Wait for all promises in the current batch to resolve
+                    await Promise.all(batchPromises);
+                    MessageFormatter.success(`Completed batch ${i + 1} of ${dataSplit.length}`, { prefix: "Import" });
+                    if (importOperation) {
+                        const adapter = new LegacyAdapter(this.database.client);
+                        await updateOperation(adapter, db.$id, importOperation.$id, {
+                            progress: processedItems,
+                        });
+                    }
+                }
+                // After all batches are processed, update the operation status to completed
+                if (importOperation) {
+                    const adapter = new LegacyAdapter(this.database.client);
+                    await updateOperation(adapter, db.$id, importOperation.$id, {
+                        status: "completed",
+                    });
+                }
+            }
+        }
+    }
+    async executePostImportActions(dbId, dataLoader, specificCollections) {
+        MessageFormatter.info("Executing post-import actions...", { prefix: "Import" });
+        const collectionsToProcess = specificCollections && specificCollections.length > 0
+            ? specificCollections
+            : this.config.collections
+                ? this.config.collections.map((c) => c.name)
+                : Array.from(dataLoader.importMap.keys());
+        MessageFormatter.info(`Collections to process: ${collectionsToProcess.join(", ")}`, { prefix: "Import" });
+        // Iterate over each collection in the importMap
+        for (const [collectionKey, collectionData,] of dataLoader.importMap.entries()) {
+            const allCollectionKeys = collectionsToProcess.map((c) => dataLoader.getCollectionKey(c));
+            if (allCollectionKeys.includes(collectionKey)) {
+                MessageFormatter.processing(`Processing post-import actions for collection: ${collectionKey}`, { prefix: "Import" });
+                // Iterate over each item in the collectionData.data
+                for (const item of collectionData.data) {
+                    // Assuming each item has attributeMappings that contain actions to be executed
+                    if (item.importDef && item.importDef.attributeMappings) {
+                        // Use item.context as the context for action execution
+                        const context = item.context; // Directly use item.context as the context for action execution
+                        // Iterate through attributeMappings to execute actions
+                        try {
+                            // Execute post-import actions for the current attributeMapping
+                            // Pass item.finalData as the data to be processed along with the context
+                            await this.importDataActions.executeAfterImportActions(item.finalData, item.importDef.attributeMappings, context);
+                        }
+                        catch (error) {
+                            MessageFormatter.error(`Failed to execute post-import actions for item in collection ${collectionKey}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Import" });
+                        }
+                    }
+                }
+            }
+            else {
+                MessageFormatter.info(`Skipping collection: ${collectionKey} because it's not valid for post-import actions`, { prefix: "Import" });
+            }
+        }
+    }
+}

package/dist/migrations/importDataActions.d.ts

@@ -0,0 +1,50 @@
+import { type Databases, type Storage } from "node-appwrite";
+import type { AppwriteConfig } from "@njdamstra/appwrite-utils";
+import { type ValidationRules, type AttributeMappings } from "@njdamstra/appwrite-utils";
+import { type ConverterFunctions } from "@njdamstra/appwrite-utils";
+import { type AfterImportActions } from "@njdamstra/appwrite-utils";
+export declare class ImportDataActions {
+    private db;
+    private storage;
+    private config;
+    private converterDefinitions;
+    private validityRuleDefinitions;
+    private afterImportActionsDefinitions;
+    constructor(db: Databases, storage: Storage, config: AppwriteConfig, converterDefinitions: ConverterFunctions, validityRuleDefinitions: ValidationRules, afterImportActionsDefinitions: AfterImportActions);
+    /**
+     * Runs converter functions on the item based on the provided attribute mappings.
+     *
+     * @param item - The item to be transformed.
+     * @param attributeMappings - The mappings that define how each attribute should be transformed.
+     * @returns The transformed item.
+     */
+    runConverterFunctions(item: any, attributeMappings: AttributeMappings): any;
+    /**
+     * Validates a single data item based on defined validation rules.
+     * @param item The data item to validate.
+     * @param attributeMap The attribute mappings for the data item.
+     * @param context The context for resolving templated parameters in validation rules.
+     * @returns A promise that resolves to true if the item is valid, false otherwise.
+     */
+    validateItem(item: any, attributeMap: AttributeMappings, context: {
+        [key: string]: any;
+    }): boolean;
+    executeAfterImportActions(item: any, attributeMap: AttributeMappings, context: {
+        [key: string]: any;
+    }): Promise<void>;
+    executeAction(actionName: string, params: any[], // Accepts any type, including objects
+    context: {
+        [key: string]: any;
+    }, item: any): Promise<void>;
+    /**
+     * Resolves a templated string or object using the provided context and current data item.
+     * If the template is a string that starts and ends with "{}", it replaces it with the corresponding value from item or context.
+     * If the template is an object, it recursively resolves its properties.
+     * @param template The templated string or object.
+     * @param context The context for resolving the template.
+     * @param item The current data item being processed.
+     */
+    resolveTemplate(template: any, context: {
+        [key: string]: any;
+    }, item: any): any;
+}

package/dist/migrations/importDataActions.js

@@ -0,0 +1,230 @@
+import {} from "node-appwrite";
+import { validationRules, } from "@njdamstra/appwrite-utils";
+import { converterFunctions } from "@njdamstra/appwrite-utils";
+import { convertObjectBySchema } from "../utils/dataConverters.js";
+import {} from "@njdamstra/appwrite-utils";
+import { afterImportActions } from "./afterImportActions.js";
+import { logger } from "../shared/logging.js";
+import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+export class ImportDataActions {
+    db;
+    storage;
+    config;
+    converterDefinitions;
+    validityRuleDefinitions;
+    afterImportActionsDefinitions;
+    constructor(db, storage, config, converterDefinitions, validityRuleDefinitions, afterImportActionsDefinitions) {
+        this.db = db;
+        this.storage = storage;
+        this.config = config;
+        this.converterDefinitions = converterDefinitions;
+        this.validityRuleDefinitions = validityRuleDefinitions;
+        this.afterImportActionsDefinitions = afterImportActionsDefinitions;
+    }
+    /**
+     * Runs converter functions on the item based on the provided attribute mappings.
+     *
+     * @param item - The item to be transformed.
+     * @param attributeMappings - The mappings that define how each attribute should be transformed.
+     * @returns The transformed item.
+     */
+    runConverterFunctions(item, attributeMappings) {
+        const conversionSchema = attributeMappings.reduce((schema, mapping) => {
+            schema[mapping.targetKey] = (originalValue) => {
+                if (!mapping.converters) {
+                    return originalValue;
+                }
+                return mapping.converters?.reduce((value, converterName) => {
+                    let shouldProcessAsArray = false;
+                    if ((converterName.includes("[Arr]") ||
+                        converterName.includes("[arr]")) &&
+                        Array.isArray(value)) {
+                        shouldProcessAsArray = true;
+                        converterName = converterName
+                            .replace("[Arr]", "")
+                            .replace("[arr]", "");
+                    }
+                    else if ((!Array.isArray(value) && converterName.includes("[Arr]")) ||
+                        converterName.includes("[arr]")) {
+                        converterName = converterName
+                            .replace("[Arr]", "")
+                            .replace("[arr]", "");
+                    }
+                    const converterFunction = converterFunctions[converterName];
+                    if (converterFunction) {
+                        if (Array.isArray(value) && !shouldProcessAsArray) {
+                            return value.map((item) => converterFunction(item));
+                        }
+                        else {
+                            return converterFunction(value);
+                        }
+                    }
+                    else {
+                        logger.warn(`Converter function '${converterName}' is not defined.`);
+                        return value;
+                    }
+                }, originalValue);
+            };
+            return schema;
+        }, {});
+        // Convert the item using the constructed schema
+        const convertedItem = convertObjectBySchema(item, conversionSchema);
+        // Merge the converted item back into the original item object
+        Object.assign(item, convertedItem);
+        return item;
+    }
+    /**
+     * Validates a single data item based on defined validation rules.
+     * @param item The data item to validate.
+     * @param attributeMap The attribute mappings for the data item.
+     * @param context The context for resolving templated parameters in validation rules.
+     * @returns A promise that resolves to true if the item is valid, false otherwise.
+     */
+    validateItem(item, attributeMap, context) {
+        for (const mapping of attributeMap) {
+            const { validationActions } = mapping;
+            if (!validationActions ||
+                !Array.isArray(validationActions) ||
+                !validationActions.length) {
+                return true; // Assume items without validation actions as valid.
+            }
+            for (const ruleDef of validationActions) {
+                const { action, params } = ruleDef;
+                const validationRule = validationRules[action];
+                if (!validationRule) {
+                    logger.warn(`Validation rule '${action}' is not defined.`);
+                    continue; // Optionally, consider undefined rules as a validation failure.
+                }
+                // Resolve templated parameters
+                const resolvedParams = params.map((param) => this.resolveTemplate(param, context, item));
+                // Apply the validation rule
+                let isValid = false;
+                if (Array.isArray(item)) {
+                    isValid = item.every((item) => validationRule(item, ...resolvedParams));
+                }
+                else {
+                    isValid = validationRule(item, ...resolvedParams);
+                }
+                if (!isValid) {
+                    logger.error(`Validation failed for rule '${action}' with params ${params.join(", ")}`);
+                    return false; // Stop validation on first failure
+                }
+            }
+        }
+        return true; // The item passed all validations
+    }
+    async executeAfterImportActions(item, attributeMap, context) {
+        for (const mapping of attributeMap) {
+            const { postImportActions } = mapping;
+            if (!postImportActions || !Array.isArray(postImportActions)) {
+                continue; // Skip to the next attribute if no actions are defined
+            }
+            for (const actionDef of postImportActions) {
+                const { action, params } = actionDef;
+                console.log(`Executing post-import action '${action}' for attribute '${mapping.targetKey}' with params ${params.join(", ")}...`);
+                try {
+                    await tryAwaitWithRetry(async () => await this.executeAction(action, params, context, item));
+                }
+                catch (error) {
+                    logger.error(`Failed to execute post-import action '${action}' for attribute '${mapping.targetKey}':`, error);
+                }
+            }
+        }
+    }
+    async executeAction(actionName, params, // Accepts any type, including objects
+    context, item) {
+        const actionMethod = afterImportActions[actionName];
+        if (typeof actionMethod === "function") {
+            try {
+                // Resolve parameters, handling both strings and objects
+                const resolvedParams = params.map((param) => {
+                    // Directly resolve each param, whether it's an object or a string
+                    return this.resolveTemplate(param, context, item);
+                });
+                // Execute the action with resolved parameters
+                // Parameters are passed as-is, with objects treated as single parameters
+                console.log(`Executing action '${actionName}' from context with params:`, resolvedParams);
+                logger.info(`Executing action '${actionName}' from context: ${JSON.stringify(context, null, 2)} with params:`, resolvedParams);
+                await actionMethod(this.config, ...resolvedParams);
+            }
+            catch (error) {
+                logger.error(`Error executing action '${actionName}' with context:`, context, error);
+                throw new Error(`Execution failed for action '${actionName}': ${error.message}`);
+            }
+        }
+        else {
+            logger.warn(`Action '${actionName}' is not defined.`);
+            throw new Error(`Action '${actionName}' is not defined.`);
+        }
+    }
+    /**
+     * Resolves a templated string or object using the provided context and current data item.
+     * If the template is a string that starts and ends with "{}", it replaces it with the corresponding value from item or context.
+     * If the template is an object, it recursively resolves its properties.
+     * @param template The templated string or object.
+     * @param context The context for resolving the template.
+     * @param item The current data item being processed.
+     */
+    resolveTemplate(template, context, item) {
+        // Function to recursively resolve paths, including handling [any] notation
+        const resolvePath = (path, currentContext) => {
+            const anyKeyRegex = /\[any\]/g;
+            let pathParts = path.split(".").filter(Boolean);
+            return pathParts.reduce((acc, part, index) => {
+                // Handle [any] part by iterating over all elements if it's an object or an array
+                if (part === "[any]") {
+                    if (Array.isArray(acc)) {
+                        return acc
+                            .map((item) => item[pathParts[index + 1]])
+                            .filter((item) => item !== undefined);
+                    }
+                    else if (typeof acc === "object") {
+                        return Object.values(acc)
+                            .map((item) => item[pathParts[index + 1]])
+                            .filter((item) => item !== undefined);
+                    }
+                }
+                else {
+                    return acc?.[part];
+                }
+            }, currentContext);
+        };
+        if (typeof template === "string") {
+            // Matches placeholders in the template
+            const regex = /\{([^}]+)\}/g;
+            let match;
+            let resolvedString = template;
+            while ((match = regex.exec(template)) !== null) {
+                const path = match[1];
+                // Resolve the path, handling [any] notation and arrays/objects
+                const resolvedValue = resolvePath(path, { ...context, ...item });
+                if (resolvedValue !== undefined) {
+                    // If it's an array (from [any] notation), join the values; adjust as needed
+                    const value = Array.isArray(resolvedValue)
+                        ? resolvedValue.join(", ")
+                        : resolvedValue;
+                    resolvedString = resolvedString.replace(match[0], value);
+                }
+                else {
+                    logger.warn(`Failed to resolve ${template} in context: `, JSON.stringify({ ...context, ...item }, null, 2));
+                }
+            }
+            // console.log(`Resolved string: ${resolvedString}`);
+            return resolvedString;
+        }
+        else if (typeof template === "object" && template !== null) {
+            // Recursively resolve templates for each property in the object
+            const resolvedObject = Array.isArray(template) ? [] : {};
+            for (const key in template) {
+                const resolvedValue = this.resolveTemplate(template[key], context, item);
+                if (resolvedValue !== undefined) {
+                    // Only assign if resolvedValue is not undefined
+                    resolvedObject[key] = resolvedValue;
+                }
+            }
+            return resolvedObject;
+        }
+        // console.log(`Template is not a string or object: ${template}`);
+        return template;
+    }
+}

package/dist/migrations/relationships.d.ts

@@ -0,0 +1,29 @@
+import { Databases } from "node-appwrite";
+import type { AppwriteConfig } from "@njdamstra/appwrite-utils";
+/**
+ * Finds collections that have defined relationship attributes.
+ */
+export declare const findCollectionsWithRelationships: (config: AppwriteConfig) => Map<string, {
+    key: string;
+    required: boolean;
+    type: "relationship";
+    relatedCollection: string;
+    relationType: "oneToMany" | "manyToOne" | "oneToOne" | "manyToMany";
+    twoWay: boolean;
+    onDelete: "setNull" | "cascade" | "restrict";
+    array?: boolean | undefined;
+    format?: string | undefined;
+    status?: string | undefined;
+    attributes?: string[] | undefined;
+    orders?: string[] | undefined;
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+    error?: string | undefined;
+    twoWayKey?: string | undefined;
+    side?: "parent" | "child" | undefined;
+    importMapping?: {
+        originalIdField: string;
+        targetField?: string | undefined;
+    } | undefined;
+}[]>;
+export declare function resolveAndUpdateRelationships(dbId: string, database: Databases, config: AppwriteConfig): Promise<void>;