appwrite-utils-cli 1.4.1 → 1.5.1

package/src/shared/operationQueue.ts

@@ -33,39 +33,54 @@ export const processQueue = async (db: Databases, dbId: string) => {
       let collectionFound: Models.Collection | undefined;
 
       // Handle relationship attribute operations
-      if (operation.attribute?.type === "relationship") {
-        // Attempt to resolve the collection directly if collectionId is specified
-        if (operation.collectionId) {
-          console.log(`\tFetching collection by ID: ${operation.collectionId}`);
-          try {
-            collectionFound = await tryAwaitWithRetry(
-              async () => await db.getCollection(dbId, operation.collectionId!)
-            );
-          } catch (e) {
-            console.log(
-              `\tCollection not found by ID: ${operation.collectionId}`
-            );
-          }
-        }
-        // Attempt to resolve related collection if specified and not already found
-        if (!collectionFound && operation.attribute?.relatedCollection) {
-          collectionFound = await fetchAndCacheCollectionByName(
-            db,
-            dbId,
-            operation.attribute.relatedCollection
-          );
-        }
-        // Handle dependencies if collection still not found
-        if (!collectionFound) {
-          for (const dep of operation.dependencies || []) {
-            collectionFound = await fetchAndCacheCollectionByName(
-              db,
-              dbId,
-              dep
-            );
-            if (collectionFound) break; // Break early if collection is found
-          }
-        }
+      if (operation.attribute?.type === "relationship") {
+        // Attempt to resolve the collection directly if collectionId is specified
+        if (operation.collectionId) {
+          console.log(`\tFetching collection by ID: ${operation.collectionId}`);
+          try {
+            collectionFound = await tryAwaitWithRetry(
+              async () => await db.getCollection(dbId, operation.collectionId!)
+            );
+          } catch (e) {
+            console.log(
+              `\tCollection not found by ID: ${operation.collectionId}`
+            );
+          }
+        }
+        // Attempt to resolve related collection if specified and not already found
+        if (!collectionFound && operation.attribute?.relatedCollection) {
+          // First, try treating relatedCollection as an ID
+          try {
+            const relAttr: any = operation.attribute as any;
+            const byId = await tryAwaitWithRetry(
+              async () => await db.getCollection(dbId, relAttr.relatedCollection as string)
+            );
+            // We still need the target collection (operation.collectionId) to create the attribute on,
+            // so only use this branch to warm caches/mappings and continue to dependency checks.
+            // Do not override collectionFound with the related collection.
+          } catch (_) {
+            // Not an ID or not found; fall back to name-based cache
+          }
+
+          // Warm cache by name (used by attribute creation path), but do not use as target collection
+          const relAttr: any = operation.attribute as any;
+          await fetchAndCacheCollectionByName(
+            db,
+            dbId,
+            relAttr.relatedCollection
+          );
+        }
+        // Handle dependencies if collection still not found
+        if (!collectionFound) {
+          for (const dep of operation.dependencies || []) {
+            collectionFound = await fetchAndCacheCollectionByName(
+              db,
+              dbId,
+              dep
+            );
+            if (collectionFound) break; // Break early if collection is found
+          }
+        }
       } else if (operation.collectionId) {
         // Handle non-relationship operations with a specified collectionId
         console.log(`\tFetching collection by ID: ${operation.collectionId}`);

package/src/shared/schemaGenerator.ts

@@ -22,16 +22,23 @@ interface RelationshipDetail {
   isChild: boolean;
 }
 
-export class SchemaGenerator {
-  private relationshipMap = new Map<string, RelationshipDetail[]>();
-  private config: AppwriteConfig;
-  private appwriteFolderPath: string;
-
-  constructor(config: AppwriteConfig, appwriteFolderPath: string) {
-    this.config = config;
-    this.appwriteFolderPath = appwriteFolderPath;
-    this.extractRelationships();
-  }
+export class SchemaGenerator {
+  private relationshipMap = new Map<string, RelationshipDetail[]>();
+  private config: AppwriteConfig;
+  private appwriteFolderPath: string;
+
+  constructor(config: AppwriteConfig, appwriteFolderPath: string) {
+    this.config = config;
+    this.appwriteFolderPath = appwriteFolderPath;
+    this.extractRelationships();
+  }
+
+  private resolveCollectionName = (idOrName: string): string => {
+    const col = this.config.collections?.find(
+      (c) => c.$id === (idOrName as any) || c.name === idOrName
+    );
+    return col?.name ?? idOrName;
+  };
 
   public updateYamlCollections(): void {
     const collections = this.config.collections;
@@ -291,12 +298,12 @@ export default appwriteConfig;
       if (!collection.attributes) {
         return;
       }
-      collection.attributes.forEach((attr) => {
-        if (attr.type === "relationship" && attr.twoWay && attr.twoWayKey) {
-          const relationshipAttr = attr as RelationshipAttribute;
-          let isArrayParent = false;
-          let isArrayChild = false;
-          switch (relationshipAttr.relationType) {
+      collection.attributes.forEach((attr) => {
+        if (attr.type === "relationship" && attr.twoWay && attr.twoWayKey) {
+          const relationshipAttr = attr as RelationshipAttribute;
+          let isArrayParent = false;
+          let isArrayChild = false;
+          switch (relationshipAttr.relationType) {
             case "oneToMany":
               isArrayParent = true;
               isArrayChild = false;
@@ -316,14 +323,14 @@ export default appwriteConfig;
             default:
               break;
           }
-          this.addRelationship(
-            collection.name,
-            relationshipAttr.relatedCollection,
-            attr.key,
-            relationshipAttr.twoWayKey,
-            isArrayParent,
-            isArrayChild
-          );
+          this.addRelationship(
+            collection.name,
+            this.resolveCollectionName(relationshipAttr.relatedCollection),
+            attr.key,
+            relationshipAttr.twoWayKey!,
+            isArrayParent,
+            isArrayChild
+          );
           console.log(
             `Extracted relationship: ${attr.key}\n\t${collection.name} -> ${relationshipAttr.relatedCollection}, databaseId: ${collection.databaseId}`
           );
@@ -383,10 +390,10 @@ export default appwriteConfig;
     // Generate Zod schemas (TypeScript)
     if (format === "zod" || format === "both") {
       this.config.collections.forEach((collection) => {
-        const schemaString = this.createSchemaString(
-          collection.name,
-          collection.attributes || []
-        );
+        const schemaString = this.createSchemaStringV4(
+          collection.name,
+          collection.attributes || []
+        );
         const camelCaseName = toCamelCase(collection.name);
         const schemaPath = path.join(schemasPath, `${camelCaseName}.ts`);
         fs.writeFileSync(schemaPath, schemaString, { encoding: "utf-8" });
@@ -409,119 +416,106 @@ export default appwriteConfig;
     if (verbose) {
       console.log(`✓ Schema generation completed (format: ${format})`);
     }
-  }
-
-  createSchemaString = (name: string, attributes: Attribute[]): string => {
-    const pascalName = toPascalCase(name);
-    let imports = `import { z } from "zod";\n`;
-
-    // Use the relationshipMap to find related collections
-    const relationshipDetails = this.relationshipMap.get(name) || [];
-    const relatedCollections = relationshipDetails
-      .filter((detail, index, self) => {
-        const uniqueKey = `${detail.parentCollection}-${detail.childCollection}-${detail.parentKey}-${detail.childKey}`;
-        return (
-          index ===
-          self.findIndex(
+  }
+
+  // Zod v4 recursive getter-based schemas
+  createSchemaStringV4 = (name: string, attributes: Attribute[]): string => {
+    const pascalName = toPascalCase(name);
+    let imports = `import { z } from "zod";\n`;
+
+    // Use the relationshipMap to find related collections
+    const relationshipDetails = this.relationshipMap.get(name) || [];
+    let relatedCollections = relationshipDetails
+      .filter((detail, index, self) => {
+        const uniqueKey = `${detail.parentCollection}-${detail.childCollection}-${detail.parentKey}-${detail.childKey}`;
+        return (
+          index ===
+          self.findIndex(
             (obj) =>
               `${obj.parentCollection}-${obj.childCollection}-${obj.parentKey}-${obj.childKey}` ===
               uniqueKey
           )
         );
       })
-      .map((detail) => {
-        const relatedCollectionName = detail.isChild
-          ? detail.parentCollection
-          : detail.childCollection;
-        const key = detail.isChild ? detail.childKey : detail.parentKey;
-        const isArray = detail.isArray ? "array" : "";
-        return [relatedCollectionName, key, isArray];
-      });
+      .map((detail) => {
+        const relatedCollectionName = detail.isChild
+          ? detail.parentCollection
+          : detail.childCollection;
+        const key = detail.isChild ? detail.childKey : detail.parentKey;
+        const isArray = detail.isArray ? "array" : "";
+        return [relatedCollectionName, key, isArray];
+      });
+
+    // Include one-way relationship attributes directly (no twoWayKey)
+    const oneWayRels: Array<[string, string, string]> = [];
+    for (const attr of attributes) {
+      if (attr.type === "relationship" && attr.relatedCollection) {
+        const relatedName = this.resolveCollectionName(attr.relatedCollection);
+        const isArray =
+          attr.relationType === "oneToMany" || attr.relationType === "manyToMany"
+            ? "array"
+            : "";
+        oneWayRels.push([relatedName, attr.key, isArray]);
+      }
+    }
+
+    // Merge and dedupe (by relatedName+key)
+    relatedCollections = [...relatedCollections, ...oneWayRels].filter(
+      (item, idx, self) =>
+        idx === self.findIndex((o) => `${o[0]}::${o[1]}` === `${item[0]}::${item[1]}`)
+    );
 
-    // 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`;
-      }
-      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`;
-      }
-      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`;
-    }
-
-    return schemaString;
-  };
+    const hasRelationships = relatedCollections.length > 0;
+
+    // Build imports for related collections
+    if (hasRelationships) {
+      const importLines = relatedCollections.map((rel) => {
+        const relatedPascalName = toPascalCase(rel[0]);
+        const relatedCamelName = toCamelCase(rel[0]);
+        return `import { ${relatedPascalName}Schema } from "./${relatedCamelName}";`;
+      });
+      const unique = Array.from(new Set(importLines));
+      imports += unique.join("\n") + (unique.length ? "\n" : "");
+    }
+
+    let schemaString = `${imports}\n`;
+
+    // Single object schema with recursive getters (Zod v4)
+    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`;
+    }
+
+    // Add recursive getters for relationships (respect required flag)
+    relatedCollections.forEach((rel) => {
+      const relatedPascalName = toPascalCase(rel[0]);
+      const isArray = rel[2] === "array";
+      const key = String(rel[1]);
+      const attrMeta = attributes.find(a => a.key === key && a.type === "relationship");
+      const isRequired = !!attrMeta?.required;
+      let getterBody = "";
+      if (isArray) {
+        getterBody = isRequired
+          ? `${relatedPascalName}Schema.array()`
+          : `${relatedPascalName}Schema.array().nullish()`;
+      } else {
+        getterBody = isRequired
+          ? `${relatedPascalName}Schema`
+          : `${relatedPascalName}Schema.nullish()`;
+      }
+      schemaString += `  get ${key}(){\n    return ${getterBody}\n  },\n`;
+    });
+
+    schemaString += `});\n\n`;
+    schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
+
+    return schemaString;
+  };
 
   typeToZod = (attribute: Attribute) => {
     let baseSchemaCode = "";

package/src/utils/loadConfigs.ts

@@ -4,7 +4,8 @@ import { type AppwriteConfig, type Collection, type CollectionCreate } from "app
 import { register } from "tsx/esm/api"; // Import the register function
 import { pathToFileURL } from "node:url";
 import chalk from "chalk";
-import { findYamlConfig, loadYamlConfig } from "../config/yamlConfig.js";
+import { findYamlConfig, loadYamlConfig } from "../config/yamlConfig.js";
+import { detectAppwriteVersionCached, fetchServerVersion, isVersionAtLeast } from "./versionDetection.js";
 import yaml from "js-yaml";
 import { z } from "zod";
 import { MessageFormatter } from "../shared/messageFormatter.js";
@@ -165,17 +166,28 @@ export const loadConfigWithPath = async (
     throw new Error("No valid configuration found");
   }
 
-  // Determine collections directory based on actual config file location
-  let collectionsDir: string;
-  const configFileDir = path.dirname(actualConfigPath);
-  
-  // Check if config is in .appwrite directory
-  if (configFileDir.endsWith('.appwrite')) {
-    collectionsDir = path.join(configFileDir, "collections");
-  } else {
-    // Config is in root or other directory
-    collectionsDir = path.join(configFileDir, "collections");
-  }
+  // Determine directory (collections or tables) based on server version / API mode
+  let dirName = "collections";
+  try {
+    const det = await detectAppwriteVersionCached(config.appwriteEndpoint, config.appwriteProject, config.appwriteKey);
+    if (det.apiMode === 'tablesdb' || isVersionAtLeast(det.serverVersion, '1.8.0')) {
+      dirName = 'tables';
+    } else {
+      // Try health version if not provided
+      const ver = await fetchServerVersion(config.appwriteEndpoint);
+      if (isVersionAtLeast(ver || undefined, '1.8.0')) dirName = 'tables';
+    }
+  } catch {}
+
+  // Determine collections directory based on actual config file location and dirName
+  let collectionsDir: string;
+  const configFileDir = path.dirname(actualConfigPath);
+  collectionsDir = path.join(configFileDir, dirName);
+  // Fallback if not found
+  if (!fs.existsSync(collectionsDir)) {
+    const fallback = path.join(configFileDir, dirName === 'tables' ? 'collections' : 'tables');
+    if (fs.existsSync(fallback)) collectionsDir = fallback;
+  }
 
   // Load collections if they exist
   if (fs.existsSync(collectionsDir)) {
@@ -267,22 +279,29 @@ export const loadConfig = async (
     throw new Error("No valid configuration found");
   }
 
-  // Determine collections directory based on actual config file location
-  let collectionsDir: string;
-  if (actualConfigPath) {
-    const configFileDir = path.dirname(actualConfigPath);
-    
-    // Check if config is in .appwrite directory
-    if (configFileDir.endsWith('.appwrite')) {
-      collectionsDir = path.join(configFileDir, "collections");
-    } else {
-      // Config is in root or other directory
-      collectionsDir = path.join(configFileDir, "collections");
-    }
-  } else {
-    // Fallback to original behavior if no actual config path found
-    collectionsDir = path.join(configDir, "collections");
-  }
+  // Determine directory (collections or tables) based on server version / API mode
+  let dirName2 = "collections";
+  try {
+    const det = await detectAppwriteVersionCached(config.appwriteEndpoint, config.appwriteProject, config.appwriteKey);
+    if (det.apiMode === 'tablesdb' || isVersionAtLeast(det.serverVersion, '1.8.0')) {
+      dirName2 = 'tables';
+    } else {
+      const ver = await fetchServerVersion(config.appwriteEndpoint);
+      if (isVersionAtLeast(ver || undefined, '1.8.0')) dirName2 = 'tables';
+    }
+  } catch {}
+
+  let collectionsDir: string;
+  if (actualConfigPath) {
+    const configFileDir = path.dirname(actualConfigPath);
+    collectionsDir = path.join(configFileDir, dirName2);
+  } else {
+    collectionsDir = path.join(configDir, dirName2);
+  }
+  if (!fs.existsSync(collectionsDir)) {
+    const fallback = path.join(path.dirname(actualConfigPath || configDir), dirName2 === 'tables' ? 'collections' : 'tables');
+    if (fs.existsSync(fallback)) collectionsDir = fallback;
+  }
 
   // Load collections if they exist
   if (fs.existsSync(collectionsDir)) {
@@ -459,4 +478,4 @@ const loadYamlCollection = (filePath: string): CollectionCreate | null => {
     console.error(`Error loading YAML collection from ${filePath}:`, error);
     return null;
   }
-};
+};