appwrite-utils-cli 1.0.5 → 1.0.6

package/README.md

@@ -23,6 +23,7 @@
 ### Development Tools
 - **Database Migrations**: Full migration control with progress tracking and operation summaries
 - **Schema Generation**: Generate TypeScript and JSON schemas from database configurations
+- **Constants Generation**: Generate cross-language constants files (TypeScript, Python, PHP, Dart, JSON, Env) for database, collection, bucket, and function IDs
 - **Data Transfer**: Transfer data between databases, collections, and instances with real-time progress
 - **Configuration Sync**: Bidirectional synchronization between local YAML configs and Appwrite projects
 - **Function Management**: Deploy and manage Appwrite Functions with specification updates
@@ -218,8 +219,53 @@ Available options:
 - `--functionId`: Function ID to update
 - `--specification`: New function specification (s-0.5vcpu-512mb to s-8vcpu-8gb)
 
+### Constants Generation
+- `--generateConstants` / `--constants`: Generate cross-language constants files with database, collection, bucket, and function IDs
+- `--constantsLanguages`: Comma-separated list of languages for constants generation (default: typescript)
+  - Available languages: `typescript`, `javascript`, `python`, `php`, `dart`, `json`, `env`
+- `--constantsOutput`: Output directory for generated constants files (default: config-folder/constants)
+
 ## Examples
 
+### Generate Constants
+
+Generate cross-language constants files for all your Appwrite resource IDs:
+
+```bash
+# Generate TypeScript constants (default)
+npx appwrite-utils-cli appwrite-migrate --generateConstants
+
+# Generate multiple language formats
+npx appwrite-utils-cli appwrite-migrate --generateConstants --constantsLanguages="typescript,python,php,json"
+
+# Generate all available formats
+npx appwrite-utils-cli appwrite-migrate --generateConstants --constantsLanguages="typescript,javascript,python,php,dart,json,env"
+
+# Generate with custom output directory
+npx appwrite-utils-cli appwrite-migrate --generateConstants --constantsOutput="./my-constants"
+```
+
+This generates constants files in your configuration directory (e.g., `.appwrite/constants/`) containing:
+- Database IDs
+- Collection IDs  
+- Bucket IDs
+- Function IDs
+
+**Example TypeScript output:**
+```typescript
+export const DATABASE_IDS = {
+  MAIN_DATABASE: "main"
+} as const;
+
+export const COLLECTION_IDS = {
+  USERS: "01JYDBQTB5W8SCBAYB654CCADQ",
+  POSTS: "01JYDBQTB5W8SCBAYB654POSTS"
+} as const;
+
+// Type helpers and utility arrays included
+export type DatabaseId = typeof DATABASE_IDS[keyof typeof DATABASE_IDS];
+```
+
 ### Transfer Databases
 
 Transfer databases within the same project or from a local to a remote project:
@@ -281,6 +327,54 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+### 1.0.6 - Cross-Language Constants Generation
+
+**🚀 Enhanced Developer Experience with Multi-Language Constants**
+
+#### Constants Generation System
+- **Cross-Language Support**: Generate constants in 7 languages for seamless multi-platform development
+  - **TypeScript**: Type-safe constants with `as const` and helper types
+  - **JavaScript**: ES6 modules with utility arrays
+  - **Python**: Class-based constants with snake_case dictionaries
+  - **PHP**: Static class methods and associative arrays
+  - **Dart**: Maps with individual getter methods (camelCase)
+  - **JSON**: Structured data with metadata for cross-platform integration
+  - **Environment Variables**: Prefixed environment variables for deployment
+- **Smart Directory Structure**: Constants generated in `{config-folder}/constants/` by default
+- **CLI Integration**: Both command-line and interactive mode support
+- **Custom Output**: Support for custom output directories when needed
+
+#### Resource ID Extraction
+- **Database IDs**: Extract all configured database identifiers
+- **Collection IDs**: Generate constants for all collection ULIDs/names
+- **Bucket IDs**: Include storage bucket identifiers
+- **Function IDs**: Support for Appwrite Function identifiers
+- **Naming Conventions**: Language-appropriate naming (UPPER_CASE, camelCase, snake_case)
+
+#### Developer Experience Improvements
+- **Interactive Mode**: Checkbox selection for languages with smart defaults
+- **CLI Commands**: Simple `--generateConstants` with language and output options
+- **Type Safety**: Full TypeScript support with generated types and helpers
+- **Cross-Platform Compatibility**: Enable seamless development across different tech stacks
+
+#### Usage Examples
+```bash
+# Default TypeScript generation
+npx appwrite-utils-cli appwrite-migrate --generateConstants
+
+# Multi-language generation
+npx appwrite-utils-cli appwrite-migrate --generateConstants --constantsLanguages="typescript,python,php,json"
+
+# All formats with custom output
+npx appwrite-utils-cli appwrite-migrate --generateConstants --constantsLanguages="typescript,javascript,python,php,dart,json,env" --constantsOutput="./constants"
+```
+
+**Migration Benefits**: 
+- Eliminates hardcoded resource IDs across codebases
+- Enables type-safe resource access in TypeScript projects
+- Supports multi-language development workflows
+- Maintains constants alongside configuration for easy maintenance
+
 ### 1.0.1 - Function Templates & Attribute Type Improvements
 
 **🚀 Enhanced Function Management & Type System Fixes**

package/dist/interactiveCLI.d.ts

@@ -24,6 +24,7 @@ export declare class InteractiveCLI {
     private wipeDatabase;
     private wipeCollections;
     private generateSchemas;
+    private generateConstants;
     private importData;
     private transferData;
     private getLocalCollections;

package/dist/interactiveCLI.js

@@ -13,6 +13,7 @@ import { DateTime } from "luxon";
 import { createFunctionTemplate, deleteFunction, downloadLatestFunctionDeployment, getFunction, listFunctions, listSpecifications, } from "./functions/methods.js";
 import { deployLocalFunction } from "./functions/deployments.js";
 import { join } from "node:path";
+import path from "path";
 import fs from "node:fs";
 import { SchemaGenerator } from "./shared/schemaGenerator.js";
 import { ConfirmationDialogs } from "./shared/confirmationDialogs.js";
@@ -36,6 +37,7 @@ var CHOICES;
     CHOICES["WIPE_DATABASE"] = "Wipe database";
     CHOICES["WIPE_COLLECTIONS"] = "Wipe collections";
     CHOICES["GENERATE_SCHEMAS"] = "Generate schemas";
+    CHOICES["GENERATE_CONSTANTS"] = "\uD83D\uDCCB Generate cross-language constants (TypeScript, Python, PHP, Dart, etc.)";
     CHOICES["IMPORT_DATA"] = "Import data";
     CHOICES["RELOAD_CONFIG"] = "Reload configuration files";
     CHOICES["UPDATE_FUNCTION_SPEC"] = "Update function specifications";
@@ -123,6 +125,10 @@ export class InteractiveCLI {
                     await this.initControllerIfNeeded();
                     await this.generateSchemas();
                     break;
+                case CHOICES.GENERATE_CONSTANTS:
+                    await this.initControllerIfNeeded();
+                    await this.generateConstants();
+                    break;
                 case CHOICES.IMPORT_DATA:
                     await this.initControllerIfNeeded();
                     await this.importData();
@@ -1167,6 +1173,66 @@ export class InteractiveCLI {
         schemaGenerator.generateSchemas({ format: schemaType, verbose: true });
         MessageFormatter.success("Schema generation completed", { prefix: "Schemas" });
     }
+    async generateConstants() {
+        console.log(chalk.yellow("Generating cross-language constants..."));
+        if (!this.controller?.config) {
+            MessageFormatter.error("No configuration found", undefined, { prefix: "Constants" });
+            return;
+        }
+        // Prompt for languages
+        const { languages } = await inquirer.prompt([
+            {
+                type: "checkbox",
+                name: "languages",
+                message: "Select languages for constants generation:",
+                choices: [
+                    { name: "TypeScript", value: "typescript", checked: true },
+                    { name: "JavaScript", value: "javascript" },
+                    { name: "Python", value: "python" },
+                    { name: "PHP", value: "php" },
+                    { name: "Dart", value: "dart" },
+                    { name: "JSON", value: "json" },
+                    { name: "Environment Variables", value: "env" },
+                ],
+                validate: (input) => {
+                    if (input.length === 0) {
+                        return "Please select at least one language";
+                    }
+                    return true;
+                },
+            },
+        ]);
+        // Determine default output directory based on config location
+        const configPath = this.controller.getAppwriteFolderPath();
+        const defaultOutputDir = configPath
+            ? path.join(configPath, "constants")
+            : path.join(process.cwd(), "constants");
+        // Prompt for output directory
+        const { outputDir } = await inquirer.prompt([
+            {
+                type: "input",
+                name: "outputDir",
+                message: "Output directory for constants files:",
+                default: defaultOutputDir,
+                validate: (input) => {
+                    if (!input.trim()) {
+                        return "Output directory cannot be empty";
+                    }
+                    return true;
+                },
+            },
+        ]);
+        try {
+            const { ConstantsGenerator } = await import("./utils/constantsGenerator.js");
+            const generator = new ConstantsGenerator(this.controller.config);
+            MessageFormatter.info(`Generating constants for: ${languages.join(", ")}`, { prefix: "Constants" });
+            await generator.generateFiles(languages, outputDir);
+            MessageFormatter.success(`Constants generated in ${outputDir}`, { prefix: "Constants" });
+        }
+        catch (error) {
+            MessageFormatter.error("Failed to generate constants", error instanceof Error ? error : new Error(String(error)), { prefix: "Constants" });
+        }
+    }
     async importData() {
         console.log(chalk.yellow("Importing data..."));
         const { doBackup } = await inquirer.prompt([

package/dist/main.js

@@ -13,6 +13,7 @@ import chalk from "chalk";
 import { listSpecifications } from "./functions/methods.js";
 import { MessageFormatter } from "./shared/messageFormatter.js";
 import { ConfirmationDialogs } from "./shared/confirmationDialogs.js";
+import path from "path";
 const argv = yargs(hideBin(process.argv))
     .option("config", {
     type: "string",
@@ -158,6 +159,21 @@ const argv = yargs(hideBin(process.argv))
     alias: ["migrate"],
     type: "boolean",
     description: "Migrate appwriteConfig.ts to .appwrite structure with YAML configuration",
+})
+    .option("generateConstants", {
+    alias: ["constants"],
+    type: "boolean",
+    description: "Generate cross-language constants file with database, collection, bucket, and function IDs",
+})
+    .option("constantsLanguages", {
+    type: "string",
+    description: "Comma-separated list of languages for constants (typescript,javascript,python,php,dart,json,env)",
+    default: "typescript",
+})
+    .option("constantsOutput", {
+    type: "string",
+    description: "Output directory for generated constants files (default: config-folder/constants)",
+    default: "auto",
 })
     .parse();
 async function main() {
@@ -186,6 +202,33 @@ async function main() {
             await migrateConfig(process.cwd());
             return;
         }
+        if (argv.generateConstants) {
+            const { ConstantsGenerator } = await import("./utils/constantsGenerator.js");
+            if (!controller.config) {
+                MessageFormatter.error("No Appwrite configuration found", undefined, { prefix: "Constants" });
+                return;
+            }
+            const languages = argv.constantsLanguages.split(",").map(l => l.trim());
+            // Determine output directory - use config folder/constants by default, or custom path if specified
+            let outputDir;
+            if (argv.constantsOutput === "auto") {
+                // Default case: use config directory + constants, fallback to current directory
+                const configPath = controller.getAppwriteFolderPath();
+                outputDir = configPath
+                    ? path.join(configPath, "constants")
+                    : path.join(process.cwd(), "constants");
+            }
+            else {
+                // Custom output directory specified
+                outputDir = argv.constantsOutput;
+            }
+            MessageFormatter.info(`Generating constants for languages: ${languages.join(", ")}`, { prefix: "Constants" });
+            const generator = new ConstantsGenerator(controller.config);
+            await generator.generateFiles(languages, outputDir);
+            operationStats.generatedConstants = languages.length;
+            MessageFormatter.success(`Constants generated in ${outputDir}`, { prefix: "Constants" });
+            return;
+        }
         if (!controller.config) {
             MessageFormatter.error("No Appwrite connection found", undefined, { prefix: "CLI" });
             return;

package/dist/utils/constantsGenerator.d.ts

@@ -0,0 +1,19 @@
+import { type AppwriteConfig } from "appwrite-utils";
+export type SupportedLanguage = "typescript" | "javascript" | "python" | "php" | "dart" | "json" | "env";
+export declare class ConstantsGenerator {
+    private config;
+    private constants;
+    constructor(config: AppwriteConfig);
+    private extractConstants;
+    private toConstantName;
+    private toCamelCase;
+    private toSnakeCase;
+    generateTypeScript(): string;
+    generateJavaScript(): string;
+    generatePython(): string;
+    generatePHP(): string;
+    generateDart(): string;
+    generateJSON(): string;
+    generateEnv(): string;
+    generateFiles(languages: SupportedLanguage[], outputDir: string): Promise<void>;
+}

package/dist/utils/constantsGenerator.js

@@ -0,0 +1,309 @@
+import fs from "fs/promises";
+import path from "path";
+import {} from "appwrite-utils";
+import { MessageFormatter } from "../shared/messageFormatter.js";
+export class ConstantsGenerator {
+    config;
+    constants;
+    constructor(config) {
+        this.config = config;
+        this.constants = this.extractConstants();
+    }
+    extractConstants() {
+        const constants = {
+            databases: {},
+            collections: {},
+            buckets: {},
+            functions: {}
+        };
+        // Extract database IDs
+        this.config.databases?.forEach(db => {
+            if (db.$id) {
+                const key = this.toConstantName(db.name || db.$id);
+                constants.databases[key] = db.$id;
+            }
+        });
+        // Extract collection IDs
+        this.config.collections?.forEach(collection => {
+            if (collection.$id) {
+                const key = this.toConstantName(collection.name || collection.$id);
+                constants.collections[key] = collection.$id;
+            }
+        });
+        // Extract bucket IDs
+        this.config.buckets?.forEach(bucket => {
+            if (bucket.$id) {
+                const key = this.toConstantName(bucket.name || bucket.$id);
+                constants.buckets[key] = bucket.$id;
+            }
+        });
+        // Extract function IDs
+        this.config.functions?.forEach(func => {
+            if (func.$id) {
+                const key = this.toConstantName(func.name || func.$id);
+                constants.functions[key] = func.$id;
+            }
+        });
+        return constants;
+    }
+    toConstantName(name) {
+        return name
+            .replace(/[^a-zA-Z0-9]/g, '_')
+            .replace(/_+/g, '_')
+            .replace(/^_|_$/g, '')
+            .toUpperCase();
+    }
+    toCamelCase(name) {
+        return name
+            .toLowerCase()
+            .replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+    }
+    toSnakeCase(name) {
+        return name.toLowerCase();
+    }
+    generateTypeScript() {
+        const { databases, collections, buckets, functions } = this.constants;
+        return `// Auto-generated Appwrite constants
+// Generated on ${new Date().toISOString()}
+
+export const DATABASE_IDS = {
+${Object.entries(databases).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+} as const;
+
+export const COLLECTION_IDS = {
+${Object.entries(collections).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+} as const;
+
+export const BUCKET_IDS = {
+${Object.entries(buckets).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+} as const;
+
+export const FUNCTION_IDS = {
+${Object.entries(functions).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+} as const;
+
+// Type helpers
+export type DatabaseId = typeof DATABASE_IDS[keyof typeof DATABASE_IDS];
+export type CollectionId = typeof COLLECTION_IDS[keyof typeof COLLECTION_IDS];
+export type BucketId = typeof BUCKET_IDS[keyof typeof BUCKET_IDS];
+export type FunctionId = typeof FUNCTION_IDS[keyof typeof FUNCTION_IDS];
+
+// Helper objects for runtime use
+export const ALL_DATABASE_IDS = Object.values(DATABASE_IDS);
+export const ALL_COLLECTION_IDS = Object.values(COLLECTION_IDS);
+export const ALL_BUCKET_IDS = Object.values(BUCKET_IDS);
+export const ALL_FUNCTION_IDS = Object.values(FUNCTION_IDS);
+`;
+    }
+    generateJavaScript() {
+        const { databases, collections, buckets, functions } = this.constants;
+        return `// Auto-generated Appwrite constants
+// Generated on ${new Date().toISOString()}
+
+export const DATABASE_IDS = {
+${Object.entries(databases).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+};
+
+export const COLLECTION_IDS = {
+${Object.entries(collections).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+};
+
+export const BUCKET_IDS = {
+${Object.entries(buckets).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+};
+
+export const FUNCTION_IDS = {
+${Object.entries(functions).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+};
+
+// Helper arrays for runtime use
+export const ALL_DATABASE_IDS = Object.values(DATABASE_IDS);
+export const ALL_COLLECTION_IDS = Object.values(COLLECTION_IDS);
+export const ALL_BUCKET_IDS = Object.values(BUCKET_IDS);
+export const ALL_FUNCTION_IDS = Object.values(FUNCTION_IDS);
+`;
+    }
+    generatePython() {
+        const { databases, collections, buckets, functions } = this.constants;
+        return `# Auto-generated Appwrite constants
+# Generated on ${new Date().toISOString()}
+
+class DatabaseIds:
+    """Database ID constants"""
+${Object.entries(databases).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
+
+class CollectionIds:
+    """Collection ID constants"""
+${Object.entries(collections).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
+
+class BucketIds:
+    """Bucket ID constants"""
+${Object.entries(buckets).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
+
+class FunctionIds:
+    """Function ID constants"""
+${Object.entries(functions).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
+
+# Helper dictionaries for runtime use
+DATABASE_ID_MAP = {
+${Object.entries(databases).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
+}
+
+COLLECTION_ID_MAP = {
+${Object.entries(collections).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
+}
+
+BUCKET_ID_MAP = {
+${Object.entries(buckets).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
+}
+
+FUNCTION_ID_MAP = {
+${Object.entries(functions).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
+}
+`;
+    }
+    generatePHP() {
+        const { databases, collections, buckets, functions } = this.constants;
+        return `<?php
+// Auto-generated Appwrite constants
+// Generated on ${new Date().toISOString()}
+
+class AppwriteConstants {
+    
+    const DATABASE_IDS = [
+${Object.entries(databases).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
+    ];
+    
+    const COLLECTION_IDS = [
+${Object.entries(collections).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
+    ];
+    
+    const BUCKET_IDS = [
+${Object.entries(buckets).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
+    ];
+    
+    const FUNCTION_IDS = [
+${Object.entries(functions).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
+    ];
+    
+    /**
+     * Get all database IDs as array
+     */
+    public static function getAllDatabaseIds(): array {
+        return array_values(self::DATABASE_IDS);
+    }
+    
+    /**
+     * Get all collection IDs as array
+     */
+    public static function getAllCollectionIds(): array {
+        return array_values(self::COLLECTION_IDS);
+    }
+    
+    /**
+     * Get all bucket IDs as array
+     */
+    public static function getAllBucketIds(): array {
+        return array_values(self::BUCKET_IDS);
+    }
+    
+    /**
+     * Get all function IDs as array
+     */
+    public static function getAllFunctionIds(): array {
+        return array_values(self::FUNCTION_IDS);
+    }
+}
+`;
+    }
+    generateDart() {
+        const { databases, collections, buckets, functions } = this.constants;
+        return `// Auto-generated Appwrite constants
+// Generated on ${new Date().toISOString()}
+
+class AppwriteConstants {
+  
+  static const Map<String, String> databaseIds = {
+${Object.entries(databases).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
+  };
+  
+  static const Map<String, String> collectionIds = {
+${Object.entries(collections).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
+  };
+  
+  static const Map<String, String> bucketIds = {
+${Object.entries(buckets).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
+  };
+  
+  static const Map<String, String> functionIds = {
+${Object.entries(functions).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
+  };
+  
+  // Helper getters for individual IDs
+${Object.entries(databases).map(([key, value]) => `  static String get ${this.toCamelCase(key)}DatabaseId => '${value}';`).join('\n')}
+  
+${Object.entries(collections).map(([key, value]) => `  static String get ${this.toCamelCase(key)}CollectionId => '${value}';`).join('\n')}
+  
+${Object.entries(buckets).map(([key, value]) => `  static String get ${this.toCamelCase(key)}BucketId => '${value}';`).join('\n')}
+  
+${Object.entries(functions).map(([key, value]) => `  static String get ${this.toCamelCase(key)}FunctionId => '${value}';`).join('\n')}
+}
+`;
+    }
+    generateJSON() {
+        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
+        }, null, 2);
+    }
+    generateEnv() {
+        const { databases, collections, buckets, functions } = this.constants;
+        const lines = [
+            "# Auto-generated Appwrite constants",
+            `# Generated on ${new Date().toISOString()}`,
+            "",
+            "# Database IDs",
+            ...Object.entries(databases).map(([key, value]) => `DATABASE_${key}=${value}`),
+            "",
+            "# Collection IDs",
+            ...Object.entries(collections).map(([key, value]) => `COLLECTION_${key}=${value}`),
+            "",
+            "# Bucket IDs",
+            ...Object.entries(buckets).map(([key, value]) => `BUCKET_${key}=${value}`),
+            "",
+            "# Function IDs",
+            ...Object.entries(functions).map(([key, value]) => `FUNCTION_${key}=${value}`)
+        ];
+        return lines.join('\n');
+    }
+    async generateFiles(languages, outputDir) {
+        await fs.mkdir(outputDir, { recursive: true });
+        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" })
+        };
+        for (const language of languages) {
+            const generator = generators[language];
+            if (generator) {
+                const { content, filename } = generator();
+                const filePath = path.join(outputDir, filename);
+                await fs.writeFile(filePath, content, 'utf-8');
+                MessageFormatter.success(`Generated ${language} constants: ${filePath}`, { prefix: "Constants" });
+            }
+            else {
+                MessageFormatter.error(`Unsupported language: ${language}`, undefined, { prefix: "Constants" });
+            }
+        }
+    }
+}

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.0.5",
+  "version": "1.0.6",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/interactiveCLI.ts

@@ -41,6 +41,7 @@ import {
 } from "./functions/methods.js";
 import { deployLocalFunction } from "./functions/deployments.js";
 import { join } from "node:path";
+import path from "path";
 import fs from "node:fs";
 import { SchemaGenerator } from "./shared/schemaGenerator.js";
 import { ConfirmationDialogs } from "./shared/confirmationDialogs.js";
@@ -64,6 +65,7 @@ enum CHOICES {
   WIPE_DATABASE = "Wipe database",
   WIPE_COLLECTIONS = "Wipe collections",
   GENERATE_SCHEMAS = "Generate schemas",
+  GENERATE_CONSTANTS = "📋 Generate cross-language constants (TypeScript, Python, PHP, Dart, etc.)",
   IMPORT_DATA = "Import data",
   RELOAD_CONFIG = "Reload configuration files",
   UPDATE_FUNCTION_SPEC = "Update function specifications",
@@ -159,6 +161,10 @@ export class InteractiveCLI {
           await this.initControllerIfNeeded();
           await this.generateSchemas();
           break;
+        case CHOICES.GENERATE_CONSTANTS:
+          await this.initControllerIfNeeded();
+          await this.generateConstants();
+          break;
         case CHOICES.IMPORT_DATA:
           await this.initControllerIfNeeded();
           await this.importData();
@@ -1595,6 +1601,73 @@ export class InteractiveCLI {
     MessageFormatter.success("Schema generation completed", { prefix: "Schemas" });
   }
 
+  private async generateConstants(): Promise<void> {
+    console.log(chalk.yellow("Generating cross-language constants..."));
+
+    if (!this.controller?.config) {
+      MessageFormatter.error("No configuration found", undefined, { prefix: "Constants" });
+      return;
+    }
+
+    // Prompt for languages
+    const { languages } = await inquirer.prompt([
+      {
+        type: "checkbox",
+        name: "languages",
+        message: "Select languages for constants generation:",
+        choices: [
+          { name: "TypeScript", value: "typescript", checked: true },
+          { name: "JavaScript", value: "javascript" },
+          { name: "Python", value: "python" },
+          { name: "PHP", value: "php" },
+          { name: "Dart", value: "dart" },
+          { name: "JSON", value: "json" },
+          { name: "Environment Variables", value: "env" },
+        ],
+        validate: (input) => {
+          if (input.length === 0) {
+            return "Please select at least one language";
+          }
+          return true;
+        },
+      },
+    ]);
+
+    // Determine default output directory based on config location
+    const configPath = this.controller!.getAppwriteFolderPath();
+    const defaultOutputDir = configPath 
+      ? path.join(configPath, "constants")
+      : path.join(process.cwd(), "constants");
+
+    // Prompt for output directory
+    const { outputDir } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "outputDir",
+        message: "Output directory for constants files:",
+        default: defaultOutputDir,
+        validate: (input) => {
+          if (!input.trim()) {
+            return "Output directory cannot be empty";
+          }
+          return true;
+        },
+      },
+    ]);
+
+    try {
+      const { ConstantsGenerator } = await import("./utils/constantsGenerator.js");
+      const generator = new ConstantsGenerator(this.controller.config);
+      
+      MessageFormatter.info(`Generating constants for: ${languages.join(", ")}`, { prefix: "Constants" });
+      await generator.generateFiles(languages, outputDir);
+      
+      MessageFormatter.success(`Constants generated in ${outputDir}`, { prefix: "Constants" });
+    } catch (error) {
+      MessageFormatter.error("Failed to generate constants", error instanceof Error ? error : new Error(String(error)), { prefix: "Constants" });
+    }
+  }
+
   private async importData(): Promise<void> {
     console.log(chalk.yellow("Importing data..."));
 

package/src/main.ts

@@ -15,6 +15,7 @@ import chalk from "chalk";
 import { listSpecifications } from "./functions/methods.js";
 import { MessageFormatter } from "./shared/messageFormatter.js";
 import { ConfirmationDialogs } from "./shared/confirmationDialogs.js";
+import path from "path";
 
 interface CliOptions {
   config?: string;
@@ -49,6 +50,9 @@ interface CliOptions {
   functionId?: string;
   specification?: string;
   migrateConfig?: boolean;
+  generateConstants?: boolean;
+  constantsLanguages?: string;
+  constantsOutput?: string;
 }
 
 type ParsedArgv = ArgumentsCamelCase<CliOptions>;
@@ -203,6 +207,21 @@ const argv = yargs(hideBin(process.argv))
     type: "boolean",
     description: "Migrate appwriteConfig.ts to .appwrite structure with YAML configuration",
   })
+  .option("generateConstants", {
+    alias: ["constants"],
+    type: "boolean", 
+    description: "Generate cross-language constants file with database, collection, bucket, and function IDs",
+  })
+  .option("constantsLanguages", {
+    type: "string",
+    description: "Comma-separated list of languages for constants (typescript,javascript,python,php,dart,json,env)",
+    default: "typescript",
+  })
+  .option("constantsOutput", {
+    type: "string",
+    description: "Output directory for generated constants files (default: config-folder/constants)",
+    default: "auto",
+  })
   .parse() as ParsedArgv;
 
 async function main() {
@@ -235,6 +254,40 @@ async function main() {
       return;
     }
 
+    if (argv.generateConstants) {
+      const { ConstantsGenerator } = await import("./utils/constantsGenerator.js");
+      type SupportedLanguage = import("./utils/constantsGenerator.js").SupportedLanguage;
+      
+      if (!controller.config) {
+        MessageFormatter.error("No Appwrite configuration found", undefined, { prefix: "Constants" });
+        return;
+      }
+
+      const languages = argv.constantsLanguages!.split(",").map(l => l.trim()) as SupportedLanguage[];
+      
+      // Determine output directory - use config folder/constants by default, or custom path if specified
+      let outputDir: string;
+      if (argv.constantsOutput === "auto") {
+        // Default case: use config directory + constants, fallback to current directory
+        const configPath = controller.getAppwriteFolderPath();
+        outputDir = configPath 
+          ? path.join(configPath, "constants")
+          : path.join(process.cwd(), "constants");
+      } else {
+        // Custom output directory specified
+        outputDir = argv.constantsOutput!;
+      }
+      
+      MessageFormatter.info(`Generating constants for languages: ${languages.join(", ")}`, { prefix: "Constants" });
+      
+      const generator = new ConstantsGenerator(controller.config);
+      await generator.generateFiles(languages, outputDir);
+      
+      operationStats.generatedConstants = languages.length;
+      MessageFormatter.success(`Constants generated in ${outputDir}`, { prefix: "Constants" });
+      return;
+    }
+
     if (!controller.config) {
       MessageFormatter.error("No Appwrite connection found", undefined, { prefix: "CLI" });
       return;

package/src/utils/constantsGenerator.ts

@@ -0,0 +1,352 @@
+import fs from "fs/promises";
+import path from "path";
+import { type AppwriteConfig } from "appwrite-utils";
+import { MessageFormatter } from "../shared/messageFormatter.js";
+
+export type SupportedLanguage = 
+  | "typescript" 
+  | "javascript" 
+  | "python" 
+  | "php" 
+  | "dart" 
+  | "json" 
+  | "env";
+
+interface Constants {
+  databases: Record<string, string>;
+  collections: Record<string, string>;
+  buckets: Record<string, string>;
+  functions: Record<string, string>;
+}
+
+export class ConstantsGenerator {
+  private config: AppwriteConfig;
+  private constants: Constants;
+
+  constructor(config: AppwriteConfig) {
+    this.config = config;
+    this.constants = this.extractConstants();
+  }
+
+  private extractConstants(): Constants {
+    const constants: Constants = {
+      databases: {},
+      collections: {},
+      buckets: {},
+      functions: {}
+    };
+
+    // Extract database IDs
+    this.config.databases?.forEach(db => {
+      if (db.$id) {
+        const key = this.toConstantName(db.name || db.$id);
+        constants.databases[key] = db.$id;
+      }
+    });
+
+    // Extract collection IDs
+    this.config.collections?.forEach(collection => {
+      if (collection.$id) {
+        const key = this.toConstantName(collection.name || collection.$id);
+        constants.collections[key] = collection.$id;
+      }
+    });
+
+    // Extract bucket IDs
+    this.config.buckets?.forEach(bucket => {
+      if (bucket.$id) {
+        const key = this.toConstantName(bucket.name || bucket.$id);
+        constants.buckets[key] = bucket.$id;
+      }
+    });
+
+    // Extract function IDs
+    this.config.functions?.forEach(func => {
+      if (func.$id) {
+        const key = this.toConstantName(func.name || func.$id);
+        constants.functions[key] = func.$id;
+      }
+    });
+
+    return constants;
+  }
+
+  private toConstantName(name: string): string {
+    return name
+      .replace(/[^a-zA-Z0-9]/g, '_')
+      .replace(/_+/g, '_')
+      .replace(/^_|_$/g, '')
+      .toUpperCase();
+  }
+
+  private toCamelCase(name: string): string {
+    return name
+      .toLowerCase()
+      .replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+  }
+
+  private toSnakeCase(name: string): string {
+    return name.toLowerCase();
+  }
+
+  generateTypeScript(): string {
+    const { databases, collections, buckets, functions } = this.constants;
+
+    return `// Auto-generated Appwrite constants
+// Generated on ${new Date().toISOString()}
+
+export const DATABASE_IDS = {
+${Object.entries(databases).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+} as const;
+
+export const COLLECTION_IDS = {
+${Object.entries(collections).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+} as const;
+
+export const BUCKET_IDS = {
+${Object.entries(buckets).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+} as const;
+
+export const FUNCTION_IDS = {
+${Object.entries(functions).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+} as const;
+
+// Type helpers
+export type DatabaseId = typeof DATABASE_IDS[keyof typeof DATABASE_IDS];
+export type CollectionId = typeof COLLECTION_IDS[keyof typeof COLLECTION_IDS];
+export type BucketId = typeof BUCKET_IDS[keyof typeof BUCKET_IDS];
+export type FunctionId = typeof FUNCTION_IDS[keyof typeof FUNCTION_IDS];
+
+// Helper objects for runtime use
+export const ALL_DATABASE_IDS = Object.values(DATABASE_IDS);
+export const ALL_COLLECTION_IDS = Object.values(COLLECTION_IDS);
+export const ALL_BUCKET_IDS = Object.values(BUCKET_IDS);
+export const ALL_FUNCTION_IDS = Object.values(FUNCTION_IDS);
+`;
+  }
+
+  generateJavaScript(): string {
+    const { databases, collections, buckets, functions } = this.constants;
+
+    return `// Auto-generated Appwrite constants
+// Generated on ${new Date().toISOString()}
+
+export const DATABASE_IDS = {
+${Object.entries(databases).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+};
+
+export const COLLECTION_IDS = {
+${Object.entries(collections).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+};
+
+export const BUCKET_IDS = {
+${Object.entries(buckets).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+};
+
+export const FUNCTION_IDS = {
+${Object.entries(functions).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+};
+
+// Helper arrays for runtime use
+export const ALL_DATABASE_IDS = Object.values(DATABASE_IDS);
+export const ALL_COLLECTION_IDS = Object.values(COLLECTION_IDS);
+export const ALL_BUCKET_IDS = Object.values(BUCKET_IDS);
+export const ALL_FUNCTION_IDS = Object.values(FUNCTION_IDS);
+`;
+  }
+
+  generatePython(): string {
+    const { databases, collections, buckets, functions } = this.constants;
+
+    return `# Auto-generated Appwrite constants
+# Generated on ${new Date().toISOString()}
+
+class DatabaseIds:
+    """Database ID constants"""
+${Object.entries(databases).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
+
+class CollectionIds:
+    """Collection ID constants"""
+${Object.entries(collections).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
+
+class BucketIds:
+    """Bucket ID constants"""
+${Object.entries(buckets).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
+
+class FunctionIds:
+    """Function ID constants"""
+${Object.entries(functions).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
+
+# Helper dictionaries for runtime use
+DATABASE_ID_MAP = {
+${Object.entries(databases).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
+}
+
+COLLECTION_ID_MAP = {
+${Object.entries(collections).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
+}
+
+BUCKET_ID_MAP = {
+${Object.entries(buckets).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
+}
+
+FUNCTION_ID_MAP = {
+${Object.entries(functions).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
+}
+`;
+  }
+
+  generatePHP(): string {
+    const { databases, collections, buckets, functions } = this.constants;
+
+    return `<?php
+// Auto-generated Appwrite constants
+// Generated on ${new Date().toISOString()}
+
+class AppwriteConstants {
+    
+    const DATABASE_IDS = [
+${Object.entries(databases).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
+    ];
+    
+    const COLLECTION_IDS = [
+${Object.entries(collections).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
+    ];
+    
+    const BUCKET_IDS = [
+${Object.entries(buckets).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
+    ];
+    
+    const FUNCTION_IDS = [
+${Object.entries(functions).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
+    ];
+    
+    /**
+     * Get all database IDs as array
+     */
+    public static function getAllDatabaseIds(): array {
+        return array_values(self::DATABASE_IDS);
+    }
+    
+    /**
+     * Get all collection IDs as array
+     */
+    public static function getAllCollectionIds(): array {
+        return array_values(self::COLLECTION_IDS);
+    }
+    
+    /**
+     * Get all bucket IDs as array
+     */
+    public static function getAllBucketIds(): array {
+        return array_values(self::BUCKET_IDS);
+    }
+    
+    /**
+     * Get all function IDs as array
+     */
+    public static function getAllFunctionIds(): array {
+        return array_values(self::FUNCTION_IDS);
+    }
+}
+`;
+  }
+
+  generateDart(): string {
+    const { databases, collections, buckets, functions } = this.constants;
+
+    return `// Auto-generated Appwrite constants
+// Generated on ${new Date().toISOString()}
+
+class AppwriteConstants {
+  
+  static const Map<String, String> databaseIds = {
+${Object.entries(databases).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
+  };
+  
+  static const Map<String, String> collectionIds = {
+${Object.entries(collections).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
+  };
+  
+  static const Map<String, String> bucketIds = {
+${Object.entries(buckets).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
+  };
+  
+  static const Map<String, String> functionIds = {
+${Object.entries(functions).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
+  };
+  
+  // Helper getters for individual IDs
+${Object.entries(databases).map(([key, value]) => `  static String get ${this.toCamelCase(key)}DatabaseId => '${value}';`).join('\n')}
+  
+${Object.entries(collections).map(([key, value]) => `  static String get ${this.toCamelCase(key)}CollectionId => '${value}';`).join('\n')}
+  
+${Object.entries(buckets).map(([key, value]) => `  static String get ${this.toCamelCase(key)}BucketId => '${value}';`).join('\n')}
+  
+${Object.entries(functions).map(([key, value]) => `  static String get ${this.toCamelCase(key)}FunctionId => '${value}';`).join('\n')}
+}
+`;
+  }
+
+  generateJSON(): string {
+    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
+    }, null, 2);
+  }
+
+  generateEnv(): string {
+    const { databases, collections, buckets, functions } = this.constants;
+    
+    const lines = [
+      "# Auto-generated Appwrite constants",
+      `# Generated on ${new Date().toISOString()}`,
+      "",
+      "# Database IDs",
+      ...Object.entries(databases).map(([key, value]) => `DATABASE_${key}=${value}`),
+      "",
+      "# Collection IDs", 
+      ...Object.entries(collections).map(([key, value]) => `COLLECTION_${key}=${value}`),
+      "",
+      "# Bucket IDs",
+      ...Object.entries(buckets).map(([key, value]) => `BUCKET_${key}=${value}`),
+      "",
+      "# Function IDs",
+      ...Object.entries(functions).map(([key, value]) => `FUNCTION_${key}=${value}`)
+    ];
+    
+    return lines.join('\n');
+  }
+
+  async generateFiles(languages: SupportedLanguage[], outputDir: string): Promise<void> {
+    await fs.mkdir(outputDir, { recursive: true });
+
+    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" })
+    };
+
+    for (const language of languages) {
+      const generator = generators[language];
+      if (generator) {
+        const { content, filename } = generator();
+        const filePath = path.join(outputDir, filename);
+        await fs.writeFile(filePath, content, 'utf-8');
+        MessageFormatter.success(`Generated ${language} constants: ${filePath}`, { prefix: "Constants" });
+      } else {
+        MessageFormatter.error(`Unsupported language: ${language}`, undefined, { prefix: "Constants" });
+      }
+    }
+  }
+}