appwrite-utils-cli 1.8.2 → 1.8.5

package/src/shared/schemaGenerator.ts

@@ -345,28 +345,34 @@ export default appwriteConfig;
     this.relationshipMap = extractTwoWayRelationships(this.config);
   }
 
-  public generateSchemas(options: {
-    format?: "zod" | "json" | "both";
-    verbose?: boolean;
-  } = {}): void {
-    const { format = "both", verbose = false } = options;
+  public async generateSchemas(options: {
+    format?: "zod" | "json" | "pydantic" | "both" | "all";
+    verbose?: boolean;
+    outputDir?: string;
+  } = {}): Promise<void> {
+    const { format = "both", verbose = false, outputDir } = options;
     
     if (!this.config.collections) {
       return;
     }
     
     // Create schemas directory using config setting
-    const outputDir = this.config.schemaConfig?.outputDirectory || "schemas";
-    const schemasPath = outputDir === "schemas"
-      ? resolveSchemaDir(this.appwriteFolderPath)
-      : path.join(this.appwriteFolderPath, outputDir);
+    const configuredDir = outputDir || this.config.schemaConfig?.outputDirectory || "schemas";
+    let schemasPath: string;
+    if (path.isAbsolute(configuredDir)) {
+      schemasPath = configuredDir;
+    } else if (configuredDir === "schemas") {
+      schemasPath = resolveSchemaDir(this.appwriteFolderPath);
+    } else {
+      schemasPath = path.join(this.appwriteFolderPath, configuredDir);
+    }
     if (!fs.existsSync(schemasPath)) {
       fs.mkdirSync(schemasPath, { recursive: true });
     }
     
-    // Generate Zod schemas (TypeScript)
-    if (format === "zod" || format === "both") {
-      this.config.collections.forEach((collection) => {
+    // Generate Zod schemas (TypeScript)
+    if (format === "zod" || format === "both" || format === "all") {
+      this.config.collections.forEach((collection) => {
         const schemaString = this.createSchemaStringV4(
           collection.name,
           collection.attributes || []
@@ -381,19 +387,26 @@ export default appwriteConfig;
     }
 
     // Generate JSON schemas (all at once)
-    if (format === "json" || format === "both") {
-      const jsonSchemaGenerator = new JsonSchemaGenerator(this.config, this.appwriteFolderPath);
-      jsonSchemaGenerator.generateJsonSchemas({
-        outputFormat: format === "json" ? "json" : "both",
-        outputDirectory: outputDir,
-        verbose: verbose
-      });
-    }
-
-    if (verbose) {
-      MessageFormatter.success(`Schema generation completed (format: ${format})`, { prefix: "Schema" });
-    }
-  }
+    if (format === "json" || format === "both" || format === "all") {
+      const jsonSchemaGenerator = new JsonSchemaGenerator(this.config, this.appwriteFolderPath);
+      jsonSchemaGenerator.generateJsonSchemas({
+        outputFormat: format === "json" ? "json" : "both",
+        outputDirectory: configuredDir,
+        verbose: verbose
+      });
+    }
+
+    // Generate Python Pydantic models
+    if (format === "pydantic" || format === "all") {
+      const mod = await import("./pydanticModelGenerator.js");
+      const pgen = new mod.PydanticModelGenerator(this.config, this.appwriteFolderPath);
+      pgen.generatePydanticModels({ baseOutputDirectory: schemasPath, verbose });
+    }
+
+    if (verbose) {
+      MessageFormatter.success(`Schema generation completed (format: ${format})`, { prefix: "Schema" });
+    }
+  }
 
   // Zod v4 recursive getter-based schemas
   createSchemaStringV4 = (name: string, attributes: Attribute[]): string => {

package/src/storage/methods.ts

@@ -105,18 +105,65 @@ export const deleteFile = async (
   return await storage.deleteFile(bucketId, fileId);
 };
 
-export const ensureDatabaseConfigBucketsExist = async (
-  storage: Storage,
-  config: AppwriteConfig,
-  databases: Models.Database[] = []
-) => {
-  for (const db of databases) {
-    const database = config.databases?.find((d) => d.$id === db.$id);
-    if (database?.bucket) {
-      try {
-        await storage.getBucket(database.bucket.$id);
-        console.log(`Bucket ${database.bucket.$id} already exists.`);
-      } catch (e) {
+export const ensureDatabaseConfigBucketsExist = async (
+  storage: Storage,
+  config: AppwriteConfig,
+  databases: Models.Database[] = []
+) => {
+  for (const db of databases) {
+    const database = config.databases?.find((d) => d.$id === db.$id);
+    if (database?.bucket) {
+      try {
+        const existing = await storage.getBucket(database.bucket.$id);
+        // Compare and update if needed
+        const desired = database.bucket;
+        // Build desired permissions via Permission helper
+        const permissions: string[] = [];
+        if (desired.permissions && desired.permissions.length > 0) {
+          for (const p of desired.permissions as any[]) {
+            switch (p.permission) {
+              case 'read': permissions.push(Permission.read(p.target)); break;
+              case 'create': permissions.push(Permission.create(p.target)); break;
+              case 'update': permissions.push(Permission.update(p.target)); break;
+              case 'delete': permissions.push(Permission.delete(p.target)); break;
+              case 'write': permissions.push(Permission.write(p.target)); break;
+              default: break;
+            }
+          }
+        }
+        const diff = (
+          existing.name !== desired.name ||
+          JSON.stringify(existing.$permissions || []) !== JSON.stringify(permissions) ||
+          !!existing.fileSecurity !== !!desired.fileSecurity ||
+          !!existing.enabled !== !!desired.enabled ||
+          (existing.maximumFileSize ?? undefined) !== (desired.maximumFileSize ?? undefined) ||
+          JSON.stringify(existing.allowedFileExtensions || []) !== JSON.stringify(desired.allowedFileExtensions || []) ||
+          String(existing.compression || 'none') !== String(desired.compression || 'none') ||
+          !!existing.encryption !== !!desired.encryption ||
+          !!existing.antivirus !== !!desired.antivirus
+        );
+        if (diff) {
+          try {
+            await storage.updateBucket(
+              desired.$id,
+              desired.name,
+              permissions,
+              desired.fileSecurity,
+              desired.enabled,
+              desired.maximumFileSize,
+              desired.allowedFileExtensions,
+              desired.compression as Compression,
+              desired.encryption,
+              desired.antivirus
+            );
+            MessageFormatter.info(`Updated bucket ${desired.$id} to match config`, { prefix: 'Buckets' });
+          } catch (updateErr) {
+            MessageFormatter.warning(`Failed to update bucket ${desired.$id}: ${updateErr instanceof Error ? updateErr.message : String(updateErr)}`, { prefix: 'Buckets' });
+          }
+        } else {
+          MessageFormatter.debug(`Bucket ${desired.$id} up-to-date`, undefined, { prefix: 'Buckets' });
+        }
+      } catch (e) {
         const permissions: string[] = [];
         if (
           database.bucket.permissions &&
@@ -158,17 +205,14 @@ export const ensureDatabaseConfigBucketsExist = async (
             database.bucket.encryption,
             database.bucket.antivirus
           );
-          console.log(`Bucket ${database.bucket.$id} created successfully.`);
-        } catch (createError) {
-          // console.error(
-          //   `Failed to create bucket ${database.bucket.$id}:`,
-          //   createError
-          // );
-        }
-      }
-    }
-  }
-};
+          MessageFormatter.success(`Bucket ${database.bucket.$id} created`, { prefix: 'Buckets' });
+        } catch (createError) {
+          MessageFormatter.error(`Failed to create bucket ${database.bucket.$id}`, createError instanceof Error ? createError : new Error(String(createError)), { prefix: 'Buckets' });
+        }
+      }
+    }
+  }
+};
 
 export const wipeDocumentStorage = async (
   storage: Storage,

package/src/utils/configDiscovery.ts

@@ -173,28 +173,27 @@ const YamlTableSchema = z.object({
       target: z.string()
     })
   ).optional().default([]),
-  columns: z.array( // Tables use columns terminology
-    z.object({
-      key: z.string(),
-      type: z.string(),
-      size: z.number().optional(),
-      required: z.boolean().default(false),
-      array: z.boolean().optional(),
-      encrypted: z.boolean().optional(), // Tables support encrypted property
-      default: z.any().optional(),
-      min: z.number().optional(),
-      max: z.number().optional(),
-      elements: z.array(z.string()).optional(),
-      relatedTable: z.string().optional(), // Tables use relatedTable
-      relationType: z.string().optional(),
-      twoWay: z.boolean().optional(),
-      twoWayKey: z.string().optional(),
-      onDelete: z.string().optional(),
-      side: z.string().optional(),
-      encrypt: z.boolean().optional(),
-      format: z.string().optional()
-    })
-  ).optional().default([]),
+  columns: z.array( // Tables use columns terminology
+    z.object({
+      key: z.string(),
+      type: z.string(),
+      size: z.number().optional(),
+      required: z.boolean().default(false),
+      array: z.boolean().optional(),
+      encrypt: z.boolean().optional(), // Tables support encrypt property
+      default: z.any().optional(),
+      min: z.number().optional(),
+      max: z.number().optional(),
+      elements: z.array(z.string()).optional(),
+      relatedTable: z.string().optional(), // Tables use relatedTable
+      relationType: z.string().optional(),
+      twoWay: z.boolean().optional(),
+      twoWayKey: z.string().optional(),
+      onDelete: z.string().optional(),
+      side: z.string().optional(),
+      format: z.string().optional()
+    })
+  ).optional().default([]),
   indexes: z.array(
     z.object({
       key: z.string(),
@@ -289,25 +288,25 @@ export const loadYamlTable = (filePath: string): CollectionCreate | null => {
         permission: p.permission as any,
         target: p.target
       })),
-      attributes: parsedTable.columns.map(col => ({ // Convert columns to attributes
-        key: col.key,
-        type: col.type as any,
-        size: col.size,
-        required: col.required,
-        array: col.array,
-        xdefault: col.default,
-        min: col.min,
-        max: col.max,
-        elements: col.elements,
-        relatedCollection: col.relatedTable, // Convert relatedTable to relatedCollection
-        relationType: col.relationType as any,
-        twoWay: col.twoWay,
-        twoWayKey: col.twoWayKey,
-        onDelete: col.onDelete as any,
-        side: col.side as any,
-        encrypted: col.encrypted || col.encrypt, // Support both encrypted and encrypt
-        format: col.format
-      })),
+      attributes: parsedTable.columns.map(col => ({ // Convert columns to attributes
+        key: col.key,
+        type: col.type as any,
+        size: col.size,
+        required: col.required,
+        array: col.array,
+        xdefault: col.default,
+        min: col.min,
+        max: col.max,
+        elements: col.elements,
+        relatedCollection: col.relatedTable, // Convert relatedTable to relatedCollection
+        relationType: col.relationType as any,
+        twoWay: col.twoWay,
+        twoWayKey: col.twoWayKey,
+        onDelete: col.onDelete as any,
+        side: col.side as any,
+        encrypt: col.encrypt,
+        format: col.format
+      })),
       indexes: parsedTable.indexes.map(idx => ({
         key: idx.key,
         type: idx.type as any,

package/src/utils/constantsGenerator.ts

@@ -89,8 +89,8 @@ export class ConstantsGenerator {
     return name.toLowerCase();
   }
 
-  generateTypeScript(): string {
-    const { databases, collections, buckets, functions } = this.constants;
+  generateTypeScript(constantsOverride?: Constants): string {
+    const { databases, collections, buckets, functions } = constantsOverride || this.constants;
 
     return `// Auto-generated Appwrite constants
 // Generated on ${new Date().toISOString()}
@@ -125,8 +125,8 @@ export const ALL_FUNCTION_IDS = Object.values(FUNCTION_IDS);
 `;
   }
 
-  generateJavaScript(): string {
-    const { databases, collections, buckets, functions } = this.constants;
+  generateJavaScript(constantsOverride?: Constants): string {
+    const { databases, collections, buckets, functions } = constantsOverride || this.constants;
 
     return `// Auto-generated Appwrite constants
 // Generated on ${new Date().toISOString()}
@@ -155,8 +155,8 @@ export const ALL_FUNCTION_IDS = Object.values(FUNCTION_IDS);
 `;
   }
 
-  generatePython(): string {
-    const { databases, collections, buckets, functions } = this.constants;
+  generatePython(constantsOverride?: Constants): string {
+    const { databases, collections, buckets, functions } = constantsOverride || this.constants;
 
     return `# Auto-generated Appwrite constants
 # Generated on ${new Date().toISOString()}
@@ -196,8 +196,8 @@ ${Object.entries(functions).map(([key, value]) => `    "${this.toSnakeCase(key)}
 `;
   }
 
-  generatePHP(): string {
-    const { databases, collections, buckets, functions } = this.constants;
+  generatePHP(constantsOverride?: Constants): string {
+    const { databases, collections, buckets, functions } = constantsOverride || this.constants;
 
     return `<?php
 // Auto-generated Appwrite constants
@@ -252,8 +252,8 @@ ${Object.entries(functions).map(([key, value]) => `        '${key}' => '${value}
 `;
   }
 
-  generateDart(): string {
-    const { databases, collections, buckets, functions } = this.constants;
+  generateDart(constantsOverride?: Constants): string {
+    const { databases, collections, buckets, functions } = constantsOverride || this.constants;
 
     return `// Auto-generated Appwrite constants
 // Generated on ${new Date().toISOString()}
@@ -288,21 +288,22 @@ ${Object.entries(functions).map(([key, value]) => `  static String get ${this.to
 `;
   }
 
-  generateJSON(): string {
+  generateJSON(constantsOverride?: Constants): string {
+    const c = constantsOverride || this.constants;
     return JSON.stringify({
       meta: {
         generated: new Date().toISOString(),
         generator: "appwrite-utils-cli"
       },
-      databases: this.constants.databases,
-      collections: this.constants.collections,
-      buckets: this.constants.buckets,
-      functions: this.constants.functions
+      databases: c.databases,
+      collections: c.collections,
+      buckets: c.buckets,
+      functions: c.functions
     }, null, 2);
   }
 
-  generateEnv(): string {
-    const { databases, collections, buckets, functions } = this.constants;
+  generateEnv(constantsOverride?: Constants): string {
+    const { databases, collections, buckets, functions } = constantsOverride || this.constants;
     
     const lines = [
       "# Auto-generated Appwrite constants",
@@ -324,17 +325,33 @@ ${Object.entries(functions).map(([key, value]) => `  static String get ${this.to
     return lines.join('\n');
   }
 
-  async generateFiles(languages: SupportedLanguage[], outputDir: string): Promise<void> {
+  async generateFiles(
+    languages: SupportedLanguage[],
+    outputDir: string,
+    include?: { databases?: boolean; collections?: boolean; buckets?: boolean; functions?: boolean }
+  ): Promise<void> {
     await fs.mkdir(outputDir, { recursive: true });
 
+    const filterConstants = (): Constants => {
+      if (!include) return this.constants;
+      return {
+        databases: include.databases === false ? {} : this.constants.databases,
+        collections: include.collections === false ? {} : this.constants.collections,
+        buckets: include.buckets === false ? {} : this.constants.buckets,
+        functions: include.functions === false ? {} : this.constants.functions,
+      };
+    };
+
+    const subset = filterConstants();
+
     const generators = {
-      typescript: () => ({ content: this.generateTypeScript(), filename: "appwrite-constants.ts" }),
-      javascript: () => ({ content: this.generateJavaScript(), filename: "appwrite-constants.js" }),
-      python: () => ({ content: this.generatePython(), filename: "appwrite_constants.py" }),
-      php: () => ({ content: this.generatePHP(), filename: "AppwriteConstants.php" }),
-      dart: () => ({ content: this.generateDart(), filename: "appwrite_constants.dart" }),
-      json: () => ({ content: this.generateJSON(), filename: "appwrite-constants.json" }),
-      env: () => ({ content: this.generateEnv(), filename: ".env.appwrite" })
+      typescript: () => ({ content: this.generateTypeScript(subset), filename: "appwrite-constants.ts" }),
+      javascript: () => ({ content: this.generateJavaScript(subset), filename: "appwrite-constants.js" }),
+      python: () => ({ content: this.generatePython(subset), filename: "appwrite_constants.py" }),
+      php: () => ({ content: this.generatePHP(subset), filename: "AppwriteConstants.php" }),
+      dart: () => ({ content: this.generateDart(subset), filename: "appwrite_constants.dart" }),
+      json: () => ({ content: this.generateJSON(subset), filename: "appwrite-constants.json" }),
+      env: () => ({ content: this.generateEnv(subset), filename: ".env.appwrite" })
     };
 
     for (const language of languages) {
@@ -349,4 +366,4 @@ ${Object.entries(functions).map(([key, value]) => `  static String get ${this.to
       }
     }
   }
-}
+}

package/src/utils/projectConfig.ts

@@ -251,16 +251,16 @@ export function getCollectionsFromProject(projectConfig: AppwriteProjectConfig):
       documentSecurity: table.rowSecurity || false,
       enabled: table.enabled !== false,
       // Convert columns to attributes for compatibility
-      attributes: table.columns.map(col => ({
-        key: col.key,
-        type: col.type,
-        required: col.required,
-        array: col.array,
-        size: col.size,
-        default: col.default,
-        encrypted: col.encrypt,
-        unique: col.unique,
-      })),
+      attributes: table.columns.map(col => ({
+        key: col.key,
+        type: col.type,
+        required: col.required,
+        array: col.array,
+        size: col.size,
+        default: col.default,
+        encrypt: col.encrypt,
+        unique: col.unique,
+      })),
       indexes: table.indexes || [],
       // Mark as coming from TablesDB for processing
       _isFromTablesDir: true,
@@ -296,4 +296,4 @@ export function isTablesDBProject(projectConfig: AppwriteProjectConfig): boolean
  */
 export function getProjectDirectoryName(projectConfig: AppwriteProjectConfig): "tables" | "collections" {
   return isTablesDBProject(projectConfig) ? "tables" : "collections";
-}
+}

package/src/utils/yamlConverter.ts

@@ -101,43 +101,43 @@ export interface YamlCollectionData {
     permission: string;
     target: string;
   }>;
-  attributes?: Array<{
-    key: string;
-    type: string;
-    size?: number;
-    required?: boolean;
-    array?: boolean;
-    encrypted?: boolean;
-    default?: any;
-    min?: number;
-    max?: number;
-    elements?: string[];
-    relatedCollection?: string;
-    relationType?: string;
-    twoWay?: boolean;
-    twoWayKey?: string;
-    onDelete?: string;
-    side?: string;
-  }>;
+  attributes?: Array<{
+    key: string;
+    type: string;
+    size?: number;
+    required?: boolean;
+    array?: boolean;
+    encrypt?: boolean;
+    default?: any;
+    min?: number;
+    max?: number;
+    elements?: string[];
+    relatedCollection?: string;
+    relationType?: string;
+    twoWay?: boolean;
+    twoWayKey?: string;
+    onDelete?: string;
+    side?: string;
+  }>;
   // Table terminology support (columns is an alias for attributes)
-  columns?: Array<{
-    key: string;
-    type: string;
-    size?: number;
-    required?: boolean;
-    array?: boolean;
-    encrypted?: boolean;
-    default?: any;
-    min?: number;
-    max?: number;
-    elements?: string[];
-    relatedTable?: string;
-    relationType?: string;
-    twoWay?: boolean;
-    twoWayKey?: string;
-    onDelete?: string;
-    side?: string;
-  }>;
+  columns?: Array<{
+    key: string;
+    type: string;
+    size?: number;
+    required?: boolean;
+    array?: boolean;
+    encrypt?: boolean;
+    default?: any;
+    min?: number;
+    max?: number;
+    elements?: string[];
+    relatedTable?: string;
+    relationType?: string;
+    twoWay?: boolean;
+    twoWayKey?: string;
+    onDelete?: string;
+    side?: string;
+  }>;
   indexes?: Array<{
     key: string;
     type: string;
@@ -205,10 +205,10 @@ export function collectionToYaml(
       if (attr.required !== undefined) yamlAttr.required = attr.required;
       if (attr.array !== undefined) yamlAttr.array = attr.array;
 
-      // Always include encrypted field for string attributes (default to false)
-      if (attr.type === 'string') {
-        yamlAttr.encrypted = ('encrypted' in attr && attr.encrypted === true) ? true : false;
-      }
+      // Always include encrypt field for string attributes (default to false)
+      if (attr.type === 'string') {
+        yamlAttr.encrypt = ('encrypt' in attr && (attr as any).encrypt === true) ? true : false;
+      }
 
       if ('xdefault' in attr && attr.xdefault !== undefined) yamlAttr.default = attr.xdefault;