appwrite-utils-cli 1.4.0 → 1.5.0

package/dist/shared/schemaGenerator.js

@@ -16,6 +16,10 @@ export class SchemaGenerator {
         this.appwriteFolderPath = appwriteFolderPath;
         this.extractRelationships();
     }
+    resolveCollectionName = (idOrName) => {
+        const col = this.config.collections?.find((c) => c.$id === idOrName || c.name === idOrName);
+        return col?.name ?? idOrName;
+    };
     updateYamlCollections() {
         const collections = this.config.collections;
         delete this.config.collections;
@@ -265,7 +269,7 @@ 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}`);
                 }
             });
@@ -307,7 +311,7 @@ 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" });
@@ -329,12 +333,13 @@ export default appwriteConfig;
             console.log(`✓ Schema generation completed (format: ${format})`);
         }
     }
-    createSchemaString = (name, attributes) => {
+    // Zod v4 recursive getter-based schemas
+    createSchemaStringV4 = (name, attributes) => {
         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
+        let relatedCollections = relationshipDetails
             .filter((detail, index, self) => {
             const uniqueKey = `${detail.parentCollection}-${detail.childCollection}-${detail.parentKey}-${detail.childKey}`;
             return (index ===
@@ -349,86 +354,64 @@ export default appwriteConfig;
             const isArray = detail.isArray ? "array" : "";
             return [relatedCollectionName, key, isArray];
         });
-        // 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`;
+        // Include one-way relationship attributes directly (no twoWayKey)
+        const oneWayRels = [];
+        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]);
             }
-            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 += "  ";
-                }
+        // 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]}`));
+        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}";`;
             });
-            // 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`;
+            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 {
-                schemaString += `;\n`;
+                getterBody = isRequired
+                    ? `${relatedPascalName}Schema`
+                    : `${relatedPascalName}Schema.nullish()`;
             }
-            schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
-        }
+            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) => {

package/dist/storage/schemas.d.ts

@@ -162,12 +162,12 @@ export declare const getMigrationCollectionSchemas: () => {
                 relatedCollection: string;
                 relationType: "oneToMany" | "manyToOne" | "oneToOne" | "manyToMany";
                 twoWay: boolean;
-                twoWayKey: string;
                 onDelete: "setNull" | "cascade" | "restrict";
-                side: "parent" | "child";
                 error?: string | undefined;
                 required?: boolean | undefined;
                 array?: boolean | undefined;
+                twoWayKey?: string | undefined;
+                side?: "parent" | "child" | undefined;
                 importMapping?: {
                     originalIdField: string;
                     targetField?: string | undefined;
@@ -313,12 +313,12 @@ export declare const getMigrationCollectionSchemas: () => {
             relatedCollection: string;
             relationType: "oneToMany" | "manyToOne" | "oneToOne" | "manyToMany";
             twoWay: boolean;
-            twoWayKey: string;
             onDelete: "setNull" | "cascade" | "restrict";
-            side: "parent" | "child";
             error?: string | undefined;
             required?: boolean | undefined;
             array?: boolean | undefined;
+            twoWayKey?: string | undefined;
+            side?: "parent" | "child" | undefined;
             importMapping?: {
                 originalIdField: string;
                 targetField?: string | undefined;
@@ -414,12 +414,12 @@ export declare const getMigrationCollectionSchemas: () => {
                 relatedCollection: string;
                 relationType: "oneToMany" | "manyToOne" | "oneToOne" | "manyToMany";
                 twoWay: boolean;
-                twoWayKey: string;
                 onDelete: "setNull" | "cascade" | "restrict";
-                side: "parent" | "child";
                 error?: string | undefined;
                 required?: boolean | undefined;
                 array?: boolean | undefined;
+                twoWayKey?: string | undefined;
+                side?: "parent" | "child" | undefined;
                 importMapping?: {
                     originalIdField: string;
                     targetField?: string | undefined;
@@ -565,12 +565,12 @@ export declare const getMigrationCollectionSchemas: () => {
             relatedCollection: string;
             relationType: "oneToMany" | "manyToOne" | "oneToOne" | "manyToMany";
             twoWay: boolean;
-            twoWayKey: string;
             onDelete: "setNull" | "cascade" | "restrict";
-            side: "parent" | "child";
             error?: string | undefined;
             required?: boolean | undefined;
             array?: boolean | undefined;
+            twoWayKey?: string | undefined;
+            side?: "parent" | "child" | undefined;
             importMapping?: {
                 originalIdField: string;
                 targetField?: string | undefined;

package/dist/utils/loadConfigs.js

@@ -5,6 +5,7 @@ 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 { detectAppwriteVersionCached, fetchServerVersion, isVersionAtLeast } from "./versionDetection.js";
 import yaml from "js-yaml";
 import { z } from "zod";
 import { MessageFormatter } from "../shared/messageFormatter.js";
@@ -149,16 +150,30 @@ export const loadConfigWithPath = async (configDir) => {
     if (!config || !actualConfigPath) {
         throw new Error("No valid configuration found");
     }
-    // Determine collections directory based on actual config file location
+    // 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;
     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");
+    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)) {
@@ -238,22 +253,32 @@ export const loadConfig = async (configDir) => {
     if (!config) {
         throw new Error("No valid configuration found");
     }
-    // Determine collections directory based on actual config file location
-    let collectionsDir;
-    if (actualConfigPath) {
-        const configFileDir = path.dirname(actualConfigPath);
-        // Check if config is in .appwrite directory
-        if (configFileDir.endsWith('.appwrite')) {
-            collectionsDir = path.join(configFileDir, "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 {
-            // Config is in root or other directory
-            collectionsDir = path.join(configFileDir, "collections");
+            const ver = await fetchServerVersion(config.appwriteEndpoint);
+            if (isVersionAtLeast(ver || undefined, '1.8.0'))
+                dirName2 = 'tables';
         }
     }
+    catch { }
+    let collectionsDir;
+    if (actualConfigPath) {
+        const configFileDir = path.dirname(actualConfigPath);
+        collectionsDir = path.join(configFileDir, dirName2);
+    }
     else {
-        // Fallback to original behavior if no actual config path found
-        collectionsDir = path.join(configDir, "collections");
+        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)) {

package/dist/utils/schemaStrings.d.ts

@@ -4,10 +4,11 @@ export declare class SchemaGenerator {
     private config;
     private appwriteFolderPath;
     constructor(config: AppwriteConfig, appwriteFolderPath: string);
+    private resolveCollectionName;
     updateTsSchemas(): void;
     private extractRelationships;
     private addRelationship;
     generateSchemas(): void;
-    createSchemaString: (name: string, attributes: Attribute[]) => string;
+    createSchemaStringV4: (name: string, attributes: Attribute[]) => string;
     typeToZod: (attribute: Attribute) => string;
 }

package/dist/utils/schemaStrings.js

@@ -15,6 +15,10 @@ export class SchemaGenerator {
         this.appwriteFolderPath = appwriteFolderPath;
         this.extractRelationships();
     }
+    resolveCollectionName = (idOrName) => {
+        const col = this.config.collections?.find((c) => c.$id === idOrName || c.name === idOrName);
+        return col?.name ?? idOrName;
+    };
     updateTsSchemas() {
         const collections = this.config.collections;
         const functions = this.config.functions || [];
@@ -168,7 +172,7 @@ export class SchemaGenerator {
                         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}`);
                 }
             });
@@ -201,19 +205,20 @@ export class SchemaGenerator {
             return;
         }
         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(this.appwriteFolderPath, "schemas", `${camelCaseName}.ts`);
             fs.writeFileSync(schemaPath, schemaString, { encoding: "utf-8" });
             console.log(`Schema written to ${schemaPath}`);
         });
     }
-    createSchemaString = (name, attributes) => {
+    // Zod v4 recursive getter-based schemas
+    createSchemaStringV4 = (name, attributes) => {
         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
+        let relatedCollections = relationshipDetails
             .filter((detail, index, self) => {
             const uniqueKey = `${detail.parentCollection}-${detail.childCollection}-${detail.parentKey}-${detail.childKey}`;
             return (index ===
@@ -228,86 +233,64 @@ export class SchemaGenerator {
             const isArray = detail.isArray ? "array" : "";
             return [relatedCollectionName, key, isArray];
         });
-        // 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`;
+        // Include one-way relationship attributes directly (no twoWayKey)
+        const oneWayRels = [];
+        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]);
             }
-            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 += "  ";
-                }
+        // 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]}`));
+        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}";`;
             });
-            // 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`;
+            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 {
-                schemaString += `;\n`;
+                getterBody = isRequired
+                    ? `${relatedPascalName}Schema`
+                    : `${relatedPascalName}Schema.nullish()`;
             }
-            schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
-        }
+            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) => {

package/dist/utils/setupFiles.js

@@ -1,6 +1,8 @@
 import { mkdirSync, writeFileSync, existsSync } from "node:fs";
 import path from "node:path";
 import { findAppwriteConfig } from "./loadConfigs.js";
+import { loadYamlConfig } from "../config/yamlConfig.js";
+import { fetchServerVersion, isVersionAtLeast } from "./versionDetection.js";
 import { findYamlConfig } from "../config/yamlConfig.js";
 import { ID } from "node-appwrite";
 import { ulid } from "ulidx";
@@ -240,7 +242,23 @@ export const setupDirsFiles = async (example = false, currentDir, useYaml = true
     const appwriteSchemaFolder = path.join(appwriteFolder, "schemas");
     const appwriteYamlSchemaFolder = path.join(appwriteFolder, ".yaml_schemas");
     const appwriteDataFolder = path.join(appwriteFolder, "importData");
-    const collectionsFolder = path.join(appwriteFolder, "collections");
+    // Decide between collections or tables folder
+    let useTables = false;
+    try {
+        // Try reading YAML config if present to detect version
+        const yamlPath = findYamlConfig(basePath);
+        if (yamlPath) {
+            const cfg = await loadYamlConfig(yamlPath);
+            if (cfg) {
+                const ver = await fetchServerVersion(cfg.appwriteEndpoint);
+                if (isVersionAtLeast(ver || undefined, '1.8.0'))
+                    useTables = true;
+            }
+        }
+    }
+    catch { }
+    const targetFolderName = useTables ? "tables" : "collections";
+    const collectionsFolder = path.join(appwriteFolder, targetFolderName);
     // Create directory structure
     if (!existsSync(appwriteFolder)) {
         mkdirSync(appwriteFolder, { recursive: true });

package/dist/utils/versionDetection.d.ts

@@ -54,3 +54,9 @@ export declare function detectSdkSupport(): Promise<{
  * Clear version detection cache (useful for testing)
  */
 export declare function clearVersionDetectionCache(): void;
+/**
+ * Fetch server version from /health/version (no auth required)
+ */
+export declare function fetchServerVersion(endpoint: string): Promise<string | null>;
+/** Compare semantic versions (basic) */
+export declare function isVersionAtLeast(current: string | undefined, target: string): boolean;

package/dist/utils/versionDetection.js

@@ -215,3 +215,33 @@ export async function detectSdkSupport() {
 export function clearVersionDetectionCache() {
     detectionCache.clear();
 }
+/**
+ * Fetch server version from /health/version (no auth required)
+ */
+export async function fetchServerVersion(endpoint) {
+    try {
+        const clean = endpoint.replace(/\/$/, '');
+        const res = await fetch(`${clean}/health/version`, { method: 'GET', signal: AbortSignal.timeout(5000) });
+        if (!res.ok)
+            return null;
+        const data = await res.json().catch(() => null);
+        const version = (data && (data.version || data.build || data.release)) ?? null;
+        return typeof version === 'string' ? version : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Compare semantic versions (basic) */
+export function isVersionAtLeast(current, target) {
+    if (!current)
+        return false;
+    const toNums = (v) => v.split('.').map(n => parseInt(n, 10));
+    const [a1 = 0, a2 = 0, a3 = 0] = toNums(current);
+    const [b1, b2, b3] = toNums(target);
+    if (a1 !== b1)
+        return a1 > b1;
+    if (a2 !== b2)
+        return a2 > b2;
+    return a3 >= b3;
+}