appwrite-utils-cli 1.2.7 → 1.2.9

package/dist/config/yamlConfig.d.ts

@@ -492,6 +492,12 @@ export declare const convertYamlToAppwriteConfig: (yamlConfig: YamlConfig) => Ap
 export declare const loadYamlConfig: (configPath: string) => Promise<AppwriteConfig | null>;
 export declare const findYamlConfig: (startDir: string) => string | null;
 export declare const generateYamlConfigTemplate: (outputPath: string) => void;
+/**
+ * Converts AppwriteConfig back to YAML format and writes to file
+ * @param configPath Path to the YAML config file
+ * @param config The AppwriteConfig to convert and save
+ */
+export declare const writeYamlConfig: (configPath: string, config: AppwriteConfig) => Promise<void>;
 /**
  * Adds a new function to the YAML config file
  * @param configPath Path to the YAML config file

package/dist/config/yamlConfig.js

@@ -206,7 +206,7 @@ export const convertYamlToAppwriteConfig = (yamlConfig) => {
             templateBranch: func.templateBranch || "",
             specification: func.specification || "s-0.5vcpu-512mb",
         })),
-        collections: [],
+        collections: [], // Note: Collections are managed separately in YAML configs via individual collection files
     };
     return appwriteConfig;
 };
@@ -397,6 +397,132 @@ export const generateYamlConfigTemplate = (outputPath) => {
     const finalContent = schemaReference + "# Appwrite Project Configuration\n" + yamlContent;
     fs.writeFileSync(outputPath, finalContent, "utf8");
 };
+/**
+ * Converts AppwriteConfig back to YAML format and writes to file
+ * @param configPath Path to the YAML config file
+ * @param config The AppwriteConfig to convert and save
+ */
+export const writeYamlConfig = async (configPath, config) => {
+    try {
+        // Convert AppwriteConfig back to YAML format
+        const yamlConfig = {
+            appwrite: {
+                endpoint: config.appwriteEndpoint,
+                project: config.appwriteProject,
+                key: config.appwriteKey,
+            },
+            logging: {
+                enabled: config.logging?.enabled || false,
+                level: config.logging?.level || "info",
+                directory: config.logging?.logDirectory,
+                console: config.logging?.console || false,
+            },
+            backups: {
+                enabled: config.enableBackups !== false,
+                interval: config.backupInterval || 3600,
+                retention: config.backupRetention || 30,
+                cleanup: config.enableBackupCleanup !== false,
+            },
+            data: {
+                enableMockData: config.enableMockData || false,
+                documentBucketId: config.documentBucketId || "documents",
+                usersCollectionName: config.usersCollectionName || "Members",
+                importDirectory: config.schemaConfig?.importDirectory || "importData",
+            },
+            schemas: {
+                outputDirectory: config.schemaConfig?.outputDirectory || "schemas",
+                yamlSchemaDirectory: config.schemaConfig?.yamlSchemaDirectory || ".yaml_schemas",
+            },
+            migrations: {
+                enabled: config.useMigrations !== false,
+            },
+            databases: config.databases?.map(db => ({
+                id: db.$id,
+                name: db.name,
+                bucket: db.bucket ? {
+                    id: db.bucket.$id,
+                    name: db.bucket.name,
+                    permissions: db.bucket.permissions || [],
+                    fileSecurity: db.bucket.fileSecurity,
+                    enabled: db.bucket.enabled,
+                    maximumFileSize: db.bucket.maximumFileSize,
+                    allowedFileExtensions: db.bucket.allowedFileExtensions,
+                    compression: db.bucket.compression,
+                    encryption: db.bucket.encryption,
+                    antivirus: db.bucket.antivirus,
+                } : undefined,
+            })) || [],
+            buckets: config.buckets?.map(bucket => ({
+                id: bucket.$id,
+                name: bucket.name,
+                permissions: bucket.permissions || [],
+                fileSecurity: bucket.fileSecurity,
+                enabled: bucket.enabled,
+                maximumFileSize: bucket.maximumFileSize,
+                allowedFileExtensions: bucket.allowedFileExtensions,
+                compression: bucket.compression,
+                encryption: bucket.encryption,
+                antivirus: bucket.antivirus,
+            })) || [],
+            functions: config.functions?.map(func => ({
+                id: func.$id,
+                name: func.name,
+                runtime: func.runtime,
+                execute: func.execute,
+                events: func.events,
+                schedule: func.schedule,
+                timeout: func.timeout,
+                enabled: func.enabled,
+                logging: func.logging,
+                entrypoint: func.entrypoint,
+                commands: func.commands,
+                scopes: func.scopes,
+                installationId: func.installationId,
+                providerRepositoryId: func.providerRepositoryId,
+                providerBranch: func.providerBranch,
+                providerSilentMode: func.providerSilentMode,
+                providerRootDirectory: func.providerRootDirectory,
+                templateRepository: func.templateRepository,
+                templateOwner: func.templateOwner,
+                templateRootDirectory: func.templateRootDirectory,
+                // templateBranch: func.templateBranch, // Not available in AppwriteFunction type
+                specification: func.specification,
+            })) || [],
+        };
+        // Write YAML config
+        const yamlContent = yaml.dump(yamlConfig, {
+            indent: 2,
+            lineWidth: 120,
+            sortKeys: false,
+        });
+        // Preserve schema reference if it exists
+        let finalContent = yamlContent;
+        if (fs.existsSync(configPath)) {
+            const existingContent = fs.readFileSync(configPath, "utf8");
+            const lines = existingContent.split('\n');
+            const schemaLine = lines.find(line => line.startsWith('# yaml-language-server:'));
+            const commentLine = lines.find(line => line.startsWith('# Appwrite Project Configuration'));
+            if (schemaLine) {
+                finalContent = schemaLine + '\n';
+                if (commentLine) {
+                    finalContent += commentLine + '\n';
+                }
+                finalContent += yamlContent;
+            }
+        }
+        else {
+            // Add schema reference for new files
+            const schemaReference = "# yaml-language-server: $schema=./.yaml_schemas/appwrite-config.schema.json\n";
+            finalContent = schemaReference + "# Appwrite Project Configuration\n" + yamlContent;
+        }
+        fs.writeFileSync(configPath, finalContent, "utf8");
+        console.log(`✅ Updated YAML configuration at ${configPath}`);
+    }
+    catch (error) {
+        console.error("❌ Error writing YAML config:", error instanceof Error ? error.message : error);
+        throw error;
+    }
+};
 /**
  * Adds a new function to the YAML config file
  * @param configPath Path to the YAML config file

package/dist/interactiveCLI.js

@@ -1067,7 +1067,7 @@ export class InteractiveCLI {
             }
             // Update schemas after all changes
             const schemaGenerator = new SchemaGenerator(this.controller.config, this.controller.getAppwriteFolderPath());
-            schemaGenerator.updateConfig(this.controller.config);
+            await schemaGenerator.updateConfig(this.controller.config);
         }
         console.log(chalk.green("✨ Configurations synchronized successfully!"));
     }

package/dist/shared/schemaGenerator.d.ts

@@ -6,7 +6,9 @@ export declare class SchemaGenerator {
     constructor(config: AppwriteConfig, appwriteFolderPath: string);
     updateYamlCollections(): void;
     updateTsSchemas(): void;
-    updateConfig(config: AppwriteConfig): void;
+    updateConfig(config: AppwriteConfig): Promise<void>;
+    private updateYamlConfig;
+    private updateTypeScriptConfig;
     private extractRelationships;
     private addRelationship;
     generateSchemas(options?: {

package/dist/shared/schemaGenerator.js

@@ -154,7 +154,34 @@ export class SchemaGenerator {
             console.log(`Collection schema written to ${collectionFilePath}`);
         });
     }
-    updateConfig(config) {
+    async updateConfig(config) {
+        // Check if user is using YAML config
+        const { findYamlConfig } = await import("../config/yamlConfig.js");
+        const yamlConfigPath = findYamlConfig(this.appwriteFolderPath);
+        if (yamlConfigPath) {
+            // User has YAML config - update it and generate individual collection files
+            await this.updateYamlConfig(config, yamlConfigPath);
+        }
+        else {
+            // User has TypeScript config - update the TS file
+            this.updateTypeScriptConfig(config);
+        }
+    }
+    async updateYamlConfig(config, yamlConfigPath) {
+        try {
+            const { writeYamlConfig } = await import("../config/yamlConfig.js");
+            // Write the main YAML config (without collections)
+            await writeYamlConfig(yamlConfigPath, config);
+            // Generate individual collection YAML files
+            this.updateYamlCollections();
+            console.log("✅ Updated YAML configuration and collection files");
+        }
+        catch (error) {
+            console.error("❌ Error updating YAML config:", error instanceof Error ? error.message : error);
+            throw error;
+        }
+    }
+    updateTypeScriptConfig(config) {
         const configPath = path.join(this.appwriteFolderPath, "appwriteConfig.ts");
         const configContent = `import { type AppwriteConfig } from "appwrite-utils";
 
@@ -175,7 +202,7 @@ const appwriteConfig: AppwriteConfig = {
             $id: func.$id || ulid(),
             name: func.name,
             runtime: func.runtime,
-            dirPath: func.dirPath || `functions/${func.name}`,
+            dirPath: func.dirPath || "functions/" + func.name,
             entrypoint: func.entrypoint || "src/index.ts",
             execute: func.execute || [],
             events: func.events || [],
@@ -191,12 +218,14 @@ const appwriteConfig: AppwriteConfig = {
             providerSilentMode: func.providerSilentMode,
             providerRootDirectory: func.providerRootDirectory,
             specification: func.specification,
-        })), null, 4)}
+        })), null, 4)},
+  collections: ${JSON.stringify(config.collections, null, 4)}
 };
 
 export default appwriteConfig;
 `;
         fs.writeFileSync(configPath, configContent, { encoding: "utf-8" });
+        console.log("✅ Updated TypeScript configuration file");
     }
     extractRelationships() {
         if (!this.config.collections) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/config/yamlConfig.ts

@@ -216,7 +216,7 @@ export const convertYamlToAppwriteConfig = (yamlConfig: YamlConfig): AppwriteCon
       templateBranch: func.templateBranch || "",
       specification: func.specification || "s-0.5vcpu-512mb",
     })),
-    collections: [],
+    collections: [], // Note: Collections are managed separately in YAML configs via individual collection files
   };
 
   return appwriteConfig;
@@ -427,6 +427,135 @@ export const generateYamlConfigTemplate = (outputPath: string) => {
   fs.writeFileSync(outputPath, finalContent, "utf8");
 };
 
+/**
+ * Converts AppwriteConfig back to YAML format and writes to file
+ * @param configPath Path to the YAML config file
+ * @param config The AppwriteConfig to convert and save
+ */
+export const writeYamlConfig = async (configPath: string, config: AppwriteConfig): Promise<void> => {
+  try {
+    // Convert AppwriteConfig back to YAML format
+    const yamlConfig: YamlConfig = {
+      appwrite: {
+        endpoint: config.appwriteEndpoint,
+        project: config.appwriteProject,
+        key: config.appwriteKey,
+      },
+      logging: {
+        enabled: config.logging?.enabled || false,
+        level: config.logging?.level || "info",
+        directory: config.logging?.logDirectory,
+        console: config.logging?.console || false,
+      },
+      backups: {
+        enabled: config.enableBackups !== false,
+        interval: config.backupInterval || 3600,
+        retention: config.backupRetention || 30,
+        cleanup: config.enableBackupCleanup !== false,
+      },
+      data: {
+        enableMockData: config.enableMockData || false,
+        documentBucketId: config.documentBucketId || "documents",
+        usersCollectionName: config.usersCollectionName || "Members",
+        importDirectory: config.schemaConfig?.importDirectory || "importData",
+      },
+      schemas: {
+        outputDirectory: config.schemaConfig?.outputDirectory || "schemas",
+        yamlSchemaDirectory: config.schemaConfig?.yamlSchemaDirectory || ".yaml_schemas",
+      },
+      migrations: {
+        enabled: config.useMigrations !== false,
+      },
+      databases: config.databases?.map(db => ({
+        id: db.$id,
+        name: db.name,
+        bucket: db.bucket ? {
+          id: db.bucket.$id,
+          name: db.bucket.name,
+          permissions: db.bucket.permissions || [],
+          fileSecurity: db.bucket.fileSecurity,
+          enabled: db.bucket.enabled,
+          maximumFileSize: db.bucket.maximumFileSize,
+          allowedFileExtensions: db.bucket.allowedFileExtensions,
+          compression: db.bucket.compression as "none" | "gzip" | "zstd",
+          encryption: db.bucket.encryption,
+          antivirus: db.bucket.antivirus,
+        } : undefined,
+      })) || [],
+      buckets: config.buckets?.map(bucket => ({
+        id: bucket.$id,
+        name: bucket.name,
+        permissions: bucket.permissions || [],
+        fileSecurity: bucket.fileSecurity,
+        enabled: bucket.enabled,
+        maximumFileSize: bucket.maximumFileSize,
+        allowedFileExtensions: bucket.allowedFileExtensions,
+        compression: bucket.compression as "none" | "gzip" | "zstd",
+        encryption: bucket.encryption,
+        antivirus: bucket.antivirus,
+      })) || [],
+      functions: config.functions?.map(func => ({
+        id: func.$id,
+        name: func.name,
+        runtime: func.runtime,
+        execute: func.execute,
+        events: func.events,
+        schedule: func.schedule,
+        timeout: func.timeout,
+        enabled: func.enabled,
+        logging: func.logging,
+        entrypoint: func.entrypoint,
+        commands: func.commands,
+        scopes: func.scopes,
+        installationId: func.installationId,
+        providerRepositoryId: func.providerRepositoryId,
+        providerBranch: func.providerBranch,
+        providerSilentMode: func.providerSilentMode,
+        providerRootDirectory: func.providerRootDirectory,
+        templateRepository: func.templateRepository,
+        templateOwner: func.templateOwner,
+        templateRootDirectory: func.templateRootDirectory,
+        // templateBranch: func.templateBranch, // Not available in AppwriteFunction type
+        specification: func.specification,
+      })) || [],
+    };
+
+    // Write YAML config
+    const yamlContent = yaml.dump(yamlConfig, {
+      indent: 2,
+      lineWidth: 120,
+      sortKeys: false,
+    });
+
+    // Preserve schema reference if it exists
+    let finalContent = yamlContent;
+    if (fs.existsSync(configPath)) {
+      const existingContent = fs.readFileSync(configPath, "utf8");
+      const lines = existingContent.split('\n');
+      const schemaLine = lines.find(line => line.startsWith('# yaml-language-server:'));
+      const commentLine = lines.find(line => line.startsWith('# Appwrite Project Configuration'));
+      
+      if (schemaLine) {
+        finalContent = schemaLine + '\n';
+        if (commentLine) {
+          finalContent += commentLine + '\n';
+        }
+        finalContent += yamlContent;
+      }
+    } else {
+      // Add schema reference for new files
+      const schemaReference = "# yaml-language-server: $schema=./.yaml_schemas/appwrite-config.schema.json\n";
+      finalContent = schemaReference + "# Appwrite Project Configuration\n" + yamlContent;
+    }
+
+    fs.writeFileSync(configPath, finalContent, "utf8");
+    console.log(`✅ Updated YAML configuration at ${configPath}`);
+  } catch (error) {
+    console.error("❌ Error writing YAML config:", error instanceof Error ? error.message : error);
+    throw error;
+  }
+};
+
 /**
  * Adds a new function to the YAML config file
  * @param configPath Path to the YAML config file

package/src/interactiveCLI.ts

@@ -1442,7 +1442,7 @@ export class InteractiveCLI {
         this.controller!.config!,
         this.controller!.getAppwriteFolderPath()!
       );
-      schemaGenerator.updateConfig(this.controller!.config!);
+      await schemaGenerator.updateConfig(this.controller!.config!);
     }
 
     console.log(chalk.green("✨ Configurations synchronized successfully!"));

package/src/shared/schemaGenerator.ts

@@ -197,7 +197,38 @@ export class SchemaGenerator {
     });
   }
 
-  public updateConfig(config: AppwriteConfig): void {
+  public async updateConfig(config: AppwriteConfig): Promise<void> {
+    // Check if user is using YAML config
+    const { findYamlConfig } = await import("../config/yamlConfig.js");
+    const yamlConfigPath = findYamlConfig(this.appwriteFolderPath);
+    
+    if (yamlConfigPath) {
+      // User has YAML config - update it and generate individual collection files
+      await this.updateYamlConfig(config, yamlConfigPath);
+    } else {
+      // User has TypeScript config - update the TS file
+      this.updateTypeScriptConfig(config);
+    }
+  }
+
+  private async updateYamlConfig(config: AppwriteConfig, yamlConfigPath: string): Promise<void> {
+    try {
+      const { writeYamlConfig } = await import("../config/yamlConfig.js");
+      
+      // Write the main YAML config (without collections)
+      await writeYamlConfig(yamlConfigPath, config);
+      
+      // Generate individual collection YAML files
+      this.updateYamlCollections();
+      
+      console.log("✅ Updated YAML configuration and collection files");
+    } catch (error) {
+      console.error("❌ Error updating YAML config:", error instanceof Error ? error.message : error);
+      throw error;
+    }
+  }
+
+  private updateTypeScriptConfig(config: AppwriteConfig): void {
     const configPath = path.join(this.appwriteFolderPath, "appwriteConfig.ts");
     const configContent = `import { type AppwriteConfig } from "appwrite-utils";
 
@@ -219,7 +250,7 @@ const appwriteConfig: AppwriteConfig = {
       $id: func.$id || ulid(),
       name: func.name,
       runtime: func.runtime,
-      dirPath: func.dirPath || `functions/${func.name}`,
+      dirPath: func.dirPath || "functions/" + func.name,
       entrypoint: func.entrypoint || "src/index.ts",
       execute: func.execute || [],
       events: func.events || [],
@@ -238,12 +269,14 @@ const appwriteConfig: AppwriteConfig = {
     })),
     null,
     4
-  )}
+  )},
+  collections: ${JSON.stringify(config.collections, null, 4)}
 };
 
 export default appwriteConfig;
 `;
     fs.writeFileSync(configPath, configContent, { encoding: "utf-8" });
+    console.log("✅ Updated TypeScript configuration file");
   }
 
   private extractRelationships(): void {

package/src/utils/yamlConverter.ts

@@ -128,4 +128,5 @@ export function sanitizeFilename(name: string): string {
  */
 export function getCollectionYamlFilename(collection: Collection | CollectionCreate): string {
   return `${sanitizeFilename(collection.name)}.yaml`;
-}
+}
+