appwrite-utils-cli 0.0.273 → 0.0.275

package/dist/migrations/attributes.js

@@ -1,174 +1,202 @@
 import { Query } from "node-appwrite";
-import { parseAttribute } from "./schema.js";
+import { attributeSchema, parseAttribute, } from "appwrite-utils";
 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;
+const attributesSame = (databaseAttribute, configAttribute) => {
+    return (databaseAttribute.key == configAttribute.key &&
+        databaseAttribute.type == configAttribute.type &&
+        databaseAttribute.array == configAttribute.array);
 };
 export const createOrUpdateAttribute = async (db, dbId, collection, attribute) => {
     let action = "create";
     let foundAttribute;
+    const updateEnabled = false;
+    let finalAttribute = attribute;
     try {
-        foundAttribute = await db.getAttribute(dbId, collection.$id, attribute.key);
-        foundAttribute = parseAttribute(foundAttribute);
+        const collectionAttr = collection.attributes.find(
+        // @ts-expect-error
+        (attr) => attr.key === attribute.key);
+        foundAttribute = parseAttribute(collectionAttr);
     }
     catch (error) {
         foundAttribute = undefined;
     }
-    let numSameAttributes = 0;
-    if (foundAttribute && attributesSame(foundAttribute, attribute)) {
-        numSameAttributes++;
-        return;
+    if (foundAttribute &&
+        attributesSame(foundAttribute, attribute) &&
+        updateEnabled) {
+        // Check if mutable properties have changed and set action to "update" if necessary
+        const requiredChanged = "required" in foundAttribute && "required" in attribute
+            ? foundAttribute.required !== attribute.required
+            : false;
+        // const xdefaultChanged =
+        //   "xdefault" in foundAttribute && "xdefault" in attribute
+        //     ? foundAttribute.xdefault !== attribute.xdefault
+        //     : false;
+        const onDeleteChanged = foundAttribute.type === "relationship" &&
+            attribute.type === "relationship" &&
+            "onDelete" in foundAttribute &&
+            "onDelete" in attribute
+            ? foundAttribute.onDelete !== attribute.onDelete
+            : false;
+        if (requiredChanged || onDeleteChanged) {
+            console.log(`Required changed: ${requiredChanged}\nOnDelete changed: ${onDeleteChanged}`);
+            console.log(`Found attribute: ${JSON.stringify(foundAttribute, null, 2)}`);
+            console.log(`Attribute: ${JSON.stringify(attribute, null, 2)}`);
+            finalAttribute = {
+                ...attribute,
+                ...foundAttribute,
+            };
+            action = "update";
+        }
+        else {
+            // If no properties that can be updated have changed, return early
+            return;
+        }
     }
-    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)}`);
+    else if (foundAttribute &&
+        !attributesSame(foundAttribute, attribute) &&
+        updateEnabled) {
+        console.log(`Deleting attribute with same key ${attribute.key} -- but different values -- ${JSON.stringify(attribute, null, 2)} -- ${JSON.stringify(foundAttribute, null, 2)}`);
         await db.deleteAttribute(dbId, collection.$id, attribute.key);
+        // After deletion, you might want to create the attribute anew
+        finalAttribute = attribute;
+        action = "create";
+    }
+    else if (!updateEnabled && foundAttribute) {
+        return;
     }
     // Relationship attribute logic with adjustments
     let collectionFoundViaRelatedCollection;
     let relatedCollectionId;
-    if (attribute.type === "relationship") {
-        if (nameToIdMapping.has(attribute.relatedCollection)) {
-            relatedCollectionId = nameToIdMapping.get(attribute.relatedCollection);
+    if (finalAttribute.type === "relationship") {
+        if (nameToIdMapping.has(finalAttribute.relatedCollection)) {
+            relatedCollectionId = nameToIdMapping.get(finalAttribute.relatedCollection);
             try {
                 collectionFoundViaRelatedCollection = await db.getCollection(dbId, relatedCollectionId);
             }
             catch (e) {
-                console.log(`Collection not found: ${attribute.relatedCollection} when nameToIdMapping was set`);
+                console.log(`Collection not found: ${finalAttribute.relatedCollection} when nameToIdMapping was set`);
                 collectionFoundViaRelatedCollection = undefined;
             }
         }
         else {
             const collectionsPulled = await db.listCollections(dbId, [
-                Query.equal("name", attribute.relatedCollection),
+                Query.equal("name", finalAttribute.relatedCollection),
             ]);
             if (collectionsPulled.total > 0) {
                 collectionFoundViaRelatedCollection = collectionsPulled.collections[0];
                 relatedCollectionId = collectionFoundViaRelatedCollection.$id;
-                nameToIdMapping.set(attribute.relatedCollection, relatedCollectionId);
+                nameToIdMapping.set(finalAttribute.relatedCollection, relatedCollectionId);
             }
         }
         if (!(relatedCollectionId && collectionFoundViaRelatedCollection)) {
-            console.log(`Enqueueing operation for attribute: ${attribute.key}`);
+            console.log(`Enqueueing operation for attribute: ${finalAttribute.key}`);
             enqueueOperation({
                 type: "attribute",
                 collectionId: collection.$id,
                 collection: collection,
                 attribute,
-                dependencies: [attribute.relatedCollection],
+                dependencies: [finalAttribute.relatedCollection],
             });
             return;
         }
     }
-    switch (attribute.type) {
+    finalAttribute = attributeSchema.parse(finalAttribute);
+    switch (finalAttribute.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);
+                await db.createStringAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.size, finalAttribute.required || false, finalAttribute.xdefault || undefined, finalAttribute.array || false, finalAttribute.encrypted);
             }
             else {
-                await db.updateStringAttribute(dbId, collection.$id, attribute.key, attribute.required, attribute.xdefault || undefined);
+                await db.updateStringAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.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);
+                if (finalAttribute.min &&
+                    BigInt(finalAttribute.min) === BigInt(-9223372036854776000)) {
+                    delete finalAttribute.min;
+                }
+                if (finalAttribute.max &&
+                    BigInt(finalAttribute.max) === BigInt(9223372036854776000)) {
+                    delete finalAttribute.max;
+                }
+                await db.createIntegerAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.min, finalAttribute.max, finalAttribute.xdefault || undefined, finalAttribute.array);
             }
             else {
-                await db.updateIntegerAttribute(dbId, collection.$id, attribute.key, attribute.required, attribute.min || 0, attribute.max || 2147483647, attribute.xdefault || undefined);
+                if (finalAttribute.min &&
+                    BigInt(finalAttribute.min) === BigInt(-9223372036854776000)) {
+                    delete finalAttribute.min;
+                }
+                if (finalAttribute.max &&
+                    BigInt(finalAttribute.max) === BigInt(9223372036854776000)) {
+                    delete finalAttribute.max;
+                }
+                await db.updateIntegerAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.min || 0, finalAttribute.max || 2147483647, finalAttribute.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);
+                await db.createFloatAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.min, finalAttribute.max, finalAttribute.xdefault || undefined, finalAttribute.array);
             }
             else {
-                await db.updateFloatAttribute(dbId, collection.$id, attribute.key, attribute.required, attribute.min || 0, attribute.max || 2147483647, attribute.xdefault || undefined);
+                await db.updateFloatAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.min || 0, finalAttribute.max || 2147483647, finalAttribute.xdefault || undefined);
             }
             break;
         case "boolean":
             if (action === "create") {
-                await db.createBooleanAttribute(dbId, collection.$id, attribute.key, attribute.required, attribute.xdefault || undefined, attribute.array);
+                await db.createBooleanAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || undefined, finalAttribute.array);
             }
             else {
-                await db.updateBooleanAttribute(dbId, collection.$id, attribute.key, attribute.required, attribute.xdefault || undefined);
+                await db.updateBooleanAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || null);
             }
             break;
         case "datetime":
             if (action === "create") {
-                await db.createDatetimeAttribute(dbId, collection.$id, attribute.key, attribute.required, attribute.xdefault || undefined, attribute.array);
+                await db.createDatetimeAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || undefined, finalAttribute.array);
             }
             else {
-                await db.updateDatetimeAttribute(dbId, collection.$id, attribute.key, attribute.required, attribute.xdefault || undefined);
+                await db.updateDatetimeAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || undefined);
             }
             break;
         case "email":
             if (action === "create") {
-                await db.createEmailAttribute(dbId, collection.$id, attribute.key, attribute.required, attribute.xdefault || undefined, attribute.array);
+                await db.createEmailAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || undefined, finalAttribute.array);
             }
             else {
-                await db.updateEmailAttribute(dbId, collection.$id, attribute.key, attribute.required, attribute.xdefault || undefined);
+                await db.updateEmailAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || undefined);
             }
             break;
         case "ip":
             if (action === "create") {
-                await db.createIpAttribute(dbId, collection.$id, attribute.key, attribute.required, attribute.xdefault || undefined, attribute.array);
+                await db.createIpAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || undefined, finalAttribute.array);
             }
             else {
-                await db.updateIpAttribute(dbId, collection.$id, attribute.key, attribute.required, attribute.xdefault || undefined);
+                await db.updateIpAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || undefined);
             }
             break;
         case "url":
             if (action === "create") {
-                await db.createUrlAttribute(dbId, collection.$id, attribute.key, attribute.required, attribute.xdefault || undefined, attribute.array);
+                await db.createUrlAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault || undefined, finalAttribute.array);
             }
             else {
-                await db.updateUrlAttribute(dbId, collection.$id, attribute.key, attribute.required, attribute.xdefault || undefined);
+                await db.updateUrlAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.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);
+                await db.createEnumAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.elements, finalAttribute.required || false, finalAttribute.xdefault || undefined, finalAttribute.array);
             }
             else {
-                await db.updateEnumAttribute(dbId, collection.$id, attribute.key, attribute.elements, attribute.required, attribute.xdefault || undefined);
+                await db.updateEnumAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.elements, finalAttribute.required || false, finalAttribute.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);
+                await db.createRelationshipAttribute(dbId, collection.$id, relatedCollectionId, finalAttribute.relationType, finalAttribute.twoWay, finalAttribute.key, finalAttribute.twoWayKey, finalAttribute.onDelete);
             }
             else {
-                await db.updateRelationshipAttribute(dbId, collection.$id, attribute.key, attribute.onDelete);
+                await db.updateRelationshipAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.onDelete);
             }
             break;
         default: