appwrite-utils-cli 1.7.8 → 1.8.1

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/interactiveCLI.js

@@ -2,7 +2,7 @@ import inquirer from "inquirer";
 import { UtilsController } from "./utilsController.js";
 import { fetchAllCollections } from "./collections/methods.js";
 import { listBuckets, createBucket } from "./storage/methods.js";
-import { Databases, Storage, Client, Compression, Query, Functions, } from "node-appwrite";
+import { Databases, Storage, Client, Compression, Query, Functions, DatabaseType, } from "node-appwrite";
 import { PermissionToAppwritePermission, RuntimeSchema, permissionSchema, } from "appwrite-utils";
 import { ulid } from "ulidx";
 import chalk from "chalk";
@@ -192,10 +192,10 @@ export class InteractiveCLI {
         const configDatabases = this.getLocalDatabases();
         const allDatabases = [...databases, ...configDatabases]
             .reduce((acc, db) => {
-            // Local config takes precedence - if a database with same name exists, use local version
-            const existingIndex = acc.findIndex((d) => d.name === db.name);
+            // Local config takes precedence - if a database with same name or ID exists, use local version
+            const existingIndex = acc.findIndex((d) => d.name === db.name || d.$id === db.$id);
             if (existingIndex >= 0) {
-                if (configDatabases.some((cdb) => cdb.name === db.name)) {
+                if (configDatabases.some((cdb) => cdb.name === db.name || cdb.$id === db.$id)) {
                     acc[existingIndex] = db; // Replace with local version
                 }
             }
@@ -204,14 +204,14 @@ export class InteractiveCLI {
             }
             return acc;
         }, []);
-        const hasLocalAndRemote = allDatabases.some((db) => configDatabases.some((c) => c.name === db.name)) &&
-            allDatabases.some((db) => !configDatabases.some((c) => c.name === db.name));
+        const hasLocalAndRemote = allDatabases.some((db) => configDatabases.some((c) => c.name === db.name || c.$id === db.$id)) &&
+            allDatabases.some((db) => !configDatabases.some((c) => c.name === db.name || c.$id === db.$id));
         const choices = allDatabases
             .sort((a, b) => a.name.localeCompare(b.name))
             .map((db) => ({
             name: db.name +
                 (hasLocalAndRemote
-                    ? configDatabases.some((c) => c.name === db.name)
+                    ? configDatabases.some((c) => c.name === db.name || c.$id === db.$id)
                         ? " (Local)"
                         : " (Remote)"
                     : ""),
@@ -245,20 +245,20 @@ export class InteractiveCLI {
         }
         let allCollections = preferLocal
             ? remoteCollections.reduce((acc, remoteCollection) => {
-                if (!acc.some((c) => c.name === remoteCollection.name)) {
+                if (!acc.some((c) => c.name === remoteCollection.name || c.$id === remoteCollection.$id)) {
                     acc.push(remoteCollection);
                 }
                 return acc;
             }, [...configCollections])
             : [
                 ...remoteCollections,
-                ...configCollections.filter((c) => !remoteCollections.some((rc) => rc.name === c.name)),
+                ...configCollections.filter((c) => !remoteCollections.some((rc) => rc.name === c.name || rc.$id === c.$id)),
             ];
         if (shouldFilterByDatabase) {
             // Show collections that EITHER exist in the remote database OR have matching local databaseId metadata
             allCollections = allCollections.filter((c) => {
                 // Include if it exists remotely in this database
-                const existsInRemoteDb = remoteCollections.some((rc) => rc.name === c.name);
+                const existsInRemoteDb = remoteCollections.some((rc) => rc.name === c.name || rc.$id === c.$id);
                 // Include if local metadata claims it belongs to this database
                 const hasMatchingLocalMetadata = c.databaseId === database.$id;
                 return existsInRemoteDb || hasMatchingLocalMetadata;
@@ -266,8 +266,8 @@ export class InteractiveCLI {
         }
         // Filter out system tables (those starting with underscore)
         allCollections = allCollections.filter((collection) => !collection.$id.startsWith('_'));
-        const hasLocalAndRemote = allCollections.some((coll) => configCollections.some((c) => c.name === coll.name)) &&
-            allCollections.some((coll) => !configCollections.some((c) => c.name === coll.name));
+        const hasLocalAndRemote = allCollections.some((coll) => configCollections.some((c) => c.name === coll.name || c.$id === coll.$id)) &&
+            allCollections.some((coll) => !configCollections.some((c) => c.name === coll.name || c.$id === coll.$id));
         // Enhanced choice display with type indicators
         const choices = allCollections
             .sort((a, b) => {
@@ -280,7 +280,7 @@ export class InteractiveCLI {
             return a.name.localeCompare(b.name);
         })
             .map((collection) => {
-            const localCollection = configCollections.find((c) => c.name === collection.name);
+            const localCollection = configCollections.find((c) => c.name === collection.name || c.$id === collection.$id);
             const isLocal = !!localCollection;
             const isTable = localCollection?._isFromTablesDir || collection._isFromTablesDir || false;
             const sourceFolder = localCollection?._sourceFolder || collection._sourceFolder || 'collections';
@@ -350,6 +350,8 @@ export class InteractiveCLI {
         else if (tablesCount > 0) {
             MessageFormatter.info(`📊 ${tablesCount} tables available from tables/ folder`, { prefix: "Collections" });
         }
+        // Show current database context clearly before view mode selection
+        MessageFormatter.info(`DB: ${database.name}`, { prefix: "Collections" });
         // Ask user if they want to filter by database or show all
         const { filterChoice } = await inquirer.prompt([
             {
@@ -499,7 +501,7 @@ export class InteractiveCLI {
         // Combine functions, preferring local ones
         const allFunctions = [
             ...localFunctions,
-            ...remoteFunctions.functions.filter((rf) => !localFunctions.some((lf) => lf.name === rf.name)),
+            ...remoteFunctions.functions.filter((rf) => !localFunctions.some((lf) => lf.name === rf.name || lf.$id === rf.$id)),
         ];
         const { selectedFunctions } = await inquirer.prompt([
             {
@@ -507,7 +509,7 @@ export class InteractiveCLI {
                 name: "selectedFunctions",
                 message,
                 choices: allFunctions.map((f) => ({
-                    name: `${f.name} (${f.$id})${localFunctions.some((lf) => lf.name === f.name)
+                    name: `${f.name} (${f.$id})${localFunctions.some((lf) => lf.name === f.name || lf.$id === f.$id)
                         ? " (Local)"
                         : " (Remote)"}`,
                     value: f,
@@ -773,6 +775,7 @@ export class InteractiveCLI {
             $updatedAt: DateTime.now().toISO(),
             name: db.name,
             enabled: true,
+            type: "tablesdb",
         }));
     }
     /**