appwrite-utils-cli 1.9.7 → 1.12.0

package/dist/functions/deployments.js

@@ -10,9 +10,9 @@ import cliProgress from "cli-progress";
 import { execSync } from "child_process";
 import { createFunction, getFunction, updateFunction, updateFunctionSpecifications, } from "./methods.js";
 import ignore from "ignore";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { resolveFunctionDirectory, validateFunctionDirectory } from './pathResolution.js';
-export const deployFunction = async (client, functionId, codePath, activate = true, entrypoint = "index.js", commands = "npm install", ignored = [
+import { MessageFormatter } from "appwrite-utils-helpers";
+import { resolveFunctionDirectory, validateFunctionDirectory } from 'appwrite-utils-helpers';
+export const deployFunction = async (client, functionId, codePath, activate = true, entrypoint = "main.js", commands = "npm install", ignored = [
     "node_modules",
     ".git",
     ".vscode",
@@ -98,7 +98,7 @@ export const deployFunction = async (client, functionId, codePath, activate = tr
         throw error;
     }
 };
-export const deployLocalFunction = async (client, functionName, functionConfig, functionPath) => {
+export const deployLocalFunction = async (client, functionName, functionConfig, functionPath, configDirPath) => {
     let functionExists = true;
     let functionThatExists;
     try {
@@ -107,8 +107,8 @@ export const deployLocalFunction = async (client, functionName, functionConfig,
     catch (error) {
         functionExists = false;
     }
-    const configDirPath = process.cwd(); // TODO: This should be passed from caller
-    const resolvedPath = resolveFunctionDirectory(functionName, configDirPath, functionConfig.dirPath, functionPath);
+    const resolvedConfigDir = configDirPath ?? process.cwd();
+    const resolvedPath = resolveFunctionDirectory(functionName, resolvedConfigDir, functionConfig.dirPath, functionPath);
     if (!validateFunctionDirectory(resolvedPath)) {
         throw new Error(`Function directory is invalid or missing required files: ${resolvedPath}`);
     }

package/dist/functions/fnConfigDiscovery.js

@@ -3,8 +3,8 @@ import path from 'node:path';
 import yaml from 'js-yaml';
 import { homedir } from 'node:os';
 import { AppwriteFunctionSchema } from 'appwrite-utils';
-import { shouldIgnoreDirectory } from '../utils/directoryUtils.js';
-import { MessageFormatter } from '../shared/messageFormatter.js';
+import { shouldIgnoreDirectory } from 'appwrite-utils-helpers';
+import { MessageFormatter } from 'appwrite-utils-helpers';
 function findGitRoot(startDir) {
     let dir = path.resolve(startDir);
     while (dir !== path.parse(dir).root) {

package/dist/functions/methods.js

@@ -5,8 +5,8 @@ import fs from "node:fs";
 import { EventTypeSchema, } from "appwrite-utils";
 import chalk from "chalk";
 import { extract as extractTar } from "tar";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { expandTildePath, normalizeFunctionName } from "./pathResolution.js";
+import { MessageFormatter } from "appwrite-utils-helpers";
+import { expandTildePath, normalizeFunctionName } from 'appwrite-utils-helpers';
 /**
  * Validates and filters events array for Appwrite functions
  * - Filters out empty/invalid strings

package/dist/functions/templates/count-docs-in-collection/README.md

@@ -1,54 +1,54 @@
-# Count Documents in Collection Function
-
-A utility function that accurately counts documents in an Appwrite collection, even when there are more than 5,000 documents.
-
-## Features
-- Handles collections with any number of documents
-- Supports filtering using Appwrite queries
-- Uses efficient binary search algorithm for large collections
-- Provides detailed logging during the counting process
-
-## Structure
-- `src/main.ts`: Main function implementation with counting logic
-- `src/request.ts`: Request validation schema using Zod
-
-## Usage
-Send a POST request with:
-```json
-{
-  "databaseId": "your-database-id",
-  "collectionId": "your-collection-id",
-  "queries": [Query.orderDesc("$createdAt"), Query.contains("name", "John")] // Or put the string array from after this, they are the same
-}
-```
-
-## Response
-```json
-{
-  "success": true,
-  "count": 12345
-}
-```
-
-## 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`.
-
-## Example Config
-```typescript
-{
-  $id: 'count-docs',
-  name: 'Count Documents',
-  runtime: 'node-18.0',
-  path: 'functions/count-docs',
-  entrypoint: './main.js',
-  execute: ['any'],
-  predeployCommands: ['npm install', 'npm run build'],
-  deployDir: './dist'
-}
+# Count Documents in Collection Function
+
+A utility function that accurately counts documents in an Appwrite collection, even when there are more than 5,000 documents.
+
+## Features
+- Handles collections with any number of documents
+- Supports filtering using Appwrite queries
+- Uses efficient binary search algorithm for large collections
+- Provides detailed logging during the counting process
+
+## Structure
+- `src/main.ts`: Main function implementation with counting logic
+- `src/request.ts`: Request validation schema using Zod
+
+## Usage
+Send a POST request with:
+```json
+{
+  "databaseId": "your-database-id",
+  "collectionId": "your-collection-id",
+  "queries": [Query.orderDesc("$createdAt"), Query.contains("name", "John")] // Or put the string array from after this, they are the same
+}
+```
+
+## Response
+```json
+{
+  "success": true,
+  "count": 12345
+}
+```
+
+## 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`.
+
+## Example Config
+```typescript
+{
+  $id: 'count-docs',
+  name: 'Count Documents',
+  runtime: 'node-18.0',
+  path: 'functions/count-docs',
+  entrypoint: './main.js',
+  execute: ['any'],
+  predeployCommands: ['npm install', 'npm run build'],
+  deployDir: './dist'
+}
 ```

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

@@ -1,159 +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;
-}
+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/dist/functions/templates/count-docs-in-collection/src/request.ts

@@ -1,9 +1,9 @@
-import { z } from "zod";
-
-export const requestSchema = z.object({
-  databaseId: z.string(),
-  collectionId: z.string(),
-  queries: z.array(z.string()).optional(),
-});
-
+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>;