appwrite-utils-cli 1.3.4 → 1.4.0

package/dist/migrations/backup.js

@@ -1,175 +0,0 @@
-import { z } from "zod";
-import { attributeSchema, parseAttribute, CollectionCreateSchema, } from "appwrite-utils";
-export const BackupSchema = z.object({
-    $id: z.string(),
-    $createdAt: z.string(),
-    $updatedAt: z.string(),
-    database: z.string(),
-    collections: z.array(z.string()),
-    documents: z
-        .array(z.object({
-        collectionId: z.string(),
-        data: z.string(),
-    }))
-        .default([]),
-});
-export const BackupCreateSchema = BackupSchema.omit({
-    $id: true,
-    $createdAt: true,
-    $updatedAt: true,
-});
-export const BatchSchema = z.object({
-    $id: z.string(),
-    $createdAt: z.string(),
-    $updatedAt: z.string(),
-    data: z.string().describe("The serialized data for this batch"),
-    processed: z
-        .boolean()
-        .default(false)
-        .describe("Whether the batch has been processed"),
-});
-export const BatchCreateSchema = BatchSchema.omit({
-    $id: true,
-    $createdAt: true,
-    $updatedAt: true,
-});
-export const OperationSchema = z.object({
-    $id: z.string(),
-    $createdAt: z.string(),
-    $updatedAt: z.string(),
-    operationType: z.string(),
-    collectionId: z.string(),
-    data: z.any(),
-    batches: z.array(z.string()).default([]).optional(),
-    progress: z.number(),
-    total: z.number(),
-    error: z.string(),
-    status: z
-        .enum([
-        "pending",
-        "ready",
-        "in_progress",
-        "completed",
-        "error",
-        "cancelled",
-    ])
-        .default("pending"),
-});
-export const OperationCreateSchema = OperationSchema.omit({
-    $id: true,
-    $createdAt: true,
-    $updatedAt: true,
-});
-export const getMigrationCollectionSchemas = () => {
-    const currentOperationsAttributes = [
-        parseAttribute({
-            key: "operationType",
-            type: "string",
-            error: "Invalid Operation Type",
-            size: 50,
-            required: true,
-            array: false,
-            xdefault: null,
-        }),
-        attributeSchema.parse({
-            key: "collectionId",
-            type: "string",
-            error: "Invalid Collection Id",
-            size: 50,
-            array: false,
-            xdefault: null,
-        }),
-        attributeSchema.parse({
-            key: "batches",
-            type: "string",
-            error: "Invalid Batches",
-            size: 1073741824,
-            array: true,
-        }),
-        attributeSchema.parse({
-            key: "data",
-            type: "string",
-            error: "Invalid Data",
-            size: 1073741824,
-        }),
-        attributeSchema.parse({
-            key: "progress",
-            type: "integer",
-            error: "Invalid Progress",
-            required: true,
-            array: false,
-        }),
-        attributeSchema.parse({
-            key: "total",
-            type: "integer",
-            error: "Invalid Total",
-            required: true,
-            array: false,
-        }),
-        attributeSchema.parse({
-            key: "error",
-            type: "string",
-            error: "Operation Error",
-            required: false,
-            array: false,
-        }),
-        attributeSchema.parse({
-            key: "status",
-            type: "enum",
-            elements: [
-                "pending",
-                "ready",
-                "in_progress",
-                "completed",
-                "error",
-                "cancelled",
-            ],
-            error: "Invalid Status",
-            array: false,
-            xdefault: "pending",
-        }),
-    ];
-    const currentOperationsConfig = CollectionCreateSchema.parse({
-        name: "CurrentOperations",
-        enabled: true,
-        documentSecurity: false,
-        attributes: [],
-        indexes: [],
-    });
-    const batchesAttributes = [
-        attributeSchema.parse({
-            key: "data",
-            type: "string",
-            size: 1073741824,
-            error: "Invalid Data",
-            required: true,
-            array: false,
-        }),
-        attributeSchema.parse({
-            key: "processed",
-            type: "boolean",
-            error: "Invalid Processed",
-            required: true,
-            array: false,
-            xdefault: false,
-        }),
-    ];
-    const batchesConfig = CollectionCreateSchema.parse({
-        name: "Batches",
-        enabled: true,
-        documentSecurity: false,
-        attributes: [],
-        indexes: [],
-    });
-    const toReturn = {
-        CurrentOperations: {
-            collection: currentOperationsConfig,
-            attributes: currentOperationsAttributes,
-        },
-        Batches: {
-            collection: batchesConfig,
-            attributes: batchesAttributes,
-        },
-    };
-    return toReturn;
-};

package/dist/migrations/collections.d.ts

@@ -1,22 +0,0 @@
-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[]>;
-/**
- * Transfers all documents from one collection to another in a different database
- * within the same Appwrite Project
- */
-export declare const transferDocumentsBetweenDbsLocalToLocal: (db: Databases, fromDbId: string, toDbId: string, fromCollId: string, toCollId: string) => Promise<void>;
-export declare const transferDocumentsBetweenDbsLocalToRemote: (localDb: Databases, endpoint: string, projectId: string, apiKey: string, fromDbId: string, toDbId: string, fromCollId: string, toCollId: string) => Promise<void>;

package/dist/migrations/collections.js

@@ -1,347 +0,0 @@
-import { Client, Databases, ID, Permission, Query, } from "node-appwrite";
-import { nameToIdMapping, processQueue } from "./queue.js";
-import { createUpdateCollectionAttributes } from "./attributes.js";
-import { createOrUpdateIndexes } from "./indexes.js";
-import _ from "lodash";
-import { SchemaGenerator } from "./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;
-};
-/**
- * Transfers all documents from one collection to another in a different database
- * within the same Appwrite Project
- */
-export const transferDocumentsBetweenDbsLocalToLocal = async (db, fromDbId, toDbId, fromCollId, toCollId) => {
-    let fromCollDocs = await tryAwaitWithRetry(async () => db.listDocuments(fromDbId, fromCollId, [Query.limit(50)]));
-    let totalDocumentsTransferred = 0;
-    if (fromCollDocs.documents.length === 0) {
-        console.log(`No documents found in collection ${fromCollId}`);
-        return;
-    }
-    else if (fromCollDocs.documents.length < 50) {
-        const batchedPromises = fromCollDocs.documents.map((doc) => {
-            const toCreateObject = {
-                ...doc,
-            };
-            delete toCreateObject.$databaseId;
-            delete toCreateObject.$collectionId;
-            delete toCreateObject.$createdAt;
-            delete toCreateObject.$updatedAt;
-            delete toCreateObject.$id;
-            delete toCreateObject.$permissions;
-            return tryAwaitWithRetry(async () => await db.createDocument(toDbId, toCollId, doc.$id, toCreateObject, doc.$permissions));
-        });
-        await Promise.all(batchedPromises);
-        totalDocumentsTransferred += fromCollDocs.documents.length;
-    }
-    else {
-        const batchedPromises = fromCollDocs.documents.map((doc) => {
-            const toCreateObject = {
-                ...doc,
-            };
-            delete toCreateObject.$databaseId;
-            delete toCreateObject.$collectionId;
-            delete toCreateObject.$createdAt;
-            delete toCreateObject.$updatedAt;
-            delete toCreateObject.$id;
-            delete toCreateObject.$permissions;
-            return tryAwaitWithRetry(async () => db.createDocument(toDbId, toCollId, doc.$id, toCreateObject, doc.$permissions));
-        });
-        await Promise.all(batchedPromises);
-        totalDocumentsTransferred += fromCollDocs.documents.length;
-        while (fromCollDocs.documents.length === 50) {
-            fromCollDocs = await tryAwaitWithRetry(async () => await db.listDocuments(fromDbId, fromCollId, [
-                Query.limit(50),
-                Query.cursorAfter(fromCollDocs.documents[fromCollDocs.documents.length - 1].$id),
-            ]));
-            const batchedPromises = fromCollDocs.documents.map((doc) => {
-                const toCreateObject = {
-                    ...doc,
-                };
-                delete toCreateObject.$databaseId;
-                delete toCreateObject.$collectionId;
-                delete toCreateObject.$createdAt;
-                delete toCreateObject.$updatedAt;
-                delete toCreateObject.$id;
-                delete toCreateObject.$permissions;
-                return tryAwaitWithRetry(async () => await db.createDocument(toDbId, toCollId, doc.$id, toCreateObject, doc.$permissions));
-            });
-            await Promise.all(batchedPromises);
-            totalDocumentsTransferred += fromCollDocs.documents.length;
-        }
-    }
-    console.log(`Transferred ${totalDocumentsTransferred} documents from database ${fromDbId} to database ${toDbId} -- collection ${fromCollId} to collection ${toCollId}`);
-};
-export const transferDocumentsBetweenDbsLocalToRemote = async (localDb, endpoint, projectId, apiKey, fromDbId, toDbId, fromCollId, toCollId) => {
-    const client = new Client()
-        .setEndpoint(endpoint)
-        .setProject(projectId)
-        .setKey(apiKey);
-    let totalDocumentsTransferred = 0;
-    const remoteDb = new Databases(client);
-    let fromCollDocs = await tryAwaitWithRetry(async () => localDb.listDocuments(fromDbId, fromCollId, [Query.limit(50)]));
-    if (fromCollDocs.documents.length === 0) {
-        console.log(`No documents found in collection ${fromCollId}`);
-        return;
-    }
-    else if (fromCollDocs.documents.length < 50) {
-        const batchedPromises = fromCollDocs.documents.map((doc) => {
-            const toCreateObject = {
-                ...doc,
-            };
-            delete toCreateObject.$databaseId;
-            delete toCreateObject.$collectionId;
-            delete toCreateObject.$createdAt;
-            delete toCreateObject.$updatedAt;
-            delete toCreateObject.$id;
-            delete toCreateObject.$permissions;
-            return tryAwaitWithRetry(async () => remoteDb.createDocument(toDbId, toCollId, doc.$id, toCreateObject, doc.$permissions));
-        });
-        await Promise.all(batchedPromises);
-        totalDocumentsTransferred += fromCollDocs.documents.length;
-    }
-    else {
-        const batchedPromises = fromCollDocs.documents.map((doc) => {
-            const toCreateObject = {
-                ...doc,
-            };
-            delete toCreateObject.$databaseId;
-            delete toCreateObject.$collectionId;
-            delete toCreateObject.$createdAt;
-            delete toCreateObject.$updatedAt;
-            delete toCreateObject.$id;
-            delete toCreateObject.$permissions;
-            return tryAwaitWithRetry(async () => remoteDb.createDocument(toDbId, toCollId, doc.$id, toCreateObject, doc.$permissions));
-        });
-        await Promise.all(batchedPromises);
-        totalDocumentsTransferred += fromCollDocs.documents.length;
-        while (fromCollDocs.documents.length === 50) {
-            fromCollDocs = await tryAwaitWithRetry(async () => localDb.listDocuments(fromDbId, fromCollId, [
-                Query.limit(50),
-                Query.cursorAfter(fromCollDocs.documents[fromCollDocs.documents.length - 1].$id),
-            ]));
-            const batchedPromises = fromCollDocs.documents.map((doc) => {
-                const toCreateObject = {
-                    ...doc,
-                };
-                delete toCreateObject.$databaseId;
-                delete toCreateObject.$collectionId;
-                delete toCreateObject.$createdAt;
-                delete toCreateObject.$updatedAt;
-                delete toCreateObject.$id;
-                delete toCreateObject.$permissions;
-                return tryAwaitWithRetry(async () => remoteDb.createDocument(toDbId, toCollId, doc.$id, toCreateObject, doc.$permissions));
-            });
-            await Promise.all(batchedPromises);
-            totalDocumentsTransferred += fromCollDocs.documents.length;
-        }
-    }
-    console.log(`Total documents transferred from database ${fromDbId} to database ${toDbId} -- collection ${fromCollId} to collection ${toCollId}: ${totalDocumentsTransferred}`);
-};

package/dist/migrations/converters.d.ts

@@ -1,46 +0,0 @@
-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;