appwrite-utils-cli 0.10.82 → 0.10.83

package/README.md

@@ -150,6 +150,7 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+- 0.10.83: Actually fixed the import oops
 - 0.10.82: Fixed the `lodash` import, replaced with `es-toolkit`
 - 0.10.81: Fixed `wipeCollection` -- it wasn't properly deleting all files in a loop
 - 0.10.80: Updated `appwrite-utils` req

package/dist/collections/attributes.js

@@ -1,28 +1,27 @@
 import { Query } from "node-appwrite";
 import { attributeSchema, parseAttribute, } from "appwrite-utils";
 import { nameToIdMapping, enqueueOperation } from "../migrations/queue.js";
-import _ from "lodash";
 import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
 import chalk from "chalk";
 const attributesSame = (databaseAttribute, configAttribute) => {
     const attributesToCheck = [
-        'key',
-        'type',
-        'array',
-        'encrypted',
-        'required',
-        'size',
-        'min',
-        'max',
-        'xdefault',
-        'elements',
-        'relationType',
-        'twoWay',
-        'twoWayKey',
-        'onDelete',
-        'relatedCollection'
+        "key",
+        "type",
+        "array",
+        "encrypted",
+        "required",
+        "size",
+        "min",
+        "max",
+        "xdefault",
+        "elements",
+        "relationType",
+        "twoWay",
+        "twoWayKey",
+        "onDelete",
+        "relatedCollection",
     ];
-    return attributesToCheck.every(attr => {
+    return attributesToCheck.every((attr) => {
         // Check if both objects have the attribute
         const dbHasAttr = attr in databaseAttribute;
         const configHasAttr = attr in configAttribute;
@@ -31,7 +30,8 @@ const attributesSame = (databaseAttribute, configAttribute) => {
             const dbValue = databaseAttribute[attr];
             const configValue = configAttribute[attr];
             // Consider undefined and null as equivalent
-            if ((dbValue === undefined || dbValue === null) && (configValue === undefined || configValue === null)) {
+            if ((dbValue === undefined || dbValue === null) &&
+                (configValue === undefined || configValue === null)) {
                 return true;
             }
             return dbValue === configValue;
@@ -68,11 +68,15 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
     catch (error) {
         foundAttribute = undefined;
     }
-    if (foundAttribute && attributesSame(foundAttribute, attribute) && updateEnabled) {
+    if (foundAttribute &&
+        attributesSame(foundAttribute, attribute) &&
+        updateEnabled) {
         // No need to do anything, they are the same
         return;
     }
-    else if (foundAttribute && !attributesSame(foundAttribute, attribute) && updateEnabled) {
+    else if (foundAttribute &&
+        !attributesSame(foundAttribute, attribute) &&
+        updateEnabled) {
         // console.log(
         //   `Updating attribute with same key ${attribute.key} but different values`
         // );
@@ -82,7 +86,9 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
         };
         action = "update";
     }
-    else if (!updateEnabled && foundAttribute && !attributesSame(foundAttribute, attribute)) {
+    else if (!updateEnabled &&
+        foundAttribute &&
+        !attributesSame(foundAttribute, attribute)) {
         await db.deleteAttribute(dbId, collection.$id, attribute.key);
         console.log(`Deleted attribute: ${attribute.key} to recreate it because they diff (update disabled temporarily)`);
         return;
@@ -131,10 +137,14 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
     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.required ? finalAttribute.xdefault : null, finalAttribute.array || false, finalAttribute.encrypted));
+                await tryAwaitWithRetry(async () => await db.createStringAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.size, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                    ? finalAttribute.xdefault
+                    : null, finalAttribute.array || false, finalAttribute.encrypted));
             }
             else {
-                await tryAwaitWithRetry(async () => await db.updateStringAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required ? finalAttribute.xdefault : null));
+                await tryAwaitWithRetry(async () => await db.updateStringAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                    ? finalAttribute.xdefault
+                    : null));
             }
             break;
         case "integer":
@@ -147,7 +157,9 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
                     BigInt(finalAttribute.max) === BigInt(9223372036854776000)) {
                     delete finalAttribute.max;
                 }
-                await tryAwaitWithRetry(async () => await db.createIntegerAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.min || -2147483647, finalAttribute.max || 2147483647, finalAttribute.xdefault !== undefined && !finalAttribute.required ? finalAttribute.xdefault : null, finalAttribute.array || false));
+                await tryAwaitWithRetry(async () => await db.createIntegerAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.min || -2147483647, finalAttribute.max || 2147483647, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                    ? finalAttribute.xdefault
+                    : null, finalAttribute.array || false));
             }
             else {
                 if (finalAttribute.min &&
@@ -158,63 +170,93 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
                     BigInt(finalAttribute.max) === BigInt(9223372036854776000)) {
                     delete finalAttribute.max;
                 }
-                await tryAwaitWithRetry(async () => await db.updateIntegerAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.min || -2147483647, finalAttribute.max || 2147483647, finalAttribute.xdefault !== undefined && !finalAttribute.required ? finalAttribute.xdefault : null));
+                await tryAwaitWithRetry(async () => await db.updateIntegerAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.min || -2147483647, finalAttribute.max || 2147483647, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                    ? finalAttribute.xdefault
+                    : null));
             }
             break;
         case "float":
             if (action === "create") {
-                await tryAwaitWithRetry(async () => await db.createFloatAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.min || -2147483647, finalAttribute.max || 2147483647, finalAttribute.xdefault !== undefined && !finalAttribute.required ? finalAttribute.xdefault : null, finalAttribute.array || false));
+                await tryAwaitWithRetry(async () => await db.createFloatAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.min || -2147483647, finalAttribute.max || 2147483647, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                    ? finalAttribute.xdefault
+                    : null, finalAttribute.array || false));
             }
             else {
-                await tryAwaitWithRetry(async () => await db.updateFloatAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.min || -2147483647, finalAttribute.max || 2147483647, finalAttribute.xdefault !== undefined && !finalAttribute.required ? finalAttribute.xdefault : null));
+                await tryAwaitWithRetry(async () => await db.updateFloatAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.min || -2147483647, finalAttribute.max || 2147483647, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                    ? finalAttribute.xdefault
+                    : null));
             }
             break;
         case "boolean":
             if (action === "create") {
-                await tryAwaitWithRetry(async () => await db.createBooleanAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required ? finalAttribute.xdefault : null, finalAttribute.array || false));
+                await tryAwaitWithRetry(async () => await db.createBooleanAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                    ? finalAttribute.xdefault
+                    : null, finalAttribute.array || false));
             }
             else {
-                await tryAwaitWithRetry(async () => await db.updateBooleanAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required ? finalAttribute.xdefault : null));
+                await tryAwaitWithRetry(async () => await db.updateBooleanAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                    ? 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.required ? finalAttribute.xdefault : null, finalAttribute.array || false));
+                await tryAwaitWithRetry(async () => await db.createDatetimeAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                    ? finalAttribute.xdefault
+                    : null, finalAttribute.array || false));
             }
             else {
-                await tryAwaitWithRetry(async () => await db.updateDatetimeAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required ? finalAttribute.xdefault : null));
+                await tryAwaitWithRetry(async () => await db.updateDatetimeAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                    ? finalAttribute.xdefault
+                    : null));
             }
             break;
         case "email":
             if (action === "create") {
-                await tryAwaitWithRetry(async () => await db.createEmailAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required ? finalAttribute.xdefault : null, finalAttribute.array || false));
+                await tryAwaitWithRetry(async () => await db.createEmailAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                    ? finalAttribute.xdefault
+                    : null, finalAttribute.array || false));
             }
             else {
-                await tryAwaitWithRetry(async () => await db.updateEmailAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required ? finalAttribute.xdefault : null));
+                await tryAwaitWithRetry(async () => await db.updateEmailAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                    ? finalAttribute.xdefault
+                    : null));
             }
             break;
         case "ip":
             if (action === "create") {
-                await tryAwaitWithRetry(async () => await db.createIpAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required ? finalAttribute.xdefault : null, finalAttribute.array || false));
+                await tryAwaitWithRetry(async () => await db.createIpAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                    ? finalAttribute.xdefault
+                    : null, finalAttribute.array || false));
             }
             else {
-                await tryAwaitWithRetry(async () => await db.updateIpAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required ? finalAttribute.xdefault : null));
+                await tryAwaitWithRetry(async () => await db.updateIpAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                    ? finalAttribute.xdefault
+                    : null));
             }
             break;
         case "url":
             if (action === "create") {
-                await tryAwaitWithRetry(async () => await db.createUrlAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required ? finalAttribute.xdefault : null, finalAttribute.array || false));
+                await tryAwaitWithRetry(async () => await db.createUrlAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                    ? finalAttribute.xdefault
+                    : null, finalAttribute.array || false));
             }
             else {
-                await tryAwaitWithRetry(async () => await db.updateUrlAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required ? finalAttribute.xdefault : null));
+                await tryAwaitWithRetry(async () => await db.updateUrlAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                    ? finalAttribute.xdefault
+                    : null));
             }
             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.required ? finalAttribute.xdefault : null, finalAttribute.array || false));
+                await tryAwaitWithRetry(async () => await db.createEnumAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.elements, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                    ? finalAttribute.xdefault
+                    : null, finalAttribute.array || false));
             }
             else {
-                await tryAwaitWithRetry(async () => await db.updateEnumAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.elements, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required ? finalAttribute.xdefault : null));
+                await tryAwaitWithRetry(async () => await db.updateEnumAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.elements, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                    ? finalAttribute.xdefault
+                    : null));
             }
             break;
         case "relationship":
@@ -232,13 +274,16 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
 };
 export const createUpdateCollectionAttributes = async (db, dbId, collection, attributes) => {
     console.log(chalk.green(`Creating/Updating attributes for collection: ${collection.name}`));
+    const existingAttributes = 
     // @ts-expect-error
-    const existingAttributes = collection.attributes.map((attr) => parseAttribute(attr)) || [];
+    collection.attributes.map((attr) => parseAttribute(attr)) || [];
     const attributesToRemove = existingAttributes.filter((attr) => !attributes.some((a) => a.key === attr.key));
     const indexesToRemove = collection.indexes.filter((index) => attributesToRemove.some((attr) => index.attributes.includes(attr.key)));
     if (attributesToRemove.length > 0) {
         if (indexesToRemove.length > 0) {
-            console.log(chalk.red(`Removing indexes as they rely on an attribute that is being removed: ${indexesToRemove.map((index) => index.key).join(", ")}`));
+            console.log(chalk.red(`Removing indexes as they rely on an attribute that is being removed: ${indexesToRemove
+                .map((index) => index.key)
+                .join(", ")}`));
             for (const index of indexesToRemove) {
                 await tryAwaitWithRetry(async () => await db.deleteIndex(dbId, collection.$id, index.key));
                 await delay(100);

package/dist/collections/methods.d.ts

@@ -15,3 +15,9 @@ export declare const createOrUpdateCollections: (database: Databases, databaseId
 }[], selectedCollections?: Models.Collection[]) => 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/collections/methods.js

@@ -243,8 +243,12 @@ export const createOrUpdateCollections = async (database, databaseId, config, de
         attributes);
         // Add delay after creating attributes
         await delay(250);
+        const indexesToUse = indexes.length > 0
+            ? indexes
+            : config.collections?.find((c) => c.$id === collectionToUse.$id)
+                ?.indexes ?? [];
         console.log("Creating Indexes");
-        await createOrUpdateIndexes(databaseId, database, collectionToUse.$id, (indexes ?? []));
+        await createOrUpdateIndexes(databaseId, database, collectionToUse.$id, indexesToUse);
         // Add delay after creating indexes
         await delay(250);
     }
@@ -283,3 +287,134 @@ export const fetchAllCollections = async (dbId, database) => {
     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/appwriteToX.js

@@ -1,6 +1,6 @@
 import { SchemaGenerator } from "./schemaStrings.js";
 import { Client, Compression, Databases, Query, Storage, } from "node-appwrite";
-import { fetchAllCollections } from "./collections.js";
+import { fetchAllCollections } from "../collections/methods.js";
 import { fetchAllDatabases } from "./databases.js";
 import { CollectionSchema, attributeSchema, AppwriteConfigSchema, permissionsSchema, attributesSchema, indexesSchema, parseAttribute, } from "appwrite-utils";
 import { getDatabaseFromConfig } from "./afterImportActions.js";

package/dist/migrations/attributes.js

@@ -1,7 +1,6 @@
 import { Query } from "node-appwrite";
 import { attributeSchema, parseAttribute, } from "appwrite-utils";
 import { nameToIdMapping, enqueueOperation } from "./queue.js";
-import _ from "lodash";
 import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
 const attributesSame = (databaseAttribute, configAttribute) => {
     const attributesToCheck = [

package/dist/migrations/converters.js

@@ -1,6 +1,5 @@
-import _ from "lodash";
 import { converterFunctions } from "appwrite-utils";
-const { cloneDeep, isObject } = _;
+import { cloneDeep, isPlainObject } from "es-toolkit";
 /**
  * Deeply converts all properties of an object (or array) to strings.
  * @param data The input data to convert.
@@ -10,7 +9,7 @@ export const deepAnyToString = (data) => {
     if (Array.isArray(data)) {
         return data.map((item) => deepAnyToString(item));
     }
-    else if (isObject(data)) {
+    else if (isPlainObject(data)) {
         return Object.keys(data).reduce((acc, key) => {
             acc[key] = deepAnyToString(data[key]);
             return acc;
@@ -31,7 +30,7 @@ export const deepConvert = (data, convertFn) => {
     if (Array.isArray(data)) {
         return data.map((item) => deepConvert(item, convertFn));
     }
-    else if (isObject(data)) {
+    else if (isPlainObject(data)) {
         return Object.keys(data).reduce((acc, key) => {
             acc[key] = deepConvert(data[key], convertFn);
             return acc;

package/dist/migrations/dataLoader.js

@@ -3,14 +3,14 @@ import path from "path";
 import fs from "fs";
 import { convertObjectByAttributeMappings } from "./converters.js";
 import { z } from "zod";
-import { checkForCollection } from "./collections.js";
+import { checkForCollection } from "../collections/methods.js";
 import { ID, Users } from "node-appwrite";
 import { logger } from "./logging.js";
 import { findOrCreateOperation, updateOperation } from "./migrationHelper.js";
 import { AuthUserCreateSchema } from "../schemas/authUser.js";
-import _ from "lodash";
 import { UsersController } from "./users.js";
 import { finalizeByAttributeMap } from "../utils/helperFunctions.js";
+import { isEmpty } from "es-toolkit/compat";
 // Define a schema for the structure of collection import data using Zod for validation
 export const CollectionImportDataSchema = z.object({
     // Optional collection creation schema
@@ -447,7 +447,7 @@ export class DataLoader {
                                 const sourceValue = this.getValueFromData(collectionData.data[i].finalData, collectionData.data[i].context, idMapping.sourceField);
                                 // Skip if value to match is missing or empty
                                 if (!sourceValue ||
-                                    _.isEmpty(sourceValue) ||
+                                    isEmpty(sourceValue) ||
                                     sourceValue === null)
                                     continue;
                                 const isFieldToSetArray = collectionConfig.attributes.find((attribute) => attribute.key === fieldToSetKey)?.array;

package/dist/migrations/importController.js

@@ -1,5 +1,4 @@
 import { AppwriteException, ID, Query, } from "node-appwrite";
-import _ from "lodash";
 import { areCollectionNamesSame, tryAwaitWithRetry } from "../utils/index.js";
 import { resolveAndUpdateRelationships } from "./relationships.js";
 import { UsersController } from "./users.js";

package/dist/migrations/queue.js

@@ -1,7 +1,6 @@
 import { Query } from "node-appwrite";
 import { createOrUpdateAttribute } from "./attributes.js";
-import _ from "lodash";
-import { fetchAndCacheCollectionByName } from "./collections.js";
+import { fetchAndCacheCollectionByName } from "../collections/methods.js";
 import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
 export const queuedOperations = [];
 export const nameToIdMapping = new Map();

package/dist/migrations/relationships.js

@@ -1,5 +1,5 @@
 import { Databases, Query } from "node-appwrite";
-import { fetchAllCollections } from "./collections.js";
+import { fetchAllCollections } from "../collections/methods.js";
 import { logger } from "./logging.js";
 /**
  * Finds collections that have defined relationship attributes.

package/dist/migrations/users.js

@@ -1,9 +1,10 @@
 import { AppwriteException, Databases, ID, Query, Users, } from "node-appwrite";
 import { AuthUserSchema, } from "../schemas/authUser.js";
-import _ from "lodash";
 import { logger } from "./logging.js";
 import { splitIntoBatches } from "./migrationHelper.js";
 import { getAppwriteClient, tryAwaitWithRetry, } from "../utils/helperFunctions.js";
+import { isUndefined } from "es-toolkit/compat";
+import { isEmpty } from "es-toolkit/compat";
 export class UsersController {
     config;
     users;
@@ -131,8 +132,8 @@ export class UsersController {
                 // Update user details as necessary, ensuring email uniqueness if attempting an update.
                 if (item.email &&
                     item.email !== userToReturn.email &&
-                    !_.isEmpty(item.email) &&
-                    !_.isUndefined(item.email)) {
+                    !isEmpty(item.email) &&
+                    !isUndefined(item.email)) {
                     const emailExists = await this.users.list([
                         Query.equal("email", item.email),
                     ]);
@@ -153,7 +154,7 @@ export class UsersController {
                     item.phone !== userToReturn.phone &&
                     item.phone.length < 15 &&
                     item.phone.startsWith("+") &&
-                    (_.isUndefined(userToReturn.phone) || _.isEmpty(userToReturn.phone))) {
+                    (isUndefined(userToReturn.phone) || isEmpty(userToReturn.phone))) {
                     const userFoundWithPhone = await this.users.list([
                         Query.equal("phone", item.phone),
                     ]);

package/dist/migrations/validationRules.js

@@ -1,11 +1,11 @@
-import _ from "lodash";
+import { isNumber, isString, isBoolean, isArray, isPlainObject, isNull, isUndefined, isDate, isEmpty, isInteger, isArrayLike, isArrayLikeObject, isFunction, isLength, isMap, isSet, isRegExp, isSymbol, isObjectLike, isSafeInteger, isTypedArray, isEqual, isMatch, has, get, } from "es-toolkit/compat";
 export const validationRules = {
-    isNumber: (value) => _.isNumber(value),
-    isString: (value) => _.isString(value),
-    isBoolean: (value) => _.isBoolean(value),
-    isArray: (value) => _.isArray(value),
-    isObject: (value) => _.isObject(value) && !_.isArray(value) && !_.isFunction(value),
-    isNull: (value) => _.isNull(value),
+    isNumber: (value) => isNumber(value),
+    isString: (value) => isString(value),
+    isBoolean: (value) => isBoolean(value),
+    isArray: (value) => isArray(value),
+    isObject: (value) => isPlainObject(value) && !isArray(value) && !isFunction(value),
+    isNull: (value) => isNull(value),
     isValidEmail: (value) => value.match(/^[\w\-\.]+@([\w-]+\.)+[\w-]{2,}$/) !== null,
     isValidPhone: (value) => value.match(/^[+]?[(]?[0-9]{3}[)]?[-\s.]?[0-9]{3}[-\s.]?[0-9]{4,6}$/im) !==
         null,
@@ -16,27 +16,27 @@ export const validationRules = {
     isValidHexAlpha: (value) => value.match(/^#([a-f0-9]{8}|[a-f0-9]{4})$/i) !== null,
     isValidDate: (value) => value.match(/^\d{4}-\d{2}-\d{2}$/) !== null,
     isValidTime: (value) => value.match(/^\d{2}:\d{2}(:\d{2})?$/) !== null,
-    isNullish: (value) => _.isNull(value) || _.isUndefined(value),
-    isUndefined: (value) => _.isUndefined(value),
-    isDefined: (value) => !_.isUndefined(value) && !_.isNull(value) && !_.isEmpty(value),
-    isDate: (value) => _.isDate(value),
-    isEmpty: (value) => _.isEmpty(value),
-    isInteger: (value) => _.isInteger(value),
-    isFloat: (value) => _.isNumber(value) && !_.isInteger(value),
-    isArrayLike: (value) => _.isArrayLike(value),
-    isArrayLikeObject: (value) => _.isArrayLikeObject(value),
-    isFunction: (value) => _.isFunction(value),
-    isLength: (value) => _.isLength(value),
-    isMap: (value) => _.isMap(value),
-    isSet: (value) => _.isSet(value),
-    isRegExp: (value) => _.isRegExp(value),
-    isSymbol: (value) => _.isSymbol(value),
-    isObjectLike: (value) => _.isObjectLike(value),
-    isPlainObject: (value) => _.isPlainObject(value),
-    isSafeInteger: (value) => _.isSafeInteger(value),
-    isTypedArray: (value) => _.isTypedArray(value),
-    isEqual: (value, other) => _.isEqual(value, other),
-    isMatch: (object, source) => _.isMatch(object, source),
-    has: (object, path) => _.has(object, path),
-    get: (object, path, defaultValue) => _.get(object, path, defaultValue),
+    isNullish: (value) => isNull(value) || isUndefined(value),
+    isUndefined: (value) => isUndefined(value),
+    isDefined: (value) => !isUndefined(value) && !isNull(value) && !isEmpty(value),
+    isDate: (value) => isDate(value),
+    isEmpty: (value) => isEmpty(value),
+    isInteger: (value) => isInteger(value),
+    isFloat: (value) => isNumber(value) && !isInteger(value),
+    isArrayLike: (value) => isArrayLike(value),
+    isArrayLikeObject: (value) => isArrayLikeObject(value),
+    isFunction: (value) => isFunction(value),
+    isLength: (value) => isLength(value),
+    isMap: (value) => isMap(value),
+    isSet: (value) => isSet(value),
+    isRegExp: (value) => isRegExp(value),
+    isSymbol: (value) => isSymbol(value),
+    isObjectLike: (value) => isObjectLike(value),
+    isPlainObject: (value) => isPlainObject(value),
+    isSafeInteger: (value) => isSafeInteger(value),
+    isTypedArray: (value) => isTypedArray(value),
+    isEqual: (value, other) => isEqual(value, other),
+    isMatch: (object, source) => isMatch(object, source),
+    has: (object, path) => has(object, path),
+    get: (object, path, defaultValue) => get(object, path, defaultValue),
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "0.10.82",
+  "version": "0.10.83",
   "main": "src/main.ts",
   "type": "module",
   "repository": {