@njdamstra/appwrite-utils-cli 1.8.9 → 1.10.1

package/dist/functions/pathResolution.d.ts

@@ -1,37 +0,0 @@
-/**
- * Expands tilde (~) in paths to the user's home directory
- * @param pathStr - Path string that may contain ~
- * @returns Expanded path with home directory
- */
-export declare function expandTildePath(pathStr: string): string;
-/**
- * Normalizes function name to standard format (lowercase, dashes instead of spaces)
- * @param name - Function name to normalize
- * @returns Normalized function name
- */
-export declare function normalizeFunctionName(name: string): string;
-/**
- * Validates that a directory exists and contains function markers
- * @param dirPath - Directory path to validate
- * @returns True if directory is a valid function directory
- */
-export declare function validateFunctionDirectory(dirPath: string): boolean;
-/**
- * Helper function to search for function in standard locations
- * @param configDirPath - Directory where config file is located
- * @param normalizedName - Normalized function name
- * @returns First valid function directory path or undefined
- */
-export declare function findFunctionInStandardLocations(configDirPath: string, normalizedName: string): string | undefined;
-/**
- * Resolves the absolute path to a function directory
- * Handles multiple resolution strategies with proper priority
- *
- * @param functionName - Name of the function
- * @param configDirPath - Directory where config file is located
- * @param dirPath - Optional explicit dirPath from config
- * @param explicitPath - Optional path passed as parameter (highest priority)
- * @returns Absolute path to the function directory
- * @throws Error if function directory cannot be found or is invalid
- */
-export declare function resolveFunctionDirectory(functionName: string, configDirPath: string, dirPath?: string, explicitPath?: string): string;

package/dist/functions/pathResolution.js

@@ -1,185 +0,0 @@
-import { existsSync, statSync, readdirSync } from 'node:fs';
-import { join, resolve, isAbsolute } from 'node:path';
-import { homedir } from 'node:os';
-import { MessageFormatter } from '../shared/messageFormatter.js';
-import { logger } from '../shared/logging.js';
-/**
- * Expands tilde (~) in paths to the user's home directory
- * @param pathStr - Path string that may contain ~
- * @returns Expanded path with home directory
- */
-export function expandTildePath(pathStr) {
-    if (!pathStr)
-        return pathStr;
-    if (pathStr.startsWith('~/') || pathStr === '~') {
-        const expandedPath = pathStr.replace(/^~(?=$|\/|\\)/, homedir());
-        logger.debug('Expanded tilde path', { original: pathStr, expanded: expandedPath });
-        return expandedPath;
-    }
-    return pathStr;
-}
-/**
- * Normalizes function name to standard format (lowercase, dashes instead of spaces)
- * @param name - Function name to normalize
- * @returns Normalized function name
- */
-export function normalizeFunctionName(name) {
-    if (!name)
-        return name;
-    const normalized = name.toLowerCase().replace(/\s+/g, '-');
-    if (normalized !== name) {
-        logger.debug('Normalized function name', { original: name, normalized });
-    }
-    return normalized;
-}
-/**
- * Validates that a directory exists and contains function markers
- * @param dirPath - Directory path to validate
- * @returns True if directory is a valid function directory
- */
-export function validateFunctionDirectory(dirPath) {
-    try {
-        // Check if directory exists
-        if (!existsSync(dirPath)) {
-            logger.debug('Directory does not exist', { dirPath });
-            return false;
-        }
-        // Check if it's actually a directory
-        const stats = statSync(dirPath);
-        if (!stats.isDirectory()) {
-            logger.debug('Path is not a directory', { dirPath });
-            return false;
-        }
-        // Check for function markers
-        const contents = readdirSync(dirPath);
-        const hasPackageJson = contents.includes('package.json');
-        const hasPyprojectToml = contents.includes('pyproject.toml');
-        const hasSrcDir = contents.includes('src');
-        const isValid = hasPackageJson || hasPyprojectToml || hasSrcDir;
-        logger.debug('Function directory validation', {
-            dirPath,
-            isValid,
-            markers: {
-                hasPackageJson,
-                hasPyprojectToml,
-                hasSrcDir
-            }
-        });
-        return isValid;
-    }
-    catch (error) {
-        logger.debug('Error validating function directory', {
-            dirPath,
-            error: error instanceof Error ? error.message : String(error)
-        });
-        return false;
-    }
-}
-/**
- * Helper function to search for function in standard locations
- * @param configDirPath - Directory where config file is located
- * @param normalizedName - Normalized function name
- * @returns First valid function directory path or undefined
- */
-export function findFunctionInStandardLocations(configDirPath, normalizedName) {
-    const searchPaths = [
-        // Same directory as config
-        join(configDirPath, 'functions', normalizedName),
-        // Parent directory of config
-        join(configDirPath, '..', 'functions', normalizedName),
-        // Current working directory
-        join(process.cwd(), 'functions', normalizedName),
-    ];
-    logger.debug('Searching for function in standard locations', {
-        normalizedName,
-        configDirPath,
-        searchPaths
-    });
-    for (const searchPath of searchPaths) {
-        const resolvedPath = resolve(searchPath);
-        logger.debug('Checking search path', { searchPath, resolvedPath });
-        if (validateFunctionDirectory(resolvedPath)) {
-            logger.debug('Found function in standard location', { resolvedPath });
-            return resolvedPath;
-        }
-    }
-    logger.debug('Function not found in any standard location', { normalizedName });
-    return undefined;
-}
-/**
- * Resolves the absolute path to a function directory
- * Handles multiple resolution strategies with proper priority
- *
- * @param functionName - Name of the function
- * @param configDirPath - Directory where config file is located
- * @param dirPath - Optional explicit dirPath from config
- * @param explicitPath - Optional path passed as parameter (highest priority)
- * @returns Absolute path to the function directory
- * @throws Error if function directory cannot be found or is invalid
- */
-export function resolveFunctionDirectory(functionName, configDirPath, dirPath, explicitPath) {
-    logger.debug('Resolving function directory', {
-        functionName,
-        configDirPath,
-        dirPath,
-        explicitPath
-    });
-    const normalizedName = normalizeFunctionName(functionName);
-    // Priority 1: Explicit path parameter (highest priority)
-    if (explicitPath) {
-        logger.debug('Using explicit path parameter');
-        const expandedPath = expandTildePath(explicitPath);
-        const resolvedPath = isAbsolute(expandedPath)
-            ? expandedPath
-            : resolve(process.cwd(), expandedPath);
-        if (!validateFunctionDirectory(resolvedPath)) {
-            const errorMsg = `Explicit path is not a valid function directory: ${resolvedPath}`;
-            logger.error(errorMsg);
-            MessageFormatter.error('Invalid function directory', errorMsg, { prefix: 'Path Resolution' });
-            throw new Error(errorMsg);
-        }
-        logger.debug('Resolved using explicit path', { resolvedPath });
-        MessageFormatter.debug(`Resolved function directory using explicit path: ${resolvedPath}`, undefined, { prefix: 'Path Resolution' });
-        return resolvedPath;
-    }
-    // Priority 2: dirPath from config (relative to config location)
-    if (dirPath) {
-        logger.debug('Using dirPath from config');
-        const expandedPath = expandTildePath(dirPath);
-        const resolvedPath = isAbsolute(expandedPath)
-            ? expandedPath
-            : resolve(configDirPath, expandedPath);
-        if (!validateFunctionDirectory(resolvedPath)) {
-            const errorMsg = `Config dirPath is not a valid function directory: ${resolvedPath}`;
-            logger.error(errorMsg);
-            MessageFormatter.error('Invalid function directory', errorMsg, { prefix: 'Path Resolution' });
-            throw new Error(errorMsg);
-        }
-        logger.debug('Resolved using config dirPath', { resolvedPath });
-        MessageFormatter.debug(`Resolved function directory using config dirPath: ${resolvedPath}`, undefined, { prefix: 'Path Resolution' });
-        return resolvedPath;
-    }
-    // Priority 3: Search standard locations
-    logger.debug('Searching standard locations for function');
-    const foundPath = findFunctionInStandardLocations(configDirPath, normalizedName);
-    if (foundPath) {
-        logger.debug('Resolved using standard location search', { foundPath });
-        MessageFormatter.debug(`Found function directory in standard location: ${foundPath}`, undefined, { prefix: 'Path Resolution' });
-        return foundPath;
-    }
-    // Priority 4: Not found - throw error
-    const searchedLocations = [
-        join(configDirPath, 'functions', normalizedName),
-        join(configDirPath, '..', 'functions', normalizedName),
-        join(process.cwd(), 'functions', normalizedName),
-    ];
-    const errorMsg = `Function directory not found for '${functionName}' (normalized: '${normalizedName}'). ` +
-        `Searched locations:\n${searchedLocations.map(p => `  - ${p}`).join('\n')}`;
-    logger.error('Function directory not found', {
-        functionName,
-        normalizedName,
-        searchedLocations
-    });
-    MessageFormatter.error('Function directory not found', errorMsg, { prefix: 'Path Resolution' });
-    throw new Error(errorMsg);
-}

package/dist/shared/attributeMapper.d.ts

@@ -1,20 +0,0 @@
-import type { CreateAttributeParams, UpdateAttributeParams } from "../adapters/DatabaseAdapter.js";
-import type { Attribute } from "@njdamstra/appwrite-utils";
-/**
- * Map a schema Attribute into DatabaseAdapter CreateAttributeParams
- * Only includes fields valid for the specific type to satisfy TS unions.
- * Also normalizes min/max ordering for numeric types to avoid server errors.
- */
-export declare function mapToCreateAttributeParams(attr: Attribute, base: {
-    databaseId: string;
-    tableId: string;
-}): CreateAttributeParams;
-/**
- * Map a schema Attribute into DatabaseAdapter UpdateAttributeParams
- * Omits fields that are not explicitly provided, and guards enum updates
- * so we never send an empty elements array (preserve existing on server).
- */
-export declare function mapToUpdateAttributeParams(attr: Attribute, base: {
-    databaseId: string;
-    tableId: string;
-}): UpdateAttributeParams;

package/dist/shared/attributeMapper.js

@@ -1,203 +0,0 @@
-function ensureNumber(n) {
-    if (n === null || n === undefined)
-        return undefined;
-    const num = Number(n);
-    return Number.isFinite(num) ? num : undefined;
-}
-/**
- * Map a schema Attribute into DatabaseAdapter CreateAttributeParams
- * Only includes fields valid for the specific type to satisfy TS unions.
- * Also normalizes min/max ordering for numeric types to avoid server errors.
- */
-export function mapToCreateAttributeParams(attr, base) {
-    const type = String(attr.type || "").toLowerCase();
-    const required = !!attr.required;
-    const array = !!attr.array;
-    const xdefault = attr.xdefault;
-    const encrypt = attr.encrypt;
-    // Numeric helpers
-    const rawMin = ensureNumber(attr.min);
-    const rawMax = ensureNumber(attr.max);
-    let min = rawMin;
-    let max = rawMax;
-    if (min !== undefined && max !== undefined && min >= max) {
-        // Swap to satisfy server-side validation
-        const tmp = min;
-        min = Math.min(min, max);
-        max = Math.max(tmp, max);
-        if (min === max) {
-            // If still equal, unset max to avoid error
-            max = undefined;
-        }
-    }
-    switch (type) {
-        case "string":
-            return {
-                databaseId: base.databaseId,
-                tableId: base.tableId,
-                key: attr.key,
-                type,
-                size: attr.size ?? 255,
-                required,
-                default: xdefault,
-                array,
-                encrypt: !!encrypt,
-            };
-        case "integer":
-            return {
-                databaseId: base.databaseId,
-                tableId: base.tableId,
-                key: attr.key,
-                type,
-                required,
-                default: xdefault,
-                array,
-                min,
-                max,
-            };
-        case "double":
-        case "float":
-            return {
-                databaseId: base.databaseId,
-                tableId: base.tableId,
-                key: attr.key,
-                type,
-                required,
-                default: xdefault,
-                array,
-                min,
-                max,
-            };
-        case "boolean":
-            return {
-                databaseId: base.databaseId,
-                tableId: base.tableId,
-                key: attr.key,
-                type,
-                required,
-                default: xdefault,
-                array,
-            };
-        case "datetime":
-        case "email":
-        case "ip":
-        case "url":
-            return {
-                databaseId: base.databaseId,
-                tableId: base.tableId,
-                key: attr.key,
-                type,
-                required,
-                default: xdefault,
-                array,
-            };
-        case "enum":
-            {
-                const elements = attr.elements;
-                if (!Array.isArray(elements) || elements.length === 0) {
-                    // Creating an enum without elements is invalid – fail fast with clear messaging
-                    throw new Error(`Enum attribute '${attr.key}' requires a non-empty 'elements' array for creation`);
-                }
-            }
-            return {
-                databaseId: base.databaseId,
-                tableId: base.tableId,
-                key: attr.key,
-                type,
-                required,
-                default: xdefault,
-                array,
-                elements: attr.elements,
-            };
-        case "relationship": {
-            // Relationship attributes require related collection and metadata
-            return {
-                databaseId: base.databaseId,
-                tableId: base.tableId,
-                key: attr.key,
-                type,
-                relatedCollection: attr.relatedCollection,
-                relationType: attr.relationType,
-                twoWay: attr.twoWay,
-                twoWayKey: attr.twoWayKey,
-                onDelete: attr.onDelete,
-                side: attr.side,
-            };
-        }
-        default:
-            return {
-                databaseId: base.databaseId,
-                tableId: base.tableId,
-                key: attr.key,
-                type,
-                required,
-            };
-    }
-}
-/**
- * Map a schema Attribute into DatabaseAdapter UpdateAttributeParams
- * Omits fields that are not explicitly provided, and guards enum updates
- * so we never send an empty elements array (preserve existing on server).
- */
-export function mapToUpdateAttributeParams(attr, base) {
-    const type = String(attr.type || "").toLowerCase();
-    const params = {
-        databaseId: base.databaseId,
-        tableId: base.tableId,
-        key: attr.key,
-    };
-    const setIfDefined = (key, value) => {
-        if (value !== undefined)
-            params[key] = value;
-    };
-    // Common fields
-    setIfDefined("type", type);
-    setIfDefined("required", attr.required);
-    // Only send default if explicitly provided and not on required
-    if (!attr.required && attr.xdefault !== undefined) {
-        setIfDefined("default", attr.xdefault);
-    }
-    setIfDefined("array", attr.array);
-    // encrypt only applies to string types
-    if (type === "string")
-        setIfDefined("encrypt", attr.encrypt);
-    // Numeric normalization
-    const toNum = (n) => (n === null || n === undefined ? undefined : (Number(n)));
-    let min = toNum(attr.min);
-    let max = toNum(attr.max);
-    if (min !== undefined && max !== undefined && min >= max) {
-        const tmp = min;
-        min = Math.min(min, max);
-        max = Math.max(tmp, max);
-        if (min === max)
-            max = undefined;
-    }
-    switch (type) {
-        case "string":
-            setIfDefined("size", attr.size);
-            break;
-        case "integer":
-        case "float":
-        case "double":
-            setIfDefined("min", min);
-            setIfDefined("max", max);
-            break;
-        case "enum": {
-            const elements = attr.elements;
-            if (Array.isArray(elements) && elements.length > 0) {
-                // Only include when non-empty; otherwise preserve existing on server
-                setIfDefined("elements", elements);
-            }
-            break;
-        }
-        case "relationship": {
-            setIfDefined("relatedCollection", attr.relatedCollection);
-            setIfDefined("relationType", attr.relationType);
-            setIfDefined("twoWay", attr.twoWay);
-            setIfDefined("twoWayKey", attr.twoWayKey);
-            setIfDefined("onDelete", attr.onDelete);
-            break;
-        }
-    }
-    return params;
-}

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 "@njdamstra/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[];
-    };
-}