appwrite-utils-cli 1.4.1 → 1.5.1

package/dist/shared/jsonSchemaGenerator.d.ts

@@ -31,6 +31,7 @@ export declare class JsonSchemaGenerator {
     private appwriteFolderPath;
     private relationshipMap;
     constructor(config: AppwriteConfig, appwriteFolderPath: string);
+    private resolveCollectionName;
     private extractRelationships;
     private attributeToJsonSchemaProperty;
     private getBaseTypeSchema;

package/dist/shared/jsonSchemaGenerator.js

@@ -11,6 +11,10 @@ export class JsonSchemaGenerator {
         this.appwriteFolderPath = appwriteFolderPath;
         this.extractRelationships();
     }
+    resolveCollectionName = (idOrName) => {
+        const col = this.config.collections?.find((c) => c.$id === idOrName || c.name === idOrName);
+        return col?.name ?? idOrName;
+    };
     extractRelationships() {
         if (!this.config.collections)
             return;
@@ -22,7 +26,7 @@ export class JsonSchemaGenerator {
                     const relationships = this.relationshipMap.get(collection.name) || [];
                     relationships.push({
                         attributeKey: attr.key,
-                        relatedCollection: attr.relatedCollection,
+                        relatedCollection: this.resolveCollectionName(attr.relatedCollection),
                         relationType: attr.relationType,
                         isArray: attr.relationType === "oneToMany" || attr.relationType === "manyToMany"
                     });
@@ -108,7 +112,7 @@ export class JsonSchemaGenerator {
             case "relationship":
                 if (attribute.relatedCollection) {
                     // For relationships, reference the related collection schema
-                    schema.$ref = `#/definitions/${toPascalCase(attribute.relatedCollection)}`;
+                    schema.$ref = `#/definitions/${toPascalCase(this.resolveCollectionName(attribute.relatedCollection))}`;
                 }
                 else {
                     schema.type = "string";

package/dist/shared/operationQueue.js

@@ -33,7 +33,20 @@ export const processQueue = async (db, dbId) => {
                 }
                 // Attempt to resolve related collection if specified and not already found
                 if (!collectionFound && operation.attribute?.relatedCollection) {
-                    collectionFound = await fetchAndCacheCollectionByName(db, dbId, operation.attribute.relatedCollection);
+                    // First, try treating relatedCollection as an ID
+                    try {
+                        const relAttr = operation.attribute;
+                        const byId = await tryAwaitWithRetry(async () => await db.getCollection(dbId, relAttr.relatedCollection));
+                        // 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 = operation.attribute;
+                    await fetchAndCacheCollectionByName(db, dbId, relAttr.relatedCollection);
                 }
                 // Handle dependencies if collection still not found
                 if (!collectionFound) {

package/dist/shared/schemaGenerator.d.ts

@@ -4,6 +4,7 @@ export declare class SchemaGenerator {
     private config;
     private appwriteFolderPath;
     constructor(config: AppwriteConfig, appwriteFolderPath: string);
+    private resolveCollectionName;
     updateYamlCollections(): void;
     updateTsSchemas(): void;
     updateConfig(config: AppwriteConfig, isYamlConfig?: boolean): Promise<void>;
@@ -15,6 +16,6 @@ export declare class SchemaGenerator {
         format?: "zod" | "json" | "both";
         verbose?: boolean;
     }): void;
-    createSchemaString: (name: string, attributes: Attribute[]) => string;
+    createSchemaStringV4: (name: string, attributes: Attribute[]) => string;
     typeToZod: (attribute: Attribute) => string;
 }

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) => {