appwrite-utils-cli 1.9.6 → 1.11.0

package/dist/utils/projectConfig.js

@@ -1,206 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join, dirname, resolve, isAbsolute } from "node:path";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-/**
- * Find appwrite.json or appwrite.config.json in current directory or parents
- */
-export function findAppwriteProjectConfig(startDir = process.cwd()) {
-    const configNames = ["appwrite.json", "appwrite.config.json"];
-    let currentDir = startDir;
-    // Search up to 5 levels up the directory tree
-    for (let i = 0; i < 5; i++) {
-        for (const configName of configNames) {
-            const configPath = join(currentDir, configName);
-            if (existsSync(configPath)) {
-                return configPath;
-            }
-        }
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir) {
-            break; // Reached filesystem root
-        }
-        currentDir = parentDir;
-    }
-    return null;
-}
-/**
- * Load and parse appwrite project configuration
- */
-export function loadAppwriteProjectConfig(configPath) {
-    let actualConfigPath = configPath;
-    if (!actualConfigPath) {
-        actualConfigPath = findAppwriteProjectConfig() || undefined;
-    }
-    if (!actualConfigPath || !existsSync(actualConfigPath)) {
-        return null;
-    }
-    try {
-        const configContent = readFileSync(actualConfigPath, "utf-8");
-        const config = JSON.parse(configContent);
-        // Validate required fields
-        if (!config.projectId) {
-            MessageFormatter.warning(`Appwrite project config missing required 'projectId' field: ${actualConfigPath}`, { prefix: "ProjectConfig" });
-            return null;
-        }
-        return config;
-    }
-    catch (error) {
-        MessageFormatter.error(`Failed to parse Appwrite project config: ${actualConfigPath}`, error instanceof Error ? error : new Error(String(error)), { prefix: "ProjectConfig" });
-        return null;
-    }
-}
-/**
- * Detect API mode from project configuration
- */
-export function detectApiModeFromProject(projectConfig) {
-    // If both are present, prefer TablesDB (newer)
-    if (projectConfig.tablesDB && projectConfig.tables) {
-        return "tablesdb";
-    }
-    // If only legacy structure is present
-    if (projectConfig.databases && projectConfig.collections) {
-        return "legacy";
-    }
-    // If only TablesDB structure is present
-    if (projectConfig.tablesDB && projectConfig.tables) {
-        return "tablesdb";
-    }
-    // Default to auto-detection
-    return "auto";
-}
-/**
- * Convert project config to AppwriteConfig format
- * @param projectConfig The project config to convert
- * @param configPath Optional path to the config file (for resolving relative paths)
- * @param existingConfig Optional existing config to merge with
- */
-export function projectConfigToAppwriteConfig(projectConfig, configPath, existingConfig) {
-    const apiMode = detectApiModeFromProject(projectConfig);
-    const configDir = configPath ? dirname(configPath) : process.cwd();
-    const baseConfig = {
-        ...existingConfig,
-        appwriteProject: projectConfig.projectId,
-        apiMode,
-    };
-    // Set endpoint if provided in project config
-    if (projectConfig.endpoint) {
-        baseConfig.appwriteEndpoint = projectConfig.endpoint;
-    }
-    // Merge databases and tablesDB arrays (modern Appwrite may have both)
-    const allDatabases = [
-        ...(projectConfig.databases || []),
-        ...(projectConfig.tablesDB || [])
-    ];
-    // Remove duplicates by $id
-    const uniqueDatabasesMap = new Map();
-    for (const db of allDatabases) {
-        if (!uniqueDatabasesMap.has(db.$id)) {
-            uniqueDatabasesMap.set(db.$id, db);
-        }
-    }
-    if (uniqueDatabasesMap.size > 0) {
-        baseConfig.databases = Array.from(uniqueDatabasesMap.values()).map(db => ({
-            $id: db.$id,
-            name: db.name,
-            // Add basic bucket configuration if not exists
-            bucket: {
-                $id: `${db.$id}_bucket`,
-                name: `${db.name} Bucket`,
-                enabled: true,
-                maximumFileSize: 30000000,
-                allowedFileExtensions: [],
-                encryption: true,
-                antivirus: true,
-            },
-        }));
-    }
-    // Convert buckets if present
-    if (projectConfig.buckets) {
-        baseConfig.buckets = projectConfig.buckets.map(bucket => ({
-            $id: (bucket.bucketId || bucket.$id || `bucket_${Date.now()}`),
-            name: bucket.name,
-            enabled: true,
-            maximumFileSize: bucket.maximumFileSize || 30000000,
-            allowedFileExtensions: bucket.allowedFileExtensions || [],
-            encryption: bucket.encryption ?? true,
-            antivirus: bucket.antiVirus ?? false,
-        }));
-    }
-    // Convert functions with path normalization
-    if (projectConfig.functions) {
-        baseConfig.functions = projectConfig.functions.map(func => {
-            const normalizedFunc = {
-                $id: func.$id,
-                name: func.name,
-                runtime: func.runtime,
-                entrypoint: func.entrypoint,
-                commands: func.commands,
-                events: func.events,
-            };
-            // Convert path to dirPath and make absolute
-            if (func.path) {
-                const expandedPath = func.path;
-                normalizedFunc.dirPath = isAbsolute(expandedPath)
-                    ? expandedPath
-                    : resolve(configDir, expandedPath);
-            }
-            return normalizedFunc;
-        });
-    }
-    return baseConfig;
-}
-/**
- * Get collection/table definitions from project config
- */
-export function getCollectionsFromProject(projectConfig) {
-    if (projectConfig.tables) {
-        // Convert TablesDB tables to collection format
-        return projectConfig.tables.map(table => ({
-            name: table.name,
-            $id: table.$id,
-            $permissions: table.$permissions || [],
-            documentSecurity: table.rowSecurity || false,
-            enabled: table.enabled !== false,
-            // Convert columns to attributes for compatibility
-            attributes: table.columns.map(col => ({
-                key: col.key,
-                type: col.type,
-                required: col.required,
-                array: col.array,
-                size: col.size,
-                default: col.default,
-                encrypt: col.encrypt,
-                unique: col.unique,
-            })),
-            indexes: table.indexes || [],
-            // Mark as coming from TablesDB for processing
-            _isFromTablesDir: true,
-        }));
-    }
-    if (projectConfig.collections) {
-        // Legacy collections format
-        return projectConfig.collections.map(collection => ({
-            name: collection.name,
-            $id: collection.$id,
-            $permissions: collection.$permissions || [],
-            documentSecurity: collection.documentSecurity || false,
-            enabled: collection.enabled !== false,
-            attributes: collection.attributes,
-            indexes: collection.indexes || [],
-            _isFromTablesDir: false,
-        }));
-    }
-    return [];
-}
-/**
- * Check if project config indicates TablesDB usage
- */
-export function isTablesDBProject(projectConfig) {
-    return !!(projectConfig.tablesDB && projectConfig.tables);
-}
-/**
- * Get the appropriate directory name based on project config
- */
-export function getProjectDirectoryName(projectConfig) {
-    return isTablesDBProject(projectConfig) ? "tables" : "collections";
-}

package/dist/utils/retryFailedPromises.d.ts

@@ -1,2 +0,0 @@
-import type { Models } from "node-appwrite";
-export declare const retryFailedPromises: (batch: Promise<Models.Document>[], maxRetries?: number) => Promise<PromiseSettledResult<Models.Document>[]>;

package/dist/utils/retryFailedPromises.js

@@ -1,23 +0,0 @@
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { logger } from "../shared/logging.js";
-export const retryFailedPromises = async (batch, maxRetries = 3) => {
-    const results = await Promise.allSettled(batch);
-    const toRetry = [];
-    results.forEach((result, index) => {
-        if (result.status === "rejected") {
-            logger.error("Promise rejected with reason:", { reason: result.reason });
-            if (maxRetries > 0) {
-                toRetry.push(batch[index]);
-            }
-        }
-    });
-    if (toRetry.length > 0) {
-        MessageFormatter.info(`Retrying ${toRetry.length} promises`, { prefix: "Retry" });
-        return retryFailedPromises(toRetry, maxRetries - 1);
-    }
-    else {
-        return results
-            .filter((result) => result.status === "fulfilled")
-            .map((result) => result);
-    }
-};

package/dist/utils/sessionAuth.d.ts

@@ -1,48 +0,0 @@
-export interface AppwriteSessionPrefs {
-    [projectId: string]: {
-        endpoint: string;
-        email: string;
-        cookie: string;
-    };
-}
-export interface SessionAuthInfo {
-    projectId: string;
-    endpoint: string;
-    sessionCookie: string;
-    email?: string;
-}
-/**
- * Load session preferences from ~/.appwrite/prefs.json
- */
-export declare function loadSessionPrefs(): AppwriteSessionPrefs | null;
-/**
- * Get session authentication info for a specific project
- */
-export declare function getSessionAuth(projectId: string): SessionAuthInfo | null;
-/**
- * Check if a session cookie appears to be valid (enhanced validation)
- */
-export declare function isValidSessionCookie(cookie: string): boolean;
-/**
- * Get all available sessions from prefs
- */
-export declare function getAvailableSessions(): SessionAuthInfo[];
-/**
- * Find session by endpoint and project combination
- */
-export declare function findSessionByEndpointAndProject(endpoint: string, projectId: string): SessionAuthInfo | null;
-/**
- * Check if session authentication is available for a project configuration
- */
-export declare function hasSessionAuth(endpoint: string, projectId: string): boolean;
-/**
- * Get detailed authentication status for debugging and error reporting
- */
-export declare function getAuthenticationStatus(endpoint: string, projectId: string): {
-    hasValidSession: boolean;
-    sessionExists: boolean;
-    endpointMatches: boolean;
-    cookieValid: boolean;
-    sessionInfo?: SessionAuthInfo;
-    message: string;
-};

package/dist/utils/sessionAuth.js

@@ -1,164 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-/**
- * Normalizes an endpoint URL by removing trailing slashes and converting to lowercase
- */
-function normalizeEndpoint(url) {
-    return url.replace(/\/+$/, "").toLowerCase();
-}
-/**
- * Load session preferences from ~/.appwrite/prefs.json
- */
-export function loadSessionPrefs() {
-    try {
-        const prefsPath = join(homedir(), ".appwrite", "prefs.json");
-        if (!existsSync(prefsPath)) {
-            return null;
-        }
-        const prefsContent = readFileSync(prefsPath, "utf-8");
-        const prefs = JSON.parse(prefsContent);
-        return prefs;
-    }
-    catch (error) {
-        MessageFormatter.warning("Failed to load Appwrite session preferences", { prefix: "Session" });
-        return null;
-    }
-}
-/**
- * Get session authentication info for a specific project
- */
-export function getSessionAuth(projectId) {
-    const prefs = loadSessionPrefs();
-    if (!prefs || !prefs[projectId]) {
-        return null;
-    }
-    const sessionData = prefs[projectId];
-    // Validate session data structure
-    if (!sessionData.endpoint || !sessionData.cookie) {
-        MessageFormatter.warning(`Invalid session data for project ${projectId}`, { prefix: "Session" });
-        return null;
-    }
-    return {
-        projectId,
-        endpoint: sessionData.endpoint,
-        sessionCookie: sessionData.cookie,
-        email: sessionData.email,
-    };
-}
-/**
- * Check if a session cookie appears to be valid (enhanced validation)
- */
-export function isValidSessionCookie(cookie) {
-    if (!cookie || typeof cookie !== "string") {
-        return false;
-    }
-    // Trim whitespace
-    cookie = cookie.trim();
-    // Basic length check
-    if (cookie.length < 10) {
-        return false;
-    }
-    // Basic validation - Appwrite session cookies are typically JWT-like
-    // They should contain dots and be reasonably long
-    if (!cookie.includes(".")) {
-        return false;
-    }
-    // Check for obviously expired or malformed tokens
-    // JWT tokens typically have 3 parts separated by dots
-    const parts = cookie.split('.');
-    if (parts.length < 2) {
-        return false;
-    }
-    // Additional validation - ensure it's not obviously corrupted
-    // Should contain alphanumeric characters and common JWT characters
-    const validChars = /^[A-Za-z0-9._-]+$/;
-    if (!validChars.test(cookie)) {
-        return false;
-    }
-    return true;
-}
-/**
- * Get all available sessions from prefs
- */
-export function getAvailableSessions() {
-    const prefs = loadSessionPrefs();
-    if (!prefs) {
-        return [];
-    }
-    const sessions = [];
-    for (const [projectId, sessionData] of Object.entries(prefs)) {
-        if (sessionData.endpoint && sessionData.cookie && isValidSessionCookie(sessionData.cookie)) {
-            sessions.push({
-                projectId,
-                endpoint: sessionData.endpoint,
-                sessionCookie: sessionData.cookie,
-                email: sessionData.email,
-            });
-        }
-    }
-    return sessions;
-}
-/**
- * Find session by endpoint and project combination
- */
-export function findSessionByEndpointAndProject(endpoint, projectId) {
-    const sessionAuth = getSessionAuth(projectId);
-    if (!sessionAuth) {
-        MessageFormatter.debug(`No session found for project ${projectId}`, { prefix: "Session" });
-        return null;
-    }
-    // Normalize endpoints for comparison (remove trailing slashes, etc.)
-    if (normalizeEndpoint(sessionAuth.endpoint) !== normalizeEndpoint(endpoint)) {
-        MessageFormatter.warning(`Session endpoint mismatch for project ${projectId}:\n` +
-            `  Session endpoint: ${sessionAuth.endpoint}\n` +
-            `  Config endpoint:  ${endpoint}\n` +
-            `  Tip: Run 'appwrite login' to update session for this endpoint`, { prefix: "Session" });
-        return null;
-    }
-    return sessionAuth;
-}
-/**
- * Check if session authentication is available for a project configuration
- */
-export function hasSessionAuth(endpoint, projectId) {
-    const sessionAuth = findSessionByEndpointAndProject(endpoint, projectId);
-    return sessionAuth !== null && isValidSessionCookie(sessionAuth.sessionCookie);
-}
-/**
- * Get detailed authentication status for debugging and error reporting
- */
-export function getAuthenticationStatus(endpoint, projectId) {
-    const sessionAuth = getSessionAuth(projectId);
-    if (!sessionAuth) {
-        return {
-            hasValidSession: false,
-            sessionExists: false,
-            endpointMatches: false,
-            cookieValid: false,
-            message: `No session found for project ${projectId}. Run 'appwrite login' to authenticate.`
-        };
-    }
-    const endpointMatches = normalizeEndpoint(sessionAuth.endpoint) === normalizeEndpoint(endpoint);
-    const cookieValid = isValidSessionCookie(sessionAuth.sessionCookie);
-    const hasValidSession = endpointMatches && cookieValid;
-    let message = "";
-    if (!endpointMatches) {
-        message = `Session endpoint mismatch. Expected: ${endpoint}, Found: ${sessionAuth.endpoint}`;
-    }
-    else if (!cookieValid) {
-        message = `Session cookie is invalid or expired for project ${projectId}`;
-    }
-    else {
-        message = `Valid session found for ${sessionAuth.email || 'unknown user'}`;
-    }
-    return {
-        hasValidSession,
-        sessionExists: true,
-        endpointMatches,
-        cookieValid,
-        sessionInfo: sessionAuth,
-        message
-    };
-}

package/dist/utils/setupFiles.d.ts

@@ -1,4 +0,0 @@
-export declare const customDefinitionsFile = "import type { ConverterFunctions, ValidationRules, AfterImportActions } from \"appwrite-utils\";\n\nexport const customConverterFunctions: ConverterFunctions = {\n  // Add your custom converter functions here\n}\nexport const customValidationRules: ValidationRules = {\n  // Add your custom validation rules here\n}\nexport const customAfterImportActions: AfterImportActions = {\n  // Add your custom after import actions here\n}";
-export declare const createEmptyCollection: (collectionName: string) => void;
-export declare const generateYamlConfig: (currentDir?: string, useAppwriteDir?: boolean) => string;
-export declare const setupDirsFiles: (example?: boolean, currentDir?: string, useYaml?: boolean) => Promise<void>;