appwrite-utils-cli 0.9.993 → 0.9.994

package/src/functions/methods.ts

@@ -1,235 +1,295 @@
-import {
-  AppwriteException,
-  Client,
-  Functions,
-  Query,
-  Runtime,
-  type Models,
-} from "node-appwrite";
-import { InputFile } from "node-appwrite/file";
-import { create as createTarball } from "tar";
-import { join } from "node:path";
-import fs from "node:fs";
-import { type Specification } from "appwrite-utils";
-import chalk from "chalk";
-
-export const listFunctions = async (
-  client: Client,
-  queries?: string[],
-  search?: string
-) => {
-  const functions = new Functions(client);
-  const functionsList = await functions.list(queries, search);
-  return functionsList;
-};
-
-export const getFunction = async (client: Client, functionId: string) => {
-  const functions = new Functions(client);
-  const functionResponse = await functions.get(functionId);
-  return functionResponse;
-};
-
-export const deleteFunction = async (client: Client, functionId: string) => {
-  const functions = new Functions(client);
-  const functionResponse = await functions.delete(functionId);
-  return functionResponse;
-};
-
-export const createFunction = async (
-  client: Client,
-  functionId: string,
-  name: string,
-  runtime: Runtime,
-  execute?: string[],
-  events?: string[],
-  schedule?: string,
-  timeout?: number,
-  enabled?: boolean,
-  logging?: boolean,
-  entrypoint?: string,
-  commands?: string,
-  scopes?: string[],
-  installationId?: string,
-  providerRepositoryId?: string,
-  providerBranch?: string,
-  providerSilentMode?: boolean,
-  providerRootDirectory?: string,
-  templateRepository?: string,
-  templateOwner?: string,
-  templateRootDirectory?: string,
-  templateVersion?: string,
-  specification?: string
-) => {
-  const functions = new Functions(client);
-  const functionResponse = await functions.create(
-    functionId,
-    name,
-    runtime,
-    execute,
-    events,
-    schedule,
-    timeout,
-    enabled,
-    logging,
-    entrypoint,
-    commands,
-    scopes,
-    installationId,
-    providerRepositoryId,
-    providerBranch,
-    providerSilentMode,
-    providerRootDirectory,
-    templateRepository,
-    templateOwner,
-    templateRootDirectory,
-    templateVersion,
-    specification
-  );
-  return functionResponse;
-};
-
-export const updateFunctionSpecifications = async (
-  client: Client,
-  functionId: string,
-  specification: Specification
-) => {
-  const curFunction = await listFunctions(client, [
-    Query.equal("$id", functionId),
-  ]);
-  if (curFunction.functions.length === 0) {
-    throw new Error("Function not found");
-  }
-  const functionFound = curFunction.functions[0];
-  try {
-    const functionResponse = await updateFunction(
-      client,
-      functionId,
-      functionFound.name,
-      functionFound.runtime as Runtime,
-      functionFound.execute,
-      functionFound.events,
-      functionFound.schedule,
-      functionFound.timeout,
-      functionFound.enabled,
-      functionFound.logging,
-      functionFound.entrypoint,
-      functionFound.commands,
-      functionFound.scopes,
-      functionFound.installationId,
-      functionFound.providerRepositoryId,
-      functionFound.providerBranch,
-      functionFound.providerSilentMode,
-      functionFound.providerRootDirectory,
-      specification
-    );
-    return functionResponse;
-  } catch (error) {
-    if (
-      error instanceof AppwriteException &&
-      error.message.includes("Invalid `specification`")
-    ) {
-      console.error(
-        chalk.red(
-          "Error updating function specifications, please try setting the env variable `_FUNCTIONS_CPUS` and `_FUNCTIONS_RAM` to non-zero values"
-        )
-      );
-    } else {
-      console.error(chalk.red("Error updating function specifications."));
-      throw error;
-    }
-  }
-};
-
-export const listSpecifications = async (client: Client) => {
-  const functions = new Functions(client);
-  const specifications = await functions.listSpecifications();
-  return specifications;
-};
-
-export const updateFunction = async (
-  client: Client,
-  functionId: string,
-  name: string,
-  runtime?: Runtime,
-  execute?: string[],
-  events?: string[],
-  schedule?: string,
-  timeout?: number,
-  enabled?: boolean,
-  logging?: boolean,
-  entrypoint?: string,
-  commands?: string,
-  scopes?: string[],
-  installationId?: string,
-  providerRepositoryId?: string,
-  providerBranch?: string,
-  providerSilentMode?: boolean,
-  providerRootDirectory?: string,
-  specification?: Specification
-) => {
-  const functions = new Functions(client);
-  const functionResponse = await functions.update(
-    functionId,
-    name,
-    runtime,
-    execute,
-    events,
-    schedule,
-    timeout,
-    enabled,
-    logging,
-    entrypoint,
-    commands,
-    scopes,
-    installationId,
-    providerRepositoryId,
-    providerBranch,
-    providerSilentMode,
-    providerRootDirectory,
-    specification
-  );
-  return functionResponse;
-};
-
-export const deployFunction = async (
-  client: Client,
-  functionId: string,
-  codePath: string,
-  activate: boolean = true,
-  entrypoint: string = "index.js",
-  commands: string = "npm install"
-) => {
-  const functions = new Functions(client);
-
-  // Create temporary tar.gz file
-  const tarPath = join(process.cwd(), `function-${functionId}.tar.gz`);
-  await createTarball(
-    {
-      gzip: true,
-      file: tarPath,
-      cwd: codePath,
-    },
-    ["."] // Include all files from codePath
-  );
-
-  // Read the tar.gz file and create a File object
-  const fileBuffer = await fs.promises.readFile(tarPath);
-  const fileObject = InputFile.fromBuffer(
-    new Uint8Array(fileBuffer),
-    `function-${functionId}.tar.gz`
-  );
-
-  // Create deployment with the File object
-  const functionResponse = await functions.createDeployment(
-    functionId,
-    fileObject,
-    activate,
-    entrypoint,
-    commands
-  );
-
-  // Clean up the temporary tar file
-  await fs.promises.unlink(tarPath);
-
-  return functionResponse;
-};
+import {
+  AppwriteException,
+  Client,
+  Functions,
+  Query,
+  Runtime,
+} from "node-appwrite";
+import { join } from "node:path";
+import fs from "node:fs";
+import { type Specification } from "appwrite-utils";
+import chalk from "chalk";
+import { extract as extractTar } from "tar";
+
+export const listFunctions = async (
+  client: Client,
+  queries?: string[],
+  search?: string
+) => {
+  const functions = new Functions(client);
+  const functionsList = await functions.list(queries, search);
+  return functionsList;
+};
+
+export const getFunction = async (client: Client, functionId: string) => {
+  const functions = new Functions(client);
+  const functionResponse = await functions.get(functionId);
+  return functionResponse;
+};
+
+export const downloadLatestFunctionDeployment = async (
+  client: Client,
+  functionId: string,
+  basePath: string = process.cwd()
+) => {
+  const functions = new Functions(client);
+  const functionInfo = await getFunction(client, functionId);
+  const functionDeployments = await functions.listDeployments(functionId, [
+    Query.orderDesc("$createdAt"),
+  ]);
+
+  if (functionDeployments.deployments.length === 0) {
+    throw new Error("No deployments found for function");
+  }
+
+  const latestDeployment = functionDeployments.deployments[0];
+  const deploymentData = await functions.getDeploymentDownload(
+    functionId,
+    latestDeployment.$id
+  );
+
+  // Create function directory using provided basePath
+  const functionDir = join(
+    basePath,
+    functionInfo.name.toLowerCase().replace(/\s+/g, "-")
+  );
+  await fs.promises.mkdir(functionDir, { recursive: true });
+
+  // Create temporary file for tar extraction
+  const tarPath = join(functionDir, "temp.tar.gz");
+  const uint8Array = new Uint8Array(deploymentData);
+  await fs.promises.writeFile(tarPath, uint8Array);
+
+  try {
+    // Extract tar file
+    extractTar({
+      C: functionDir,
+      file: tarPath,
+      sync: true,
+    });
+
+    return {
+      path: functionDir,
+      function: functionInfo,
+      deployment: latestDeployment,
+    };
+  } finally {
+    // Clean up tar file
+    await fs.promises.unlink(tarPath).catch(() => {});
+  }
+};
+
+export const deleteFunction = async (client: Client, functionId: string) => {
+  const functions = new Functions(client);
+  const functionResponse = await functions.delete(functionId);
+  return functionResponse;
+};
+
+export const createFunction = async (
+  client: Client,
+  functionId: string,
+  name: string,
+  runtime: Runtime,
+  execute?: string[],
+  events?: string[],
+  schedule?: string,
+  timeout?: number,
+  enabled?: boolean,
+  logging?: boolean,
+  entrypoint?: string,
+  commands?: string,
+  scopes?: string[],
+  installationId?: string,
+  providerRepositoryId?: string,
+  providerBranch?: string,
+  providerSilentMode?: boolean,
+  providerRootDirectory?: string,
+  templateRepository?: string,
+  templateOwner?: string,
+  templateRootDirectory?: string,
+  templateVersion?: string,
+  specification?: string
+) => {
+  const functions = new Functions(client);
+  const functionResponse = await functions.create(
+    functionId,
+    name,
+    runtime,
+    execute,
+    events,
+    schedule,
+    timeout,
+    enabled,
+    logging,
+    entrypoint,
+    commands,
+    scopes,
+    installationId,
+    providerRepositoryId,
+    providerBranch,
+    providerSilentMode,
+    providerRootDirectory,
+    templateRepository,
+    templateOwner,
+    templateRootDirectory,
+    templateVersion,
+    specification
+  );
+  return functionResponse;
+};
+
+export const updateFunctionSpecifications = async (
+  client: Client,
+  functionId: string,
+  specification: Specification
+) => {
+  const curFunction = await listFunctions(client, [
+    Query.equal("$id", functionId),
+  ]);
+  if (curFunction.functions.length === 0) {
+    throw new Error("Function not found");
+  }
+  const functionFound = curFunction.functions[0];
+  try {
+    const functionResponse = await updateFunction(
+      client,
+      functionId,
+      functionFound.name,
+      functionFound.runtime as Runtime,
+      functionFound.execute,
+      functionFound.events,
+      functionFound.schedule,
+      functionFound.timeout,
+      functionFound.enabled,
+      functionFound.logging,
+      functionFound.entrypoint,
+      functionFound.commands,
+      functionFound.scopes,
+      functionFound.installationId,
+      functionFound.providerRepositoryId,
+      functionFound.providerBranch,
+      functionFound.providerSilentMode,
+      functionFound.providerRootDirectory,
+      specification
+    );
+    return functionResponse;
+  } catch (error) {
+    if (
+      error instanceof AppwriteException &&
+      error.message.includes("Invalid `specification`")
+    ) {
+      console.error(
+        chalk.red(
+          "Error updating function specifications, please try setting the env variable `_FUNCTIONS_CPUS` and `_FUNCTIONS_RAM` to non-zero values"
+        )
+      );
+    } else {
+      console.error(chalk.red("Error updating function specifications."));
+      throw error;
+    }
+  }
+};
+
+export const listSpecifications = async (client: Client) => {
+  const functions = new Functions(client);
+  const specifications = await functions.listSpecifications();
+  return specifications;
+};
+
+export const updateFunction = async (
+  client: Client,
+  functionId: string,
+  name: string,
+  runtime?: Runtime,
+  execute?: string[],
+  events?: string[],
+  schedule?: string,
+  timeout?: number,
+  enabled?: boolean,
+  logging?: boolean,
+  entrypoint?: string,
+  commands?: string,
+  scopes?: string[],
+  installationId?: string,
+  providerRepositoryId?: string,
+  providerBranch?: string,
+  providerSilentMode?: boolean,
+  providerRootDirectory?: string,
+  specification?: Specification
+) => {
+  const functions = new Functions(client);
+  const functionResponse = await functions.update(
+    functionId,
+    name,
+    runtime,
+    execute,
+    events,
+    schedule,
+    timeout,
+    enabled,
+    logging,
+    entrypoint,
+    commands,
+    scopes,
+    installationId,
+    providerRepositoryId,
+    providerBranch,
+    providerSilentMode,
+    providerRootDirectory,
+    specification
+  );
+  return functionResponse;
+};
+
+export const createFunctionTemplate = async (
+  templateType: "typescript-node" | "poetry" | "count-docs-in-collection",
+  functionName: string,
+  basePath: string = "./functions"
+) => {
+  const functionPath = join(basePath, functionName);
+  const templatesPath = join(__dirname, "templates", templateType);
+
+  // Create function directory
+  await fs.promises.mkdir(functionPath, { recursive: true });
+
+  // Copy template files recursively
+  const copyTemplateFiles = async (sourcePath: string, targetPath: string) => {
+    const entries = await fs.promises.readdir(sourcePath, {
+      withFileTypes: true,
+    });
+
+    for (const entry of entries) {
+      const srcPath = join(sourcePath, entry.name);
+      const destPath = join(targetPath, entry.name);
+
+      if (entry.isDirectory()) {
+        await fs.promises.mkdir(destPath, { recursive: true });
+        await copyTemplateFiles(srcPath, destPath);
+      } else {
+        let content = await fs.promises.readFile(srcPath, "utf-8");
+
+        // Replace template variables
+        content = content
+          .replace(/\{\{functionName\}\}/g, functionName)
+          .replace(/\{\{databaseId\}\}/g, "{{databaseId}}")
+          .replace(/\{\{collectionId\}\}/g, "{{collectionId}}");
+
+        await fs.promises.writeFile(destPath, content);
+      }
+    }
+  };
+
+  try {
+    await copyTemplateFiles(templatesPath, functionPath);
+    console.log(
+      chalk.green(
+        `✨ Created ${templateType} function template at ${functionPath}`
+      )
+    );
+  } catch (error) {
+    console.error(chalk.red(`Failed to create function template: ${error}`));
+    throw error;
+  }
+
+  return functionPath;
+};

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

@@ -0,0 +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'
+}
+```