appwrite-utils-cli 0.0.1

package/src/migrations/afterImportActions.ts

@@ -0,0 +1,300 @@
+import {
+  Databases,
+  Storage,
+  InputFile,
+  Query,
+  ID,
+  type Models,
+  Client,
+} from "node-appwrite";
+import type { AppwriteConfig } from "./schema.js";
+import path from "path";
+import fs from "fs";
+import os from "os";
+
+const getDatabaseFromConfig = (config: AppwriteConfig) => {
+  if (!config.appwriteClient) {
+    config.appwriteClient = new Client()
+      .setEndpoint(config.appwriteEndpoint)
+      .setProject(config.appwriteProject)
+      .setKey(config.appwriteKey);
+  }
+  return new Databases(config.appwriteClient!);
+};
+
+const getStorageFromConfig = (config: AppwriteConfig) => {
+  if (!config.appwriteClient) {
+    config.appwriteClient = new Client()
+      .setEndpoint(config.appwriteEndpoint)
+      .setProject(config.appwriteProject)
+      .setKey(config.appwriteKey);
+  }
+  return new Storage(config.appwriteClient!);
+};
+
+export interface AfterImportActions {
+  [key: string]: (config: AppwriteConfig, ...args: any[]) => Promise<any>;
+}
+
+export const afterImportActions = {
+  updateCreatedDocument: async (
+    config: AppwriteConfig,
+    dbId: string,
+    collId: string,
+    docId: string,
+    data: any
+  ) => {
+    try {
+      const db = getDatabaseFromConfig(config);
+      await db.updateDocument(dbId, collId, docId, data);
+    } catch (error) {
+      console.error("Error updating document: ", error);
+    }
+  },
+  checkAndUpdateFieldInDocument: async (
+    config: AppwriteConfig,
+    dbId: string,
+    collId: string,
+    docId: string,
+    fieldName: string,
+    oldFieldValue: any,
+    newFieldValue: any
+  ) => {
+    try {
+      const db = getDatabaseFromConfig(config);
+      const doc = await db.getDocument(dbId, collId, docId);
+      if (doc[fieldName as keyof typeof doc] == oldFieldValue) {
+        await db.updateDocument(dbId, collId, docId, {
+          [fieldName]: newFieldValue,
+        });
+      }
+    } catch (error) {
+      console.error("Error updating document: ", error);
+    }
+  },
+  setFieldFromOtherCollectionDocument: async (
+    config: AppwriteConfig,
+    dbId: string,
+    collIdOrName: string,
+    docId: string,
+    fieldName: string,
+    otherCollIdOrName: string,
+    otherDocId: string,
+    otherFieldName: string
+  ) => {
+    const db = getDatabaseFromConfig(config);
+
+    // Helper function to find a collection ID by name or return the ID if given
+    const findCollectionId = async (collectionIdentifier: string) => {
+      const collectionsPulled = await db.listCollections(dbId, [
+        Query.limit(25),
+        Query.equal("name", collectionIdentifier),
+      ]);
+      if (collectionsPulled.total > 0) {
+        return collectionsPulled.collections[0].$id;
+      } else {
+        // Assuming the passed identifier might directly be an ID if not found by name
+        return collectionIdentifier;
+      }
+    };
+
+    try {
+      // Resolve the IDs for both the target and other collections
+      const targetCollectionId = await findCollectionId(collIdOrName);
+      const otherCollectionId = await findCollectionId(otherCollIdOrName);
+
+      // Retrieve the "other" document
+      const otherDoc = await db.getDocument(
+        dbId,
+        otherCollectionId,
+        otherDocId
+      );
+      const valueToSet = otherDoc[otherFieldName as keyof typeof otherDoc];
+
+      if (valueToSet) {
+        // Update the target document
+        await db.updateDocument(dbId, targetCollectionId, docId, {
+          [fieldName]: valueToSet,
+        });
+      }
+
+      console.log(
+        `Field ${fieldName} updated successfully in document ${docId}.`
+      );
+    } catch (error) {
+      console.error(
+        "Error setting field from other collection document: ",
+        error
+      );
+    }
+  },
+  createOrGetBucket: async (
+    config: AppwriteConfig,
+    bucketName: string,
+    bucketId?: string,
+    permissions?: string[],
+    fileSecurity?: boolean,
+    enabled?: boolean,
+    maxFileSize?: number,
+    allowedExtensions?: string[],
+    compression?: string,
+    encryption?: boolean,
+    antivirus?: boolean
+  ) => {
+    try {
+      const storage = getStorageFromConfig(config);
+      const bucket = await storage.listBuckets([
+        Query.equal("name", bucketName),
+      ]);
+      if (bucket.buckets.length > 0) {
+        return bucket.buckets[0];
+      } else if (bucketId) {
+        try {
+          return await storage.getBucket(bucketId);
+        } catch (error) {
+          return await storage.createBucket(
+            bucketId,
+            bucketName,
+            permissions,
+            fileSecurity,
+            enabled,
+            maxFileSize,
+            allowedExtensions,
+            compression,
+            encryption,
+            antivirus
+          );
+        }
+      } else {
+        return await storage.createBucket(
+          bucketId || ID.unique(),
+          bucketName,
+          permissions,
+          fileSecurity,
+          enabled,
+          maxFileSize,
+          allowedExtensions,
+          compression,
+          encryption,
+          antivirus
+        );
+      }
+    } catch (error) {
+      console.error("Error creating or getting bucket: ", error);
+    }
+  },
+  createFileAndUpdateField: async (
+    config: AppwriteConfig,
+    dbId: string,
+    collId: string,
+    docId: string,
+    fieldName: string,
+    bucketId: string,
+    filePath: string,
+    fileName: string
+  ) => {
+    try {
+      const db = getDatabaseFromConfig(config);
+      const storage = getStorageFromConfig(config);
+      const collection = await db.getCollection(dbId, collId);
+      const attributes = collection.attributes as any[];
+      const attribute = attributes.find((a) => a.key === fieldName);
+      // console.log(
+      //   `Processing field ${fieldName} in collection ${collId} for document ${docId} in database ${dbId} in bucket ${bucketId} with path ${filePath} and name ${fileName}...`
+      // );
+      let isArray = false;
+      if (!attribute) {
+        console.log(
+          `Field ${fieldName} not found in collection ${collId}, weird, skipping...`
+        );
+        return;
+      } else if (attribute.array === true) {
+        isArray = true;
+      }
+
+      // Define a helper function to check if a value is a URL
+      const isUrl = (value: any) =>
+        typeof value === "string" &&
+        (value.startsWith("http://") || value.startsWith("https://"));
+
+      const doc = await db.getDocument(dbId, collId, docId);
+      const existingFieldValue = doc[fieldName as keyof typeof doc];
+
+      // Handle the case where the field is an array
+      let updateData: string | string[] = isArray ? [] : "";
+      if (isArray && Array.isArray(existingFieldValue)) {
+        updateData = existingFieldValue.filter((val) => !isUrl(val)); // Remove URLs from the array
+      }
+
+      // Process file upload and update logic
+      if (isUrl(filePath)) {
+        // Create a temporary directory
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "appwrite_tmp"));
+        const tempFilePath = path.join(tempDir, fileName);
+
+        // Download the file using fetch
+        const response = await fetch(filePath);
+        if (!response.ok)
+          console.error(
+            `Failed to fetch ${filePath}: ${response.statusText} for document ${docId} with field ${fieldName}`
+          );
+
+        // Use arrayBuffer if buffer is not available
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        fs.writeFileSync(tempFilePath, buffer);
+
+        // Create InputFile from the downloaded file
+        const inputFile = InputFile.fromPath(tempFilePath, fileName);
+
+        // Use the full file name (with extension) for creating the file
+        const file = await storage.createFile(bucketId, ID.unique(), inputFile);
+
+        console.log("Created file from URL: ", file.$id);
+
+        // After uploading, adjust the updateData based on whether the field is an array or not
+        if (isArray) {
+          updateData = [...updateData, file.$id]; // Append the new file ID
+        } else {
+          updateData = file.$id; // Set the new file ID
+        }
+        // console.log(
+        //   "Updating document with file: ",
+        //   doc.$id,
+        //   `${fieldName}: `,
+        //   updateData
+        // );
+
+        // If the file was downloaded, delete it after uploading
+        fs.unlinkSync(tempFilePath);
+      } else {
+        const files = fs.readdirSync(filePath);
+        const fileFullName = files.find((file) => file.includes(fileName));
+        if (!fileFullName) {
+          console.error(
+            `File starting with '${fileName}' not found in '${filePath}'`
+          );
+          return;
+        }
+        const pathToFile = path.join(filePath, fileFullName);
+        const inputFile = InputFile.fromPath(pathToFile, fileName);
+        const file = await storage.createFile(bucketId, ID.unique(), inputFile);
+
+        if (isArray) {
+          updateData = [...updateData, file.$id]; // Append the new file ID
+        } else {
+          updateData = file.$id; // Set the new file ID
+        }
+        await db.updateDocument(dbId, collId, doc.$id, {
+          [fieldName]: updateData,
+        });
+        console.log("Created file from path: ", file.$id);
+      }
+    } catch (error) {
+      console.error("Error creating file and updating field: ", error);
+      console.log(
+        `Params were: dbId: ${dbId}, collId: ${collId}, docId: ${docId}, fieldName: ${fieldName}, filePath: ${filePath}, fileName: ${fileName}`
+      );
+    }
+  },
+};

package/src/migrations/attributes.ts

@@ -0,0 +1,315 @@
+import { Query, type Databases, type Models } from "node-appwrite";
+import type { Attribute } from "./schema.js";
+import { nameToIdMapping, enqueueOperation } from "./queue.js";
+
+export const createOrUpdateAttribute = async (
+  db: Databases,
+  dbId: string,
+  collection: Models.Collection,
+  attribute: Attribute
+): Promise<void> => {
+  let action = "create";
+  let foundAttribute;
+  try {
+    foundAttribute = await db.getAttribute(dbId, collection.$id, attribute.key);
+  } catch (error) {
+    foundAttribute = undefined;
+  }
+  let numSameAttributes = 0;
+  if (foundAttribute && foundAttribute.key === attribute.key) {
+    numSameAttributes++;
+    return;
+  } else if (foundAttribute) {
+    action = "update";
+  }
+
+  // Relationship attribute logic with adjustments
+  let collectionFoundViaRelatedCollection: Models.Collection | undefined;
+  let relatedCollectionId: string | undefined;
+  if (attribute.type === "relationship") {
+    if (nameToIdMapping.has(attribute.relatedCollection)) {
+      relatedCollectionId = nameToIdMapping.get(attribute.relatedCollection);
+      try {
+        collectionFoundViaRelatedCollection = await db.getCollection(
+          dbId,
+          relatedCollectionId!
+        );
+      } catch (e) {
+        console.log(
+          `Collection not found: ${attribute.relatedCollection} when nameToIdMapping was set`
+        );
+        collectionFoundViaRelatedCollection = undefined;
+      }
+    } else {
+      const collectionsPulled = await db.listCollections(dbId, [
+        Query.equal("name", attribute.relatedCollection),
+      ]);
+      if (collectionsPulled.total > 0) {
+        collectionFoundViaRelatedCollection = collectionsPulled.collections[0];
+        relatedCollectionId = collectionFoundViaRelatedCollection.$id;
+        nameToIdMapping.set(attribute.relatedCollection, relatedCollectionId);
+      }
+    }
+    if (!(relatedCollectionId && collectionFoundViaRelatedCollection)) {
+      console.log(`Enqueueing operation for attribute: ${attribute.key}`);
+      enqueueOperation({
+        type: "attribute",
+        collectionId: collection.$id,
+        collection: collection,
+        attribute,
+        dependencies: [attribute.relatedCollection],
+      });
+      return;
+    }
+  }
+
+  switch (attribute.type) {
+    case "string":
+      if (action === "create") {
+        await db.createStringAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.size,
+          attribute.required,
+          attribute.xdefault || undefined,
+          attribute.array,
+          attribute.encrypted
+        );
+      } else {
+        await db.updateStringAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.required,
+          attribute.xdefault || undefined
+        );
+      }
+      break;
+    case "integer":
+      if (action === "create") {
+        await db.createIntegerAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.required,
+          attribute.min,
+          attribute.max,
+          attribute.xdefault || undefined,
+          attribute.array
+        );
+      } else {
+        await db.updateIntegerAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.required,
+          attribute.min || 0,
+          attribute.max || 2147483647,
+          attribute.xdefault || undefined
+        );
+      }
+      break;
+    case "float":
+      if (action === "create") {
+        await db.createFloatAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.required,
+          attribute.min,
+          attribute.max,
+          attribute.xdefault || undefined,
+          attribute.array
+        );
+      } else {
+        await db.updateFloatAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.required,
+          attribute.min || 0,
+          attribute.max || 2147483647,
+          attribute.xdefault || undefined
+        );
+      }
+      break;
+    case "boolean":
+      if (action === "create") {
+        await db.createBooleanAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.required,
+          attribute.xdefault || undefined,
+          attribute.array
+        );
+      } else {
+        await db.updateBooleanAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.required,
+          attribute.xdefault || undefined
+        );
+      }
+      break;
+    case "datetime":
+      if (action === "create") {
+        await db.createDatetimeAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.required,
+          attribute.xdefault || undefined,
+          attribute.array
+        );
+      } else {
+        await db.updateDatetimeAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.required,
+          attribute.xdefault || undefined
+        );
+      }
+      break;
+    case "email":
+      if (action === "create") {
+        await db.createEmailAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.required,
+          attribute.xdefault || undefined,
+          attribute.array
+        );
+      } else {
+        await db.updateEmailAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.required,
+          attribute.xdefault || undefined
+        );
+      }
+      break;
+    case "ip":
+      if (action === "create") {
+        await db.createIpAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.required,
+          attribute.xdefault || undefined,
+          attribute.array
+        );
+      } else {
+        await db.updateIpAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.required,
+          attribute.xdefault || undefined
+        );
+      }
+      break;
+    case "url":
+      if (action === "create") {
+        await db.createUrlAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.required,
+          attribute.xdefault || undefined,
+          attribute.array
+        );
+      } else {
+        await db.updateUrlAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.required,
+          attribute.xdefault || undefined
+        );
+      }
+      break;
+    case "enum":
+      if (action === "create") {
+        await db.createEnumAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.elements,
+          attribute.required,
+          attribute.xdefault || undefined,
+          attribute.array
+        );
+      } else {
+        await db.updateEnumAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.elements,
+          attribute.required,
+          attribute.xdefault || undefined
+        );
+      }
+      break;
+    case "relationship":
+      if (action === "create") {
+        await db.createRelationshipAttribute(
+          dbId,
+          collection.$id,
+          relatedCollectionId!,
+          attribute.relationType,
+          attribute.twoWay,
+          attribute.key,
+          attribute.twoWayKey,
+          attribute.onDelete
+        );
+      } else {
+        await db.updateRelationshipAttribute(
+          dbId,
+          collection.$id,
+          attribute.key,
+          attribute.onDelete
+        );
+      }
+      break;
+    default:
+      console.error("Invalid attribute type");
+      break;
+  }
+};
+
+export const createUpdateCollectionAttributes = async (
+  db: Databases,
+  dbId: string,
+  collection: Models.Collection,
+  attributes: Attribute[]
+): Promise<void> => {
+  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}`
+  );
+};