appwrite-utils-cli 1.7.8 → 1.7.9

package/src/utilsController.ts

@@ -12,11 +12,10 @@ import {
   type Specification,
 } from "appwrite-utils";
 import {
-  loadConfig,
-  loadConfigWithPath,
   findAppwriteConfig,
   findFunctionsDir,
 } from "./utils/loadConfigs.js";
+import { normalizeFunctionName, validateFunctionDirectory } from './functions/pathResolution.js';
 import { UsersController } from "./users/methods.js";
 import { AppwriteToX } from "./migrations/appwriteToX.js";
 import { ImportController } from "./migrations/importController.js";
@@ -116,9 +115,33 @@ export class UtilsController {
       appwriteKey?: string;
     }
   ): UtilsController {
+    // Clear instance if currentUserDir has changed
+    if (UtilsController.instance &&
+        UtilsController.instance.currentUserDir !== currentUserDir) {
+      logger.debug(`Clearing singleton: currentUserDir changed from ${UtilsController.instance.currentUserDir} to ${currentUserDir}`, { prefix: "UtilsController" });
+      UtilsController.clearInstance();
+    }
+
+    // Clear instance if directConfig endpoint or project has changed
+    if (UtilsController.instance && directConfig) {
+      const existingConfig = UtilsController.instance.config;
+      if (existingConfig) {
+        const endpointChanged = directConfig.appwriteEndpoint &&
+          existingConfig.appwriteEndpoint !== directConfig.appwriteEndpoint;
+        const projectChanged = directConfig.appwriteProject &&
+          existingConfig.appwriteProject !== directConfig.appwriteProject;
+
+        if (endpointChanged || projectChanged) {
+          logger.debug("Clearing singleton: endpoint or project changed", { prefix: "UtilsController" });
+          UtilsController.clearInstance();
+        }
+      }
+    }
+
     if (!UtilsController.instance) {
       UtilsController.instance = new UtilsController(currentUserDir, directConfig);
     }
+
     return UtilsController.instance;
   }
 
@@ -426,10 +449,17 @@ export class UtilsController {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         const functionPath = path.join(functionsDir, entry.name);
-        // Match with config functions by name
+
+        // Validate it's a function directory
+        if (!validateFunctionDirectory(functionPath)) {
+          continue; // Skip invalid directories
+        }
+
+        // Match with config functions using normalized names
         if (this.config?.functions) {
+          const normalizedEntryName = normalizeFunctionName(entry.name);
           const matchingFunc = this.config.functions.find(
-            (f) => f.name.toLowerCase() === entry.name.toLowerCase()
+            (f) => normalizeFunctionName(f.name) === normalizedEntryName
           );
           if (matchingFunc) {
             functionDirMap.set(matchingFunc.name, functionPath);
@@ -591,28 +621,32 @@ export class UtilsController {
   async generateSchemas() {
     // Schema generation doesn't need Appwrite connection, just config
     if (!this.config) {
-      if (this.appwriteFolderPath && this.appwriteConfigPath) {
-        MessageFormatter.progress("Loading config from file...", { prefix: "Config" });
-        try {
-          const { config, actualConfigPath } = await loadConfigWithPath(
-            this.appwriteFolderPath,
-            { validate: false, strictMode: false, reportValidation: false }
-          );
-          this.config = config;
-          MessageFormatter.info(`Loaded config from: ${actualConfigPath}`, { prefix: "Config" });
-        } catch (error) {
-          MessageFormatter.error("Failed to load config from file", error instanceof Error ? error : undefined, { prefix: "Config" });
-          return;
+      MessageFormatter.progress("Loading config from ConfigManager...", { prefix: "Config" });
+      try {
+        const configManager = ConfigManager.getInstance();
+
+        // Load config if not already loaded
+        if (!configManager.hasConfig()) {
+          await configManager.loadConfig({
+            configDir: this.currentUserDir,
+            validate: false,
+            strictMode: false,
+          });
         }
-      } else {
-        MessageFormatter.error("No configuration available", undefined, { prefix: "Controller" });
+
+        this.config = configManager.getConfig();
+        MessageFormatter.info("Config loaded successfully from ConfigManager", { prefix: "Config" });
+      } catch (error) {
+        MessageFormatter.error("Failed to load config", error instanceof Error ? error : undefined, { prefix: "Config" });
         return;
       }
     }
+
     if (!this.appwriteFolderPath) {
       MessageFormatter.error("Failed to get appwriteFolderPath", undefined, { prefix: "Controller" });
       return;
     }
+
     await generateSchemas(this.config, this.appwriteFolderPath);
   }
 
@@ -728,7 +762,7 @@ export class UtilsController {
     }
   }
 
-  async selectiveSync(
+  async selectivePull(
     databaseSelections: DatabaseSelection[],
     bucketSelections: BucketSelection[]
   ): Promise<void> {
@@ -738,7 +772,7 @@ export class UtilsController {
       return;
     }
 
-    MessageFormatter.progress("Starting selective sync...", { prefix: "Controller" });
+    MessageFormatter.progress("Starting selective pull (Appwrite → local config)...", { prefix: "Controller" });
 
     // Convert database selections to Models.Database format
     const selectedDatabases: Models.Database[] = [];
@@ -762,7 +796,7 @@ export class UtilsController {
     }
 
     if (selectedDatabases.length === 0) {
-      MessageFormatter.warning("No valid databases selected for sync", { prefix: "Controller" });
+      MessageFormatter.warning("No valid databases selected for pull", { prefix: "Controller" });
       return;
     }
 
@@ -778,7 +812,89 @@ export class UtilsController {
     // Perform selective sync using the enhanced synchronizeConfigurations method
     await this.synchronizeConfigurations(selectedDatabases, this.config, databaseSelections, bucketSelections);
 
-    MessageFormatter.success("Selective sync completed successfully!", { prefix: "Controller" });
+    MessageFormatter.success("Selective pull completed successfully! Remote config pulled to local.", { prefix: "Controller" });
+  }
+
+  async selectivePush(
+    databaseSelections: DatabaseSelection[],
+    bucketSelections: BucketSelection[]
+  ): Promise<void> {
+    await this.init();
+    if (!this.database) {
+      MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
+      return;
+    }
+
+    MessageFormatter.progress("Starting selective push (local config → Appwrite)...", { prefix: "Controller" });
+
+    // Convert database selections to Models.Database format
+    const selectedDatabases: Models.Database[] = [];
+
+    for (const dbSelection of databaseSelections) {
+      // Get the full database object from the controller
+      const databases = await fetchAllDatabases(this.database);
+      const database = databases.find(db => db.$id === dbSelection.databaseId);
+
+      if (database) {
+        selectedDatabases.push(database);
+        MessageFormatter.info(`Selected database: ${database.name} (${database.$id})`, { prefix: "Controller" });
+
+        // Log selected tables for this database
+        if (dbSelection.tableIds && dbSelection.tableIds.length > 0) {
+          MessageFormatter.info(`  Tables: ${dbSelection.tableIds.join(', ')}`, { prefix: "Controller" });
+        }
+      } else {
+        MessageFormatter.warning(`Database with ID ${dbSelection.databaseId} not found`, { prefix: "Controller" });
+      }
+    }
+
+    if (selectedDatabases.length === 0) {
+      MessageFormatter.warning("No valid databases selected for push", { prefix: "Controller" });
+      return;
+    }
+
+    // Log bucket selections if provided
+    if (bucketSelections && bucketSelections.length > 0) {
+      MessageFormatter.info(`Selected ${bucketSelections.length} buckets:`, { prefix: "Controller" });
+      for (const bucketSelection of bucketSelections) {
+        const dbInfo = bucketSelection.databaseId ? ` (DB: ${bucketSelection.databaseId})` : '';
+        MessageFormatter.info(`  - ${bucketSelection.bucketName} (${bucketSelection.bucketId})${dbInfo}`, { prefix: "Controller" });
+      }
+    }
+
+    // PUSH OPERATION: Push local configuration to Appwrite
+    // Build selected collections/tables from databaseSelections
+    const selectedCollections: any[] = [];
+
+    // Get all collections/tables from config (they're at the root level, not nested in databases)
+    const allCollections = this.config?.collections || this.config?.tables || [];
+
+    // Collect all selected table IDs from all database selections
+    const selectedTableIds = new Set<string>();
+    for (const dbSelection of databaseSelections) {
+      for (const tableId of dbSelection.tableIds) {
+        selectedTableIds.add(tableId);
+      }
+    }
+
+    // Filter to only the selected table IDs
+    for (const collection of allCollections) {
+      const collectionId = collection.$id || (collection as any).id;
+      if (selectedTableIds.has(collectionId)) {
+        selectedCollections.push(collection);
+      }
+    }
+
+    MessageFormatter.info(`Pushing ${selectedCollections.length} selected tables/collections to Appwrite`, { prefix: "Controller" });
+
+    // Ensure databases exist
+    await this.ensureDatabasesExist(selectedDatabases);
+    await this.ensureDatabaseConfigBucketsExist(selectedDatabases);
+
+    // Create/update ONLY the selected collections/tables
+    await this.createOrUpdateCollectionsForDatabases(selectedDatabases, selectedCollections);
+
+    MessageFormatter.success("Selective push completed successfully! Local config pushed to Appwrite.", { prefix: "Controller" });
   }
 
   async syncDb(

package/dist/utils/schemaStrings.d.ts

@@ -1,14 +0,0 @@
-import type { AppwriteConfig, Attribute } from "appwrite-utils";
-export declare class SchemaGenerator {
-    private relationshipMap;
-    private config;
-    private appwriteFolderPath;
-    constructor(config: AppwriteConfig, appwriteFolderPath: string);
-    private resolveCollectionName;
-    updateTsSchemas(): void;
-    private extractRelationships;
-    private addRelationship;
-    generateSchemas(): void;
-    createSchemaStringV4: (name: string, attributes: Attribute[]) => string;
-    typeToZod: (attribute: Attribute) => string;
-}

package/dist/utils/schemaStrings.js

@@ -1,428 +0,0 @@
-import { toCamelCase, toPascalCase } from "../utils/index.js";
-import { Databases } from "node-appwrite";
-import { z } from "zod";
-import fs from "fs";
-import path from "path";
-import { dump } from "js-yaml";
-import { findFunctionsDir } from "./loadConfigs.js";
-import { ulid } from "ulidx";
-export class SchemaGenerator {
-    relationshipMap = new Map();
-    config;
-    appwriteFolderPath;
-    constructor(config, appwriteFolderPath) {
-        this.config = config;
-        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 || [];
-        delete this.config.collections;
-        delete this.config.functions;
-        const configPath = path.join(this.appwriteFolderPath, "appwriteConfig.ts");
-        const configContent = `import { type AppwriteConfig } from "appwrite-utils";
-  
-  const appwriteConfig: AppwriteConfig = {
-    appwriteEndpoint: "${this.config.appwriteEndpoint}",
-    appwriteProject: "${this.config.appwriteProject}",
-    appwriteKey: "${this.config.appwriteKey}",
-    enableBackups: ${this.config.enableBackups},
-    backupInterval: ${this.config.backupInterval},
-    backupRetention: ${this.config.backupRetention},
-    enableBackupCleanup: ${this.config.enableBackupCleanup},
-    enableMockData: ${this.config.enableMockData},
-    documentBucketId: "${this.config.documentBucketId}",
-    usersCollectionName: "${this.config.usersCollectionName}",
-    databases: ${JSON.stringify(this.config.databases)},
-    buckets: ${JSON.stringify(this.config.buckets)},
-    functions: ${JSON.stringify(functions.map((func) => ({
-            functionId: func.$id || ulid(),
-            name: func.name,
-            runtime: func.runtime,
-            path: func.dirPath || `functions/${func.name}`,
-            entrypoint: func.entrypoint || "src/index.ts",
-            execute: func.execute,
-            events: func.events || [],
-            schedule: func.schedule || "",
-            timeout: func.timeout || 15,
-            enabled: func.enabled !== false,
-            logging: func.logging !== false,
-            commands: func.commands || "npm install",
-            scopes: func.scopes || [],
-            installationId: func.installationId,
-            providerRepositoryId: func.providerRepositoryId,
-            providerBranch: func.providerBranch,
-            providerSilentMode: func.providerSilentMode,
-            providerRootDirectory: func.providerRootDirectory,
-            specification: func.specification,
-            ...(func.predeployCommands
-                ? { predeployCommands: func.predeployCommands }
-                : {}),
-            ...(func.deployDir ? { deployDir: func.deployDir } : {}),
-        })), null, 2)}
-  };
-  
-  export default appwriteConfig;
-  `;
-        fs.writeFileSync(configPath, configContent, { encoding: "utf-8" });
-        const collectionsFolderPath = path.join(this.appwriteFolderPath, "collections");
-        if (!fs.existsSync(collectionsFolderPath)) {
-            fs.mkdirSync(collectionsFolderPath, { recursive: true });
-        }
-        collections?.forEach((collection) => {
-            const { databaseId, ...collectionWithoutDbId } = collection; // Destructure to exclude databaseId
-            const collectionFilePath = path.join(collectionsFolderPath, `${collection.name}.ts`);
-            const collectionContent = `import { type CollectionCreate } from "appwrite-utils";
-  
-  const ${collection.name}Config: Partial<CollectionCreate> = {
-    name: "${collection.name}",
-    $id: "${collection.$id}",
-    enabled: ${collection.enabled},
-    documentSecurity: ${collection.documentSecurity},
-    $permissions: [
-      ${collection.$permissions
-                .map((permission) => `{ permission: "${permission.permission}", target: "${permission.target}" }`)
-                .join(",\n    ")}
-    ],
-    attributes: [
-      ${(collection.attributes || [])
-                .map((attr) => {
-                return `{ ${Object.entries(attr)
-                    .map(([key, value]) => {
-                    // Check the type of the value and format it accordingly
-                    if (typeof value === "string") {
-                        // If the value is a string, wrap it in quotes
-                        return `${key}: "${value.replace(/"/g, '\\"')}"`; // Escape existing quotes in the string
-                    }
-                    else if (Array.isArray(value)) {
-                        // If the value is an array, join it with commas
-                        if (value.length > 0) {
-                            return `${key}: [${value
-                                .map((item) => `"${item}"`)
-                                .join(", ")}]`;
-                        }
-                        else {
-                            return `${key}: []`;
-                        }
-                    }
-                    else {
-                        // If the value is not a string (e.g., boolean or number), output it directly
-                        return `${key}: ${value}`;
-                    }
-                })
-                    .join(", ")} }`;
-            })
-                .join(",\n    ")}
-    ],
-    indexes: [
-      ${(collection.indexes?.map((index) => {
-                // Map each attribute to ensure it is properly quoted
-                const formattedAttributes = index.attributes.map((attr) => `"${attr}"`).join(", ") ?? "";
-                return `{ key: "${index.key}", type: "${index.type}", attributes: [${formattedAttributes}], orders: [${index.orders
-                    ?.filter((order) => order !== null)
-                    .map((order) => `"${order}"`)
-                    .join(", ") ?? ""}] }`;
-            }) ?? []).join(",\n    ")}
-    ]
-  };
-  
-  export default ${collection.name}Config;
-  `;
-            fs.writeFileSync(collectionFilePath, collectionContent, {
-                encoding: "utf-8",
-            });
-            console.log(`Collection schema written to ${collectionFilePath}`);
-        });
-    }
-    extractRelationships() {
-        if (!this.config.collections) {
-            return;
-        }
-        this.config.collections.forEach((collection) => {
-            if (!collection.attributes) {
-                return;
-            }
-            collection.attributes.forEach((attr) => {
-                if (attr.type === "relationship" && attr.twoWay && attr.twoWayKey) {
-                    const relationshipAttr = attr;
-                    let isArrayParent = false;
-                    let isArrayChild = false;
-                    switch (relationshipAttr.relationType) {
-                        case "oneToMany":
-                            isArrayParent = true;
-                            isArrayChild = false;
-                            break;
-                        case "manyToMany":
-                            isArrayParent = true;
-                            isArrayChild = true;
-                            break;
-                        case "oneToOne":
-                            isArrayParent = false;
-                            isArrayChild = false;
-                            break;
-                        case "manyToOne":
-                            isArrayParent = false;
-                            isArrayChild = true;
-                            break;
-                        default:
-                            break;
-                    }
-                    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}`);
-                }
-            });
-        });
-    }
-    addRelationship(parentCollection, childCollection, parentKey, childKey, isArrayParent, isArrayChild) {
-        const relationshipsChild = this.relationshipMap.get(childCollection) || [];
-        const relationshipsParent = this.relationshipMap.get(parentCollection) || [];
-        relationshipsParent.push({
-            parentCollection,
-            childCollection,
-            parentKey,
-            childKey,
-            isArray: isArrayParent,
-            isChild: false,
-        });
-        relationshipsChild.push({
-            parentCollection,
-            childCollection,
-            parentKey,
-            childKey,
-            isArray: isArrayChild,
-            isChild: true,
-        });
-        this.relationshipMap.set(childCollection, relationshipsChild);
-        this.relationshipMap.set(parentCollection, relationshipsParent);
-    }
-    generateSchemas() {
-        if (!this.config.collections) {
-            return;
-        }
-        this.config.collections.forEach((collection) => {
-            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}`);
-        });
-    }
-    // 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) || [];
-        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];
-        });
-        // 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]);
-            }
-        }
-        // 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}";`;
-            });
-            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) => {
-        let baseSchemaCode = "";
-        const finalAttribute = (attribute.type === "string" &&
-            attribute.format &&
-            attribute.format === "enum" &&
-            attribute.type === "string"
-            ? { ...attribute, type: attribute.format }
-            : attribute);
-        switch (finalAttribute.type) {
-            case "string":
-                baseSchemaCode = "z.string()";
-                if (finalAttribute.size) {
-                    baseSchemaCode += `.max(${finalAttribute.size}, "Maximum length of ${finalAttribute.size} characters exceeded")`;
-                }
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default("${finalAttribute.xdefault}")`;
-                }
-                if (!attribute.required && !attribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "integer":
-                baseSchemaCode = "z.number().int()";
-                if (finalAttribute.min !== undefined) {
-                    if (BigInt(finalAttribute.min) === BigInt(-9223372036854776000)) {
-                        finalAttribute.min = undefined;
-                    }
-                    else {
-                        baseSchemaCode += `.min(${finalAttribute.min}, "Minimum value of ${finalAttribute.min} not met")`;
-                    }
-                }
-                if (finalAttribute.max !== undefined) {
-                    if (BigInt(finalAttribute.max) === BigInt(9223372036854776000)) {
-                        finalAttribute.max = undefined;
-                    }
-                    else {
-                        baseSchemaCode += `.max(${finalAttribute.max}, "Maximum value of ${finalAttribute.max} exceeded")`;
-                    }
-                }
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default(${finalAttribute.xdefault})`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "double":
-            case "float": // Backward compatibility
-                baseSchemaCode = "z.number()";
-                if (finalAttribute.min !== undefined) {
-                    baseSchemaCode += `.min(${finalAttribute.min}, "Minimum value of ${finalAttribute.min} not met")`;
-                }
-                if (finalAttribute.max !== undefined) {
-                    baseSchemaCode += `.max(${finalAttribute.max}, "Maximum value of ${finalAttribute.max} exceeded")`;
-                }
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default(${finalAttribute.xdefault})`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "boolean":
-                baseSchemaCode = "z.boolean()";
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default(${finalAttribute.xdefault})`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "datetime":
-                baseSchemaCode = "z.date()";
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default(new Date("${finalAttribute.xdefault}"))`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "email":
-                baseSchemaCode = "z.string().email()";
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default("${finalAttribute.xdefault}")`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "ip":
-                baseSchemaCode = "z.string()"; // Add custom validation as needed
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default("${finalAttribute.xdefault}")`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "url":
-                baseSchemaCode = "z.string().url()";
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default("${finalAttribute.xdefault}")`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "enum":
-                baseSchemaCode = `z.enum([${finalAttribute.elements
-                    .map((element) => `"${element}"`)
-                    .join(", ")}])`;
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default("${finalAttribute.xdefault}")`;
-                }
-                if (!attribute.required && !attribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "relationship":
-                break;
-            default:
-                baseSchemaCode = "z.any()";
-        }
-        // Handle arrays
-        if (attribute.array) {
-            baseSchemaCode = `z.array(${baseSchemaCode})`;
-        }
-        if (attribute.array && !attribute.required) {
-            baseSchemaCode += ".nullish()";
-        }
-        return baseSchemaCode;
-    };
-}