appwrite-utils-cli 0.0.285 → 0.9.0

package/README.md

@@ -1,96 +1,122 @@
-# appwrite-utils-cli
-
-## Overview
-
-`appwrite-utils-cli` is a powerful command-line interface tool designed for Appwrite developers who need to manage database migrations, schema generation, data import, and much more. This CLI tool facilitates complex tasks like setting up databases, running migrations, generating schemas, and managing backups efficiently, making it an indispensable part of your Appwrite project management.
-
-## Features
-
-- **Easy Configuration**: Initialize your Appwrite project configurations interactively directly from the command line.
-- **Database Migrations**: Control the migration process with options to target production, staging, or development environments.
-- **Schema Generation**: Generate and manage TypeScript schemas directly from your Appwrite database schemas.
-- **Data Import**: Facilitate the import of data into your Appwrite databases with comprehensive command-line support.
-- **Backup Management**: Create backups of your Appwrite databases to ensure data integrity and safety.
-- **Flexible Database Management**: Includes commands to wipe databases, documents, or user data, providing flexibility in managing your database state during development or testing.
-
-## Installation
-
-To use `appwrite-utils-cli`, you can install it globally via npm to make it accessible from anywhere in your command line:
-
-```bash
-npm install -g appwrite-utils-cli
-```
-
-However, due to the nature of the speed at which I am developing this project, I would recommend the following command:
-
-```bash
-npx --package=appwrite-utils-cli@latest appwrite-migrate --arg1 --arg2 --arg3
-```
-
-**DO NOT INSTALL THIS LOCALLY INTO YOUR PROJECT, IT IS MEANT TO BE USED AS A COMMAND LINE TOOL ONLY**
-
-## Usage
-
-After installation, you can access the tool directly from your command line using the provided commands. Here's how you can use the different functionalities:
-
-### Initialization
-
-Interactively set up your Appwrite project with necessary configurations:
-
-```bash
-npx --package=appwrite-utils-cli@latest appwrite-init
-```
-
-### Running Migrations and Tasks
-
-Run migration and management tasks with specific flags according to your needs:
-
-```bash
-npx --package=appwrite-utils-cli@latest appwrite-migrate --args
-```
-
-Replace `--args` with the appropriate options:
-
-- `--prod`: Run tasks in the production environment.
-- `--staging`: Run tasks in the staging environment.
-- `--dev`: Run tasks in the development environment.
-- `--wipe`: Wipe all databases.
-- `--wipe-docs` or `--wipeDocs`: Wipe all documents in the databases.
-- `--generate`: Generate TypeScript schemas from database schemas.
-- `--import`: Import data into your databases.
-- `--backup`: Perform a backup of your databases.
-- `--wipe-users` or `--wipeUsers`: Wipe all user data.
-- `--write-data` or `--writeData`: Write converted imported data to file
-- `--sync`: Synchronize your project's config and generate schema for your database
-- `--endpoint`: Set a different endpoint for the migration target
-- `--project`: Set a different project ID for the migration target
-- `--key`: Set a different API key for the migration target
-
-### OpenAPI Generation (almost done, in progress)
-
-Recently, I have also added an optional OpenAPI generation for each attribute in the schema. This is because I needed it and because I felt it would be nice to have. This is done using [this package](https://github.com/asteasolutions/zod-to-openapi), many thanks to them.
-
-To use it, add a `description` to any attribute or collection, and it will export that schema to the `appwrite/openapi` folder
-
-This setup ensures that developers have robust tools at their fingertips to manage complex Appwrite projects effectively from the command line. I also have added logging automatically for information and errors as the console can be hard to keep up with.
-
-### Roadmap
-
-- Syncing configuration (DONE)
-- Better file format for config (potentially)
-- Separation of collections and import configuration from main config
-
-### Changelog
-
-- 0.0.275: THINGS ARE NOW IN TYPESCRIPT WOOHOO. No but for reaal, super happy to report that everything has been converted to TypeScript, just way too many changes, I hope you enjoy it!
-- 0.0.274: Small improvement for attribute handling, rather than getting it every attribute, I check the collections attributes
-- 0.0.273: Small fix for relationship attribute comparisons
-- 0.0.272: That's what I get for not testing lmao, also updated logic for checking for existing attributes to take the `format` into consideration from the database (URL's are not of `type: "url"`, they are of `format: "url"`)
-- 0.0.271: Small change to update attributes that are different from each other by deleting the attribute and recreating, as we cannot update most things
-- 0.0.270: Fixed enums in `--sync`, added optional OpenAPI generation (in progress, almost done, but wanted to push other changes), added `--endpoint`, `--project`, `--key` as optional parameters to change the target destination (shoutout to [pingu24k](https://github.com/pingu2k4) for pointing out these bugs and suggesting those changes for endpoint customization)
-- 0.0.254: Added `--sync` to synchronize your Appwrite instance with your local `appwriteConfig.yaml` and generate schemas
-- 0.0.253: Added `--writeData` (or `--write-data`) to command to write the output of the import data to a file called dataLoaderOutput in your root dir
-- 0.0.23: Added batching to user deletion
-- 0.0.22: Converted all import processes except `postImportActions` and Relationship Resolution to the local data import, so it should be much faster.
-- 0.0.6: Added `setTargetFieldFromOtherCollectionDocumentsByMatchingField` for the below, but setting a different field than the field you matched. The names are long, but at least you know what's going on lmao.
-- 0.0.5: Added `setFieldFromOtherCollectionDocuments` to set an array of ID's for instance from another collection as a `postImportAction`
+# appwrite-utils-cli
+
+## Overview
+
+`appwrite-utils-cli` is a powerful command-line interface tool designed for Appwrite developers who need to manage database migrations, schema generation, data import, and much more. This CLI tool facilitates complex tasks like setting up databases, running migrations, generating schemas, and managing backups efficiently, making it an indispensable part of your Appwrite project management.
+
+## Features
+
+- **Interactive Mode**: Run the CLI in interactive mode for a guided experience through all available options.
+- **Easy Configuration**: Initialize your Appwrite project configurations interactively directly from the command line.
+- **Database Migrations**: Control the migration process with options to target specific databases and collections.
+- **Schema Generation**: Generate and manage TypeScript schemas directly from your Appwrite database schemas.
+- **Data Import**: Facilitate the import of data into your Appwrite databases with comprehensive command-line support.
+- **Backup Management**: Create backups of your Appwrite databases to ensure data integrity and safety.
+- **Flexible Database Management**: Includes commands to wipe databases, documents, or user data, providing flexibility in managing your database state during development or testing.
+- **Data Transfer**: Transfer data between databases, collections, and even between local and remote Appwrite instances.
+- **Configuration Synchronization**: Sync your local Appwrite configuration with your remote Appwrite project.
+
+## Installation
+
+To use `appwrite-utils-cli`, you can install it globally via npm to make it accessible from anywhere in your command line:
+
+```bash
+npm install -g appwrite-utils-cli
+```
+
+However, due to the rapid development of this project, it's recommended to use the following command:
+
+```bash
+npx --package=appwrite-utils-cli@latest appwrite-migrate [options]
+```
+
+**Note: Do not install this locally into your project. It is meant to be used as a command-line tool only.**
+
+## Usage
+
+After installation, you can access the tool directly from your command line using the provided commands.
+
+### Interactive Mode
+
+Run the CLI in interactive mode:
+
+```bash
+npx --package=appwrite-utils-cli@latest appwrite-migrate --it
+```
+
+This will guide you through all available options interactively.
+
+### Non-Interactive Mode
+
+You can also use specific flags to run tasks without the interactive prompt:
+
+```bash
+npx --package=appwrite-utils-cli@latest appwrite-migrate [options]
+```
+
+Available options:
+
+- `--it`: Run in interactive mode
+- `--dbIds`: Comma-separated list of database IDs to operate on
+- `--collectionIds`: Comma-separated list of collection IDs to operate on
+- `--bucketIds`: Comma-separated list of bucket IDs to operate on
+- `--wipe`: Wipe data (all: everything, docs: only documents, users: only user data)
+- `--generate`: Generate TypeScript schemas from database schemas
+- `--import`: Import data into your databases
+- `--backup`: Perform a backup of your databases
+- `--writeData`: Write converted imported data to file
+- `--push`: Push your local Appwrite config to your configured Appwrite Project
+- `--sync`: Synchronize by pulling your Appwrite config from your configured Appwrite Project
+- `--endpoint`: Set the Appwrite endpoint
+- `--projectId`: Set the Appwrite project ID
+- `--apiKey`: Set the Appwrite API key
+- `--transfer`: Transfer data between databases or collections
+- `--fromDbId`: Set the source database ID for transfer
+- `--toDbId`: Set the destination database ID for transfer
+- `--fromCollectionId`: Set the source collection ID for transfer
+- `--toCollectionId`: Set the destination collection ID for transfer
+- `--fromBucketId`: Set the source bucket ID for transfer
+- `--toBucketId`: Set the destination bucket ID for transfer
+- `--remoteEndpoint`: Set the remote Appwrite endpoint for transfers
+- `--remoteProjectId`: Set the remote Appwrite project ID for transfers
+- `--remoteApiKey`: Set the remote Appwrite API key for transfers
+
+## Examples
+
+### Transfer Databases
+
+Transfer databases within the same project or from a local to a remote project:
+
+```bash
+npx appwrite-utils-cli appwrite-migrate --transfer --fromDbId sourceDbId --toDbId targetDbId --remoteEndpoint https://appwrite.otherserver.com --remoteProjectId yourProjectId --remoteApiKey yourApiKey
+```
+
+### Transfer Specific Collections
+
+Transfer specific collections from one place to another, with all of their data:
+
+```bash
+npx appwrite-utils-cli appwrite-migrate --transfer --fromDbId sourceDbId --toDbId targetDbId --fromCollectionId sourceCollectionId --toCollectionId targetCollectionId --remoteEndpoint https://appwrite.otherserver.com --remoteProjectId yourProjectId --remoteApiKey yourApiKey
+```
+
+### Transfer Buckets
+
+Transfer files between buckets:
+
+```bash
+npx appwrite-utils-cli appwrite-migrate --transfer --fromBucketId sourceBucketId --toBucketId targetBucketId --remoteEndpoint https://appwrite.otherserver.com --remoteProjectId yourProjectId --remoteApiKey yourApiKey
+```
+
+## Additional Notes
+
+- If you run out of RAM during large data imports, you can increase Node's memory allocation:
+
+  ```bash
+  export NODE_OPTIONS="--max-old-space-size=16384"
+  ```
+
+  This sets the allocation to 16GB. For most cases, 8GB (`8192`) should be sufficient.
+
+- The CLI now supports OpenAPI generation for each attribute in the schema. Add a `description` to any attribute or collection, and it will export that schema to the `appwrite/openapi` folder.
+
+This updated CLI ensures that developers have robust tools at their fingertips to manage complex Appwrite projects effectively from the command line, with both interactive and non-interactive modes available for flexibility.

package/dist/collections/attributes.d.ts

@@ -0,0 +1,4 @@
+import { type Databases, type Models } from "node-appwrite";
+import { type Attribute } from "appwrite-utils";
+export declare const createOrUpdateAttribute: (db: Databases, dbId: string, collection: Models.Collection, attribute: Attribute) => Promise<void>;
+export declare const createUpdateCollectionAttributes: (db: Databases, dbId: string, collection: Models.Collection, attributes: Attribute[]) => Promise<void>;

package/dist/collections/attributes.js

@@ -0,0 +1,224 @@
+import { Query } from "node-appwrite";
+import { attributeSchema, parseAttribute, } from "appwrite-utils";
+import { nameToIdMapping, enqueueOperation } from "../migrations/queue.js";
+import _ from "lodash";
+import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+const attributesSame = (databaseAttribute, configAttribute) => {
+    return (databaseAttribute.key == configAttribute.key &&
+        databaseAttribute.type == configAttribute.type &&
+        databaseAttribute.array == configAttribute.array);
+};
+export const createOrUpdateAttribute = async (db, dbId, collection, attribute) => {
+    let action = "create";
+    let foundAttribute;
+    const updateEnabled = false;
+    let finalAttribute = attribute;
+    try {
+        const collectionAttr = collection.attributes.find(
+        // @ts-expect-error
+        (attr) => attr.key === attribute.key);
+        foundAttribute = parseAttribute(collectionAttr);
+    }
+    catch (error) {
+        foundAttribute = undefined;
+    }
+    if (foundAttribute &&
+        attributesSame(foundAttribute, attribute) &&
+        updateEnabled) {
+        // Check if mutable properties have changed and set action to "update" if necessary
+        const requiredChanged = "required" in foundAttribute && "required" in attribute
+            ? foundAttribute.required !== attribute.required
+            : false;
+        // const xdefaultChanged =
+        //   "xdefault" in foundAttribute && "xdefault" in attribute
+        //     ? foundAttribute.xdefault !== attribute.xdefault
+        //     : false;
+        const onDeleteChanged = foundAttribute.type === "relationship" &&
+            attribute.type === "relationship" &&
+            "onDelete" in foundAttribute &&
+            "onDelete" in attribute
+            ? foundAttribute.onDelete !== attribute.onDelete
+            : false;
+        if (requiredChanged || onDeleteChanged) {
+            console.log(`Required changed: ${requiredChanged}\nOnDelete changed: ${onDeleteChanged}`);
+            console.log(`Found attribute: ${JSON.stringify(foundAttribute, null, 2)}`);
+            console.log(`Attribute: ${JSON.stringify(attribute, null, 2)}`);
+            finalAttribute = {
+                ...attribute,
+                ...foundAttribute,
+            };
+            action = "update";
+        }
+        else {
+            // If no properties that can be updated have changed, return early
+            return;
+        }
+    }
+    else if (foundAttribute &&
+        !attributesSame(foundAttribute, attribute) &&
+        updateEnabled) {
+        console.log(`Deleting attribute with same key ${attribute.key} -- but different values -- ${JSON.stringify(attribute, null, 2)} -- ${JSON.stringify(foundAttribute, null, 2)}`);
+        await db.deleteAttribute(dbId, collection.$id, attribute.key);
+        // After deletion, you might want to create the attribute anew
+        finalAttribute = attribute;
+        action = "create";
+    }
+    else if (!updateEnabled && foundAttribute) {
+        return;
+    }
+    // Relationship attribute logic with adjustments
+    let collectionFoundViaRelatedCollection;
+    let relatedCollectionId;
+    if (finalAttribute.type === "relationship") {
+        if (nameToIdMapping.has(finalAttribute.relatedCollection)) {
+            relatedCollectionId = nameToIdMapping.get(finalAttribute.relatedCollection);
+            try {
+                collectionFoundViaRelatedCollection = await db.getCollection(dbId, relatedCollectionId);
+            }
+            catch (e) {
+                console.log(`Collection not found: ${finalAttribute.relatedCollection} when nameToIdMapping was set`);
+                collectionFoundViaRelatedCollection = undefined;
+            }
+        }
+        else {
+            const collectionsPulled = await db.listCollections(dbId, [
+                Query.equal("name", finalAttribute.relatedCollection),
+            ]);
+            if (collectionsPulled.total > 0) {
+                collectionFoundViaRelatedCollection = collectionsPulled.collections[0];
+                relatedCollectionId = collectionFoundViaRelatedCollection.$id;
+                nameToIdMapping.set(finalAttribute.relatedCollection, relatedCollectionId);
+            }
+        }
+        if (!(relatedCollectionId && collectionFoundViaRelatedCollection)) {
+            console.log(`Enqueueing operation for attribute: ${finalAttribute.key}`);
+            enqueueOperation({
+                type: "attribute",
+                collectionId: collection.$id,
+                collection: collection,
+                attribute,
+                dependencies: [finalAttribute.relatedCollection],
+            });
+            return;
+        }
+    }
+    finalAttribute = attributeSchema.parse(finalAttribute);
+    switch (finalAttribute.type) {
+        case "string":
+            if (action === "create") {
+                await tryAwaitWithRetry(async () => await db.createStringAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.size, finalAttribute.required || false, finalAttribute.xdefault || undefined, finalAttribute.array || false, finalAttribute.encrypted));
+            }
+            else {
+                await tryAwaitWithRetry(async () => await db.updateStringAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || undefined));
+            }
+            break;
+        case "integer":
+            if (action === "create") {
+                if (finalAttribute.min &&
+                    BigInt(finalAttribute.min) === BigInt(-9223372036854776000)) {
+                    delete finalAttribute.min;
+                }
+                if (finalAttribute.max &&
+                    BigInt(finalAttribute.max) === BigInt(9223372036854776000)) {
+                    delete finalAttribute.max;
+                }
+                await tryAwaitWithRetry(async () => await db.createIntegerAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.min, finalAttribute.max, finalAttribute.xdefault || undefined, finalAttribute.array));
+            }
+            else {
+                if (finalAttribute.min &&
+                    BigInt(finalAttribute.min) === BigInt(-9223372036854776000)) {
+                    delete finalAttribute.min;
+                }
+                if (finalAttribute.max &&
+                    BigInt(finalAttribute.max) === BigInt(9223372036854776000)) {
+                    delete finalAttribute.max;
+                }
+                await tryAwaitWithRetry(async () => await db.updateIntegerAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.min || 0, finalAttribute.max || 2147483647, finalAttribute.xdefault || undefined));
+            }
+            break;
+        case "float":
+            if (action === "create") {
+                await tryAwaitWithRetry(async () => await db.createFloatAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.min, finalAttribute.max, finalAttribute.xdefault || undefined, finalAttribute.array));
+            }
+            else {
+                await tryAwaitWithRetry(async () => await db.updateFloatAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.min || 0, finalAttribute.max || 2147483647, finalAttribute.xdefault || undefined));
+            }
+            break;
+        case "boolean":
+            if (action === "create") {
+                await tryAwaitWithRetry(async () => await db.createBooleanAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || undefined, finalAttribute.array));
+            }
+            else {
+                await tryAwaitWithRetry(async () => await db.updateBooleanAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || null));
+            }
+            break;
+        case "datetime":
+            if (action === "create") {
+                await tryAwaitWithRetry(async () => await db.createDatetimeAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || undefined, finalAttribute.array));
+            }
+            else {
+                await tryAwaitWithRetry(async () => await db.updateDatetimeAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || undefined));
+            }
+            break;
+        case "email":
+            if (action === "create") {
+                await tryAwaitWithRetry(async () => await db.createEmailAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || undefined, finalAttribute.array));
+            }
+            else {
+                await tryAwaitWithRetry(async () => await db.updateEmailAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || undefined));
+            }
+            break;
+        case "ip":
+            if (action === "create") {
+                await tryAwaitWithRetry(async () => await db.createIpAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || undefined, finalAttribute.array));
+            }
+            else {
+                await tryAwaitWithRetry(async () => await db.updateIpAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || undefined));
+            }
+            break;
+        case "url":
+            if (action === "create") {
+                await tryAwaitWithRetry(async () => await db.createUrlAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || undefined, finalAttribute.array));
+            }
+            else {
+                await tryAwaitWithRetry(async () => await db.updateUrlAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || undefined));
+            }
+            break;
+        case "enum":
+            if (action === "create") {
+                await tryAwaitWithRetry(async () => await db.createEnumAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.elements, finalAttribute.required || false, finalAttribute.xdefault || undefined, finalAttribute.array));
+            }
+            else {
+                await tryAwaitWithRetry(async () => await db.updateEnumAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.elements, finalAttribute.required || false, finalAttribute.xdefault || undefined));
+            }
+            break;
+        case "relationship":
+            if (action === "create") {
+                await tryAwaitWithRetry(async () => await db.createRelationshipAttribute(dbId, collection.$id, relatedCollectionId, finalAttribute.relationType, finalAttribute.twoWay, finalAttribute.key, finalAttribute.twoWayKey, finalAttribute.onDelete));
+            }
+            else {
+                await tryAwaitWithRetry(async () => await db.updateRelationshipAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.onDelete));
+            }
+            break;
+        default:
+            console.error("Invalid attribute type");
+            break;
+    }
+};
+export const createUpdateCollectionAttributes = async (db, dbId, collection, attributes) => {
+    console.log(`Creating/Updating attributes for collection: ${collection.name}`);
+    const batchSize = 3; // Size of each batch
+    for (let i = 0; i < attributes.length; i += batchSize) {
+        // Slice the attributes array to get a batch of at most batchSize elements
+        const batch = attributes.slice(i, i + batchSize);
+        const attributePromises = batch.map((attribute) => createOrUpdateAttribute(db, dbId, collection, attribute));
+        // Await the completion of all promises in the current batch
+        const results = await Promise.allSettled(attributePromises);
+        results.forEach((result) => {
+            if (result.status === "rejected") {
+                console.error("An attribute promise was rejected:", result.reason);
+            }
+        });
+    }
+    console.log(`Finished creating/updating attributes for collection: ${collection.name}`);
+};

package/dist/collections/indexes.d.ts

@@ -0,0 +1,4 @@
+import { type Index } from "appwrite-utils";
+import { Databases, type Models } from "node-appwrite";
+export declare const createOrUpdateIndex: (dbId: string, db: Databases, collectionId: string, index: Index) => Promise<Models.Index | null>;
+export declare const createOrUpdateIndexes: (dbId: string, db: Databases, collectionId: string, indexes: Index[]) => Promise<void>;

package/dist/collections/indexes.js

@@ -0,0 +1,27 @@
+import { indexSchema } from "appwrite-utils";
+import { Databases, IndexType, Query } from "node-appwrite";
+import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+export const createOrUpdateIndex = async (dbId, db, collectionId, index) => {
+    const existingIndex = await db.listIndexes(dbId, collectionId, [
+        Query.equal("key", index.key),
+    ]);
+    let createIndex = false;
+    let newIndex = null;
+    if (existingIndex.total > 0 &&
+        existingIndex.indexes.some((index) => (index.key === index.key &&
+            index.type === index.type &&
+            index.attributes === index.attributes) ||
+            JSON.stringify(index) === JSON.stringify(index))) {
+        await db.deleteIndex(dbId, collectionId, existingIndex.indexes[0].key);
+        createIndex = true;
+    }
+    if (createIndex) {
+        newIndex = await db.createIndex(dbId, collectionId, index.key, index.type, index.attributes, index.orders);
+    }
+    return newIndex;
+};
+export const createOrUpdateIndexes = async (dbId, db, collectionId, indexes) => {
+    for (const index of indexes) {
+        await tryAwaitWithRetry(async () => await createOrUpdateIndex(dbId, db, collectionId, index));
+    }
+};

package/dist/collections/methods.d.ts

@@ -0,0 +1,16 @@
+import { Databases, type Models } from "node-appwrite";
+import type { AppwriteConfig, CollectionCreate } from "appwrite-utils";
+export declare const documentExists: (db: Databases, dbId: string, targetCollectionId: string, toCreateObject: any) => Promise<Models.Document | null>;
+export declare const checkForCollection: (db: Databases, dbId: string, collection: Partial<CollectionCreate>) => Promise<Models.Collection | null>;
+export declare const fetchAndCacheCollectionByName: (db: Databases, dbId: string, collectionName: string) => Promise<Models.Collection | undefined>;
+export declare const wipeDatabase: (database: Databases, databaseId: string) => Promise<{
+    collectionId: string;
+    collectionName: string;
+}[]>;
+export declare const generateSchemas: (config: AppwriteConfig, appwriteFolderPath: string) => Promise<void>;
+export declare const createOrUpdateCollections: (database: Databases, databaseId: string, config: AppwriteConfig, deletedCollections?: {
+    collectionId: string;
+    collectionName: string;
+}[]) => Promise<void>;
+export declare const generateMockData: (database: Databases, databaseId: string, configCollections: any[]) => Promise<void>;
+export declare const fetchAllCollections: (dbId: string, database: Databases) => Promise<Models.Collection[]>;