appwrite-utils-cli 0.0.271 → 0.0.273

package/README.md

@@ -118,6 +118,8 @@ This setup ensures that developers have robust tools at their fingertips to mana
 
 ### Changelog
 
+- 0.0.273: Small fix for relationship attribute comparisons
+- 0.0.272: That's what I get for not testing lmao, also updated logic for checking for existing attributes to take the `format` into consideration from the database (URL's are not of `type: "url"`, they are of `format: "url"`)
 - 0.0.271: Small change to update attributes that are different from each other by deleting the attribute and recreating, as we cannot update most things
 - 0.0.270: Fixed enums in `--sync`, added optional OpenAPI generation (in progress, almost done, but wanted to push other changes), added `--endpoint`, `--project`, `--key` as optional parameters to change the target destination (shoutout to [pingu24k](https://github.com/pingu2k4) for pointing out these bugs and suggesting those changes for endpoint customization)
 - 0.0.254: Added `--sync` to synchronize your Appwrite instance with your local `appwriteConfig.yaml` and generate schemas

package/dist/migrations/attributes.d.ts

@@ -1,4 +1,4 @@
 import { type Databases, type Models } from "node-appwrite";
-import type { Attribute } from "./schema.js";
+import { type Attribute } from "./schema.js";
 export declare const createOrUpdateAttribute: (db: Databases, dbId: string, collection: Models.Collection, attribute: Attribute) => Promise<void>;
 export declare const createUpdateCollectionAttributes: (db: Databases, dbId: string, collection: Models.Collection, attributes: Attribute[]) => Promise<void>;

package/dist/migrations/attributes.js

@@ -1,22 +1,57 @@
 import { Query } from "node-appwrite";
+import { parseAttribute } from "./schema.js";
 import { nameToIdMapping, enqueueOperation } from "./queue.js";
 import _ from "lodash";
+const attributesSame = (a, b) => {
+    // Direct type comparison for non-string types
+    // Also check if the type IS string and has a format for either
+    // That means the format is the type of the attribute
+    if (a.type === b.type &&
+        !((a.type === "string" && a.format) || (b.type === "string" && b.format))) {
+        if (a.type === "relationship" && b.type === "relationship") {
+            return (a.key === b.key &&
+                a.relationType === b.relationType &&
+                a.twoWay === b.twoWay &&
+                a.twoWayKey === b.twoWayKey &&
+                a.required === b.required);
+        }
+        return a.key === b.key && a.array === b.array && a.required === b.required;
+    }
+    if (a.type === "string" && a.format) {
+        // @ts-expect-error
+        a.type = a.format;
+    }
+    if (b.type === "string" && b.format) {
+        // @ts-expect-error
+        b.type = b.format;
+    }
+    // Handling string types with specific formats in Appwrite
+    if (a.type === "string" && b.type === "string") {
+        return (a.key === b.key &&
+            a.format === b.format &&
+            a.array === b.array &&
+            a.required === b.required);
+    }
+    // Fallback to false if none of the above conditions are met
+    return false;
+};
 export const createOrUpdateAttribute = async (db, dbId, collection, attribute) => {
     let action = "create";
     let foundAttribute;
     try {
         foundAttribute = await db.getAttribute(dbId, collection.$id, attribute.key);
+        foundAttribute = parseAttribute(foundAttribute);
     }
     catch (error) {
         foundAttribute = undefined;
     }
     let numSameAttributes = 0;
-    if (foundAttribute && _.isEqual(foundAttribute, attribute)) {
+    if (foundAttribute && attributesSame(foundAttribute, attribute)) {
         numSameAttributes++;
         return;
     }
-    else if (foundAttribute && !_.isEqual(foundAttribute, attribute)) {
-        console.log("Deleting attribute with same key but different values, assuming update...");
+    else if (foundAttribute && !attributesSame(foundAttribute, attribute)) {
+        console.log(`Deleting attribute with same key ${attribute.key} -- ${foundAttribute.key} but different values -- ${JSON.stringify(attribute, null, 2)} -- ${JSON.stringify(foundAttribute, null, 2)}`);
         await db.deleteAttribute(dbId, collection.$id, attribute.key);
     }
     // Relationship attribute logic with adjustments

package/dist/migrations/schema.js

@@ -332,6 +332,14 @@ export const attributeSchema = z.discriminatedUnion("type", [
     relationshipAttributeSchema,
 ]);
 export const parseAttribute = (attribute) => {
+    if (attribute.type === "string" &&
+        attribute.format &&
+        attribute.format.length > 0) {
+        console.log(`Parsing attribute ${attribute.key} with format ${attribute.format}, setting type to ${attribute.format.toLowerCase()}`);
+        // @ts-expect-error
+        attribute.type = attribute.format.toLowerCase();
+        delete attribute.format;
+    }
     if (attribute.type === "string") {
         return stringAttributeSchema.parse(attribute);
     }

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.0.271",
+  "version": "0.0.273",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/migrations/attributes.ts

@@ -1,8 +1,51 @@
 import { Query, type Databases, type Models } from "node-appwrite";
-import type { Attribute } from "./schema.js";
+import { parseAttribute, type Attribute } from "./schema.js";
 import { nameToIdMapping, enqueueOperation } from "./queue.js";
 import _ from "lodash";
 
+const attributesSame = (a: Attribute, b: Attribute) => {
+  // Direct type comparison for non-string types
+  // Also check if the type IS string and has a format for either
+  // That means the format is the type of the attribute
+  if (
+    a.type === b.type &&
+    !((a.type === "string" && a.format) || (b.type === "string" && b.format))
+  ) {
+    if (a.type === "relationship" && b.type === "relationship") {
+      return (
+        a.key === b.key &&
+        a.relationType === b.relationType &&
+        a.twoWay === b.twoWay &&
+        a.twoWayKey === b.twoWayKey &&
+        a.required === b.required
+      );
+    }
+    return a.key === b.key && a.array === b.array && a.required === b.required;
+  }
+
+  if (a.type === "string" && a.format) {
+    // @ts-expect-error
+    a.type = a.format;
+  }
+  if (b.type === "string" && b.format) {
+    // @ts-expect-error
+    b.type = b.format;
+  }
+
+  // Handling string types with specific formats in Appwrite
+  if (a.type === "string" && b.type === "string") {
+    return (
+      a.key === b.key &&
+      a.format === b.format &&
+      a.array === b.array &&
+      a.required === b.required
+    );
+  }
+
+  // Fallback to false if none of the above conditions are met
+  return false;
+};
+
 export const createOrUpdateAttribute = async (
   db: Databases,
   dbId: string,
@@ -13,16 +56,23 @@ export const createOrUpdateAttribute = async (
   let foundAttribute;
   try {
     foundAttribute = await db.getAttribute(dbId, collection.$id, attribute.key);
+    foundAttribute = parseAttribute(foundAttribute);
   } catch (error) {
     foundAttribute = undefined;
   }
   let numSameAttributes = 0;
-  if (foundAttribute && _.isEqual(foundAttribute, attribute)) {
+  if (foundAttribute && attributesSame(foundAttribute, attribute)) {
     numSameAttributes++;
     return;
-  } else if (foundAttribute && !_.isEqual(foundAttribute, attribute)) {
+  } else if (foundAttribute && !attributesSame(foundAttribute, attribute)) {
     console.log(
-      "Deleting attribute with same key but different values, assuming update..."
+      `Deleting attribute with same key ${attribute.key} -- ${
+        foundAttribute.key
+      } but different values -- ${JSON.stringify(
+        attribute,
+        null,
+        2
+      )} -- ${JSON.stringify(foundAttribute, null, 2)}`
     );
     await db.deleteAttribute(dbId, collection.$id, attribute.key);
   }

package/src/migrations/schema.ts

@@ -410,6 +410,20 @@ export const parseAttribute = (
     | EnumAttribute
     | RelationshipAttribute
 ) => {
+  if (
+    attribute.type === "string" &&
+    attribute.format &&
+    attribute.format.length > 0
+  ) {
+    console.log(
+      `Parsing attribute ${attribute.key} with format ${
+        attribute.format
+      }, setting type to ${attribute.format.toLowerCase()}`
+    );
+    // @ts-expect-error
+    attribute.type = attribute.format.toLowerCase();
+    delete attribute.format;
+  }
   if (attribute.type === "string") {
     return stringAttributeSchema.parse(attribute);
   } else if (attribute.type === "integer") {