appwrite-utils-cli 0.0.286 → 0.9.2

package/dist/collections/methods.js

@@ -0,0 +1,216 @@
+import { Client, Databases, ID, Permission, Query, } from "node-appwrite";
+import { nameToIdMapping, processQueue } from "../migrations/queue.js";
+import { createUpdateCollectionAttributes } from "./attributes.js";
+import { createOrUpdateIndexes } from "./indexes.js";
+import _ from "lodash";
+import { SchemaGenerator } from "../utils/schemaStrings.js";
+import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+export const documentExists = async (db, dbId, targetCollectionId, toCreateObject) => {
+    // Had to do this because kept running into issues with type checking arrays so, sorry 40ms
+    const collection = await db.getCollection(dbId, targetCollectionId);
+    const attributes = collection.attributes;
+    let arrayTypeAttributes = attributes
+        .filter((attribute) => attribute.array === true)
+        .map((attribute) => attribute.key);
+    // Function to check if a string is JSON
+    const isJsonString = (str) => {
+        try {
+            const json = JSON.parse(str);
+            return typeof json === "object" && json !== null; // Check if parsed JSON is an object or array
+        }
+        catch (e) {
+            return false;
+        }
+    };
+    // Validate and prepare query parameters
+    const validQueryParams = _.chain(toCreateObject)
+        .pickBy((value, key) => !arrayTypeAttributes.includes(key) &&
+        !key.startsWith("$") &&
+        !_.isNull(value) &&
+        !_.isUndefined(value) &&
+        !_.isEmpty(value) &&
+        !_.isObject(value) && // Keeps excluding objects
+        !_.isArray(value) && // Explicitly exclude arrays
+        !(_.isString(value) && isJsonString(value)) && // Exclude JSON strings
+        (_.isString(value) ? value.length < 4096 && value.length > 0 : true) // String length check
+    )
+        .mapValues((value, key) => _.isString(value) || _.isNumber(value) || _.isBoolean(value)
+        ? value
+        : null)
+        .omitBy(_.isNull) // Remove any null values that might have been added in mapValues
+        .toPairs()
+        .slice(0, 25) // Limit to 25 to adhere to query limit
+        .map(([key, value]) => Query.equal(key, value))
+        .value();
+    // Execute the query with the validated and prepared parameters
+    const result = await db.listDocuments(dbId, targetCollectionId, validQueryParams);
+    return result.documents[0] || null;
+};
+export const checkForCollection = async (db, dbId, collection) => {
+    try {
+        console.log(`Checking for collection with name: ${collection.name}`);
+        const response = await tryAwaitWithRetry(async () => await db.listCollections(dbId, [Query.equal("name", collection.name)]));
+        if (response.collections.length > 0) {
+            console.log(`Collection found: ${response.collections[0].$id}`);
+            return { ...collection, ...response.collections[0] };
+        }
+        else {
+            console.log(`No collection found with name: ${collection.name}`);
+            return null;
+        }
+    }
+    catch (error) {
+        console.error(`Error checking for collection: ${error}`);
+        return null;
+    }
+};
+// Helper function to fetch and cache collection by name
+export const fetchAndCacheCollectionByName = async (db, dbId, collectionName) => {
+    if (nameToIdMapping.has(collectionName)) {
+        const collectionId = nameToIdMapping.get(collectionName);
+        console.log(`\tCollection found in cache: ${collectionId}`);
+        return await tryAwaitWithRetry(async () => await db.getCollection(dbId, collectionId));
+    }
+    else {
+        console.log(`\tFetching collection by name: ${collectionName}`);
+        const collectionsPulled = await tryAwaitWithRetry(async () => await db.listCollections(dbId, [Query.equal("name", collectionName)]));
+        if (collectionsPulled.total > 0) {
+            const collection = collectionsPulled.collections[0];
+            console.log(`\tCollection found: ${collection.$id}`);
+            nameToIdMapping.set(collectionName, collection.$id);
+            return collection;
+        }
+        else {
+            console.log(`\tCollection not found by name: ${collectionName}`);
+            return undefined;
+        }
+    }
+};
+export const wipeDatabase = async (database, databaseId) => {
+    console.log(`Wiping database: ${databaseId}`);
+    const existingCollections = await fetchAllCollections(databaseId, database);
+    let collectionsDeleted = [];
+    for (const { $id: collectionId, name: name } of existingCollections) {
+        console.log(`Deleting collection: ${collectionId}`);
+        collectionsDeleted.push({
+            collectionId: collectionId,
+            collectionName: name,
+        });
+        tryAwaitWithRetry(async () => await database.deleteCollection(databaseId, collectionId)); // Try to delete the collection and ignore errors if it doesn't exist or if it's already being deleted
+    }
+    return collectionsDeleted;
+};
+export const generateSchemas = async (config, appwriteFolderPath) => {
+    const schemaGenerator = new SchemaGenerator(config, appwriteFolderPath);
+    schemaGenerator.generateSchemas();
+};
+export const createOrUpdateCollections = async (database, databaseId, config, deletedCollections) => {
+    const configCollections = config.collections;
+    if (!configCollections) {
+        return;
+    }
+    const usedIds = new Set(); // To track IDs used in this operation
+    for (const { attributes, indexes, ...collection } of configCollections) {
+        // Prepare permissions for the collection
+        const permissions = [];
+        if (collection.$permissions && collection.$permissions.length > 0) {
+            for (const permission of collection.$permissions) {
+                switch (permission.permission) {
+                    case "read":
+                        permissions.push(Permission.read(permission.target));
+                        break;
+                    case "create":
+                        permissions.push(Permission.create(permission.target));
+                        break;
+                    case "update":
+                        permissions.push(Permission.update(permission.target));
+                        break;
+                    case "delete":
+                        permissions.push(Permission.delete(permission.target));
+                        break;
+                    case "write":
+                        permissions.push(Permission.write(permission.target));
+                        break;
+                    default:
+                        console.log(`Unknown permission: ${permission.permission}`);
+                        break;
+                }
+            }
+        }
+        // Check if the collection already exists by name
+        let collectionsFound = await tryAwaitWithRetry(async () => await database.listCollections(databaseId, [
+            Query.equal("name", collection.name),
+        ]));
+        let collectionToUse = collectionsFound.total > 0 ? collectionsFound.collections[0] : null;
+        // Determine the correct ID for the collection
+        let collectionId;
+        if (!collectionToUse) {
+            console.log(`Creating collection: ${collection.name}`);
+            let foundColl = deletedCollections?.find((coll) => coll.collectionName.toLowerCase().trim().replace(" ", "") ===
+                collection.name.toLowerCase().trim().replace(" ", ""));
+            if (collection.$id) {
+                collectionId = collection.$id; // Always use the provided $id if present
+            }
+            else if (foundColl && !usedIds.has(foundColl.collectionId)) {
+                collectionId = foundColl.collectionId; // Use ID from deleted collection if not already used
+            }
+            else {
+                collectionId = ID.unique(); // Generate a new unique ID
+            }
+            usedIds.add(collectionId); // Mark this ID as used
+            // Create the collection with the determined ID
+            try {
+                collectionToUse = await tryAwaitWithRetry(async () => await database.createCollection(databaseId, collectionId, collection.name, permissions, collection.documentSecurity ?? false, collection.enabled ?? true));
+                collection.$id = collectionToUse.$id;
+                nameToIdMapping.set(collection.name, collectionToUse.$id);
+            }
+            catch (error) {
+                console.error(`Failed to create collection ${collection.name} with ID ${collectionId}: ${error}`);
+                continue; // Skip to the next collection on failure
+            }
+        }
+        else {
+            console.log(`Collection ${collection.name} exists, updating it`);
+            await tryAwaitWithRetry(async () => await database.updateCollection(databaseId, collectionToUse.$id, collection.name, permissions, collection.documentSecurity ?? false, collection.enabled ?? true));
+        }
+        // Update attributes and indexes for the collection
+        console.log("Creating Attributes");
+        await createUpdateCollectionAttributes(database, databaseId, collectionToUse, attributes);
+        console.log("Creating Indexes");
+        await createOrUpdateIndexes(databaseId, database, collectionToUse.$id, indexes ?? []);
+    }
+    // Process any remaining tasks in the queue
+    await processQueue(database, databaseId);
+};
+export const generateMockData = async (database, databaseId, configCollections) => {
+    for (const { collection, mockFunction } of configCollections) {
+        if (mockFunction) {
+            console.log(`Generating mock data for collection: ${collection.name}`);
+            const mockData = mockFunction();
+            for (const data of mockData) {
+                await database.createDocument(databaseId, collection.$id, ID.unique(), data);
+            }
+        }
+    }
+};
+export const fetchAllCollections = async (dbId, database) => {
+    console.log(`Fetching all collections for database ID: ${dbId}`);
+    let collections = [];
+    let moreCollections = true;
+    let lastCollectionId;
+    while (moreCollections) {
+        const queries = [Query.limit(500)];
+        if (lastCollectionId) {
+            queries.push(Query.cursorAfter(lastCollectionId));
+        }
+        const response = await tryAwaitWithRetry(async () => await database.listCollections(dbId, queries));
+        collections = collections.concat(response.collections);
+        moreCollections = response.collections.length === 500;
+        if (moreCollections) {
+            lastCollectionId =
+                response.collections[response.collections.length - 1].$id;
+        }
+    }
+    console.log(`Fetched a total of ${collections.length} collections.`);
+    return collections;
+};

package/dist/databases/methods.d.ts

@@ -0,0 +1,6 @@
+import { Databases, type Models } from "node-appwrite";
+export declare const fetchAllDatabases: (database: Databases) => Promise<Models.Database[]>;
+export declare const wipeDatabase: (database: Databases, databaseId: string) => Promise<{
+    collectionId: string;
+    collectionName: string;
+}[]>;

package/dist/databases/methods.js

@@ -0,0 +1,33 @@
+import { Databases, Query } from "node-appwrite";
+import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { fetchAllCollections } from "../collections/methods.js";
+export const fetchAllDatabases = async (database) => {
+    const databases = await tryAwaitWithRetry(async () => await database.list([Query.limit(25)]));
+    const allDatabases = databases.databases;
+    if (allDatabases.length === 0)
+        return [];
+    let lastDatabaseId = allDatabases[allDatabases.length - 1].$id;
+    while (databases.databases.length === 25) {
+        const moreDatabases = await database.list([
+            Query.limit(25),
+            Query.cursorAfter(lastDatabaseId),
+        ]);
+        allDatabases.push(...moreDatabases.databases);
+        if (moreDatabases.databases.length < 25)
+            break;
+        lastDatabaseId =
+            moreDatabases.databases[moreDatabases.databases.length - 1].$id;
+    }
+    return allDatabases;
+};
+export const wipeDatabase = async (database, databaseId) => {
+    console.log(`Wiping database: ${databaseId}`);
+    const existingCollections = await fetchAllCollections(databaseId, database);
+    let collectionsDeleted = [];
+    for (const { $id: collectionId, name } of existingCollections) {
+        console.log(`Deleting collection: ${collectionId}`);
+        collectionsDeleted.push({ collectionId, collectionName: name });
+        await tryAwaitWithRetry(async () => await database.deleteCollection(databaseId, collectionId));
+    }
+    return collectionsDeleted;
+};

package/dist/interactiveCLI.d.ts

@@ -0,0 +1,19 @@
+import { UtilsController } from "./utilsController.js";
+export declare class InteractiveCLI {
+    private controller;
+    constructor(currentDir?: string, utilsController?: UtilsController);
+    run(): Promise<void>;
+    private selectDatabases;
+    private selectCollections;
+    private selectBuckets;
+    private createCollectionConfig;
+    private configureBuckets;
+    private createNewBucket;
+    private syncDb;
+    private synchronizeConfigurations;
+    private backupDatabase;
+    private wipeDatabase;
+    private generateSchemas;
+    private importData;
+    private transferData;
+}