appwrite-utils-cli 0.10.86 → 1.0.1

package/dist/shared/jsonSchemaGenerator.js

@@ -0,0 +1,313 @@
+import fs from "fs";
+import path from "path";
+import { toCamelCase, toPascalCase } from "../utils/index.js";
+import chalk from "chalk";
+export class JsonSchemaGenerator {
+    config;
+    appwriteFolderPath;
+    relationshipMap = new Map();
+    constructor(config, appwriteFolderPath) {
+        this.config = config;
+        this.appwriteFolderPath = appwriteFolderPath;
+        this.extractRelationships();
+    }
+    extractRelationships() {
+        if (!this.config.collections)
+            return;
+        this.config.collections.forEach((collection) => {
+            if (!collection.attributes)
+                return;
+            collection.attributes.forEach((attr) => {
+                if (attr.type === "relationship" && attr.relatedCollection) {
+                    const relationships = this.relationshipMap.get(collection.name) || [];
+                    relationships.push({
+                        attributeKey: attr.key,
+                        relatedCollection: attr.relatedCollection,
+                        relationType: attr.relationType,
+                        isArray: attr.relationType === "oneToMany" || attr.relationType === "manyToMany"
+                    });
+                    this.relationshipMap.set(collection.name, relationships);
+                }
+            });
+        });
+    }
+    attributeToJsonSchemaProperty(attribute) {
+        const property = {
+            type: "string" // Default type
+        };
+        // Set description if available
+        if (attribute.description) {
+            property.description = typeof attribute.description === 'string'
+                ? attribute.description
+                : JSON.stringify(attribute.description);
+        }
+        // Handle array attributes
+        if (attribute.array) {
+            property.type = "array";
+            property.items = this.getBaseTypeSchema(attribute);
+        }
+        else {
+            Object.assign(property, this.getBaseTypeSchema(attribute));
+        }
+        // Set default value (only for attributes that support it)
+        if (attribute.type !== "relationship" && "xdefault" in attribute &&
+            attribute.xdefault !== undefined && attribute.xdefault !== null) {
+            property.default = attribute.xdefault;
+        }
+        return property;
+    }
+    getBaseTypeSchema(attribute) {
+        const schema = {
+            type: "string" // Default type
+        };
+        switch (attribute.type) {
+            case "string":
+                schema.type = "string";
+                if (attribute.size) {
+                    schema.maxLength = attribute.size;
+                }
+                break;
+            case "integer":
+                schema.type = "integer";
+                if (attribute.min !== undefined) {
+                    schema.minimum = Number(attribute.min);
+                }
+                if (attribute.max !== undefined) {
+                    schema.maximum = Number(attribute.max);
+                }
+                break;
+            case "double":
+            case "float": // Backward compatibility
+                schema.type = "number";
+                if (attribute.min !== undefined) {
+                    schema.minimum = Number(attribute.min);
+                }
+                if (attribute.max !== undefined) {
+                    schema.maximum = Number(attribute.max);
+                }
+                break;
+            case "boolean":
+                schema.type = "boolean";
+                break;
+            case "datetime":
+                schema.type = "string";
+                schema.format = "date-time";
+                break;
+            case "email":
+                schema.type = "string";
+                schema.format = "email";
+                break;
+            case "ip":
+                schema.type = "string";
+                schema.format = "ipv4";
+                break;
+            case "url":
+                schema.type = "string";
+                schema.format = "uri";
+                break;
+            case "enum":
+                schema.type = "string";
+                if (attribute.elements) {
+                    schema.enum = attribute.elements;
+                }
+                break;
+            case "relationship":
+                if (attribute.relatedCollection) {
+                    // For relationships, reference the related collection schema
+                    schema.$ref = `#/definitions/${toPascalCase(attribute.relatedCollection)}`;
+                }
+                else {
+                    schema.type = "string";
+                    schema.description = "Document ID reference";
+                }
+                break;
+            default:
+                schema.type = "string";
+        }
+        return schema;
+    }
+    createJsonSchema(collection) {
+        const pascalName = toPascalCase(collection.name);
+        const schema = {
+            $schema: "https://json-schema.org/draft/2020-12/schema",
+            $id: `https://example.com/schemas/${toCamelCase(collection.name)}.json`,
+            title: pascalName,
+            description: collection.description || `Schema for ${collection.name} collection`,
+            type: "object",
+            properties: {
+                // Standard Appwrite document fields
+                $id: {
+                    type: "string",
+                    description: "Document ID",
+                    pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,35}$"
+                },
+                $createdAt: {
+                    type: "string",
+                    format: "date-time",
+                    description: "Document creation date"
+                },
+                $updatedAt: {
+                    type: "string",
+                    format: "date-time",
+                    description: "Document last update date"
+                },
+                $permissions: {
+                    type: "array",
+                    items: {
+                        type: "string"
+                    },
+                    description: "Document permissions"
+                }
+            },
+            required: ["$id", "$createdAt", "$updatedAt"],
+            additionalProperties: false
+        };
+        // Add custom attributes
+        const requiredFields = [...schema.required];
+        if (collection.attributes) {
+            collection.attributes.forEach((attribute) => {
+                schema.properties[attribute.key] = this.attributeToJsonSchemaProperty(attribute);
+                if (attribute.required) {
+                    requiredFields.push(attribute.key);
+                }
+            });
+        }
+        schema.required = requiredFields;
+        // Add relationship definitions if any exist
+        const relationships = this.relationshipMap.get(collection.name);
+        if (relationships && relationships.length > 0) {
+            schema.definitions = {};
+            relationships.forEach((rel) => {
+                const relatedPascalName = toPascalCase(rel.relatedCollection);
+                schema.definitions[relatedPascalName] = {
+                    type: "object",
+                    properties: {
+                        $id: { type: "string" },
+                        $createdAt: { type: "string", format: "date-time" },
+                        $updatedAt: { type: "string", format: "date-time" }
+                    },
+                    additionalProperties: true,
+                    description: `Reference to ${rel.relatedCollection} document`
+                };
+            });
+        }
+        return schema;
+    }
+    generateJsonSchemas(options = {}) {
+        const { outputFormat = "both", outputDirectory = "schemas", verbose = false } = options;
+        if (!this.config.collections) {
+            if (verbose) {
+                console.log(chalk.yellow("No collections found in config"));
+            }
+            return;
+        }
+        // Create JSON schemas directory using provided outputDirectory
+        const jsonSchemasPath = path.join(this.appwriteFolderPath, outputDirectory);
+        if (!fs.existsSync(jsonSchemasPath)) {
+            fs.mkdirSync(jsonSchemasPath, { recursive: true });
+        }
+        if (verbose) {
+            console.log(chalk.blue(`Generating JSON schemas for ${this.config.collections.length} collections...`));
+        }
+        this.config.collections.forEach((collection) => {
+            const schema = this.createJsonSchema(collection);
+            const camelCaseName = toCamelCase(collection.name);
+            // Generate JSON file
+            if (outputFormat === "json" || outputFormat === "both") {
+                const jsonPath = path.join(jsonSchemasPath, `${camelCaseName}.json`);
+                fs.writeFileSync(jsonPath, JSON.stringify(schema, null, 2), { encoding: "utf-8" });
+                if (verbose) {
+                    console.log(chalk.green(`✓ JSON schema written to ${jsonPath}`));
+                }
+            }
+            // Generate TypeScript file
+            if (outputFormat === "typescript" || outputFormat === "both") {
+                const tsContent = this.generateTypeScriptSchema(schema, collection.name);
+                const tsPath = path.join(jsonSchemasPath, `${camelCaseName}.schema.ts`);
+                fs.writeFileSync(tsPath, tsContent, { encoding: "utf-8" });
+                if (verbose) {
+                    console.log(chalk.green(`✓ TypeScript schema written to ${tsPath}`));
+                }
+            }
+        });
+        // Generate index file only for TypeScript output
+        if (outputFormat === "typescript" || outputFormat === "both") {
+            this.generateIndexFile(outputFormat, jsonSchemasPath, verbose);
+        }
+        if (verbose) {
+            console.log(chalk.green("✓ JSON schema generation completed"));
+        }
+    }
+    generateTypeScriptSchema(schema, collectionName) {
+        const camelName = toCamelCase(collectionName);
+        return `// Auto-generated JSON schema for ${collectionName}
+import type { JSONSchema7 } from "json-schema";
+
+export const ${camelName}JsonSchema: JSONSchema7 = ${JSON.stringify(schema, null, 2)} as const;
+
+export type ${toPascalCase(collectionName)}JsonSchema = typeof ${camelName}JsonSchema;
+
+export default ${camelName}JsonSchema;
+`;
+    }
+    generateIndexFile(outputFormat, jsonSchemasPath, verbose) {
+        if (!this.config.collections)
+            return;
+        const indexPath = path.join(jsonSchemasPath, "index.ts");
+        const imports = [];
+        const exports = [];
+        this.config.collections.forEach((collection) => {
+            const camelName = toCamelCase(collection.name);
+            const pascalName = toPascalCase(collection.name);
+            if (outputFormat === "typescript" || outputFormat === "both") {
+                imports.push(`import { ${camelName}JsonSchema } from "./${camelName}.schema.js";`);
+                exports.push(`  ${camelName}: ${camelName}JsonSchema,`);
+            }
+        });
+        const indexContent = `// Auto-generated index for JSON schemas
+${imports.join('\n')}
+
+export const jsonSchemas = {
+${exports.join('\n')}
+};
+
+export type JsonSchemas = typeof jsonSchemas;
+
+// Individual schema exports
+${this.config.collections.map(collection => {
+            const camelName = toCamelCase(collection.name);
+            return `export { ${camelName}JsonSchema } from "./${camelName}.schema.js";`;
+        }).join('\n')}
+
+export default jsonSchemas;
+`;
+        fs.writeFileSync(indexPath, indexContent, { encoding: "utf-8" });
+        if (verbose) {
+            console.log(chalk.green(`✓ Index file written to ${indexPath}`));
+        }
+    }
+    validateSchema(schema) {
+        const errors = [];
+        // Basic validation
+        if (!schema.$schema) {
+            errors.push("Missing $schema property");
+        }
+        if (!schema.title) {
+            errors.push("Missing title property");
+        }
+        if (!schema.properties) {
+            errors.push("Missing properties");
+        }
+        if (!schema.required || !Array.isArray(schema.required)) {
+            errors.push("Missing or invalid required array");
+        }
+        // Validate required Appwrite fields
+        const requiredAppwriteFields = ["$id", "$createdAt", "$updatedAt"];
+        requiredAppwriteFields.forEach((field) => {
+            if (!schema.properties[field]) {
+                errors.push(`Missing required Appwrite field: ${field}`);
+            }
+        });
+        return { valid: errors.length === 0, errors };
+    }
+}

package/dist/shared/logging.d.ts

@@ -0,0 +1,10 @@
+import winston from "winston";
+export interface LoggingConfig {
+    enabled: boolean;
+    level: string;
+    logDirectory?: string;
+    console: boolean;
+}
+export declare const configureLogging: (config?: Partial<LoggingConfig>) => void;
+export declare let logger: winston.Logger;
+export declare const updateLogger: () => void;

package/dist/shared/logging.js

@@ -0,0 +1,46 @@
+import winston from "winston";
+import fs from "fs";
+import path from "path";
+const DEFAULT_LOGGING_CONFIG = {
+    enabled: false,
+    level: "info",
+    console: false,
+};
+let loggingConfig = DEFAULT_LOGGING_CONFIG;
+export const configureLogging = (config = {}) => {
+    loggingConfig = { ...DEFAULT_LOGGING_CONFIG, ...config };
+};
+const createLogger = () => {
+    const transports = [];
+    // Add console transport if enabled
+    if (loggingConfig.console) {
+        transports.push(new winston.transports.Console({
+            format: winston.format.combine(winston.format.colorize(), winston.format.simple())
+        }));
+    }
+    // Add file transports if logging is enabled
+    if (loggingConfig.enabled) {
+        const logDir = loggingConfig.logDirectory || path.join(process.cwd(), "zlogs");
+        if (!fs.existsSync(logDir)) {
+            fs.mkdirSync(logDir, { recursive: true });
+        }
+        transports.push(new winston.transports.File({
+            filename: path.join(logDir, "error.log"),
+            level: "error",
+        }), new winston.transports.File({
+            filename: path.join(logDir, "combined.log"),
+        }));
+    }
+    return winston.createLogger({
+        level: loggingConfig.level,
+        format: winston.format.combine(winston.format.timestamp(), winston.format.errors({ stack: true }), winston.format.json()),
+        defaultMeta: { service: "appwrite-utils-cli" },
+        transports,
+        silent: !loggingConfig.enabled && !loggingConfig.console,
+    });
+};
+export let logger = createLogger();
+// Recreate logger when config changes
+export const updateLogger = () => {
+    logger = createLogger();
+};

package/dist/shared/messageFormatter.d.ts

@@ -0,0 +1,37 @@
+export interface MessageOptions {
+    prefix?: string;
+    skipLogging?: boolean;
+    logLevel?: "info" | "warn" | "error" | "debug";
+}
+export declare class MessageFormatter {
+    static success(message: string, options?: MessageOptions): void;
+    static error(message: string, error?: Error | string, options?: MessageOptions): void;
+    static warning(message: string, options?: MessageOptions): void;
+    static info(message: string, options?: MessageOptions): void;
+    static step(step: number, total: number, message: string, options?: MessageOptions): void;
+    static progress(message: string, options?: MessageOptions): void;
+    static debug(message: string, data?: any, options?: MessageOptions): void;
+    static banner(title: string, subtitle?: string): void;
+    static section(title: string): void;
+    static list(items: string[], title?: string): void;
+    static table(data: Record<string, string | number>[], headers?: string[]): void;
+    static operationSummary(title: string, stats: Record<string, string | number>, duration?: number): void;
+    static formatBytes(bytes: number): string;
+    static formatDuration(ms: number): string;
+    static formatNumber(num: number): string;
+}
+export declare const Messages: {
+    readonly CONFIG_NOT_FOUND: "Appwrite configuration not found. Run 'appwrite-migrate setup' first.";
+    readonly CONFIG_LOADED: (type: string, path: string) => string;
+    readonly DATABASE_CONNECTION_FAILED: "Failed to connect to Appwrite. Check your endpoint and API key.";
+    readonly OPERATION_CANCELLED: "Operation cancelled by user.";
+    readonly OPERATION_COMPLETED: (operation: string) => string;
+    readonly BACKUP_STARTED: (database: string) => string;
+    readonly BACKUP_COMPLETED: (database: string, size: number) => string;
+    readonly IMPORT_STARTED: (collections: number) => string;
+    readonly IMPORT_COMPLETED: (documents: number) => string;
+    readonly FUNCTION_DEPLOYED: (name: string) => string;
+    readonly FUNCTION_DEPLOYMENT_FAILED: (name: string, error: string) => string;
+    readonly TRANSFER_STARTED: (source: string, target: string) => string;
+    readonly TRANSFER_COMPLETED: (items: number) => string;
+};

package/dist/shared/messageFormatter.js

@@ -0,0 +1,152 @@
+import chalk from "chalk";
+import { logger } from "./logging.js";
+export class MessageFormatter {
+    static success(message, options = {}) {
+        const formatted = `${chalk.green("✅")} ${options.prefix ? `${options.prefix}: ` : ""}${message}`;
+        console.log(formatted);
+        if (!options.skipLogging) {
+            logger.info(`SUCCESS: ${options.prefix ? `${options.prefix}: ` : ""}${message}`);
+        }
+    }
+    static error(message, error, options = {}) {
+        const errorDetails = error instanceof Error ? error.message : error;
+        const formatted = `${chalk.red("❌")} ${options.prefix ? `${options.prefix}: ` : ""}${message}${errorDetails ? `\n   ${chalk.gray(errorDetails)}` : ""}`;
+        console.error(formatted);
+        if (!options.skipLogging) {
+            logger.error(`ERROR: ${options.prefix ? `${options.prefix}: ` : ""}${message}`, {
+                error: errorDetails,
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
+    }
+    static warning(message, options = {}) {
+        const formatted = `${chalk.yellow("⚠️")} ${options.prefix ? `${options.prefix}: ` : ""}${message}`;
+        console.log(formatted);
+        if (!options.skipLogging) {
+            logger.warn(`WARNING: ${options.prefix ? `${options.prefix}: ` : ""}${message}`);
+        }
+    }
+    static info(message, options = {}) {
+        const formatted = `${chalk.blue("ℹ️")} ${options.prefix ? `${options.prefix}: ` : ""}${message}`;
+        console.log(formatted);
+        if (!options.skipLogging) {
+            logger.info(`INFO: ${options.prefix ? `${options.prefix}: ` : ""}${message}`);
+        }
+    }
+    static step(step, total, message, options = {}) {
+        const formatted = `${chalk.cyan(`[${step}/${total}]`)} ${options.prefix ? `${options.prefix}: ` : ""}${message}`;
+        console.log(formatted);
+        if (!options.skipLogging) {
+            logger.info(`STEP ${step}/${total}: ${options.prefix ? `${options.prefix}: ` : ""}${message}`);
+        }
+    }
+    static progress(message, options = {}) {
+        const formatted = `${chalk.gray("⏳")} ${options.prefix ? `${options.prefix}: ` : ""}${message}`;
+        console.log(formatted);
+        if (!options.skipLogging) {
+            logger.debug(`PROGRESS: ${options.prefix ? `${options.prefix}: ` : ""}${message}`);
+        }
+    }
+    static debug(message, data, options = {}) {
+        if (process.env.NODE_ENV === "development" || process.env.DEBUG) {
+            const formatted = `${chalk.magenta("🔍")} ${options.prefix ? `${options.prefix}: ` : ""}${message}`;
+            console.log(formatted);
+            if (data) {
+                console.log(chalk.gray(JSON.stringify(data, null, 2)));
+            }
+        }
+        if (!options.skipLogging) {
+            logger.debug(`DEBUG: ${options.prefix ? `${options.prefix}: ` : ""}${message}`, data);
+        }
+    }
+    static banner(title, subtitle) {
+        const divider = chalk.cyan("═".repeat(60));
+        console.log(`\n${divider}`);
+        console.log(chalk.cyan.bold(`  ${title}`));
+        if (subtitle) {
+            console.log(chalk.gray(`  ${subtitle}`));
+        }
+        console.log(`${divider}\n`);
+    }
+    static section(title) {
+        console.log(`\n${chalk.bold.underline(title)}`);
+    }
+    static list(items, title) {
+        if (title) {
+            console.log(chalk.bold(title));
+        }
+        items.forEach((item, index) => {
+            console.log(`${chalk.gray(`  ${index + 1}.`)} ${item}`);
+        });
+    }
+    static table(data, headers) {
+        if (data.length === 0)
+            return;
+        const keys = headers || Object.keys(data[0]);
+        const maxWidths = keys.map(key => Math.max(key.length, ...data.map(row => String(row[key]).length)));
+        // Header
+        const headerRow = keys.map((key, i) => chalk.bold(key.padEnd(maxWidths[i]))).join(" │ ");
+        console.log(`┌─${keys.map((_, i) => "─".repeat(maxWidths[i])).join("─┼─")}─┐`);
+        console.log(`│ ${headerRow} │`);
+        console.log(`├─${keys.map((_, i) => "─".repeat(maxWidths[i])).join("─┼─")}─┤`);
+        // Rows
+        data.forEach(row => {
+            const dataRow = keys.map((key, i) => String(row[key]).padEnd(maxWidths[i])).join(" │ ");
+            console.log(`│ ${dataRow} │`);
+        });
+        console.log(`└─${keys.map((_, i) => "─".repeat(maxWidths[i])).join("─┴─")}─┘`);
+    }
+    static operationSummary(title, stats, duration) {
+        this.section(`${title} Summary`);
+        Object.entries(stats).forEach(([key, value]) => {
+            const formattedKey = key.replace(/([A-Z])/g, ' $1').replace(/^./, str => str.toUpperCase());
+            console.log(`${chalk.gray("●")} ${formattedKey}: ${chalk.cyan(String(value))}`);
+        });
+        if (duration) {
+            console.log(`${chalk.gray("●")} Duration: ${chalk.cyan(this.formatDuration(duration))}`);
+        }
+        console.log();
+    }
+    static formatBytes(bytes) {
+        const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+        let size = bytes;
+        let unitIndex = 0;
+        while (size >= 1024 && unitIndex < units.length - 1) {
+            size /= 1024;
+            unitIndex++;
+        }
+        return `${size.toFixed(1)} ${units[unitIndex]}`;
+    }
+    static formatDuration(ms) {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        if (hours > 0) {
+            return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+        }
+        else if (minutes > 0) {
+            return `${minutes}m ${seconds % 60}s`;
+        }
+        else {
+            return `${seconds}s`;
+        }
+    }
+    static formatNumber(num) {
+        return num.toLocaleString();
+    }
+}
+export const Messages = {
+    CONFIG_NOT_FOUND: "Appwrite configuration not found. Run 'appwrite-migrate setup' first.",
+    CONFIG_LOADED: (type, path) => `Loaded ${type} configuration from ${path}`,
+    DATABASE_CONNECTION_FAILED: "Failed to connect to Appwrite. Check your endpoint and API key.",
+    OPERATION_CANCELLED: "Operation cancelled by user.",
+    OPERATION_COMPLETED: (operation) => `${operation} completed successfully`,
+    BACKUP_STARTED: (database) => `Starting backup for database: ${database}`,
+    BACKUP_COMPLETED: (database, size) => `Backup completed for ${database} (${MessageFormatter.formatBytes(size)})`,
+    IMPORT_STARTED: (collections) => `Starting import process for ${collections} collection(s)`,
+    IMPORT_COMPLETED: (documents) => `Import completed. Processed ${MessageFormatter.formatNumber(documents)} documents`,
+    FUNCTION_DEPLOYED: (name) => `Function '${name}' deployed successfully`,
+    FUNCTION_DEPLOYMENT_FAILED: (name, error) => `Function '${name}' deployment failed: ${error}`,
+    TRANSFER_STARTED: (source, target) => `Starting transfer from ${source} to ${target}`,
+    TRANSFER_COMPLETED: (items) => `Transfer completed. Moved ${MessageFormatter.formatNumber(items)} items`,
+};