appwrite-cli 12.0.1 → 13.0.0-rc.2

package/lib/emulation/docker.ts

@@ -0,0 +1,312 @@
+import ignoreModule from "ignore";
+const ignore: typeof ignoreModule =
+  (ignoreModule as any).default ?? ignoreModule;
+import net from "net";
+import chalk from "chalk";
+import childProcess from "child_process";
+import { localConfig } from "../config.js";
+import path from "path";
+import fs from "fs";
+import { log, error, success } from "../parser.js";
+import { openRuntimesVersion, systemTools, Queue } from "./utils.js";
+import { getAllFiles } from "../utils.js";
+import type { FunctionConfig } from "../types.js";
+
+export async function dockerStop(id: string): Promise<void> {
+  const stopProcess = childProcess.spawn("docker", ["rm", "--force", id], {
+    stdio: "pipe",
+    env: {
+      ...process.env,
+      DOCKER_CLI_HINTS: "false",
+    },
+  });
+
+  await new Promise<void>((res) => {
+    stopProcess.on("close", res);
+  });
+}
+
+export async function dockerPull(func: FunctionConfig): Promise<void> {
+  const runtimeChunks = func.runtime.split("-");
+  const runtimeVersion = runtimeChunks.pop();
+  const runtimeName = runtimeChunks.join("-");
+  const imageName = `openruntimes/${runtimeName}:${openRuntimesVersion}-${runtimeVersion}`;
+
+  log("Verifying Docker image ...");
+
+  const pullProcess = childProcess.spawn("docker", ["pull", imageName], {
+    stdio: "pipe",
+    env: {
+      ...process.env,
+      DOCKER_CLI_HINTS: "false",
+    },
+  });
+
+  await new Promise<void>((res) => {
+    pullProcess.on("close", res);
+  });
+}
+
+export async function dockerBuild(
+  func: FunctionConfig,
+  variables: Record<string, string>,
+): Promise<void> {
+  const runtimeChunks = func.runtime.split("-");
+  const runtimeVersion = runtimeChunks.pop();
+  const runtimeName = runtimeChunks.join("-");
+  const imageName = `openruntimes/${runtimeName}:${openRuntimesVersion}-${runtimeVersion}`;
+
+  const functionDir = path.join(localConfig.getDirname(), func.path);
+
+  const id = func.$id;
+
+  const ignorer = ignore();
+  ignorer.add(".appwrite");
+  if (func.ignore) {
+    ignorer.add(func.ignore);
+  } else if (fs.existsSync(path.join(functionDir, ".gitignore"))) {
+    ignorer.add(
+      fs.readFileSync(path.join(functionDir, ".gitignore")).toString(),
+    );
+  }
+
+  const files = getAllFiles(functionDir)
+    .map((file) => path.relative(functionDir, file))
+    .filter((file) => !ignorer.ignores(file));
+  const tmpBuildPath = path.join(functionDir, ".appwrite/tmp-build");
+  if (!fs.existsSync(tmpBuildPath)) {
+    fs.mkdirSync(tmpBuildPath, { recursive: true });
+  }
+
+  for (const f of files) {
+    const filePath = path.join(tmpBuildPath, f);
+    const fileDir = path.dirname(filePath);
+    if (!fs.existsSync(fileDir)) {
+      fs.mkdirSync(fileDir, { recursive: true });
+    }
+
+    const sourcePath = path.join(functionDir, f);
+    fs.copyFileSync(sourcePath, filePath);
+  }
+
+  const params: string[] = ["run"];
+  params.push("--name", id);
+  params.push("-v", `${tmpBuildPath}/:/mnt/code:rw`);
+  params.push("-e", "OPEN_RUNTIMES_ENV=development");
+  params.push("-e", "OPEN_RUNTIMES_SECRET=");
+  params.push("-e", `OPEN_RUNTIMES_ENTRYPOINT=${func.entrypoint}`);
+
+  for (const k of Object.keys(variables)) {
+    params.push("-e", `${k}=${variables[k]}`);
+  }
+
+  params.push(imageName, "sh", "-c", `helpers/build.sh "${func.commands}"`);
+
+  const buildProcess = childProcess.spawn("docker", params, {
+    stdio: "pipe",
+    cwd: functionDir,
+    env: {
+      ...process.env,
+      DOCKER_CLI_HINTS: "false",
+    },
+  });
+
+  buildProcess.stdout.on("data", (data) => {
+    process.stdout.write(chalk.blackBright(`${data}\n`));
+  });
+
+  buildProcess.stderr.on("data", (data) => {
+    process.stderr.write(chalk.blackBright(`${data}\n`));
+  });
+
+  const killInterval = setInterval(() => {
+    if (!Queue.isEmpty()) {
+      log("Cancelling build ...");
+      buildProcess.stdout.destroy();
+      buildProcess.stdin.destroy();
+      buildProcess.stderr.destroy();
+      buildProcess.kill("SIGKILL");
+      clearInterval(killInterval);
+    }
+  }, 100);
+
+  await new Promise<void>((res) => {
+    buildProcess.on("close", res);
+  });
+
+  clearInterval(killInterval);
+  if (!Queue.isEmpty()) {
+    return;
+  }
+
+  const copyPath = path.join(
+    localConfig.getDirname(),
+    func.path,
+    ".appwrite",
+    "build.tar.gz",
+  );
+  const copyDir = path.dirname(copyPath);
+  if (!fs.existsSync(copyDir)) {
+    fs.mkdirSync(copyDir, { recursive: true });
+  }
+
+  const copyProcess = childProcess.spawn(
+    "docker",
+    ["cp", `${id}:/mnt/code/code.tar.gz`, copyPath],
+    {
+      stdio: "pipe",
+      cwd: functionDir,
+      env: {
+        ...process.env,
+        DOCKER_CLI_HINTS: "false",
+      },
+    },
+  );
+
+  await new Promise<void>((res) => {
+    copyProcess.on("close", res);
+  });
+
+  await dockerStop(id);
+
+  const tempPath = path.join(
+    localConfig.getDirname(),
+    func.path,
+    "code.tar.gz",
+  );
+  if (fs.existsSync(tempPath)) {
+    fs.rmSync(tempPath, { force: true });
+  }
+
+  fs.rmSync(tmpBuildPath, { recursive: true, force: true });
+}
+
+export async function dockerStart(
+  func: FunctionConfig,
+  variables: Record<string, string>,
+  port: number,
+): Promise<void> {
+  // Pack function files
+  const functionDir = path.join(localConfig.getDirname(), func.path);
+
+  const runtimeChunks = func.runtime.split("-");
+  const runtimeVersion = runtimeChunks.pop();
+  const runtimeName = runtimeChunks.join("-");
+  const imageName = `openruntimes/${runtimeName}:${openRuntimesVersion}-${runtimeVersion}`;
+
+  const tool = systemTools[runtimeName];
+
+  const id = func.$id;
+
+  const params: string[] = ["run"];
+  params.push("--rm");
+  params.push("--name", id);
+  params.push("-p", `${port}:3000`);
+  params.push("-e", "OPEN_RUNTIMES_ENV=development");
+  params.push("-e", "OPEN_RUNTIMES_SECRET=");
+
+  for (const k of Object.keys(variables)) {
+    params.push("-e", `${k}=${variables[k]}`);
+  }
+
+  params.push(
+    "-v",
+    `${functionDir}/.appwrite/logs.txt:/mnt/logs/dev_logs.log:rw`,
+  );
+  params.push(
+    "-v",
+    `${functionDir}/.appwrite/errors.txt:/mnt/logs/dev_errors.log:rw`,
+  );
+  params.push(
+    "-v",
+    `${functionDir}/.appwrite/build.tar.gz:/mnt/code/code.tar.gz:ro`,
+  );
+  params.push(imageName, "sh", "-c", `helpers/start.sh "${tool.startCommand}"`);
+
+  const startProcess = childProcess.spawn("docker", params, {
+    stdio: "pipe",
+    cwd: functionDir,
+    env: {
+      ...process.env,
+      DOCKER_CLI_HINTS: "false",
+    },
+  });
+
+  startProcess.stdout.on("data", (data) => {
+    process.stdout.write(chalk.blackBright(data));
+  });
+
+  startProcess.stderr.on("data", (data) => {
+    process.stdout.write(chalk.blackBright(data));
+  });
+
+  try {
+    await waitUntilPortOpen(port);
+  } catch (err: any) {
+    error(
+      "Failed to start function with error: " +
+        (err.message ? err.message : err.toString()),
+    );
+    return;
+  }
+
+  success(`Visit http://localhost:${port}/ to execute your function.`);
+}
+
+export async function dockerCleanup(functionId: string): Promise<void> {
+  await dockerStop(functionId);
+
+  const func = localConfig.getFunction(functionId);
+  const appwritePath = path.join(
+    localConfig.getDirname(),
+    func.path,
+    ".appwrite",
+  );
+  if (fs.existsSync(appwritePath)) {
+    fs.rmSync(appwritePath, { recursive: true, force: true });
+  }
+
+  const tempPath = path.join(
+    localConfig.getDirname(),
+    func.path,
+    "code.tar.gz",
+  );
+  if (fs.existsSync(tempPath)) {
+    fs.rmSync(tempPath, { force: true });
+  }
+}
+
+function waitUntilPortOpen(port: number, iteration: number = 0): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const client = new net.Socket();
+
+    client.once("connect", () => {
+      client.removeAllListeners("connect");
+      client.removeAllListeners("error");
+      client.end();
+      client.destroy();
+      client.unref();
+
+      resolve();
+    });
+
+    client.once("error", async (err) => {
+      client.removeAllListeners("connect");
+      client.removeAllListeners("error");
+      client.end();
+      client.destroy();
+      client.unref();
+
+      if (iteration > 100) {
+        reject(err);
+      } else {
+        await new Promise<void>((res) => setTimeout(res, 100));
+        waitUntilPortOpen(port, iteration + 1)
+          .then(resolve)
+          .catch(reject);
+      }
+    });
+
+    client.connect({ port, host: "127.0.0.1" }, function () {});
+  });
+}

package/lib/emulation/utils.ts

@@ -0,0 +1,207 @@
+import { EventEmitter } from "node:events";
+import { localConfig } from "../config.js";
+import { log } from "../parser.js";
+import { sdkForConsole } from "../sdks.js";
+import { Projects, Users } from "@appwrite.io/console";
+
+export const openRuntimesVersion = "v4";
+
+export const runtimeNames: Record<string, string> = {
+  node: "Node.js",
+  php: "PHP",
+  ruby: "Ruby",
+  python: "Python",
+  "python-ml": "Python (ML)",
+  deno: "Deno",
+  dart: "Dart",
+  dotnet: ".NET",
+  java: "Java",
+  swift: "Swift",
+  kotlin: "Kotlin",
+  bun: "Bun",
+  go: "Go",
+};
+
+interface SystemTool {
+  isCompiled: boolean;
+  startCommand: string;
+  dependencyFiles: string[];
+}
+
+export const systemTools: Record<string, SystemTool> = {
+  node: {
+    isCompiled: false,
+    startCommand: "sh helpers/server.sh",
+    dependencyFiles: ["package.json", "package-lock.json"],
+  },
+  php: {
+    isCompiled: false,
+    startCommand: "sh helpers/server.sh",
+    dependencyFiles: ["composer.json", "composer.lock"],
+  },
+  ruby: {
+    isCompiled: false,
+    startCommand: "sh helpers/server.sh",
+    dependencyFiles: ["Gemfile", "Gemfile.lock"],
+  },
+  python: {
+    isCompiled: false,
+    startCommand: "sh helpers/server.sh",
+    dependencyFiles: ["requirements.txt", "requirements.lock"],
+  },
+  "python-ml": {
+    isCompiled: false,
+    startCommand: "sh helpers/server.sh",
+    dependencyFiles: ["requirements.txt", "requirements.lock"],
+  },
+  deno: {
+    isCompiled: false,
+    startCommand: "sh helpers/server.sh",
+    dependencyFiles: [],
+  },
+  dart: {
+    isCompiled: true,
+    startCommand: "sh helpers/server.sh",
+    dependencyFiles: [],
+  },
+  dotnet: {
+    isCompiled: true,
+    startCommand: "sh helpers/server.sh",
+    dependencyFiles: [],
+  },
+  java: {
+    isCompiled: true,
+    startCommand: "sh helpers/server.sh",
+    dependencyFiles: [],
+  },
+  swift: {
+    isCompiled: true,
+    startCommand: "sh helpers/server.sh",
+    dependencyFiles: [],
+  },
+  kotlin: {
+    isCompiled: true,
+    startCommand: "sh helpers/server.sh",
+    dependencyFiles: [],
+  },
+  bun: {
+    isCompiled: false,
+    startCommand: "sh helpers/server.sh",
+    dependencyFiles: ["package.json", "package-lock.json", "bun.lockb"],
+  },
+  go: {
+    isCompiled: true,
+    startCommand: "sh helpers/server.sh",
+    dependencyFiles: [],
+  },
+};
+
+export const JwtManager = {
+  userJwt: null as string | null,
+  functionJwt: null as string | null,
+
+  timerWarn: null as NodeJS.Timeout | null,
+  timerError: null as NodeJS.Timeout | null,
+
+  async setup(
+    userId: string | null = null,
+    projectScopes: string[] = [],
+  ): Promise<void> {
+    const consoleClient = await sdkForConsole();
+    const usersClient = new Users(consoleClient);
+    const projectsClient = new Projects(consoleClient);
+
+    if (this.timerWarn) {
+      clearTimeout(this.timerWarn);
+    }
+
+    if (this.timerError) {
+      clearTimeout(this.timerError);
+    }
+
+    this.timerWarn = setTimeout(
+      () => {
+        log(
+          "Warning: Authorized JWT will expire in 5 minutes. Please stop and re-run the command to refresh tokens for 1 hour.",
+        );
+      },
+      1000 * 60 * 55,
+    ); // 55 mins
+
+    this.timerError = setTimeout(
+      () => {
+        log(
+          "Warning: Authorized JWT just expired. Please stop and re-run the command to obtain new tokens with 1 hour validity.",
+        );
+        log("Some Appwrite API communication is not authorized now.");
+      },
+      1000 * 60 * 60,
+    ); // 60 mins
+
+    if (userId) {
+      await usersClient.get({
+        userId,
+      });
+      const userResponse: any = await usersClient.createJWT({
+        userId,
+        duration: 60 * 60,
+      });
+      this.userJwt = userResponse.jwt;
+    }
+
+    const functionResponse: any = await projectsClient.createJWT({
+      projectId: localConfig.getProject().projectId!,
+      scopes: projectScopes,
+      duration: 60 * 60,
+    });
+    this.functionJwt = functionResponse.jwt;
+  },
+};
+
+interface QueueReloadEvent {
+  files: string[];
+}
+
+export const Queue = {
+  files: [] as string[],
+  locked: false,
+  events: new EventEmitter(),
+  debounce: null as NodeJS.Timeout | null,
+
+  push(file: string): void {
+    if (!this.files.includes(file)) {
+      this.files.push(file);
+    }
+
+    if (!this.locked) {
+      this._trigger();
+    }
+  },
+
+  lock(): void {
+    this.files = [];
+    this.locked = true;
+  },
+
+  isEmpty(): boolean {
+    return this.files.length === 0;
+  },
+
+  unlock(): void {
+    this.locked = false;
+    if (this.files.length > 0) {
+      this._trigger();
+    }
+  },
+
+  _trigger(): void {
+    if (this.debounce) {
+      return;
+    }
+
+    this.debounce = setTimeout(() => {
+      this.events.emit("reload", { files: this.files } as QueueReloadEvent);
+      this.debounce = null;
+    }, 300);
+  },
+};

package/lib/id.ts

@@ -0,0 +1,30 @@
+class ID {
+  // Generate an hex ID based on timestamp
+  // Recreated from https://www.php.net/manual/en/function.uniqid.php
+  static #hexTimestamp(): string {
+    const now = new Date();
+    const sec = Math.floor(now.getTime() / 1000);
+    const msec = now.getMilliseconds();
+
+    // Convert to hexadecimal
+    const hexTimestamp = sec.toString(16) + msec.toString(16).padStart(5, "0");
+    return hexTimestamp;
+  }
+
+  static custom(id: string): string {
+    return id;
+  }
+
+  static unique(padding: number = 7): string {
+    // Generate a unique ID with padding to have a longer ID
+    const baseId = ID.#hexTimestamp();
+    let randomPadding = "";
+    for (let i = 0; i < padding; i++) {
+      const randomHexDigit = Math.floor(Math.random() * 16).toString(16);
+      randomPadding += randomHexDigit;
+    }
+    return baseId + randomPadding;
+  }
+}
+
+export default ID;

package/lib/paginate.ts

@@ -0,0 +1,77 @@
+interface PaginateArgs {
+  [key: string]: any;
+}
+
+// Overload for when wrapper is empty string - returns array
+export function paginate<T = any>(
+  action: (args: PaginateArgs) => Promise<any>,
+  args: PaginateArgs,
+  limit: number,
+  wrapper: "",
+  queries?: string[],
+): Promise<T[]>;
+
+// Overload for when wrapper is specified - returns object with that key
+export function paginate<T = any, K extends string = string>(
+  action: (args: PaginateArgs) => Promise<any>,
+  args: PaginateArgs,
+  limit: number,
+  wrapper: K,
+  queries?: string[],
+): Promise<Record<K, T[]> & { total: number }>;
+
+// Implementation
+export async function paginate<T = any>(
+  action: (args: PaginateArgs) => Promise<any>,
+  args: PaginateArgs = {},
+  limit: number = 100,
+  wrapper: string = "",
+  queries: string[] = [],
+): Promise<T[] | (Record<string, T[]> & { total: number })> {
+  let pageNumber = 0;
+  let results: T[] = [];
+  let total = 0;
+
+  while (true) {
+    const offset = pageNumber * limit;
+
+    // Merge the limit and offset into the args
+    const response = await action({
+      ...args,
+      queries: [
+        ...queries,
+        JSON.stringify({ method: "limit", values: [limit] }),
+        JSON.stringify({ method: "offset", values: [offset] }),
+      ],
+    });
+
+    if (wrapper === "") {
+      if (response.length === 0) {
+        break;
+      }
+      results = results.concat(response);
+    } else {
+      if (response[wrapper].length === 0) {
+        break;
+      }
+      results = results.concat(response[wrapper]);
+    }
+
+    total = response.total;
+
+    if (results.length >= total) {
+      break;
+    }
+
+    pageNumber++;
+  }
+
+  if (wrapper === "") {
+    return results;
+  }
+
+  return {
+    [wrapper]: results,
+    total,
+  } as Record<string, T[]> & { total: number };
+}