appwrite-utils-cli 1.0.5 → 1.0.7

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,56 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+### 1.0.7 - Forgot to remove debug logs
+
+### 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/config/yamlConfig.js

@@ -243,17 +243,13 @@ export const findYamlConfig = (startDir) => {
         path.join(startDir, "appwrite.yaml"),
         path.join(startDir, "appwrite.yml"),
     ];
-    console.log(`DEBUG: Checking YAML paths in ${startDir}:`);
     for (const configPath of possiblePaths) {
-        console.log(`  - ${configPath}: ${fs.existsSync(configPath)}`);
         if (fs.existsSync(configPath)) {
             return configPath;
         }
     }
     // Recursively search subdirectories for .appwrite folders
-    console.log(`DEBUG: Starting recursive search from ${startDir}`);
     const yamlConfigInSubdirs = findYamlConfigRecursive(startDir);
-    console.log(`DEBUG: Recursive search result: ${yamlConfigInSubdirs}`);
     if (yamlConfigInSubdirs) {
         return yamlConfigInSubdirs;
     }
@@ -316,23 +312,18 @@ const shouldIgnoreDirectory = (dirName) => {
 const findYamlConfigRecursive = (dir, depth = 0) => {
     // Limit search depth to prevent infinite recursion
     if (depth > 5) {
-        console.log(`DEBUG: Stopping search at depth ${depth} in ${dir}`);
         return null;
     }
     if (shouldIgnoreDirectory(path.basename(dir))) {
-        console.log(`DEBUG: Ignoring directory ${dir}`);
         return null;
     }
     try {
         const entries = fs.readdirSync(dir, { withFileTypes: true });
-        console.log(`DEBUG: Searching directory ${dir} at depth ${depth}, found ${entries.length} entries`);
         for (const entry of entries) {
             if (entry.isDirectory() && !shouldIgnoreDirectory(entry.name)) {
                 const fullPath = path.join(dir, entry.name);
-                console.log(`DEBUG: Checking subdirectory: ${fullPath}`);
                 // Check if this is an .appwrite directory
                 if (entry.name === ".appwrite") {
-                    console.log(`DEBUG: Found .appwrite directory at ${fullPath}`);
                     const configPaths = [
                         path.join(fullPath, "appwriteConfig.yaml"),
                         path.join(fullPath, "appwriteConfig.yml"),

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";
@@ -23,23 +24,24 @@ import { findYamlConfig, addFunctionToYamlConfig } from "./config/yamlConfig.js"
 var CHOICES;
 (function (CHOICES) {
     CHOICES["MIGRATE_CONFIG"] = "\uD83D\uDD04 Migrate TypeScript config to YAML (.appwrite structure)";
-    CHOICES["CREATE_COLLECTION_CONFIG"] = "Create collection config file";
-    CHOICES["CREATE_FUNCTION"] = "Create a new function, from scratch or using a template";
-    CHOICES["DEPLOY_FUNCTION"] = "Deploy function(s)";
-    CHOICES["DELETE_FUNCTION"] = "Delete function";
-    CHOICES["SETUP_DIRS_FILES"] = "Setup directories and files";
-    CHOICES["SETUP_DIRS_FILES_WITH_EXAMPLE_DATA"] = "Setup directories and files with example data";
-    CHOICES["SYNC_DB"] = "Push local config to Appwrite";
-    CHOICES["SYNCHRONIZE_CONFIGURATIONS"] = "Synchronize configurations - Pull from Appwrite and write to local config";
-    CHOICES["TRANSFER_DATA"] = "Transfer data";
-    CHOICES["BACKUP_DATABASE"] = "Backup database";
-    CHOICES["WIPE_DATABASE"] = "Wipe database";
-    CHOICES["WIPE_COLLECTIONS"] = "Wipe collections";
-    CHOICES["GENERATE_SCHEMAS"] = "Generate schemas";
-    CHOICES["IMPORT_DATA"] = "Import data";
-    CHOICES["RELOAD_CONFIG"] = "Reload configuration files";
-    CHOICES["UPDATE_FUNCTION_SPEC"] = "Update function specifications";
-    CHOICES["EXIT"] = "Exit";
+    CHOICES["CREATE_COLLECTION_CONFIG"] = "\uD83D\uDCC4 Create collection config file";
+    CHOICES["CREATE_FUNCTION"] = "\u26A1 Create a new function, from scratch or using a template";
+    CHOICES["DEPLOY_FUNCTION"] = "\uD83D\uDE80 Deploy function(s)";
+    CHOICES["DELETE_FUNCTION"] = "\uD83D\uDDD1\uFE0F Delete function";
+    CHOICES["SETUP_DIRS_FILES"] = "\uD83D\uDCC1 Setup directories and files";
+    CHOICES["SETUP_DIRS_FILES_WITH_EXAMPLE_DATA"] = "\uD83D\uDCC1\u2728 Setup directories and files with example data";
+    CHOICES["SYNC_DB"] = "\u2B06\uFE0F Push local config to Appwrite";
+    CHOICES["SYNCHRONIZE_CONFIGURATIONS"] = "\uD83D\uDD04 Synchronize configurations - Pull from Appwrite and write to local config";
+    CHOICES["TRANSFER_DATA"] = "\uD83D\uDCE6 Transfer data";
+    CHOICES["BACKUP_DATABASE"] = "\uD83D\uDCBE Backup database";
+    CHOICES["WIPE_DATABASE"] = "\uD83E\uDDF9 Wipe database";
+    CHOICES["WIPE_COLLECTIONS"] = "\uD83E\uDDF9 Wipe collections";
+    CHOICES["GENERATE_SCHEMAS"] = "\uD83C\uDFD7\uFE0F Generate schemas";
+    CHOICES["GENERATE_CONSTANTS"] = "\uD83D\uDCCB Generate cross-language constants (TypeScript, Python, PHP, Dart, etc.)";
+    CHOICES["IMPORT_DATA"] = "\uD83D\uDCE5 Import data";
+    CHOICES["RELOAD_CONFIG"] = "\uD83D\uDD04 Reload configuration files";
+    CHOICES["UPDATE_FUNCTION_SPEC"] = "\u2699\uFE0F Update function specifications";
+    CHOICES["EXIT"] = "\uD83D\uDC4B Exit";
 })(CHOICES || (CHOICES = {}));
 export class InteractiveCLI {
     currentDir;
@@ -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>;
+}