appwrite-utils-cli 1.2.29 → 1.3.0

package/.treesummary/metadata.json

@@ -0,0 +1,47 @@
+{
+  "name": "appwrite-utils-cli",
+  "technologies": [
+    "Node.js",
+    "TypeScript"
+  ],
+  "dependencies": [
+    "@types/inquirer",
+    "@types/json-schema",
+    "@types/yargs",
+    "appwrite-utils",
+    "chalk",
+    "cli-progress",
+    "commander",
+    "es-toolkit",
+    "ignore",
+    "inquirer",
+    "js-yaml",
+    "luxon",
+    "nanostores",
+    "node-appwrite",
+    "p-limit",
+    "tar",
+    "tsx",
+    "ulidx",
+    "winston",
+    "yargs",
+    "zod",
+    "@types/cli-progress",
+    "@types/js-yaml",
+    "@types/lodash",
+    "@types/luxon",
+    "typescript"
+  ],
+  "entryPoints": [
+    "src/main.ts"
+  ],
+  "configFiles": [
+    "package.json",
+    "tsconfig.json"
+  ],
+  "buildOutputs": [
+    "dist"
+  ],
+  "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": "1.2.30"
+}

package/.treesummary/structure.txt

@@ -0,0 +1,132 @@
+📁 appwrite-utils-cli
+  📁 .appwrite
+    📁 .yaml_schemas
+      📄 appwrite-config.schema.json
+      📄 collection.schema.json
+    📁 collections
+      📄 Categories.yaml
+      📄 ExampleCollection.yaml
+      📄 Posts.yaml
+      📄 Users.yaml
+    📄 config.yaml
+    📁 import
+      📄 README.md
+      📄 categories-import.yaml
+      📄 posts-import.yaml
+      📄 users-import.yaml
+    📁 importData
+      📄 categories.json
+      📄 posts.json
+      📄 users.json
+    📁 schemas
+      📄 categories.json
+      📄 exampleCollection.json
+      📄 posts.json
+      📄 users.json
+  📄 .gitignore
+  📄 .npmignore
+  📄 README.md
+  📁 dist
+  📁 node_modules
+  📄 package.json
+  📁 src
+    📁 collections
+      📄 attributes.ts
+      📄 indexes.ts
+      📄 methods.ts
+    📁 config
+      📄 yamlConfig.ts
+    📁 databases
+      📄 methods.ts
+      📄 setup.ts
+    📁 functions
+      📄 deployments.ts
+      📄 methods.ts
+      📄 openapi.ts
+      📁 templates
+        📁 count-docs-in-collection
+          📄 README.md
+          📄 package.json
+          📁 src
+            📄 main.ts
+            📄 request.ts
+          📄 tsconfig.json
+        📁 typescript-node
+          📄 README.md
+          📄 package.json
+          📁 src
+            📄 index.ts
+          📄 tsconfig.json
+        📁 uv
+          📄 README.md
+          📄 pyproject.toml
+          📁 src
+            📄 __init__.py
+            📄 index.py
+    📄 init.ts
+    📄 interactiveCLI.ts
+    📄 main.ts
+    📁 migrations
+      📄 afterImportActions.ts
+      📄 appwriteToX.ts
+      📄 comprehensiveTransfer.ts
+      📄 dataLoader.ts
+      📄 importController.ts
+      📄 importDataActions.ts
+      📄 relationships.ts
+      📁 services
+        📄 DataTransformationService.ts
+        📄 FileHandlerService.ts
+        📄 ImportOrchestrator.ts
+        📄 RateLimitManager.ts
+        📄 RelationshipResolver.ts
+        📄 UserMappingService.ts
+        📄 ValidationService.ts
+      📄 transfer.ts
+      📁 yaml
+        📄 YamlImportConfigLoader.ts
+        📄 YamlImportIntegration.ts
+        📄 generateImportSchemas.ts
+    📁 schemas
+      📄 authUser.ts
+    📄 setup.ts
+    📄 setupCommands.ts
+    📄 setupController.ts
+    📁 shared
+      📄 attributeManager.ts
+      📄 confirmationDialogs.ts
+      📄 functionManager.ts
+      📄 indexManager.ts
+      📄 jsonSchemaGenerator.ts
+      📄 logging.ts
+      📄 messageFormatter.ts
+      📄 migrationHelpers.ts
+      📄 operationLogger.ts
+      📄 operationQueue.ts
+      📄 progressManager.ts
+      📄 schemaGenerator.ts
+    📁 storage
+      📄 methods.ts
+      📄 schemas.ts
+    📄 types.ts
+    📁 users
+      📄 methods.ts
+    📁 utils
+      📄 configMigration.ts
+      📄 constantsGenerator.ts
+      📄 dataConverters.ts
+      📄 getClientFromConfig.ts
+      📄 helperFunctions.ts
+      📄 index.ts
+      📄 loadConfigs.ts
+      📄 retryFailedPromises.ts
+      📄 schemaStrings.ts
+      📄 setupFiles.ts
+      📄 validationRules.ts
+      📄 yamlConverter.ts
+    📄 utilsController.ts
+  📄 tsconfig.json
+  📁 zlogs
+    📄 error.log
+    📄 info.log
+    📄 warn.log

package/README.md

@@ -327,6 +327,58 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+### 1.3.0 - Zod v4 Upgrade & Collection Management Fixes
+
+**🎉 Major Release - Zod v4 Compatibility & Reliability Improvements**
+
+#### Breaking Changes
+- **Zod v4 Upgrade**: Updated to Zod v4.0.0 for enhanced schema validation
+  - ⚠️ **Potential Breaking Change**: Some schema validations may behave differently
+  - Function event types are now more flexible to accommodate Zod v4 changes
+  - Review your validation schemas if you experience issues
+
+#### Major Bug Fixes
+- **Fixed Duplicate Attribute Creation**: Resolved issue where attributes were being created multiple times
+  - Implemented intelligent filtering to only process new or changed attributes
+  - Enhanced status monitoring and error handling
+  - Significantly improved sync performance and reliability
+
+- **Fixed Index Creation Issues**: Resolved indexes not being created from collection configurations
+  - Added proper null checks for index arrays from different collection sources
+  - Enhanced index creation with comprehensive status monitoring
+  - Improved error handling and retry logic for stuck indexes
+
+#### Enhanced Collection Management
+- **Smart Attribute Processing**: Attributes are now only created/updated when needed
+  - Compares existing vs. config attributes before processing
+  - Skips unchanged attributes with clear logging
+  - Better handling of edge cases and error conditions
+
+- **Improved Index Handling**: More robust index creation from collection configs
+  - Proper fallback logic when indexes are undefined
+  - Enhanced compatibility with different collection sources
+  - Better error reporting and debugging information
+
+#### Performance Improvements
+- **Optimized Sync Operations**: Collections now process only necessary changes
+- **Enhanced Status Monitoring**: Real-time feedback for attribute and index operations
+- **Better Resource Management**: Reduced API calls through intelligent filtering
+
+#### Developer Experience
+- **Build Stability**: Resolved TypeScript compilation issues with function schemas
+- **Type Safety**: Maintained strict typing while accommodating Zod v4 changes
+- **Enhanced Logging**: Better progress reporting and error messages
+
+#### Migration Guide
+1. **Update Dependencies**: Ensure compatibility with Zod v4.0.0
+2. **Test Collection Operations**: Verify that attribute and index creation works as expected
+3. **Review Validations**: Check any custom validation schemas for potential breaking changes
+4. **Function Events**: Function event arrays are now `string[]` for enhanced flexibility
+
+**Integration Note**: This version significantly improves collection management reliability and provides full Zod v4 compatibility. The fixes address core synchronization issues that could cause duplicate resources or missing indexes.
+
+---
+
 ### 1.1.0 - Enhanced Transfer System with Fault Tolerance
 
 **🔧 Robust Transfer Operations with Status Monitoring**

package/dist/collections/attributes.js

@@ -277,7 +277,8 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
                 nameToIdMapping.set(finalAttribute.relatedCollection, relatedCollectionId);
             }
         }
-        if (!(relatedCollectionId && collectionFoundViaRelatedCollection)) {
+        // Only queue relationship attributes that have dependencies
+        if (finalAttribute.type === "relationship" && !(relatedCollectionId && collectionFoundViaRelatedCollection)) {
             // console.log(`Enqueueing operation for attribute: ${finalAttribute.key}`);
             enqueueOperation({
                 type: "attribute",

package/dist/collections/methods.js

@@ -1,7 +1,7 @@
 import { Client, Databases, ID, Permission, Query, } from "node-appwrite";
 import { nameToIdMapping, processQueue } from "../shared/operationQueue.js";
-import { createUpdateCollectionAttributes } from "./attributes.js";
-import { createOrUpdateIndexes } from "./indexes.js";
+import { createUpdateCollectionAttributes, createUpdateCollectionAttributesWithStatusCheck } from "./attributes.js";
+import { createOrUpdateIndexes, createOrUpdateIndexesWithStatusCheck } from "./indexes.js";
 import { SchemaGenerator } from "../shared/schemaGenerator.js";
 import { isNull, isUndefined, isNil, isPlainObject, isString, isJSONValue, chunk, } from "es-toolkit";
 import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
@@ -267,17 +267,17 @@ export const createOrUpdateCollections = async (database, databaseId, config, de
         await delay(250);
         // Update attributes and indexes for the collection
         MessageFormatter.progress("Creating Attributes", { prefix: "Collections" });
-        await createUpdateCollectionAttributes(database, databaseId, collectionToUse, 
+        await createUpdateCollectionAttributesWithStatusCheck(database, databaseId, collectionToUse, 
         // @ts-expect-error
         attributes);
         // Add delay after creating attributes
         await delay(250);
-        const indexesToUse = indexes.length > 0
+        const indexesToUse = indexes && indexes.length > 0
             ? indexes
             : config.collections?.find((c) => c.$id === collectionToUse.$id)
                 ?.indexes ?? [];
         MessageFormatter.progress("Creating Indexes", { prefix: "Collections" });
-        await createOrUpdateIndexes(databaseId, database, collectionToUse.$id, indexesToUse);
+        await createOrUpdateIndexesWithStatusCheck(databaseId, database, collectionToUse.$id, collectionToUse, indexesToUse);
         // Add delay after creating indexes
         await delay(250);
     }

package/dist/shared/attributeManager.js

@@ -32,14 +32,20 @@ export const attributesSame = (databaseAttribute, configAttribute) => {
             const configValue = configAttribute[attr];
             // Use type-specific default values when comparing
             if (databaseAttribute.type === "integer") {
-                const defaultMin = attr === "min" ? -2147483647 : undefined;
-                const defaultMax = attr === "max" ? 2147483647 : undefined;
-                return (dbValue ?? defaultMin) === (configValue ?? defaultMax);
+                if (attr === "min") {
+                    return (dbValue ?? -2147483647) === (configValue ?? -2147483647);
+                }
+                else { // attr === "max"
+                    return (dbValue ?? 2147483647) === (configValue ?? 2147483647);
+                }
             }
             if (databaseAttribute.type === "double" || databaseAttribute.type === "float") {
-                const defaultMin = attr === "min" ? -2147483647 : undefined;
-                const defaultMax = attr === "max" ? 2147483647 : undefined;
-                return (dbValue ?? defaultMin) === (configValue ?? defaultMax);
+                if (attr === "min") {
+                    return (dbValue ?? -2147483647) === (configValue ?? -2147483647);
+                }
+                else { // attr === "max"
+                    return (dbValue ?? 2147483647) === (configValue ?? 2147483647);
+                }
             }
         }
         // Check if both objects have the attribute

package/dist/shared/schemaGenerator.js

@@ -354,62 +354,86 @@ export default appwriteConfig;
             const isArray = detail.isArray ? "array" : "";
             return [relatedCollectionName, key, isArray];
         });
-        let relatedTypes = "";
-        let relatedTypesLazy = "";
-        let curNum = 0;
-        let maxNum = relatedCollections.length;
-        relatedCollections.forEach((relatedCollection) => {
-            console.log(relatedCollection);
-            let relatedPascalName = toPascalCase(relatedCollection[0]);
-            let relatedCamelName = toCamelCase(relatedCollection[0]);
-            curNum++;
-            let endNameTypes = relatedPascalName;
-            let endNameLazy = `${relatedPascalName}Schema`;
-            if (relatedCollection[2] === "array") {
-                endNameTypes += "[]";
-                endNameLazy += ".array().default([])";
+        // Check if we have any relationships - if not, generate simple schema
+        const hasRelationships = relatedCollections.length > 0;
+        let schemaString = `${imports}\n\n`;
+        if (!hasRelationships) {
+            // Simple case: no relationships, generate single schema directly
+            schemaString += `export const ${pascalName}Schema = z.object({\n`;
+            schemaString += `  $id: z.string(),\n`;
+            schemaString += `  $createdAt: z.string(),\n`;
+            schemaString += `  $updatedAt: z.string(),\n`;
+            schemaString += `  $permissions: z.array(z.string()),\n`;
+            for (const attribute of attributes) {
+                if (attribute.type === "relationship") {
+                    continue;
+                }
+                schemaString += `  ${attribute.key}: ${this.typeToZod(attribute)},\n`;
             }
-            else if (!(relatedCollection[2] === "array")) {
-                endNameTypes += " | null";
-                endNameLazy += ".nullish()";
+            schemaString += `});\n\n`;
+            schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
+        }
+        else {
+            // Complex case: has relationships, generate BaseSchema + extended schema pattern
+            let relatedTypes = "";
+            let relatedTypesLazy = "";
+            let curNum = 0;
+            let maxNum = relatedCollections.length;
+            relatedCollections.forEach((relatedCollection) => {
+                console.log(relatedCollection);
+                let relatedPascalName = toPascalCase(relatedCollection[0]);
+                let relatedCamelName = toCamelCase(relatedCollection[0]);
+                curNum++;
+                let endNameTypes = relatedPascalName;
+                let endNameLazy = `${relatedPascalName}Schema`;
+                if (relatedCollection[2] === "array") {
+                    endNameTypes += "[]";
+                    endNameLazy += ".array().default([])";
+                }
+                else if (!(relatedCollection[2] === "array")) {
+                    endNameTypes += " | null";
+                    endNameLazy += ".nullish()";
+                }
+                imports += `import { ${relatedPascalName}Schema, type ${relatedPascalName} } from "./${relatedCamelName}";\n`;
+                relatedTypes += `${relatedCollection[1]}?: ${endNameTypes};\n`;
+                if (relatedTypes.length > 0 && curNum !== maxNum) {
+                    relatedTypes += "  ";
+                }
+                relatedTypesLazy += `${relatedCollection[1]}: z.lazy(() => ${endNameLazy}),\n`;
+                if (relatedTypesLazy.length > 0 && curNum !== maxNum) {
+                    relatedTypesLazy += "  ";
+                }
+            });
+            // Re-add imports after processing relationships
+            schemaString = `${imports}\n\n`;
+            schemaString += `export const ${pascalName}SchemaBase = z.object({\n`;
+            schemaString += `  $id: z.string(),\n`;
+            schemaString += `  $createdAt: z.string(),\n`;
+            schemaString += `  $updatedAt: z.string(),\n`;
+            schemaString += `  $permissions: z.array(z.string()),\n`;
+            for (const attribute of attributes) {
+                if (attribute.type === "relationship") {
+                    continue;
+                }
+                schemaString += `  ${attribute.key}: ${this.typeToZod(attribute)},\n`;
             }
-            imports += `import { ${relatedPascalName}Schema, type ${relatedPascalName} } from "./${relatedCamelName}";\n`;
-            relatedTypes += `${relatedCollection[1]}?: ${endNameTypes};\n`;
-            if (relatedTypes.length > 0 && curNum !== maxNum) {
-                relatedTypes += "  ";
+            schemaString += `});\n\n`;
+            schemaString += `export type ${pascalName}Base = z.infer<typeof ${pascalName}SchemaBase>`;
+            if (relatedTypes.length > 0) {
+                schemaString += ` & {\n  ${relatedTypes}};\n\n`;
             }
-            relatedTypesLazy += `${relatedCollection[1]}: z.lazy(() => ${endNameLazy}),\n`;
-            if (relatedTypesLazy.length > 0 && curNum !== maxNum) {
-                relatedTypesLazy += "  ";
+            else {
+                schemaString += `;\n\n`;
             }
-        });
-        let schemaString = `${imports}\n\n`;
-        schemaString += `export const ${pascalName}SchemaBase = z.object({\n`;
-        schemaString += `  $id: z.string().optional(),\n`;
-        schemaString += `  $createdAt: z.string().optional(),\n`;
-        schemaString += `  $updatedAt: z.string().optional(),\n`;
-        for (const attribute of attributes) {
-            if (attribute.type === "relationship") {
-                continue;
+            schemaString += `export const ${pascalName}Schema: z.ZodType<${pascalName}Base> = ${pascalName}SchemaBase`;
+            if (relatedTypes.length > 0) {
+                schemaString += `.extend({\n  ${relatedTypesLazy}});\n\n`;
             }
-            schemaString += `  ${attribute.key}: ${this.typeToZod(attribute)},\n`;
-        }
-        schemaString += `});\n\n`;
-        schemaString += `export type ${pascalName}Base = z.infer<typeof ${pascalName}SchemaBase>`;
-        if (relatedTypes.length > 0) {
-            schemaString += ` & {\n  ${relatedTypes}};\n\n`;
-        }
-        else {
-            schemaString += `;\n\n`;
-        }
-        schemaString += `export const ${pascalName}Schema: z.ZodType<${pascalName}Base> = ${pascalName}SchemaBase`;
-        if (relatedTypes.length > 0) {
-            schemaString += `.extend({\n  ${relatedTypesLazy}});\n\n`;
-        }
-        else {
-            schemaString += `;\n`;
+            else {
+                schemaString += `;\n`;
+            }
+            schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
         }
-        schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
         return schemaString;
     };
     typeToZod = (attribute) => {

package/dist/utils/schemaStrings.js

@@ -233,62 +233,86 @@ export class SchemaGenerator {
             const isArray = detail.isArray ? "array" : "";
             return [relatedCollectionName, key, isArray];
         });
-        let relatedTypes = "";
-        let relatedTypesLazy = "";
-        let curNum = 0;
-        let maxNum = relatedCollections.length;
-        relatedCollections.forEach((relatedCollection) => {
-            console.log(relatedCollection);
-            let relatedPascalName = toPascalCase(relatedCollection[0]);
-            let relatedCamelName = toCamelCase(relatedCollection[0]);
-            curNum++;
-            let endNameTypes = relatedPascalName;
-            let endNameLazy = `${relatedPascalName}Schema`;
-            if (relatedCollection[2] === "array") {
-                endNameTypes += "[]";
-                endNameLazy += ".array().default([])";
+        // Check if we have any relationships - if not, generate simple schema
+        const hasRelationships = relatedCollections.length > 0;
+        let schemaString = `${imports}\n\n`;
+        if (!hasRelationships) {
+            // Simple case: no relationships, generate single schema directly
+            schemaString += `export const ${pascalName}Schema = z.object({\n`;
+            schemaString += `  $id: z.string(),\n`;
+            schemaString += `  $createdAt: z.string(),\n`;
+            schemaString += `  $updatedAt: z.string(),\n`;
+            schemaString += `  $permissions: z.array(z.string()),\n`;
+            for (const attribute of attributes) {
+                if (attribute.type === "relationship") {
+                    continue;
+                }
+                schemaString += `  ${attribute.key}: ${this.typeToZod(attribute)},\n`;
             }
-            else if (!(relatedCollection[2] === "array")) {
-                endNameTypes += " | null";
-                endNameLazy += ".nullish()";
+            schemaString += `});\n\n`;
+            schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
+        }
+        else {
+            // Complex case: has relationships, generate BaseSchema + extended schema pattern
+            let relatedTypes = "";
+            let relatedTypesLazy = "";
+            let curNum = 0;
+            let maxNum = relatedCollections.length;
+            relatedCollections.forEach((relatedCollection) => {
+                console.log(relatedCollection);
+                let relatedPascalName = toPascalCase(relatedCollection[0]);
+                let relatedCamelName = toCamelCase(relatedCollection[0]);
+                curNum++;
+                let endNameTypes = relatedPascalName;
+                let endNameLazy = `${relatedPascalName}Schema`;
+                if (relatedCollection[2] === "array") {
+                    endNameTypes += "[]";
+                    endNameLazy += ".array().default([])";
+                }
+                else if (!(relatedCollection[2] === "array")) {
+                    endNameTypes += " | null";
+                    endNameLazy += ".nullish()";
+                }
+                imports += `import { ${relatedPascalName}Schema, type ${relatedPascalName} } from "./${relatedCamelName}";\n`;
+                relatedTypes += `${relatedCollection[1]}?: ${endNameTypes};\n`;
+                if (relatedTypes.length > 0 && curNum !== maxNum) {
+                    relatedTypes += "  ";
+                }
+                relatedTypesLazy += `${relatedCollection[1]}: z.lazy(() => ${endNameLazy}),\n`;
+                if (relatedTypesLazy.length > 0 && curNum !== maxNum) {
+                    relatedTypesLazy += "  ";
+                }
+            });
+            // Re-add imports after processing relationships
+            schemaString = `${imports}\n\n`;
+            schemaString += `export const ${pascalName}SchemaBase = z.object({\n`;
+            schemaString += `  $id: z.string(),\n`;
+            schemaString += `  $createdAt: z.string(),\n`;
+            schemaString += `  $updatedAt: z.string(),\n`;
+            schemaString += `  $permissions: z.array(z.string()),\n`;
+            for (const attribute of attributes) {
+                if (attribute.type === "relationship") {
+                    continue;
+                }
+                schemaString += `  ${attribute.key}: ${this.typeToZod(attribute)},\n`;
             }
-            imports += `import { ${relatedPascalName}Schema, type ${relatedPascalName} } from "./${relatedCamelName}";\n`;
-            relatedTypes += `${relatedCollection[1]}?: ${endNameTypes};\n`;
-            if (relatedTypes.length > 0 && curNum !== maxNum) {
-                relatedTypes += "  ";
+            schemaString += `});\n\n`;
+            schemaString += `export type ${pascalName}Base = z.infer<typeof ${pascalName}SchemaBase>`;
+            if (relatedTypes.length > 0) {
+                schemaString += ` & {\n  ${relatedTypes}};\n\n`;
             }
-            relatedTypesLazy += `${relatedCollection[1]}: z.lazy(() => ${endNameLazy}),\n`;
-            if (relatedTypesLazy.length > 0 && curNum !== maxNum) {
-                relatedTypesLazy += "  ";
+            else {
+                schemaString += `;\n\n`;
             }
-        });
-        let schemaString = `${imports}\n\n`;
-        schemaString += `export const ${pascalName}SchemaBase = z.object({\n`;
-        schemaString += `  $id: z.string().optional(),\n`;
-        schemaString += `  $createdAt: z.string().optional(),\n`;
-        schemaString += `  $updatedAt: z.string().optional(),\n`;
-        for (const attribute of attributes) {
-            if (attribute.type === "relationship") {
-                continue;
+            schemaString += `export const ${pascalName}Schema: z.ZodType<${pascalName}Base> = ${pascalName}SchemaBase`;
+            if (relatedTypes.length > 0) {
+                schemaString += `.extend({\n  ${relatedTypesLazy}});\n\n`;
             }
-            schemaString += `  ${attribute.key}: ${this.typeToZod(attribute)},\n`;
-        }
-        schemaString += `});\n\n`;
-        schemaString += `export type ${pascalName}Base = z.infer<typeof ${pascalName}SchemaBase>`;
-        if (relatedTypes.length > 0) {
-            schemaString += ` & {\n  ${relatedTypes}};\n\n`;
-        }
-        else {
-            schemaString += `;\n\n`;
-        }
-        schemaString += `export const ${pascalName}Schema: z.ZodType<${pascalName}Base> = ${pascalName}SchemaBase`;
-        if (relatedTypes.length > 0) {
-            schemaString += `.extend({\n  ${relatedTypesLazy}});\n\n`;
-        }
-        else {
-            schemaString += `;\n`;
+            else {
+                schemaString += `;\n`;
+            }
+            schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
         }
-        schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
         return schemaString;
     };
     typeToZod = (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": "1.2.29",
+  "version": "1.3.0",
   "main": "src/main.ts",
   "type": "module",
   "repository": {
@@ -50,7 +50,7 @@
     "ulidx": "^2.4.1",
     "winston": "^3.17.0",
     "yargs": "^18.0.0",
-    "zod": "^3.25.67"
+    "zod": "^4.0.0"
   },
   "devDependencies": {
     "@types/cli-progress": "^3.11.6",

package/src/collections/attributes.ts

@@ -437,7 +437,8 @@ export const createOrUpdateAttribute = async (
         );
       }
     }
-    if (!(relatedCollectionId && collectionFoundViaRelatedCollection)) {
+    // Only queue relationship attributes that have dependencies
+    if (finalAttribute.type === "relationship" && !(relatedCollectionId && collectionFoundViaRelatedCollection)) {
       // console.log(`Enqueueing operation for attribute: ${finalAttribute.key}`);
       enqueueOperation({
         type: "attribute",

package/src/collections/methods.ts

@@ -8,8 +8,8 @@ import {
 } from "node-appwrite";
 import type { AppwriteConfig, CollectionCreate, Indexes } from "appwrite-utils";
 import { nameToIdMapping, processQueue } from "../shared/operationQueue.js";
-import { createUpdateCollectionAttributes } from "./attributes.js";
-import { createOrUpdateIndexes } from "./indexes.js";
+import { createUpdateCollectionAttributes, createUpdateCollectionAttributesWithStatusCheck } from "./attributes.js";
+import { createOrUpdateIndexes, createOrUpdateIndexesWithStatusCheck } from "./indexes.js";
 import { SchemaGenerator } from "../shared/schemaGenerator.js";
 import {
   isNull,
@@ -426,7 +426,7 @@ export const createOrUpdateCollections = async (
 
     // Update attributes and indexes for the collection
     MessageFormatter.progress("Creating Attributes", { prefix: "Collections" });
-    await createUpdateCollectionAttributes(
+    await createUpdateCollectionAttributesWithStatusCheck(
       database,
       databaseId,
       collectionToUse!,
@@ -438,16 +438,17 @@ export const createOrUpdateCollections = async (
     await delay(250);
 
     const indexesToUse =
-      indexes.length > 0
+      indexes && indexes.length > 0
         ? indexes
         : config.collections?.find((c) => c.$id === collectionToUse!.$id)
             ?.indexes ?? [];
 
     MessageFormatter.progress("Creating Indexes", { prefix: "Collections" });
-    await createOrUpdateIndexes(
+    await createOrUpdateIndexesWithStatusCheck(
       databaseId,
       database,
       collectionToUse!.$id,
+      collectionToUse!,
       indexesToUse as Indexes
     );
 

package/src/shared/attributeManager.ts

@@ -43,14 +43,18 @@ export const attributesSame = (
 
       // Use type-specific default values when comparing
       if (databaseAttribute.type === "integer") {
-        const defaultMin = attr === "min" ? -2147483647 : undefined;
-        const defaultMax = attr === "max" ? 2147483647 : undefined;
-        return (dbValue ?? defaultMin) === (configValue ?? defaultMax);
+        if (attr === "min") {
+          return (dbValue ?? -2147483647) === (configValue ?? -2147483647);
+        } else { // attr === "max"
+          return (dbValue ?? 2147483647) === (configValue ?? 2147483647);
+        }
       }
       if (databaseAttribute.type === "double" || databaseAttribute.type === "float") {
-        const defaultMin = attr === "min" ? -2147483647 : undefined;
-        const defaultMax = attr === "max" ? 2147483647 : undefined;
-        return (dbValue ?? defaultMin) === (configValue ?? defaultMax);
+        if (attr === "min") {
+          return (dbValue ?? -2147483647) === (configValue ?? -2147483647);
+        } else { // attr === "max"
+          return (dbValue ?? 2147483647) === (configValue ?? 2147483647);
+        }
       }
     }
 

package/src/shared/schemaGenerator.ts

@@ -443,60 +443,87 @@ export default appwriteConfig;
         return [relatedCollectionName, key, isArray];
       });
 
-    let relatedTypes = "";
-    let relatedTypesLazy = "";
-    let curNum = 0;
-    let maxNum = relatedCollections.length;
-    relatedCollections.forEach((relatedCollection) => {
-      console.log(relatedCollection);
-      let relatedPascalName = toPascalCase(relatedCollection[0]);
-      let relatedCamelName = toCamelCase(relatedCollection[0]);
-      curNum++;
-      let endNameTypes = relatedPascalName;
-      let endNameLazy = `${relatedPascalName}Schema`;
-      if (relatedCollection[2] === "array") {
-        endNameTypes += "[]";
-        endNameLazy += ".array().default([])";
-      } else if (!(relatedCollection[2] === "array")) {
-        endNameTypes += " | null";
-        endNameLazy += ".nullish()";
+    // Check if we have any relationships - if not, generate simple schema
+    const hasRelationships = relatedCollections.length > 0;
+    
+    let schemaString = `${imports}\n\n`;
+
+    if (!hasRelationships) {
+      // Simple case: no relationships, generate single schema directly
+      schemaString += `export const ${pascalName}Schema = z.object({\n`;
+      schemaString += `  $id: z.string(),\n`;
+      schemaString += `  $createdAt: z.string(),\n`;
+      schemaString += `  $updatedAt: z.string(),\n`;
+      schemaString += `  $permissions: z.array(z.string()),\n`;
+      for (const attribute of attributes) {
+        if (attribute.type === "relationship") {
+          continue;
+        }
+        schemaString += `  ${attribute.key}: ${this.typeToZod(attribute)},\n`;
       }
-      imports += `import { ${relatedPascalName}Schema, type ${relatedPascalName} } from "./${relatedCamelName}";\n`;
-      relatedTypes += `${relatedCollection[1]}?: ${endNameTypes};\n`;
-      if (relatedTypes.length > 0 && curNum !== maxNum) {
-        relatedTypes += "  ";
+      schemaString += `});\n\n`;
+      schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
+    } else {
+      // Complex case: has relationships, generate BaseSchema + extended schema pattern
+      let relatedTypes = "";
+      let relatedTypesLazy = "";
+      let curNum = 0;
+      let maxNum = relatedCollections.length;
+      
+      relatedCollections.forEach((relatedCollection) => {
+        console.log(relatedCollection);
+        let relatedPascalName = toPascalCase(relatedCollection[0]);
+        let relatedCamelName = toCamelCase(relatedCollection[0]);
+        curNum++;
+        let endNameTypes = relatedPascalName;
+        let endNameLazy = `${relatedPascalName}Schema`;
+        if (relatedCollection[2] === "array") {
+          endNameTypes += "[]";
+          endNameLazy += ".array().default([])";
+        } else if (!(relatedCollection[2] === "array")) {
+          endNameTypes += " | null";
+          endNameLazy += ".nullish()";
+        }
+        imports += `import { ${relatedPascalName}Schema, type ${relatedPascalName} } from "./${relatedCamelName}";\n`;
+        relatedTypes += `${relatedCollection[1]}?: ${endNameTypes};\n`;
+        if (relatedTypes.length > 0 && curNum !== maxNum) {
+          relatedTypes += "  ";
+        }
+        relatedTypesLazy += `${relatedCollection[1]}: z.lazy(() => ${endNameLazy}),\n`;
+        if (relatedTypesLazy.length > 0 && curNum !== maxNum) {
+          relatedTypesLazy += "  ";
+        }
+      });
+
+      // Re-add imports after processing relationships
+      schemaString = `${imports}\n\n`;
+      
+      schemaString += `export const ${pascalName}SchemaBase = z.object({\n`;
+      schemaString += `  $id: z.string(),\n`;
+      schemaString += `  $createdAt: z.string(),\n`;
+      schemaString += `  $updatedAt: z.string(),\n`;
+      schemaString += `  $permissions: z.array(z.string()),\n`;
+      for (const attribute of attributes) {
+        if (attribute.type === "relationship") {
+          continue;
+        }
+        schemaString += `  ${attribute.key}: ${this.typeToZod(attribute)},\n`;
       }
-      relatedTypesLazy += `${relatedCollection[1]}: z.lazy(() => ${endNameLazy}),\n`;
-      if (relatedTypesLazy.length > 0 && curNum !== maxNum) {
-        relatedTypesLazy += "  ";
+      schemaString += `});\n\n`;
+      schemaString += `export type ${pascalName}Base = z.infer<typeof ${pascalName}SchemaBase>`;
+      if (relatedTypes.length > 0) {
+        schemaString += ` & {\n  ${relatedTypes}};\n\n`;
+      } else {
+        schemaString += `;\n\n`;
       }
-    });
-
-    let schemaString = `${imports}\n\n`;
-    schemaString += `export const ${pascalName}SchemaBase = z.object({\n`;
-    schemaString += `  $id: z.string().optional(),\n`;
-    schemaString += `  $createdAt: z.string().optional(),\n`;
-    schemaString += `  $updatedAt: z.string().optional(),\n`;
-    for (const attribute of attributes) {
-      if (attribute.type === "relationship") {
-        continue;
+      schemaString += `export const ${pascalName}Schema: z.ZodType<${pascalName}Base> = ${pascalName}SchemaBase`;
+      if (relatedTypes.length > 0) {
+        schemaString += `.extend({\n  ${relatedTypesLazy}});\n\n`;
+      } else {
+        schemaString += `;\n`;
       }
-      schemaString += `  ${attribute.key}: ${this.typeToZod(attribute)},\n`;
-    }
-    schemaString += `});\n\n`;
-    schemaString += `export type ${pascalName}Base = z.infer<typeof ${pascalName}SchemaBase>`;
-    if (relatedTypes.length > 0) {
-      schemaString += ` & {\n  ${relatedTypes}};\n\n`;
-    } else {
-      schemaString += `;\n\n`;
-    }
-    schemaString += `export const ${pascalName}Schema: z.ZodType<${pascalName}Base> = ${pascalName}SchemaBase`;
-    if (relatedTypes.length > 0) {
-      schemaString += `.extend({\n  ${relatedTypesLazy}});\n\n`;
-    } else {
-      schemaString += `;\n`;
+      schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
     }
-    schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
 
     return schemaString;
   };

package/src/utils/schemaStrings.ts

@@ -306,60 +306,87 @@ export class SchemaGenerator {
         return [relatedCollectionName, key, isArray];
       });
 
-    let relatedTypes = "";
-    let relatedTypesLazy = "";
-    let curNum = 0;
-    let maxNum = relatedCollections.length;
-    relatedCollections.forEach((relatedCollection) => {
-      console.log(relatedCollection);
-      let relatedPascalName = toPascalCase(relatedCollection[0]);
-      let relatedCamelName = toCamelCase(relatedCollection[0]);
-      curNum++;
-      let endNameTypes = relatedPascalName;
-      let endNameLazy = `${relatedPascalName}Schema`;
-      if (relatedCollection[2] === "array") {
-        endNameTypes += "[]";
-        endNameLazy += ".array().default([])";
-      } else if (!(relatedCollection[2] === "array")) {
-        endNameTypes += " | null";
-        endNameLazy += ".nullish()";
+    // Check if we have any relationships - if not, generate simple schema
+    const hasRelationships = relatedCollections.length > 0;
+    
+    let schemaString = `${imports}\n\n`;
+
+    if (!hasRelationships) {
+      // Simple case: no relationships, generate single schema directly
+      schemaString += `export const ${pascalName}Schema = z.object({\n`;
+      schemaString += `  $id: z.string(),\n`;
+      schemaString += `  $createdAt: z.string(),\n`;
+      schemaString += `  $updatedAt: z.string(),\n`;
+      schemaString += `  $permissions: z.array(z.string()),\n`;
+      for (const attribute of attributes) {
+        if (attribute.type === "relationship") {
+          continue;
+        }
+        schemaString += `  ${attribute.key}: ${this.typeToZod(attribute)},\n`;
       }
-      imports += `import { ${relatedPascalName}Schema, type ${relatedPascalName} } from "./${relatedCamelName}";\n`;
-      relatedTypes += `${relatedCollection[1]}?: ${endNameTypes};\n`;
-      if (relatedTypes.length > 0 && curNum !== maxNum) {
-        relatedTypes += "  ";
+      schemaString += `});\n\n`;
+      schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
+    } else {
+      // Complex case: has relationships, generate BaseSchema + extended schema pattern
+      let relatedTypes = "";
+      let relatedTypesLazy = "";
+      let curNum = 0;
+      let maxNum = relatedCollections.length;
+      
+      relatedCollections.forEach((relatedCollection) => {
+        console.log(relatedCollection);
+        let relatedPascalName = toPascalCase(relatedCollection[0]);
+        let relatedCamelName = toCamelCase(relatedCollection[0]);
+        curNum++;
+        let endNameTypes = relatedPascalName;
+        let endNameLazy = `${relatedPascalName}Schema`;
+        if (relatedCollection[2] === "array") {
+          endNameTypes += "[]";
+          endNameLazy += ".array().default([])";
+        } else if (!(relatedCollection[2] === "array")) {
+          endNameTypes += " | null";
+          endNameLazy += ".nullish()";
+        }
+        imports += `import { ${relatedPascalName}Schema, type ${relatedPascalName} } from "./${relatedCamelName}";\n`;
+        relatedTypes += `${relatedCollection[1]}?: ${endNameTypes};\n`;
+        if (relatedTypes.length > 0 && curNum !== maxNum) {
+          relatedTypes += "  ";
+        }
+        relatedTypesLazy += `${relatedCollection[1]}: z.lazy(() => ${endNameLazy}),\n`;
+        if (relatedTypesLazy.length > 0 && curNum !== maxNum) {
+          relatedTypesLazy += "  ";
+        }
+      });
+
+      // Re-add imports after processing relationships
+      schemaString = `${imports}\n\n`;
+      
+      schemaString += `export const ${pascalName}SchemaBase = z.object({\n`;
+      schemaString += `  $id: z.string(),\n`;
+      schemaString += `  $createdAt: z.string(),\n`;
+      schemaString += `  $updatedAt: z.string(),\n`;
+      schemaString += `  $permissions: z.array(z.string()),\n`;
+      for (const attribute of attributes) {
+        if (attribute.type === "relationship") {
+          continue;
+        }
+        schemaString += `  ${attribute.key}: ${this.typeToZod(attribute)},\n`;
       }
-      relatedTypesLazy += `${relatedCollection[1]}: z.lazy(() => ${endNameLazy}),\n`;
-      if (relatedTypesLazy.length > 0 && curNum !== maxNum) {
-        relatedTypesLazy += "  ";
+      schemaString += `});\n\n`;
+      schemaString += `export type ${pascalName}Base = z.infer<typeof ${pascalName}SchemaBase>`;
+      if (relatedTypes.length > 0) {
+        schemaString += ` & {\n  ${relatedTypes}};\n\n`;
+      } else {
+        schemaString += `;\n\n`;
       }
-    });
-
-    let schemaString = `${imports}\n\n`;
-    schemaString += `export const ${pascalName}SchemaBase = z.object({\n`;
-    schemaString += `  $id: z.string().optional(),\n`;
-    schemaString += `  $createdAt: z.string().optional(),\n`;
-    schemaString += `  $updatedAt: z.string().optional(),\n`;
-    for (const attribute of attributes) {
-      if (attribute.type === "relationship") {
-        continue;
+      schemaString += `export const ${pascalName}Schema: z.ZodType<${pascalName}Base> = ${pascalName}SchemaBase`;
+      if (relatedTypes.length > 0) {
+        schemaString += `.extend({\n  ${relatedTypesLazy}});\n\n`;
+      } else {
+        schemaString += `;\n`;
       }
-      schemaString += `  ${attribute.key}: ${this.typeToZod(attribute)},\n`;
-    }
-    schemaString += `});\n\n`;
-    schemaString += `export type ${pascalName}Base = z.infer<typeof ${pascalName}SchemaBase>`;
-    if (relatedTypes.length > 0) {
-      schemaString += ` & {\n  ${relatedTypes}};\n\n`;
-    } else {
-      schemaString += `;\n\n`;
-    }
-    schemaString += `export const ${pascalName}Schema: z.ZodType<${pascalName}Base> = ${pascalName}SchemaBase`;
-    if (relatedTypes.length > 0) {
-      schemaString += `.extend({\n  ${relatedTypesLazy}});\n\n`;
-    } else {
-      schemaString += `;\n`;
+      schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
     }
-    schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
 
     return schemaString;
   };