appwrite-utils-cli 1.11.0 → 1.12.0

package/dist/cli/commands/schemaCommands.js

@@ -0,0 +1,169 @@
+import inquirer from "inquirer";
+import path from "path";
+import chalk from "chalk";
+import { MessageFormatter } from 'appwrite-utils-helpers';
+import { SchemaGenerator } from 'appwrite-utils-helpers';
+import { setupDirsFiles } from "../../utils/setupFiles.js";
+import { fetchAllDatabases } from "../../databases/methods.js";
+export const schemaCommands = {
+    async generateSchemas(cli) {
+        MessageFormatter.progress("Generating schemas...", { prefix: "Schemas" });
+        // Prompt user for schema type preference
+        const { schemaType } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "schemaType",
+                message: "What type of schemas would you like to generate?",
+                choices: [
+                    { name: "TypeScript (Zod) schemas", value: "zod" },
+                    { name: "JSON schemas", value: "json" },
+                    { name: "Python (Pydantic) models", value: "pydantic" },
+                    { name: "TypeScript + JSON", value: "both" },
+                    { name: "All (Zod, JSON, Pydantic)", value: "all" },
+                ],
+                default: "all",
+            },
+        ]);
+        // Get the config folder path (where the config file is located)
+        const configFolderPath = cli.controller.getAppwriteFolderPath();
+        if (!configFolderPath) {
+            MessageFormatter.error("Failed to get config folder path", undefined, { prefix: "Schemas" });
+            return;
+        }
+        // Prompt for schema output directory (optional override)
+        const defaultSchemaOut = path.join(configFolderPath, cli.controller.config?.schemaConfig?.outputDirectory || 'schemas');
+        const { schemaOutDir } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'schemaOutDir',
+                message: 'Output directory for schemas:',
+                default: defaultSchemaOut,
+                validate: (input) => input && input.trim().length > 0 ? true : 'Please provide an output directory',
+            }
+        ]);
+        // Create SchemaGenerator with the correct base path and generate schemas
+        const schemaGenerator = new SchemaGenerator(cli.controller.config, configFolderPath);
+        const outDirRel = path.isAbsolute(schemaOutDir) ? schemaOutDir : path.relative(configFolderPath, schemaOutDir);
+        await schemaGenerator.generateSchemas({ format: schemaType, verbose: true, outputDir: outDirRel });
+        MessageFormatter.success("Schema generation completed", { prefix: "Schemas" });
+    },
+    async generateConstants(cli) {
+        MessageFormatter.progress("Generating cross-language constants...", { prefix: "Constants" });
+        if (!cli.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;
+                },
+            },
+        ]);
+        // Prompt for which constants to include
+        const { includeWhat } = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'includeWhat',
+                message: 'Select which constants to generate:',
+                choices: [
+                    { name: 'Databases', value: 'databases', checked: true },
+                    { name: 'Collections/Tables', value: 'collections', checked: true },
+                    { name: 'Buckets', value: 'buckets', checked: true },
+                    { name: 'Functions', value: 'functions', checked: true },
+                ],
+                validate: (input) => input.length > 0 ? true : 'Select at least one category',
+            }
+        ]);
+        // Determine default output directory based on config location
+        const configPath = cli.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("appwrite-utils-helpers");
+            const generator = new ConstantsGenerator(cli.controller.config);
+            const include = {
+                databases: includeWhat.includes('databases'),
+                collections: includeWhat.includes('collections'),
+                buckets: includeWhat.includes('buckets'),
+                functions: includeWhat.includes('functions'),
+            };
+            MessageFormatter.info(`Generating constants for: ${languages.join(", ")}`, { prefix: "Constants" });
+            await generator.generateFiles(languages, outputDir, include);
+            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(cli) {
+        MessageFormatter.progress("Importing data...", { prefix: "Import" });
+        const { doBackup } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "doBackup",
+                message: "Do you want to perform a backup before importing?",
+                default: true,
+            },
+        ]);
+        const databases = await cli.selectDatabases(await fetchAllDatabases(cli.controller.database), "Select databases to import data into:", true);
+        const collections = await cli.selectCollectionsAndTables(databases[0], cli.controller.database, "Select collections/tables to import data into (leave empty for all):", true);
+        const { shouldWriteFile } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "shouldWriteFile",
+                message: "Do you want to write the imported data to a file?",
+                default: false,
+            },
+        ]);
+        const options = {
+            databases,
+            collections: collections.map((c) => c.name),
+            doBackup,
+            importData: true,
+            shouldWriteFile,
+        };
+        try {
+            await cli.controller.importData(options);
+            MessageFormatter.success("Data import completed successfully", { prefix: "Import" });
+        }
+        catch (error) {
+            MessageFormatter.error("Error importing data", error instanceof Error ? error : new Error(String(error)), { prefix: "Import" });
+        }
+    },
+    async setupDirsFiles(cli, withExampleData = false) {
+        await setupDirsFiles(withExampleData, cli.currentDir);
+    }
+};

package/dist/cli/commands/storageCommands.d.ts

@@ -0,0 +1,5 @@
+import type { InteractiveCLI } from "../../interactiveCLI.js";
+export declare const storageCommands: {
+    createBucket(cli: InteractiveCLI): Promise<void>;
+    deleteBuckets(cli: InteractiveCLI): Promise<void>;
+};

package/dist/cli/commands/storageCommands.js

@@ -0,0 +1,142 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { Storage, Permission, Role, Compression } from "node-appwrite";
+import { MessageFormatter } from 'appwrite-utils-helpers';
+import { listBuckets, createBucket as createBucketApi, deleteBucket as deleteBucketApi } from "../../storage/methods.js";
+import { writeYamlConfig, ConfigManager } from "appwrite-utils-helpers";
+export const storageCommands = {
+    async createBucket(cli) {
+        const storage = cli.controller.storage;
+        if (!storage) {
+            MessageFormatter.error("Storage client not initialized", undefined, { prefix: "Buckets" });
+            return;
+        }
+        const answers = await inquirer.prompt([
+            { type: 'input', name: 'name', message: 'Bucket name:', validate: (v) => v?.trim()?.length > 0 || 'Required' },
+            { type: 'input', name: 'id', message: 'Bucket ID (optional):' },
+            { type: 'confirm', name: 'publicRead', message: 'Public read access?', default: false },
+            { type: 'confirm', name: 'fileSecurity', message: 'Enable file-level security?', default: false },
+            { type: 'confirm', name: 'enabled', message: 'Enable bucket?', default: true },
+            { type: 'number', name: 'maximumFileSize', message: 'Max file size (bytes, optional):', default: undefined },
+            { type: 'input', name: 'allowedFileExtensions', message: 'Allowed extensions (comma separated, optional):', default: '' },
+            { type: 'list', name: 'compression', message: 'Compression:', choices: ['none', 'gzip', 'zstd'], default: 'none' },
+            { type: 'confirm', name: 'encryption', message: 'Enable encryption?', default: false },
+            { type: 'confirm', name: 'antivirus', message: 'Enable antivirus?', default: false },
+        ]);
+        const permissions = [];
+        if (answers.publicRead)
+            permissions.push(Permission.read(Role.any()));
+        const bucketInput = {
+            name: answers.name,
+            $permissions: permissions,
+            fileSecurity: !!answers.fileSecurity,
+            enabled: !!answers.enabled,
+            maximumFileSize: answers.maximumFileSize || undefined,
+            allowedFileExtensions: String(answers.allowedFileExtensions || '')
+                .split(',')
+                .map((s) => s.trim())
+                .filter(Boolean),
+            compression: answers.compression,
+            encryption: !!answers.encryption,
+            antivirus: !!answers.antivirus,
+        };
+        try {
+            const created = await createBucketApi(storage, bucketInput, answers.id || undefined);
+            MessageFormatter.success(`Bucket '${answers.name}' created`, { prefix: 'Buckets' });
+            // Update in-memory config and persist to YAML as a global bucket entry
+            const controller = cli.controller;
+            controller.config.buckets = controller.config.buckets || [];
+            controller.config.buckets.push({
+                $id: created.$id || answers.id || bucketInput.name,
+                name: bucketInput.name,
+                permissions: [],
+                fileSecurity: bucketInput.fileSecurity,
+                enabled: bucketInput.enabled,
+                maximumFileSize: bucketInput.maximumFileSize,
+                allowedFileExtensions: bucketInput.allowedFileExtensions,
+                compression: bucketInput.compression,
+                encryption: bucketInput.encryption,
+                antivirus: bucketInput.antivirus,
+            });
+            const cfgMgr = ConfigManager.getInstance();
+            const cfgPath = cfgMgr.getConfigPath();
+            if (cfgPath && /\.ya?ml$/i.test(cfgPath)) {
+                await writeYamlConfig(cfgPath, controller.config);
+                MessageFormatter.info(`Added bucket to config.yaml`, { prefix: 'Buckets' });
+            }
+            else {
+                MessageFormatter.warning(`Config is not YAML; updated in-memory only. Please update your TypeScript config manually.`, { prefix: 'Buckets' });
+            }
+        }
+        catch (e) {
+            MessageFormatter.error('Failed to create bucket', e instanceof Error ? e : new Error(String(e)), { prefix: 'Buckets' });
+        }
+    },
+    async deleteBuckets(cli) {
+        const storage = cli.controller.storage;
+        if (!storage) {
+            MessageFormatter.error("Storage client not initialized", undefined, { prefix: "Buckets" });
+            return;
+        }
+        try {
+            const res = await listBuckets(storage);
+            const buckets = res.buckets || [];
+            if (buckets.length === 0) {
+                MessageFormatter.info('No buckets found', { prefix: 'Buckets' });
+                return;
+            }
+            const { toDelete } = await inquirer.prompt([
+                {
+                    type: 'checkbox',
+                    name: 'toDelete',
+                    message: chalk.red('Select buckets to delete:'),
+                    choices: buckets.map((b) => ({ name: `${b.name} (${b.$id})`, value: b.$id })),
+                    pageSize: 10,
+                }
+            ]);
+            if (!toDelete || toDelete.length === 0) {
+                MessageFormatter.info('No buckets selected', { prefix: 'Buckets' });
+                return;
+            }
+            const { confirm } = await inquirer.prompt([
+                { type: 'confirm', name: 'confirm', message: `Delete ${toDelete.length} bucket(s)?`, default: false }
+            ]);
+            if (!confirm)
+                return;
+            const controller = cli.controller;
+            for (const id of toDelete) {
+                try {
+                    await deleteBucketApi(storage, id);
+                    MessageFormatter.success(`Deleted bucket ${id}`, { prefix: 'Buckets' });
+                    // Remove from in-memory config (global buckets)
+                    if (Array.isArray(controller.config.buckets)) {
+                        controller.config.buckets = controller.config.buckets.filter((b) => b.$id !== id);
+                    }
+                    // Clear database-linked bucket references if matching
+                    if (Array.isArray(controller.config.databases)) {
+                        controller.config.databases = controller.config.databases.map((db) => ({
+                            ...db,
+                            bucket: db.bucket && db.bucket.$id === id ? undefined : db.bucket,
+                        }));
+                    }
+                }
+                catch (e) {
+                    MessageFormatter.error(`Failed to delete bucket ${id}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Buckets' });
+                }
+            }
+            // Persist YAML changes
+            const cfgMgr = ConfigManager.getInstance();
+            const cfgPath = cfgMgr.getConfigPath();
+            if (cfgPath && /\.ya?ml$/i.test(cfgPath)) {
+                await writeYamlConfig(cfgPath, controller.config);
+                MessageFormatter.info(`Updated config.yaml after deletion`, { prefix: 'Buckets' });
+            }
+            else {
+                MessageFormatter.warning(`Config is not YAML; updated in-memory only. Please update your TypeScript config manually.`, { prefix: 'Buckets' });
+            }
+        }
+        catch (e) {
+            MessageFormatter.error('Failed to list buckets', e instanceof Error ? e : new Error(String(e)), { prefix: 'Buckets' });
+        }
+    }
+};

package/dist/cli/commands/transferCommands.d.ts

@@ -0,0 +1,5 @@
+import type { InteractiveCLI } from "../../interactiveCLI.js";
+export declare const transferCommands: {
+    transferData(cli: InteractiveCLI): Promise<void>;
+    comprehensiveTransfer(cli: InteractiveCLI): Promise<void>;
+};