appwrite-utils-cli 0.9.993 → 0.9.995

package/package.json

@@ -1,55 +1,57 @@
-{
-  "name": "appwrite-utils-cli",
-  "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "0.9.993",
-  "main": "src/main.ts",
-  "type": "module",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/zachhandley/AppwriteUtils"
-  },
-  "author": "Zach Handley <zach@blackleafdigital.com> (https://zachhandley.com)",
-  "keywords": [
-    "appwrite",
-    "cli",
-    "utils",
-    "migrations",
-    "data",
-    "database",
-    "import",
-    "migration",
-    "utility"
-  ],
-  "bin": {
-    "appwrite-migrate": "./dist/main.js"
-  },
-  "scripts": {
-    "build": "bun run tsc",
-    "start": "tsx --no-cache src/main.ts",
-    "deploy": "bun run build && npm publish --access public",
-    "postinstall": "echo 'This package is intended for CLI use only and should not be added as a dependency in other projects.'"
-  },
-  "dependencies": {
-    "@types/inquirer": "^9.0.7",
-    "appwrite-utils": "^0.3.96",
-    "chalk": "^5.3.0",
-    "commander": "^12.1.0",
-    "inquirer": "^9.3.6",
-    "js-yaml": "^4.1.0",
-    "lodash": "^4.17.21",
-    "luxon": "^3.5.0",
-    "nanostores": "^0.10.3",
-    "node-appwrite": "^14.1.0",
-    "tar": "^7.4.3",
-    "tsx": "^4.17.0",
-    "ulidx": "^2.4.0",
-    "winston": "^3.14.2",
-    "zod": "^3.23.8"
-  },
-  "devDependencies": {
-    "@types/js-yaml": "^4.0.9",
-    "@types/lodash": "^4.17.7",
-    "@types/luxon": "^3.4.2",
-    "typescript": "^5.5.4"
-  }
-}
+{
+  "name": "appwrite-utils-cli",
+  "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
+  "version": "0.9.995",
+  "main": "src/main.ts",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zachhandley/AppwriteUtils"
+  },
+  "author": "Zach Handley <zach@blackleafdigital.com> (https://zachhandley.com)",
+  "keywords": [
+    "appwrite",
+    "cli",
+    "utils",
+    "migrations",
+    "data",
+    "database",
+    "import",
+    "migration",
+    "utility"
+  ],
+  "bin": {
+    "appwrite-migrate": "./dist/main.js"
+  },
+  "scripts": {
+    "build": "bun run tsc",
+    "start": "tsx --no-cache src/main.ts",
+    "deploy": "bun run build && npm publish --access public",
+    "postinstall": "echo 'This package is intended for CLI use only and should not be added as a dependency in other projects.'"
+  },
+  "dependencies": {
+    "@types/inquirer": "^9.0.7",
+    "appwrite-utils": "^0.3.97",
+    "chalk": "^5.3.0",
+    "cli-progress": "^3.12.0",
+    "commander": "^12.1.0",
+    "inquirer": "^9.3.6",
+    "js-yaml": "^4.1.0",
+    "lodash": "^4.17.21",
+    "luxon": "^3.5.0",
+    "nanostores": "^0.10.3",
+    "node-appwrite": "^14.1.0",
+    "tar": "^7.4.3",
+    "tsx": "^4.17.0",
+    "ulidx": "^2.4.0",
+    "winston": "^3.14.2",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/cli-progress": "^3.11.6",
+    "@types/js-yaml": "^4.0.9",
+    "@types/lodash": "^4.17.7",
+    "@types/luxon": "^3.4.2",
+    "typescript": "^5.5.4"
+  }
+}

package/src/collections/methods.ts

@@ -11,7 +11,7 @@ import { nameToIdMapping, processQueue } from "../migrations/queue.js";
 import { createUpdateCollectionAttributes } from "./attributes.js";
 import { createOrUpdateIndexes } from "./indexes.js";
 import _ from "lodash";
-import { SchemaGenerator } from "../utils/schemaStrings.js";
+import { SchemaGenerator } from "../migrations/schemaStrings.js";
 import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
 
 export const documentExists = async (
@@ -124,20 +124,36 @@ export const fetchAndCacheCollectionByName = async (
   }
 };
 
-async function wipeDocumentsFromCollection(database: Databases, databaseId: string, collectionId: string) {
-  const initialDocuments = await database.listDocuments(databaseId, collectionId, [Query.limit(1000)]);
+async function wipeDocumentsFromCollection(
+  database: Databases,
+  databaseId: string,
+  collectionId: string
+) {
+  const initialDocuments = await database.listDocuments(
+    databaseId,
+    collectionId,
+    [Query.limit(1000)]
+  );
   let documents = initialDocuments.documents;
   while (documents.length === 1000) {
-    const docsResponse = await database.listDocuments(databaseId, collectionId, [Query.limit(1000)]);
+    const docsResponse = await database.listDocuments(
+      databaseId,
+      collectionId,
+      [Query.limit(1000)]
+    );
     documents = documents.concat(docsResponse.documents);
   }
-  const batchDeletePromises = documents.map(doc => database.deleteDocument(databaseId, collectionId, doc.$id));
+  const batchDeletePromises = documents.map((doc) =>
+    database.deleteDocument(databaseId, collectionId, doc.$id)
+  );
   const maxStackSize = 100;
   for (let i = 0; i < batchDeletePromises.length; i += maxStackSize) {
     await Promise.all(batchDeletePromises.slice(i, i + maxStackSize));
     await delay(100);
   }
-  console.log(`Deleted ${documents.length} documents from collection ${collectionId}`);
+  console.log(
+    `Deleted ${documents.length} documents from collection ${collectionId}`
+  );
 }
 
 export const wipeDatabase = async (
@@ -167,7 +183,9 @@ export const wipeCollection = async (
   databaseId: string,
   collectionId: string
 ): Promise<void> => {
-  const collections = await database.listCollections(databaseId, [Query.equal("$id", collectionId)]);
+  const collections = await database.listCollections(databaseId, [
+    Query.equal("$id", collectionId),
+  ]);
   if (collections.total === 0) {
     console.log(`Collection ${collectionId} not found`);
     return;
@@ -191,7 +209,8 @@ export const createOrUpdateCollections = async (
   deletedCollections?: { collectionId: string; collectionName: string }[],
   selectedCollections: Models.Collection[] = []
 ): Promise<void> => {
-  const collectionsToProcess = selectedCollections.length > 0 ? selectedCollections : config.collections;
+  const collectionsToProcess =
+    selectedCollections.length > 0 ? selectedCollections : config.collections;
   if (!collectionsToProcess) {
     return;
   }
@@ -204,7 +223,7 @@ export const createOrUpdateCollections = async (
     const permissions: string[] = [];
     if (collection.$permissions && collection.$permissions.length > 0) {
       for (const permission of collection.$permissions) {
-        if (typeof permission === 'string') {
+        if (typeof permission === "string") {
           permissions.push(permission);
         } else {
           switch (permission.permission) {
@@ -319,7 +338,7 @@ export const createOrUpdateCollections = async (
       databaseId,
       database,
       collectionToUse!.$id,
-      (indexes ?? []) as Indexes,
+      (indexes ?? []) as Indexes
     );
 
     // Add delay after creating indexes

package/src/functions/deployments.ts

@@ -0,0 +1,190 @@
+import { Client, Functions, Runtime } 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 AppwriteFunction, type Specification } from "appwrite-utils";
+import chalk from "chalk";
+import cliProgress from "cli-progress";
+import { execSync } from "child_process";
+import {
+  createFunction,
+  getFunction,
+  updateFunctionSpecifications,
+} from "./methods.js";
+
+const findFunctionDirectory = (
+  basePath: string,
+  functionName: string
+): string | undefined => {
+  const normalizedName = functionName.toLowerCase().replace(/\s+/g, "-");
+  const dirs = fs.readdirSync(basePath, { withFileTypes: true });
+
+  for (const dir of dirs) {
+    if (dir.isDirectory()) {
+      const fullPath = join(basePath, dir.name);
+      if (dir.name.toLowerCase() === normalizedName) {
+        return fullPath;
+      }
+
+      const nestedResult = findFunctionDirectory(fullPath, functionName);
+      if (nestedResult) {
+        return nestedResult;
+      }
+    }
+  }
+
+  return undefined;
+};
+
+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);
+  console.log(chalk.blue("📦 Preparing function deployment..."));
+
+  const progressBar = new cliProgress.SingleBar({
+    format:
+      "Uploading |" +
+      chalk.cyan("{bar}") +
+      "| {percentage}% | {value}/{total} Chunks",
+    barCompleteChar: "█",
+    barIncompleteChar: "░",
+    hideCursor: true,
+  });
+
+  const tarPath = join(process.cwd(), `function-${functionId}.tar.gz`);
+  await createTarball(
+    {
+      gzip: true,
+      file: tarPath,
+      cwd: codePath,
+    },
+    ["."]
+  );
+
+  const fileBuffer = await fs.promises.readFile(tarPath);
+  const fileObject = InputFile.fromBuffer(
+    new Uint8Array(fileBuffer),
+    `function-${functionId}.tar.gz`
+  );
+
+  try {
+    console.log(chalk.blue("🚀 Creating deployment..."));
+    const functionResponse = await functions.createDeployment(
+      functionId,
+      fileObject,
+      activate,
+      entrypoint,
+      commands,
+      (progress) => {
+        const chunks = progress.chunksUploaded;
+        const total = progress.chunksTotal;
+        if (chunks && total) {
+          if (chunks === 0) {
+            progressBar.start(total, 0);
+          } else if (chunks === total) {
+            progressBar.update(total);
+            progressBar.stop();
+            console.log(chalk.green("✅ Upload complete!"));
+          } else {
+            progressBar.update(chunks);
+          }
+        }
+      }
+    );
+
+    await fs.promises.unlink(tarPath);
+    console.log(chalk.green("✨ Function deployed successfully!"));
+    return functionResponse;
+  } catch (error) {
+    progressBar.stop();
+    console.error(chalk.red("❌ Deployment failed:"), error);
+    throw error;
+  }
+};
+
+export const deployLocalFunction = async (
+  client: Client,
+  functionName: string,
+  functionConfig: AppwriteFunction,
+  functionPath?: string
+) => {
+  let functionExists = true;
+  try {
+    await getFunction(client, functionConfig.$id);
+  } catch (error) {
+    functionExists = false;
+  }
+
+  const resolvedPath =
+    functionPath ||
+    functionConfig.dirPath ||
+    findFunctionDirectory(process.cwd(), functionName) ||
+    join(
+      process.cwd(),
+      "functions",
+      functionName.toLowerCase().replace(/\s+/g, "-")
+    );
+
+  if (functionConfig.predeployCommands?.length) {
+    console.log(chalk.blue("Executing predeploy commands..."));
+    for (const command of functionConfig.predeployCommands) {
+      try {
+        console.log(chalk.gray(`Executing: ${command}`));
+        execSync(command, {
+          cwd: resolvedPath,
+          stdio: "inherit",
+        });
+      } catch (error) {
+        console.error(
+          chalk.red(`Failed to execute predeploy command: ${command}`)
+        );
+        throw error;
+      }
+    }
+  }
+
+  if (!functionExists) {
+    await createFunction(
+      client,
+      functionConfig.$id,
+      functionConfig.name,
+      functionConfig.runtime as Runtime,
+      functionConfig.execute,
+      functionConfig.events,
+      functionConfig.schedule,
+      functionConfig.timeout,
+      functionConfig.enabled,
+      functionConfig.logging,
+      functionConfig.entrypoint,
+      functionConfig.commands
+    );
+  }
+
+  if (functionConfig.specification) {
+    await updateFunctionSpecifications(
+      client,
+      functionConfig.$id,
+      functionConfig.specification
+    );
+  }
+
+  const deployPath = functionConfig.deployDir
+    ? join(resolvedPath, functionConfig.deployDir)
+    : resolvedPath;
+
+  return deployFunction(
+    client,
+    functionConfig.$id,
+    deployPath,
+    true,
+    functionConfig.entrypoint,
+    functionConfig.commands
+  );
+};