appwrite-utils-cli 0.9.993 → 0.9.995

package/src/functions/templates/count-docs-in-collection/src/main.ts

@@ -0,0 +1,159 @@
+import { Client, Databases, Query } from "node-appwrite";
+import { AppwriteRequest, type AppwriteResponse } from "appwrite-utils";
+import { requestSchema } from "./request.js";
+
+/**
+ * Main function to handle document counting requests.
+ * @param {Object} params - The function parameters.
+ * @param {Object} params.req - The request object.
+ * @param {Object} params.res - The response object.
+ * @param {Function} params.log - Logging function.
+ * @param {Function} params.error - Error logging function.
+ * @returns {Promise<Object>} JSON response with count or error message.
+ */
+export default async ({
+  req,
+  res,
+  log,
+  error,
+}: {
+  req: AppwriteRequest;
+  res: AppwriteResponse;
+  log: (message: string) => void;
+  error: (message: string) => void;
+}) => {
+  // Initialize Appwrite client
+  const client = new Client()
+    .setEndpoint(process.env["APPWRITE_FUNCTION_ENDPOINT"]!)
+    .setProject(process.env["APPWRITE_FUNCTION_PROJECT_ID"]!)
+    .setKey(req.headers["x-appwrite-key"] || "");
+
+  const databases = new Databases(client);
+
+  try {
+    if (req.method === "POST") {
+      // Parse request body
+      const body = requestSchema.safeParse(
+        typeof req.body === "string" ? JSON.parse(req.body) : req.body
+      );
+
+      if (!body.success) {
+        return res.json({ success: false, error: body.error }, 400);
+      }
+
+      const { databaseId, collectionId, queries = [] } = body.data;
+
+      log(`Queries: ${JSON.stringify(queries)}`);
+
+      // Count documents in the specified collection
+      const count = await countAllDocuments(
+        log,
+        databases,
+        databaseId,
+        collectionId,
+        queries
+      );
+
+      // Return successful response with document count
+      return res.json({
+        success: true,
+        count: count,
+      });
+    } else {
+      // Return error for non-POST requests
+      return res.json({ success: false, error: "Method not allowed" }, 405);
+    }
+  } catch (err) {
+    // Log and return any errors
+    error(`Error processing request: ${err}`);
+    return res.json({ success: false, error: (err as Error).message }, 500);
+  }
+};
+
+/**
+ * Counts all documents in a collection, handling large collections efficiently.
+ * @param {Function} log - Logging function.
+ * @param {Databases} databases - Appwrite Databases instance.
+ * @param {string} databaseId - ID of the database.
+ * @param {string} collectionId - ID of the collection.
+ * @param {string[]} queries - Array of query strings to filter documents.
+ * @param {number} batchSize - Size of batches for processing (default: 1000).
+ * @returns {Promise<number>} Total count of documents.
+ */
+async function countAllDocuments(
+  log: any,
+  databases: Databases,
+  databaseId: string,
+  collectionId: string,
+  queries: string[] = [],
+  batchSize: number = 1000
+): Promise<number> {
+  // Filter out limit and offset queries
+  const initialQueries = queries.filter(
+    (q) => !(q.includes("limit") || q.includes("offset"))
+  );
+
+  // Initial query to check if total is less than 5000
+  const initialResponse = await databases.listDocuments(
+    databaseId,
+    collectionId,
+    [...initialQueries, Query.limit(1)]
+  );
+
+  if (initialResponse.total < 5000) {
+    log(`Total documents (from initial response): ${initialResponse.total}`);
+    return initialResponse.total;
+  }
+
+  // If total is 5000 or more, we need to count manually
+  let bound = 5000;
+
+  // Exponential search to find an upper bound
+  while (true) {
+    log(`Querying for offset ${bound}`);
+    try {
+      const response = await databases.listDocuments(databaseId, collectionId, [
+        ...initialQueries,
+        Query.limit(1),
+        Query.offset(bound),
+      ]);
+
+      if (response.documents.length === 0) {
+        break;
+      }
+      bound *= 2;
+    } catch (error) {
+      break;
+    }
+  }
+
+  // Binary search to find the exact count
+  let low = Math.floor(bound / 2);
+  let high = bound;
+  let lastValidCount = low;
+
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    log(`Binary search: Querying for offset ${mid}`);
+
+    try {
+      const response = await databases.listDocuments(databaseId, collectionId, [
+        ...initialQueries,
+        Query.limit(1),
+        Query.offset(mid),
+      ]);
+
+      if (response.documents.length > 0) {
+        lastValidCount = mid + 1; // +1 because offset is 0-based
+        low = mid + 1;
+      } else {
+        high = mid - 1;
+      }
+    } catch (error) {
+      high = mid - 1;
+    }
+  }
+
+  log(`Total documents: ${lastValidCount}`);
+  return lastValidCount;
+}

package/src/functions/templates/count-docs-in-collection/src/request.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+export const requestSchema = z.object({
+  databaseId: z.string(),
+  collectionId: z.string(),
+  queries: z.array(z.string()).optional(),
+});
+
+export type Request = z.infer<typeof requestSchema>;

package/src/functions/templates/poetry/README.md

@@ -0,0 +1,30 @@
+# Python Poetry Function Template
+
+This is a Python template for Appwrite Functions using Poetry for dependency management.
+
+## Structure
+- `src/index.py`: Main function entry point
+- `pyproject.toml`: Poetry configuration and dependencies
+
+## Usage
+Your function will receive a context object with:
+- `req`: Request object containing request data, headers, and environment variables
+- `res`: Response object for sending responses
+- `log`: Function for logging (shows in your function logs)
+- `error`: Function for error logging
+
+## Example Request
+```json
+{
+  "key": "value"
+}
+```
+
+## Development
+1. Install Poetry: `curl -sSL https://install.python-poetry.org | python3 -`
+2. Install dependencies: `poetry install`
+3. Deploy: Dependencies will be installed during deployment
+
+## Deployment
+Make sure it's inside `appwriteConfig.ts` functions array, and if you want to install dependencies FIRST, before Appwrite (using your system), you can
+add the `predeployCommands` to the function in `appwriteConfig.ts`.

package/src/functions/templates/poetry/pyproject.toml

@@ -0,0 +1,16 @@
+[tool.poetry]
+name = "{{functionName}}"
+version = "0.1.0"
+description = ""
+authors = ["Your Name <you@example.com>"]
+packages = [
+    { include = "src" }
+]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+appwrite = "^7.0.1"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

package/src/functions/templates/poetry/src/index.py

@@ -0,0 +1,16 @@
+from appwrite.client import Client
+
+def main(context):
+    req = context.req
+    res = context.res
+    log = context.log
+    error = context.error
+
+    client = Client()
+    client.set_endpoint(req.env['APPWRITE_FUNCTION_ENDPOINT'])
+    client.set_project(req.env['APPWRITE_FUNCTION_PROJECT_ID'])
+    client.set_key(req.env['APPWRITE_FUNCTION_API_KEY'])
+
+    return res.json({
+        'message': 'Hello from Python function!'
+    })

package/src/functions/templates/typescript-node/README.md

@@ -0,0 +1,32 @@
+# TypeScript Node.js Function Template
+
+This is a TypeScript template for Appwrite Functions using Node.js runtime.
+
+## Structure
+- `src/index.ts`: Main function entry point
+- `src/appwriteRequest.ts`: Type definitions for Appwrite request object
+- `src/appwriteResponse.ts`: Type definitions for Appwrite response object
+
+## Usage
+Your function will receive:
+- `req`: AppwriteRequest object containing request data, headers, and environment variables
+- `res`: AppwriteResponse object for sending responses
+- `log`: Function for logging (shows in your function logs)
+- `error`: Function for error logging
+
+## Example Request
+```json
+{
+  "databaseId": "your-database-id",
+  "collectionId": "your-collection-id"
+}
+```
+
+## Development
+1. Install dependencies: `npm|yarn|bun install`
+2. Build: `npm|yarn|bun run build`
+3. Deploy: Function will be built automatically during deployment
+
+## Deployment
+Make sure it's inside `appwriteConfig.ts` functions array, and if you want to build it FIRST, before Appwrite (using your system), you can
+add the `predeployCommands` to the function in `appwriteConfig.ts` -- for an example, see `count-docs-in-collection` function.

package/src/functions/templates/typescript-node/src/index.ts

@@ -0,0 +1,23 @@
+import { Client } from "node-appwrite";
+import { AppwriteRequest, type AppwriteResponse } from "appwrite-utils";
+
+export default async function ({
+  req,
+  res,
+  log,
+  error,
+}: {
+  req: AppwriteRequest;
+  res: AppwriteResponse;
+  log: (message: string) => void;
+  error: (message: string) => void;
+}) {
+  const client = new Client()
+    .setEndpoint(process.env["APPWRITE_FUNCTION_ENDPOINT"]!)
+    .setProject(process.env["APPWRITE_FUNCTION_PROJECT_ID"]!)
+    .setKey(req.headers["x-appwrite-key"] || "");
+
+  return res.json({
+    message: "Hello from TypeScript function!",
+  });
+}