appwrite-utils-cli 1.9.7 → 1.12.0

package/dist/shared/errorUtils.d.ts

@@ -1,54 +0,0 @@
-/**
- * Shared error handling utilities for consistent error processing
- */
-/**
- * Extracts error message from unknown error type
- * @param error - Error of unknown type
- * @returns String error message
- */
-export declare function getErrorMessage(error: unknown): string;
-/**
- * Normalizes unknown error to Error instance
- * @param error - Error of unknown type
- * @returns Normalized Error object
- */
-export declare function normalizeError(error: unknown): Error;
-/**
- * Checks if error is a conflict error (409)
- * @param error - Error object to check
- * @returns True if error is a conflict (duplicate resource)
- */
-export declare function isConflictError(error: any): boolean;
-/**
- * Checks if error is a Cloudflare error (522)
- * @param error - Error object to check
- * @returns True if error is from Cloudflare connection timeout
- */
-export declare function isCloudflareError(error: any): boolean;
-/**
- * Checks if error is authentication/authorization related
- * @param error - Error object to check
- * @returns True if error is auth-related (401, 403)
- */
-export declare function isAuthError(error: any): boolean;
-/**
- * Error categorization helpers for smart fallback logic
- */
-/**
- * Checks if an error is retryable (network issues, rate limits, etc.)
- * @param errorMessage - Error message to check
- * @returns True if error is retryable
- */
-export declare function isRetryableError(errorMessage: string): boolean;
-/**
- * Checks if an error indicates bulk operations are not supported
- * @param errorMessage - Error message to check
- * @returns True if bulk operations not supported
- */
-export declare function isBulkNotSupportedError(errorMessage: string): boolean;
-/**
- * Checks if an error is critical (authentication, authorization, permissions)
- * @param errorMessage - Error message to check
- * @returns True if error is critical
- */
-export declare function isCriticalError(errorMessage: string): boolean;

package/dist/shared/errorUtils.js

@@ -1,95 +0,0 @@
-/**
- * Shared error handling utilities for consistent error processing
- */
-/**
- * Extracts error message from unknown error type
- * @param error - Error of unknown type
- * @returns String error message
- */
-export function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-/**
- * Normalizes unknown error to Error instance
- * @param error - Error of unknown type
- * @returns Normalized Error object
- */
-export function normalizeError(error) {
-    return error instanceof Error ? error : new Error(String(error));
-}
-/**
- * Checks if error is a conflict error (409)
- * @param error - Error object to check
- * @returns True if error is a conflict (duplicate resource)
- */
-export function isConflictError(error) {
-    return error?.code === 409 || (error?.message?.toLowerCase().includes('already exists') ?? false);
-}
-/**
- * Checks if error is a Cloudflare error (522)
- * @param error - Error object to check
- * @returns True if error is from Cloudflare connection timeout
- */
-export function isCloudflareError(error) {
-    return error?.code === 522 || error?.code === "522";
-}
-/**
- * Checks if error is authentication/authorization related
- * @param error - Error object to check
- * @returns True if error is auth-related (401, 403)
- */
-export function isAuthError(error) {
-    const code = error?.code;
-    return code === 401 || code === 403 || code === "401" || code === "403";
-}
-/**
- * Error categorization helpers for smart fallback logic
- */
-/**
- * Checks if an error is retryable (network issues, rate limits, etc.)
- * @param errorMessage - Error message to check
- * @returns True if error is retryable
- */
-export function isRetryableError(errorMessage) {
-    const retryableErrors = [
-        "rate limit",
-        "timeout",
-        "network",
-        "temporary",
-        "503",
-        "502",
-        "429"
-    ];
-    return retryableErrors.some(error => errorMessage.toLowerCase().includes(error));
-}
-/**
- * Checks if an error indicates bulk operations are not supported
- * @param errorMessage - Error message to check
- * @returns True if bulk operations not supported
- */
-export function isBulkNotSupportedError(errorMessage) {
-    const notSupportedErrors = [
-        "method not found",
-        "not implemented",
-        "unsupported",
-        "not available",
-        "404"
-    ];
-    return notSupportedErrors.some(error => errorMessage.toLowerCase().includes(error));
-}
-/**
- * Checks if an error is critical (authentication, authorization, permissions)
- * @param errorMessage - Error message to check
- * @returns True if error is critical
- */
-export function isCriticalError(errorMessage) {
-    const criticalErrors = [
-        "authentication",
-        "authorization",
-        "permission",
-        "forbidden",
-        "401",
-        "403"
-    ];
-    return criticalErrors.some(error => errorMessage.toLowerCase().includes(error));
-}

package/dist/shared/functionManager.d.ts

@@ -1,48 +0,0 @@
-import { Client, type Models } from "node-appwrite";
-import { type AppwriteFunction } from "appwrite-utils";
-export interface FunctionSearchOptions {
-    searchPaths?: string[];
-    caseSensitive?: boolean;
-    allowFuzzyMatch?: boolean;
-    verbose?: boolean;
-}
-export interface FunctionDeploymentOptions {
-    activate?: boolean;
-    entrypoint?: string;
-    commands?: string;
-    ignored?: string[];
-    verbose?: boolean;
-    forceRedeploy?: boolean;
-}
-export declare class FunctionManager {
-    private client;
-    private functions;
-    constructor(client: Client);
-    /**
-     * Improved function directory detection with multiple strategies
-     */
-    findFunctionDirectory(functionName: string, options?: FunctionSearchOptions): Promise<string | null>;
-    private generateNameVariations;
-    private getStandardFunctionPaths;
-    private recursiveDirectorySearch;
-    private shouldSkipDirectory;
-    private isValidFunctionDirectory;
-    /**
-     * Enhanced function deployment with better error handling and validation
-     */
-    deployFunction(functionConfig: AppwriteFunction, functionPath: string, options?: FunctionDeploymentOptions): Promise<Models.Deployment>;
-    private createFunction;
-    private updateFunction;
-    private executePredeployCommands;
-    private createDeployment;
-    getFunction(functionId: string): Promise<Models.Function>;
-    listFunctions(): Promise<Models.FunctionList>;
-    deleteFunction(functionId: string): Promise<void>;
-    /**
-     * Validate function configuration
-     */
-    validateFunctionConfig(functionConfig: AppwriteFunction): {
-        valid: boolean;
-        errors: string[];
-    };
-}

package/dist/shared/functionManager.js

@@ -1,348 +0,0 @@
-import { Client, Functions, Runtime } from "node-appwrite";
-import { EventTypeSchema } from "appwrite-utils";
-import { join, relative, resolve, basename } from "node:path";
-import fs from "node:fs";
-import chalk from "chalk";
-import pLimit from "p-limit";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
-import { MessageFormatter } from "./messageFormatter.js";
-/**
- * Validates and filters events array for Appwrite functions
- * - Filters out empty/invalid strings
- * - Validates against EventTypeSchema
- * - Limits to 100 items maximum (Appwrite limit)
- * - Returns empty array if input is invalid
- */
-const validateEvents = (events) => {
-    if (!events || !Array.isArray(events))
-        return [];
-    return events
-        .filter(event => {
-        if (!event || typeof event !== 'string' || event.trim().length === 0) {
-            return false;
-        }
-        // Validate against EventTypeSchema
-        const result = EventTypeSchema.safeParse(event);
-        if (!result.success) {
-            MessageFormatter.warning(`Invalid event type "${event}" will be filtered out`, { prefix: "Functions" });
-            return false;
-        }
-        return true;
-    })
-        .slice(0, 100);
-};
-// Concurrency limits
-const functionLimit = pLimit(5); // Moderate limit for function operations
-const queryLimit = pLimit(25); // Higher limit for read operations
-export class FunctionManager {
-    client;
-    functions;
-    constructor(client) {
-        this.client = client;
-        this.functions = new Functions(client);
-    }
-    /**
-     * Improved function directory detection with multiple strategies
-     */
-    async findFunctionDirectory(functionName, options = {}) {
-        const { searchPaths = [process.cwd()], caseSensitive = false, allowFuzzyMatch = true, verbose = false } = options;
-        if (verbose) {
-            MessageFormatter.info(`Searching for function: ${functionName}`, { prefix: "Functions" });
-        }
-        // Normalize function name for comparison
-        const normalizedName = caseSensitive ? functionName : functionName.toLowerCase();
-        const nameVariations = this.generateNameVariations(normalizedName);
-        // Strategy 1: Check standard locations first
-        const standardPaths = this.getStandardFunctionPaths(searchPaths, functionName);
-        for (const path of standardPaths) {
-            if (await this.isValidFunctionDirectory(path)) {
-                if (verbose) {
-                    MessageFormatter.success(`Found function at standard location: ${path}`, { prefix: "Functions" });
-                }
-                return path;
-            }
-        }
-        // Strategy 2: Recursive directory search with fuzzy matching
-        if (allowFuzzyMatch) {
-            for (const searchPath of searchPaths) {
-                const foundPath = await this.recursiveDirectorySearch(searchPath, nameVariations, { caseSensitive, verbose });
-                if (foundPath) {
-                    if (verbose) {
-                        MessageFormatter.success(`Found function via fuzzy search: ${foundPath}`, { prefix: "Functions" });
-                    }
-                    return foundPath;
-                }
-            }
-        }
-        if (verbose) {
-            MessageFormatter.warning(`Function directory not found: ${functionName}`, { prefix: "Functions" });
-        }
-        return null;
-    }
-    generateNameVariations(name) {
-        const variations = new Set([
-            name,
-            name.toLowerCase(),
-            name.replace(/\s+/g, "-"),
-            name.replace(/\s+/g, "_"),
-            name.replace(/[^a-z0-9]/gi, ""),
-            name.replace(/[-_\s]+/g, ""),
-            name.replace(/[-_\s]+/g, "-").toLowerCase(),
-            name.replace(/[-_\s]+/g, "_").toLowerCase(),
-        ]);
-        return variations;
-    }
-    getStandardFunctionPaths(searchPaths, functionName) {
-        const normalizedName = functionName.toLowerCase().replace(/\s+/g, "-");
-        const paths = [];
-        for (const basePath of searchPaths) {
-            paths.push(join(basePath, "functions", functionName), join(basePath, "functions", normalizedName), join(basePath, "src", "functions", functionName), join(basePath, "src", "functions", normalizedName), join(basePath, functionName), join(basePath, normalizedName), join(basePath, "appwrite", "functions", functionName), join(basePath, "appwrite", "functions", normalizedName));
-        }
-        return paths;
-    }
-    async recursiveDirectorySearch(searchPath, nameVariations, options) {
-        const { caseSensitive, verbose } = options;
-        try {
-            const stats = await fs.promises.stat(searchPath);
-            if (!stats.isDirectory())
-                return null;
-            const entries = await fs.promises.readdir(searchPath, { withFileTypes: true });
-            for (const entry of entries) {
-                if (!entry.isDirectory())
-                    continue;
-                // Skip common directories that won't contain functions
-                if (this.shouldSkipDirectory(entry.name))
-                    continue;
-                const entryPath = join(searchPath, entry.name);
-                // Check if this directory matches our function name
-                const entryNameToCheck = caseSensitive ? entry.name : entry.name.toLowerCase();
-                if (nameVariations.has(entryNameToCheck)) {
-                    if (await this.isValidFunctionDirectory(entryPath)) {
-                        return entryPath;
-                    }
-                }
-                // Recursively search subdirectories
-                const result = await this.recursiveDirectorySearch(entryPath, nameVariations, options);
-                if (result)
-                    return result;
-            }
-        }
-        catch (error) {
-            if (verbose) {
-                MessageFormatter.debug(`Skipping inaccessible directory: ${searchPath}`, undefined, { prefix: "Functions" });
-            }
-        }
-        return null;
-    }
-    shouldSkipDirectory(dirName) {
-        const skipDirs = new Set([
-            'node_modules',
-            '.git',
-            '.vscode',
-            '.idea',
-            'dist',
-            'build',
-            'coverage',
-            '.nyc_output',
-            'tmp',
-            'temp',
-            '.cache',
-            '__pycache__',
-            '.pytest_cache',
-            'venv',
-            '.venv',
-            'env',
-            '.env'
-        ]);
-        return skipDirs.has(dirName) || dirName.startsWith('.');
-    }
-    async isValidFunctionDirectory(path) {
-        try {
-            const stats = await fs.promises.stat(path);
-            if (!stats.isDirectory())
-                return false;
-            const files = await fs.promises.readdir(path);
-            // Check for common function indicators
-            const hasPackageJson = files.includes('package.json');
-            const hasMainFile = files.some(file => file.match(/^(index|main|app)\.(js|ts|py)$/i) ||
-                file === 'src' ||
-                file === 'lib');
-            const hasRequirements = files.includes('requirements.txt');
-            const hasPyProject = files.includes('pyproject.toml');
-            return hasPackageJson || hasMainFile || hasRequirements || hasPyProject;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Enhanced function deployment with better error handling and validation
-     */
-    async deployFunction(functionConfig, functionPath, options = {}) {
-        const { activate = true, entrypoint = functionConfig.entrypoint || "index.js", commands = functionConfig.commands || "npm install", ignored = ["node_modules", ".git", ".vscode", ".DS_Store", "__pycache__", ".venv"], verbose = false, forceRedeploy = false } = options;
-        return await functionLimit(async () => {
-            if (verbose) {
-                MessageFormatter.processing(`Deploying function: ${functionConfig.name}`, { prefix: "Functions" });
-                MessageFormatter.debug(`Path: ${functionPath}`, undefined, { prefix: "Functions" });
-                MessageFormatter.debug(`Entrypoint: ${entrypoint}`, undefined, { prefix: "Functions" });
-            }
-            // Validate function directory
-            if (!await this.isValidFunctionDirectory(functionPath)) {
-                throw new Error(`Invalid function directory: ${functionPath}`);
-            }
-            // Ensure function exists
-            let functionExists = false;
-            try {
-                await this.getFunction(functionConfig.$id);
-                functionExists = true;
-            }
-            catch (error) {
-                if (verbose) {
-                    MessageFormatter.info(`Function ${functionConfig.$id} does not exist, creating...`, { prefix: "Functions" });
-                }
-            }
-            // Create function if it doesn't exist
-            if (!functionExists) {
-                await this.createFunction(functionConfig, { verbose });
-            }
-            else if (forceRedeploy) {
-                await this.updateFunction(functionConfig, { verbose });
-            }
-            // Execute pre-deploy commands if specified
-            if (functionConfig.predeployCommands?.length) {
-                await this.executePredeployCommands(functionConfig.predeployCommands, functionPath, { verbose });
-            }
-            // Deploy the function
-            const deployment = await this.createDeployment(functionConfig.$id, functionPath, { activate, entrypoint, commands, ignored, verbose });
-            if (verbose) {
-                MessageFormatter.success(`Function ${functionConfig.name} deployed successfully`, { prefix: "Functions" });
-            }
-            return deployment;
-        });
-    }
-    async createFunction(functionConfig, options = {}) {
-        const { verbose = false } = options;
-        if (verbose) {
-            MessageFormatter.processing(`Creating function: ${functionConfig.name}`, { prefix: "Functions" });
-        }
-        return await tryAwaitWithRetry(async () => {
-            return await this.functions.create(functionConfig.$id, functionConfig.name, functionConfig.runtime, functionConfig.execute || [], functionConfig.events || [], functionConfig.schedule || "", functionConfig.timeout || 15, functionConfig.enabled !== false, functionConfig.logging !== false, functionConfig.entrypoint, functionConfig.commands, functionConfig.scopes || [], functionConfig.installationId, functionConfig.providerRepositoryId, functionConfig.providerBranch, functionConfig.providerSilentMode, functionConfig.providerRootDirectory);
-        });
-    }
-    async updateFunction(functionConfig, options = {}) {
-        const { verbose = false } = options;
-        if (verbose) {
-            MessageFormatter.processing(`Updating function: ${functionConfig.name}`, { prefix: "Functions" });
-        }
-        return await tryAwaitWithRetry(async () => {
-            return await this.functions.update(functionConfig.$id, functionConfig.name, functionConfig.runtime, functionConfig.execute || [], functionConfig.events || [], functionConfig.schedule || "", functionConfig.timeout || 15, functionConfig.enabled !== false, functionConfig.logging !== false, functionConfig.entrypoint, functionConfig.commands, functionConfig.scopes || [], functionConfig.installationId, functionConfig.providerRepositoryId, functionConfig.providerBranch, functionConfig.providerSilentMode, functionConfig.providerRootDirectory, functionConfig.specification);
-        });
-    }
-    async executePredeployCommands(commands, workingDir, options = {}) {
-        const { verbose = false } = options;
-        const { execSync } = await import("child_process");
-        const { platform } = await import("node:os");
-        if (verbose) {
-            MessageFormatter.processing("Executing pre-deploy commands...", { prefix: "Functions" });
-        }
-        const isWindows = platform() === "win32";
-        for (const command of commands) {
-            if (verbose) {
-                MessageFormatter.debug(`$ ${command}`, undefined, { prefix: "Functions" });
-            }
-            try {
-                execSync(command, {
-                    cwd: workingDir,
-                    stdio: verbose ? "inherit" : "pipe",
-                    shell: isWindows ? "cmd.exe" : "/bin/sh",
-                    windowsHide: true,
-                });
-            }
-            catch (error) {
-                MessageFormatter.error(`Failed to execute command: ${command}`, error, { prefix: "Functions" });
-                throw error;
-            }
-        }
-        if (verbose) {
-            MessageFormatter.success("Pre-deploy commands completed", { prefix: "Functions" });
-        }
-    }
-    async createDeployment(functionId, codePath, options = {}) {
-        const { activate = true, entrypoint = "index.js", commands = "npm install", ignored = [], verbose = false } = options;
-        const { InputFile } = await import("node-appwrite/file");
-        const { create: createTarball } = await import("tar");
-        const tarPath = join(process.cwd(), `function-${functionId}-${Date.now()}.tar.gz`);
-        try {
-            if (verbose) {
-                MessageFormatter.processing("Creating deployment archive...", { prefix: "Functions" });
-            }
-            // Create tarball
-            await createTarball({
-                gzip: true,
-                file: tarPath,
-                cwd: codePath,
-                filter: (path) => {
-                    const relativePath = relative(codePath, join(codePath, path)).toLowerCase();
-                    const shouldIgnore = ignored.some(pattern => relativePath.startsWith(pattern.toLowerCase()) ||
-                        relativePath.includes(`/${pattern.toLowerCase()}`) ||
-                        relativePath.includes(`\\${pattern.toLowerCase()}`));
-                    if (shouldIgnore && verbose) {
-                        MessageFormatter.debug(`Ignoring: ${path}`, undefined, { prefix: "Functions" });
-                    }
-                    return !shouldIgnore;
-                },
-            }, ["."]);
-            // Read and upload
-            const fileBuffer = await fs.promises.readFile(tarPath);
-            const fileObject = InputFile.fromBuffer(new Uint8Array(fileBuffer), `function-${functionId}.tar.gz`);
-            if (verbose) {
-                MessageFormatter.processing("Uploading deployment...", { prefix: "Functions" });
-            }
-            const deployment = await tryAwaitWithRetry(async () => {
-                return await this.functions.createDeployment(functionId, fileObject, activate, entrypoint, commands);
-            });
-            return deployment;
-        }
-        finally {
-            // Clean up tarball
-            try {
-                await fs.promises.unlink(tarPath);
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-    }
-    async getFunction(functionId) {
-        return await queryLimit(() => tryAwaitWithRetry(async () => await this.functions.get(functionId)));
-    }
-    async listFunctions() {
-        return await queryLimit(() => tryAwaitWithRetry(async () => await this.functions.list()));
-    }
-    async deleteFunction(functionId) {
-        await functionLimit(() => tryAwaitWithRetry(async () => await this.functions.delete(functionId)));
-    }
-    /**
-     * Validate function configuration
-     */
-    validateFunctionConfig(functionConfig) {
-        const errors = [];
-        if (!functionConfig.$id) {
-            errors.push("Function ID is required");
-        }
-        if (!functionConfig.name) {
-            errors.push("Function name is required");
-        }
-        if (!functionConfig.runtime) {
-            errors.push("Function runtime is required");
-        }
-        if (!functionConfig.entrypoint) {
-            errors.push("Function entrypoint is required");
-        }
-        // Validate timeout
-        if (functionConfig.timeout && (functionConfig.timeout < 1 || functionConfig.timeout > 900)) {
-            errors.push("Function timeout must be between 1 and 900 seconds");
-        }
-        return { valid: errors.length === 0, errors };
-    }
-}

package/dist/shared/jsonSchemaGenerator.d.ts

@@ -1,50 +0,0 @@
-import type { AppwriteConfig } from "appwrite-utils";
-export interface JsonSchemaProperty {
-    type: string | string[];
-    format?: string;
-    minimum?: number;
-    maximum?: number;
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-    enum?: any[];
-    items?: JsonSchemaProperty;
-    $ref?: string;
-    properties?: Record<string, JsonSchemaProperty>;
-    additionalProperties?: boolean;
-    required?: string[];
-    default?: any;
-    oneOf?: JsonSchemaProperty[];
-}
-export interface JsonSchema {
-    $schema: string;
-    $id: string;
-    title: string;
-    type: "object";
-    properties: Record<string, JsonSchemaProperty>;
-    required: string[];
-    additionalProperties: boolean;
-    definitions?: Record<string, JsonSchemaProperty>;
-}
-export declare class JsonSchemaGenerator {
-    private config;
-    private appwriteFolderPath;
-    private relationshipMap;
-    constructor(config: AppwriteConfig, appwriteFolderPath: string);
-    private resolveCollectionName;
-    private extractRelationships;
-    private attributeToJsonSchemaProperty;
-    private getBaseTypeSchema;
-    private createJsonSchema;
-    generateJsonSchemas(options?: {
-        outputFormat?: "json" | "typescript" | "both";
-        outputDirectory?: string;
-        verbose?: boolean;
-    }): void;
-    private generateTypeScriptSchema;
-    private generateIndexFile;
-    validateSchema(schema: JsonSchema): {
-        valid: boolean;
-        errors: string[];
-    };
-}