appwrite-utils-cli 0.0.286 → 0.9.2

package/src/migrations/databases.ts

@@ -1,25 +1,44 @@
-import { Databases, Query, type Models } from "node-appwrite";
-
-export const fetchAllDatabases = async (
-  database: Databases
-): Promise<Models.Database[]> => {
-  const databases = await database.list([Query.limit(25)]);
-  const allDatabases = databases.databases;
-  let lastDatabaseId = allDatabases[allDatabases.length - 1].$id;
-  if (databases.databases.length < 25) {
-    return allDatabases;
-  } else {
-    while (lastDatabaseId) {
-      const databases = await database.list([
-        Query.limit(25),
-        Query.cursorAfter(lastDatabaseId),
-      ]);
-      allDatabases.push(...databases.databases);
-      if (databases.databases.length < 25) {
-        break;
-      }
-      lastDatabaseId = databases.databases[databases.databases.length - 1].$id;
-    }
-  }
-  return allDatabases;
-};
+import {
+  Client,
+  Databases,
+  IndexType,
+  Query,
+  type Models,
+} from "node-appwrite";
+import {
+  getAppwriteClient,
+  tryAwaitWithRetry,
+} from "../utils/helperFunctions.js";
+import {
+  transferDocumentsBetweenDbsLocalToLocal,
+  transferDocumentsBetweenDbsLocalToRemote,
+} from "./collections.js";
+import { createOrUpdateAttribute } from "./attributes.js";
+import { parseAttribute } from "appwrite-utils";
+
+export const fetchAllDatabases = async (
+  database: Databases
+): Promise<Models.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;
+  if (databases.databases.length < 25) {
+    return allDatabases;
+  } else {
+    while (lastDatabaseId) {
+      const databases = await database.list([
+        Query.limit(25),
+        Query.cursorAfter(lastDatabaseId),
+      ]);
+      allDatabases.push(...databases.databases);
+      if (databases.databases.length < 25) {
+        break;
+      }
+      lastDatabaseId = databases.databases[databases.databases.length - 1].$id;
+    }
+  }
+  return allDatabases;
+};

package/src/migrations/dbHelpers.ts

@@ -1,92 +1,92 @@
-import type {
-  AppwriteConfig,
-  Attribute,
-  RelationshipAttribute,
-} from "appwrite-utils";
-
-// Helper function to categorize collections based on relationship sides
-export const categorizeCollectionByRelationshipSide = (
-  attributes: Attribute[]
-): "parent" | "mixed" | "child" => {
-  let hasParent = false;
-  let hasChild = false;
-
-  for (const attr of attributes) {
-    if (attr.type === "relationship") {
-      if (attr.side === "parent") {
-        hasParent = true;
-      } else if (attr.side === "child") {
-        hasChild = true;
-      }
-    }
-  }
-
-  if (hasParent && hasChild) return "mixed";
-  if (hasParent) return "parent";
-  return "child";
-};
-
-// Helper function to get all dependencies of a collection
-export const getDependencies = (attributes: Attribute[]): string[] => {
-  return attributes
-    .filter(
-      (attr) =>
-        attr.type === "relationship" && attr.relatedCollection !== undefined
-    )
-    .map((attr) => (attr as RelationshipAttribute).relatedCollection);
-};
-
-// Function to sort collections based on dependencies and relationship sides
-export const sortCollections = (
-  configCollections: AppwriteConfig["collections"]
-): AppwriteConfig["collections"] => {
-  if (!configCollections) {
-    return [];
-  }
-  // Categorize collections based on their relationship sides
-  const parentCollections = configCollections.filter(
-    ({ attributes }) =>
-      categorizeCollectionByRelationshipSide(attributes) === "parent"
-  );
-  const mixedCollections = configCollections.filter(
-    ({ attributes }) =>
-      categorizeCollectionByRelationshipSide(attributes) === "mixed"
-  );
-  const childCollections = configCollections.filter(
-    ({ attributes }) =>
-      categorizeCollectionByRelationshipSide(attributes) === "child"
-  );
-
-  // Sort mixedCollections to ensure parents are processed before children within the mixed category
-  // This might involve more sophisticated logic if you need to order mixed collections based on specific parent-child relationships
-  mixedCollections.sort((a, b) => {
-    // Example sorting logic for mixed collections; adjust based on your specific needs
-    const aDependencies = getDependencies(a.attributes).length;
-    const bDependencies = getDependencies(b.attributes).length;
-    return aDependencies - bDependencies;
-  });
-
-  // Combine them back into a single array with the desired order
-  // Children first because they have no dependencies and parents will create the relationship if it's twoWay
-  return [...childCollections, ...parentCollections, ...mixedCollections];
-};
-
-// Function to sort attributes within a collection based on relationship sides
-export const sortAttributesByRelationshipSide = (
-  attributes: Attribute[]
-): Attribute[] => {
-  // Separate attributes into parent and child based on their relationship side
-  const parentAttributes = attributes.filter(
-    (attr) => attr.type === "relationship" && attr.side === "parent"
-  );
-  const childAttributes = attributes.filter(
-    (attr) => attr.type === "relationship" && attr.side === "child"
-  );
-  const otherAttributes = attributes.filter(
-    (attr) => attr.type !== "relationship"
-  );
-
-  // Combine them back into a single array with child attributes first, then other attributes, and parent attributes last
-  // as parent attributes will create the relationship with the child if needed
-  return [...childAttributes, ...otherAttributes, ...parentAttributes];
-};
+import type {
+  AppwriteConfig,
+  Attribute,
+  RelationshipAttribute,
+} from "appwrite-utils";
+
+// Helper function to categorize collections based on relationship sides
+export const categorizeCollectionByRelationshipSide = (
+  attributes: Attribute[]
+): "parent" | "mixed" | "child" => {
+  let hasParent = false;
+  let hasChild = false;
+
+  for (const attr of attributes) {
+    if (attr.type === "relationship") {
+      if (attr.side === "parent") {
+        hasParent = true;
+      } else if (attr.side === "child") {
+        hasChild = true;
+      }
+    }
+  }
+
+  if (hasParent && hasChild) return "mixed";
+  if (hasParent) return "parent";
+  return "child";
+};
+
+// Helper function to get all dependencies of a collection
+export const getDependencies = (attributes: Attribute[]): string[] => {
+  return attributes
+    .filter(
+      (attr) =>
+        attr.type === "relationship" && attr.relatedCollection !== undefined
+    )
+    .map((attr) => (attr as RelationshipAttribute).relatedCollection);
+};
+
+// Function to sort collections based on dependencies and relationship sides
+export const sortCollections = (
+  configCollections: AppwriteConfig["collections"]
+): AppwriteConfig["collections"] => {
+  if (!configCollections) {
+    return [];
+  }
+  // Categorize collections based on their relationship sides
+  const parentCollections = configCollections.filter(
+    ({ attributes }) =>
+      categorizeCollectionByRelationshipSide(attributes) === "parent"
+  );
+  const mixedCollections = configCollections.filter(
+    ({ attributes }) =>
+      categorizeCollectionByRelationshipSide(attributes) === "mixed"
+  );
+  const childCollections = configCollections.filter(
+    ({ attributes }) =>
+      categorizeCollectionByRelationshipSide(attributes) === "child"
+  );
+
+  // Sort mixedCollections to ensure parents are processed before children within the mixed category
+  // This might involve more sophisticated logic if you need to order mixed collections based on specific parent-child relationships
+  mixedCollections.sort((a, b) => {
+    // Example sorting logic for mixed collections; adjust based on your specific needs
+    const aDependencies = getDependencies(a.attributes).length;
+    const bDependencies = getDependencies(b.attributes).length;
+    return aDependencies - bDependencies;
+  });
+
+  // Combine them back into a single array with the desired order
+  // Children first because they have no dependencies and parents will create the relationship if it's twoWay
+  return [...childCollections, ...parentCollections, ...mixedCollections];
+};
+
+// Function to sort attributes within a collection based on relationship sides
+export const sortAttributesByRelationshipSide = (
+  attributes: Attribute[]
+): Attribute[] => {
+  // Separate attributes into parent and child based on their relationship side
+  const parentAttributes = attributes.filter(
+    (attr) => attr.type === "relationship" && attr.side === "parent"
+  );
+  const childAttributes = attributes.filter(
+    (attr) => attr.type === "relationship" && attr.side === "child"
+  );
+  const otherAttributes = attributes.filter(
+    (attr) => attr.type !== "relationship"
+  );
+
+  // Combine them back into a single array with child attributes first, then other attributes, and parent attributes last
+  // as parent attributes will create the relationship with the child if needed
+  return [...childAttributes, ...otherAttributes, ...parentAttributes];
+};

package/src/migrations/helper.ts

@@ -0,0 +1,40 @@
+import type { Databases, Models } from "node-appwrite";
+import type { OperationCreate } from "../storage/schemas.js";
+import { tryAwaitWithRetry } from "appwrite-utils";
+import { ulid } from "ulidx";
+
+export const logOperation = async (
+  db: Databases,
+  dbId: string,
+  operationDetails: OperationCreate,
+  operationId?: string
+): Promise<Models.Document> => {
+  try {
+    let operation;
+    if (operationId) {
+      // Update existing operation log
+      operation = await tryAwaitWithRetry(
+        async () =>
+          await db.updateDocument(
+            "migrations",
+            "currentOperations",
+            operationId,
+            operationDetails
+          )
+      );
+    } else {
+      // Create new operation log
+      operation = await db.createDocument(
+        "migrations",
+        "currentOperations",
+        ulid(),
+        operationDetails
+      );
+    }
+    console.log(`Operation logged: ${operation.$id}`);
+    return operation;
+  } catch (error) {
+    console.error(`Error logging operation: ${error}`);
+    throw error;
+  }
+};