appwrite-utils-cli 1.7.7 → 1.7.9

package/dist/functions/templates/uv/src/context.py

@@ -0,0 +1,125 @@
+from collections.abc import Callable
+from typing import Any, Literal, Protocol
+
+from pydantic import BaseModel, Field
+
+
+class AppwriteHeaders(BaseModel):
+    """Appwrite request headers"""
+
+    x_appwrite_trigger: Literal["http", "schedule", "event"] | None = Field(
+        None, alias="x-appwrite-trigger"
+    )
+    x_appwrite_event: str | None = Field(None, alias="x-appwrite-event")
+    x_appwrite_key: str | None = Field(None, alias="x-appwrite-key")
+    x_appwrite_user_id: str | None = Field(None, alias="x-appwrite-user-id")
+    x_appwrite_user_jwt: str | None = Field(None, alias="x-appwrite-user-jwt")
+    x_appwrite_country_code: str | None = Field(None, alias="x-appwrite-country-code")
+    x_appwrite_continent_code: str | None = Field(
+        None, alias="x-appwrite-continent-code"
+    )
+    x_appwrite_continent_eu: str | None = Field(None, alias="x-appwrite-continent-eu")
+
+    # Allow additional headers
+    model_config = {"extra": "allow", "populate_by_name": True}
+
+
+class AppwriteEnv(BaseModel):
+    """Appwrite environment variables"""
+
+    APPWRITE_FUNCTION_API_ENDPOINT: str
+    APPWRITE_VERSION: str
+    APPWRITE_REGION: str
+    APPWRITE_FUNCTION_API_KEY: str | None = None
+    APPWRITE_FUNCTION_ID: str
+    APPWRITE_FUNCTION_NAME: str
+    APPWRITE_FUNCTION_DEPLOYMENT: str
+    APPWRITE_FUNCTION_PROJECT_ID: str
+    APPWRITE_FUNCTION_RUNTIME_NAME: str
+    APPWRITE_FUNCTION_RUNTIME_VERSION: str
+
+
+class AppwriteRequest(Protocol):
+    """Appwrite function request object with proper callable typing"""
+
+    bodyText: str | None
+    bodyJson: dict[str, Any] | str | None
+    body: Any
+    headers: dict[str, str]
+    scheme: Literal["http", "https"] | None
+    method: Literal["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]
+    url: str | None
+    host: str | None
+    port: int | str | None
+    path: str | None
+    queryString: str | None
+    query: dict[str, str | list[str]] | None
+    variables: dict[str, str] | None
+    payload: str | None
+
+    async def text(self) -> str: ...
+
+
+class AppwriteResponse(Protocol):
+    """Appwrite function response object with proper callable typing"""
+
+    def json(
+        self,
+        data: Any,
+        status: int | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> None: ...
+
+    def text(
+        self,
+        body: str,
+        status: int | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> None: ...
+
+    def empty(self) -> None: ...
+
+    def binary(self, data: bytes) -> None: ...
+
+    def redirect(self, url: str, status: int | None = None) -> None: ...
+
+
+class AppwriteContext(Protocol):
+    """Complete Appwrite function context with proper typing"""
+
+    req: AppwriteRequest
+    res: AppwriteResponse
+
+    def log(self, message: str) -> None: ...
+
+    def error(self, message: str) -> None: ...
+
+
+# Alternative: BaseModel version for cases where you need Pydantic features
+# but want proper typing hints
+
+
+class AppwriteRequestModel(BaseModel):
+    """Pydantic model for request validation (if needed)"""
+
+    bodyText: str | None = None
+    bodyJson: dict[str, Any] | str | None = None
+    body: Any = None
+    headers: dict[str, str] = Field(default_factory=dict)
+    scheme: Literal["http", "https"] | None = None
+    method: Literal["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]
+    url: str | None = None
+    host: str | None = None
+    port: int | str | None = None
+    path: str | None = None
+    queryString: str | None = None
+    query: dict[str, str | list[str]] | None = None
+    variables: dict[str, str] | None = None
+    payload: str | None = None
+
+    model_config = {"arbitrary_types_allowed": True}
+
+
+# Type alias for the log/error functions
+LogFunction = Callable[[str], None]
+ErrorFunction = Callable[[str], None]

package/dist/functions/templates/uv/src/index.py

@@ -0,0 +1,46 @@
+import os
+from appwrite.client import Client
+from context import AppwriteContext, AppwriteHeaders, AppwriteRequestModel
+
+def main(context: AppwriteContext):
+    req = context.req
+    res = context.res
+    log = context.log
+    error = context.error
+
+    # Optional: Validate request headers using Pydantic
+    try:
+        headers = AppwriteHeaders.model_validate(req.headers)
+        log("Headers validation successful")
+    except Exception as validation_error:
+        error(f"Headers validation failed: {validation_error}")
+
+    # Optional: Validate full request using Pydantic model
+    try:
+        request_model = AppwriteRequestModel.model_validate({
+            'method': req.method,
+            'headers': req.headers,
+            'path': req.path,
+            'url': req.url,
+            'body': req.body,
+            'bodyText': req.bodyText,
+            'bodyJson': req.bodyJson
+        })
+        log("Request validation successful")
+    except Exception as validation_error:
+        error(f"Request validation failed: {validation_error}")
+
+    client = Client()
+    client.set_endpoint(os.getenv('APPWRITE_FUNCTION_ENDPOINT'))
+    client.set_project(os.getenv('APPWRITE_FUNCTION_PROJECT_ID'))
+    client.set_key(os.getenv('APPWRITE_FUNCTION_API_KEY'))
+
+    log(f"Processing {req.method} request to {req.path}")
+
+    return res.json({
+        'message': 'Hello from Python function!',
+        'functionName': '{{functionName}}',
+        'method': req.method,
+        'path': req.path,
+        'headers': req.headers
+    })

package/dist/main.js

@@ -13,6 +13,8 @@ import chalk from "chalk";
 import { listSpecifications } from "./functions/methods.js";
 import { MessageFormatter } from "./shared/messageFormatter.js";
 import { ConfirmationDialogs } from "./shared/confirmationDialogs.js";
+import { SelectionDialogs } from "./shared/selectionDialogs.js";
+import { logger } from "./shared/logging.js";
 import path from "path";
 import fs from "fs";
 import { createRequire } from "node:module";
@@ -23,6 +25,153 @@ const require = createRequire(import.meta.url);
 if (!globalThis.require) {
     globalThis.require = require;
 }
+/**
+ * Enhanced sync function with intelligent configuration detection and selection dialogs
+ */
+async function performEnhancedSync(controller, parsedArgv) {
+    try {
+        MessageFormatter.banner("Enhanced Sync", "Intelligent configuration detection and selection");
+        if (!controller.config) {
+            MessageFormatter.error("No Appwrite configuration found", undefined, { prefix: "Sync" });
+            return null;
+        }
+        // Get all available databases from remote
+        const availableDatabases = await fetchAllDatabases(controller.database);
+        if (availableDatabases.length === 0) {
+            MessageFormatter.warning("No databases found in remote project", { prefix: "Sync" });
+            return null;
+        }
+        // Get existing configuration
+        const configuredDatabases = controller.config.databases || [];
+        const configuredBuckets = controller.config.buckets || [];
+        // Check if we have existing configuration
+        const hasExistingConfig = configuredDatabases.length > 0 || configuredBuckets.length > 0;
+        let syncExisting = false;
+        let modifyConfiguration = true;
+        if (hasExistingConfig) {
+            // Prompt about existing configuration
+            const response = await SelectionDialogs.promptForExistingConfig([
+                ...configuredDatabases,
+                ...configuredBuckets
+            ]);
+            syncExisting = response.syncExisting;
+            modifyConfiguration = response.modifyConfiguration;
+            if (syncExisting && !modifyConfiguration) {
+                // Just sync existing configuration without changes
+                MessageFormatter.info("Syncing existing configuration without modifications", { prefix: "Sync" });
+                // Convert configured databases to DatabaseSelection format
+                const databaseSelections = configuredDatabases.map(db => ({
+                    databaseId: db.$id,
+                    databaseName: db.name,
+                    tableIds: [], // Tables will be populated from collections config
+                    tableNames: [],
+                    isNew: false
+                }));
+                // Convert configured buckets to BucketSelection format
+                const bucketSelections = configuredBuckets.map(bucket => ({
+                    bucketId: bucket.$id,
+                    bucketName: bucket.name,
+                    databaseId: undefined,
+                    databaseName: undefined,
+                    isNew: false
+                }));
+                const selectionSummary = SelectionDialogs.createSyncSelectionSummary(databaseSelections, bucketSelections);
+                const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary, 'pull');
+                if (!confirmed) {
+                    MessageFormatter.info("Pull operation cancelled by user", { prefix: "Sync" });
+                    return null;
+                }
+                // Perform sync with existing configuration (pull from remote)
+                await controller.selectivePull(databaseSelections, bucketSelections);
+                return selectionSummary;
+            }
+        }
+        if (!modifyConfiguration) {
+            MessageFormatter.info("No configuration changes requested", { prefix: "Sync" });
+            return null;
+        }
+        // Allow new items selection based on user choice
+        const allowNewOnly = !syncExisting;
+        // Select databases
+        const selectedDatabaseIds = await SelectionDialogs.selectDatabases(availableDatabases, configuredDatabases, {
+            showSelectAll: true,
+            allowNewOnly,
+            defaultSelected: syncExisting ? configuredDatabases.map(db => db.$id) : []
+        });
+        if (selectedDatabaseIds.length === 0) {
+            MessageFormatter.warning("No databases selected for sync", { prefix: "Sync" });
+            return null;
+        }
+        // For each selected database, get available tables and select them
+        const tableSelectionsMap = new Map();
+        const availableTablesMap = new Map();
+        for (const databaseId of selectedDatabaseIds) {
+            const database = availableDatabases.find(db => db.$id === databaseId);
+            SelectionDialogs.showProgress(`Fetching tables for database: ${database.name}`);
+            // Get available tables from remote
+            const availableTables = await fetchAllCollections(databaseId, controller.database);
+            availableTablesMap.set(databaseId, availableTables);
+            // Get configured tables for this database
+            // Note: Collections are stored globally in the config, not per database
+            const configuredTables = controller.config.collections || [];
+            // Select tables for this database
+            const selectedTableIds = await SelectionDialogs.selectTablesForDatabase(databaseId, database.name, availableTables, configuredTables, {
+                showSelectAll: true,
+                allowNewOnly,
+                defaultSelected: syncExisting ? configuredTables.map((t) => t.$id) : []
+            });
+            tableSelectionsMap.set(databaseId, selectedTableIds);
+            if (selectedTableIds.length === 0) {
+                MessageFormatter.warning(`No tables selected for database: ${database.name}`, { prefix: "Sync" });
+            }
+        }
+        // Select buckets
+        let selectedBucketIds = [];
+        // Get available buckets from remote
+        if (controller.storage) {
+            try {
+                // Note: We need to implement fetchAllBuckets or use storage.listBuckets
+                // For now, we'll use configured buckets as available
+                SelectionDialogs.showProgress("Fetching storage buckets...");
+                // Create a mock availableBuckets array - in real implementation,
+                // you'd fetch this from the Appwrite API
+                const availableBuckets = configuredBuckets; // Placeholder
+                selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(selectedDatabaseIds, availableBuckets, configuredBuckets, {
+                    showSelectAll: true,
+                    allowNewOnly: parsedArgv.selectBuckets ? false : allowNewOnly,
+                    groupByDatabase: true,
+                    defaultSelected: syncExisting ? configuredBuckets.map(b => b.$id) : []
+                });
+            }
+            catch (error) {
+                MessageFormatter.warning("Could not fetch storage buckets", { prefix: "Sync" });
+                logger.warn("Failed to fetch buckets during sync", { error });
+            }
+        }
+        // Create selection objects
+        const databaseSelections = SelectionDialogs.createDatabaseSelection(selectedDatabaseIds, availableDatabases, tableSelectionsMap, configuredDatabases, availableTablesMap);
+        const bucketSelections = SelectionDialogs.createBucketSelection(selectedBucketIds, [], // availableBuckets - would be populated from API
+        configuredBuckets, availableDatabases);
+        // Show final confirmation
+        const selectionSummary = SelectionDialogs.createSyncSelectionSummary(databaseSelections, bucketSelections);
+        const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary, 'pull');
+        if (!confirmed) {
+            MessageFormatter.info("Pull operation cancelled by user", { prefix: "Sync" });
+            return null;
+        }
+        // Perform the selective sync (pull from remote)
+        await controller.selectivePull(databaseSelections, bucketSelections);
+        MessageFormatter.success("Enhanced sync completed successfully", { prefix: "Sync" });
+        return selectionSummary;
+    }
+    catch (error) {
+        SelectionDialogs.showError("Enhanced sync failed", error instanceof Error ? error : new Error(String(error)));
+        return null;
+    }
+}
+/**
+ * Performs selective sync with the given database and bucket selections
+ */
 /**
  * Checks if the migration from collections to tables should be allowed
  * Returns an object with:
@@ -143,6 +292,15 @@ const argv = yargs(hideBin(process.argv))
     .option("sync", {
     type: "boolean",
     description: "Pull and synchronize your local config with the remote Appwrite project schema",
+})
+    .option("autoSync", {
+    alias: ["auto"],
+    type: "boolean",
+    description: "Skip prompts and sync all databases, tables, and buckets (current behavior)"
+})
+    .option("selectBuckets", {
+    type: "boolean",
+    description: "Force bucket selection dialog even if buckets are already configured"
 })
     .option("endpoint", {
     type: "string",
@@ -711,10 +869,23 @@ async function main() {
             operationStats.pushedCollections = controller.config?.collections?.length || 0;
         }
         else if (parsedArgv.sync) {
-            // SYNC: Pull from remote
-            const databases = options.databases || (await fetchAllDatabases(controller.database));
-            await controller.synchronizeConfigurations(databases);
-            operationStats.syncedDatabases = databases.length;
+            // Enhanced SYNC: Pull from remote with intelligent configuration detection
+            if (parsedArgv.autoSync) {
+                // Legacy behavior: sync everything without prompts
+                MessageFormatter.info("Using auto-sync mode (legacy behavior)", { prefix: "Sync" });
+                const databases = options.databases || (await fetchAllDatabases(controller.database));
+                await controller.synchronizeConfigurations(databases);
+                operationStats.syncedDatabases = databases.length;
+            }
+            else {
+                // Enhanced sync flow with selection dialogs
+                const syncResult = await performEnhancedSync(controller, parsedArgv);
+                if (syncResult) {
+                    operationStats.syncedDatabases = syncResult.databases.length;
+                    operationStats.syncedCollections = syncResult.totalTables;
+                    operationStats.syncedBuckets = syncResult.buckets.length;
+                }
+            }
         }
         if (options.generateSchemas) {
             await controller.generateSchemas();

package/dist/migrations/appwriteToX.d.ts

@@ -1,5 +1,7 @@
 import { Storage, type Models } from "node-appwrite";
 import { type AppwriteConfig } from "appwrite-utils";
+import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseSelection, BucketSelection } from "../shared/selectionDialogs.js";
 export declare class AppwriteToX {
     config: AppwriteConfig;
     storage: Storage;
@@ -102,7 +104,14 @@ export declare class AppwriteToX {
         } | undefined;
     })[]>;
     appwriteFolderPath: string;
+    adapter?: DatabaseAdapter;
+    apiMode?: 'legacy' | 'tablesdb';
+    databaseApiModes: Map<string, "legacy" | "tablesdb">;
     constructor(config: AppwriteConfig, appwriteFolderPath: string, storage: Storage);
+    /**
+     * Initialize adapter for database operations with API mode detection
+     */
+    private initializeAdapter;
     private ensureClientInitialized;
     parsePermissionString: (permissionString: string) => {
         permission: string;
@@ -116,6 +125,22 @@ export declare class AppwriteToX {
         target: string;
     })[];
     updateCollectionConfigAttributes: (collection: Models.Collection) => void;
-    appwriteSync(config: AppwriteConfig, databases?: Models.Database[]): Promise<void>;
-    toSchemas(databases?: Models.Database[]): Promise<void>;
+    /**
+     * Fetch collections/tables using the appropriate adapter or legacy client
+     */
+    private fetchCollectionsOrTables;
+    /**
+     * Get collection/table using the appropriate adapter or legacy client
+     */
+    private getCollectionOrTable;
+    /**
+     * Detect API mode for a specific database by testing adapter capabilities
+     */
+    private detectDatabaseApiMode;
+    /**
+     * Get API mode context for schema generation
+     */
+    private getSchemaGeneratorApiContext;
+    appwriteSync(config: AppwriteConfig, databases?: Models.Database[], databaseSelections?: DatabaseSelection[], bucketSelections?: BucketSelection[]): Promise<void>;
+    toSchemas(databases?: Models.Database[], databaseSelections?: DatabaseSelection[], bucketSelections?: BucketSelection[]): Promise<void>;
 }