appwrite-cli 12.0.1 → 13.0.0-rc.2

package/lib/types.ts

@@ -0,0 +1,304 @@
+import type { File } from "undici";
+import type { ReadableStream } from "node:stream/web";
+import type { Models } from "@appwrite.io/console";
+
+export type ResponseType = "json" | "arraybuffer";
+
+export interface Headers {
+  [key: string]: string;
+}
+
+export interface RequestParams {
+  [key: string]: unknown;
+}
+
+export interface FileUpload {
+  type: "file";
+  file: File;
+  filename: string;
+}
+
+export interface FileInput {
+  type: "file";
+  stream: ReadableStream;
+  filename: string;
+  size: number;
+}
+
+export interface UploadProgress {
+  $id: string;
+  progress: number;
+  sizeUploaded: number;
+  chunksTotal: number;
+  chunksUploaded: number;
+}
+
+export interface ConfigData {
+  [key: string]: unknown;
+}
+
+export interface Entity {
+  $id: string;
+  [key: string]: unknown;
+}
+
+export interface ParsedData {
+  [key: string]: unknown;
+}
+
+export interface CommandDescription {
+  [key: string]: string;
+}
+
+export interface CliConfig {
+  verbose: boolean;
+  json: boolean;
+  force: boolean;
+  all: boolean;
+  ids: string[];
+  report: boolean;
+  reportData: Record<string, unknown>;
+}
+
+export interface SessionData {
+  endpoint: string;
+  email?: string;
+  phone?: string;
+  cookie?: string;
+}
+
+export interface GlobalConfigData extends ConfigData {
+  sessions: {
+    [key: string]: SessionData;
+  };
+  current: string;
+  cookie?: string;
+}
+
+export interface ProjectSettings {
+  services?: {
+    account?: boolean;
+    avatars?: boolean;
+    databases?: boolean;
+    locale?: boolean;
+    health?: boolean;
+    storage?: boolean;
+    teams?: boolean;
+    users?: boolean;
+    sites?: boolean;
+    functions?: boolean;
+    graphql?: boolean;
+    messaging?: boolean;
+  };
+  auth?: {
+    methods?: {
+      jwt?: boolean;
+      phone?: boolean;
+      invites?: boolean;
+      anonymous?: boolean;
+      "email-otp"?: boolean;
+      "magic-url"?: boolean;
+      "email-password"?: boolean;
+    };
+    security?: {
+      duration?: number;
+      limit?: number;
+      sessionsLimit?: number;
+      passwordHistory?: number;
+      passwordDictionary?: boolean;
+      personalDataCheck?: boolean;
+      sessionAlerts?: boolean;
+      mockNumbers?: Models.MockNumber[];
+    };
+  };
+}
+
+export interface RawProjectSettings {
+  serviceStatusForAccount?: boolean;
+  serviceStatusForAvatars?: boolean;
+  serviceStatusForDatabases?: boolean;
+  serviceStatusForLocale?: boolean;
+  serviceStatusForHealth?: boolean;
+  serviceStatusForStorage?: boolean;
+  serviceStatusForTeams?: boolean;
+  serviceStatusForUsers?: boolean;
+  serviceStatusForSites?: boolean;
+  serviceStatusForFunctions?: boolean;
+  serviceStatusForGraphql?: boolean;
+  serviceStatusForMessaging?: boolean;
+  authJWT?: boolean;
+  authPhone?: boolean;
+  authInvites?: boolean;
+  authAnonymous?: boolean;
+  authEmailOtp?: boolean;
+  authUsersAuthMagicURL?: boolean;
+  authEmailPassword?: boolean;
+  authDuration?: number;
+  authLimit?: number;
+  authSessionsLimit?: number;
+  authPasswordHistory?: number;
+  authPasswordDictionary?: boolean;
+  authPersonalDataCheck?: boolean;
+  authSessionAlerts?: boolean;
+  authMockNumbers?: Models.MockNumber[];
+}
+
+export interface DatabaseConfig {
+  $id: string;
+  name: string;
+  enabled?: boolean;
+}
+
+export interface AttributeConfig {
+  key: string;
+  type: string;
+  required?: boolean;
+  array?: boolean;
+  size?: number;
+  default?: unknown;
+  min?: number;
+  max?: number;
+  format?: string;
+  elements?: string[];
+  relatedCollection?: string;
+  relationType?: string;
+  twoWay?: boolean;
+  twoWayKey?: string;
+  onDelete?: string;
+  side?: string;
+  encrypt?: boolean;
+}
+
+export interface IndexConfig {
+  key: string;
+  type: string;
+  status?: string;
+  attributes?: string[];
+  orders?: string[];
+}
+
+export interface CollectionConfig {
+  $id: string;
+  $permissions?: string[];
+  databaseId: string;
+  name: string;
+  enabled?: boolean;
+  documentSecurity?: boolean;
+  attributes?: AttributeConfig[];
+  indexes?: IndexConfig[];
+}
+
+export interface ColumnConfig {
+  key: string;
+  type: string;
+  required?: boolean;
+  array?: boolean;
+  size?: number;
+  default?: unknown;
+  min?: number;
+  max?: number;
+  format?: string;
+  elements?: string[];
+  relatedTable?: string;
+  relationType?: string;
+  twoWay?: boolean;
+  twoWayKey?: string;
+  onDelete?: string;
+  side?: string;
+  encrypt?: boolean;
+}
+
+export interface TableIndexConfig {
+  key: string;
+  type: string;
+  status?: string;
+  columns?: string[];
+  orders?: string[];
+}
+
+export interface TableConfig {
+  $id: string;
+  $permissions?: string[];
+  databaseId: string;
+  name: string;
+  enabled?: boolean;
+  rowSecurity?: boolean;
+  columns?: ColumnConfig[];
+  indexes?: TableIndexConfig[];
+}
+
+export interface BucketConfig {
+  $id: string;
+  $permissions?: string[];
+  name: string;
+  enabled?: boolean;
+  fileSecurity?: boolean;
+  maximumFileSize?: number;
+  allowedFileExtensions?: string[];
+  compression?: string;
+  encryption?: boolean;
+  antivirus?: boolean;
+}
+
+export interface FunctionConfig {
+  $id: string;
+  name: string;
+  runtime: string;
+  path: string;
+  entrypoint: string;
+  execute?: string[];
+  enabled?: boolean;
+  logging?: boolean;
+  events?: string[];
+  schedule?: string;
+  timeout?: number;
+  vars?: Record<string, string>;
+  commands?: string;
+  scopes?: string[];
+  specification?: string;
+  ignore?: string;
+}
+
+export interface SiteConfig {
+  $id: string;
+  name: string;
+  path: string;
+  enabled?: boolean;
+  logging?: boolean;
+  timeout?: number;
+  framework: string;
+  buildRuntime?: string;
+  adapter?: string;
+  installCommand?: string;
+  buildCommand?: string;
+  outputDirectory?: string;
+  fallbackFile?: string;
+  specification?: string;
+  vars?: Record<string, string>;
+  ignore?: string;
+}
+
+export interface TeamConfig {
+  $id: string;
+  name: string;
+}
+
+export interface TopicConfig {
+  $id: string;
+  name: string;
+  subscribe?: string[];
+}
+
+export interface ProjectConfigData extends ConfigData {
+  projectId?: string;
+  projectName?: string;
+  settings?: ProjectSettings;
+  functions?: FunctionConfig[];
+  collections?: CollectionConfig[];
+  databases?: DatabaseConfig[];
+  buckets?: BucketConfig[];
+  teams?: TeamConfig[];
+  topics?: TopicConfig[];
+  sites?: SiteConfig[];
+  tables?: TableConfig[];
+}

package/lib/utils.ts

@@ -0,0 +1,352 @@
+import fs from "fs";
+import path from "path";
+import net from "net";
+import childProcess from "child_process";
+import chalk from "chalk";
+import { fetch } from "undici";
+import { localConfig, globalConfig } from "./config.js";
+
+/**
+ * Get the latest version from npm registry
+ */
+export async function getLatestVersion(): Promise<string> {
+  try {
+    const response = await fetch(
+      "https://registry.npmjs.org/appwrite-cli/latest",
+    );
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const data = (await response.json()) as { version: string };
+    return data.version;
+  } catch (e) {
+    throw new Error(`Failed to fetch latest version: ${(e as Error).message}`);
+  }
+}
+
+/**
+ * Compare versions using semantic versioning
+ */
+export function compareVersions(current: string, latest: string): number {
+  const currentParts = current.split(".").map(Number);
+  const latestParts = latest.split(".").map(Number);
+
+  for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
+    const currentPart = currentParts[i] || 0;
+    const latestPart = latestParts[i] || 0;
+
+    if (latestPart > currentPart) return 1; // Latest is newer
+    if (latestPart < currentPart) return -1; // Current is newer
+  }
+
+  return 0; // Same version
+}
+
+export function getAllFiles(folder: string): string[] {
+  const files: string[] = [];
+  for (const pathDir of fs.readdirSync(folder)) {
+    const pathAbsolute = path.join(folder, pathDir);
+    let stats: fs.Stats;
+    try {
+      stats = fs.statSync(pathAbsolute);
+    } catch (error) {
+      continue;
+    }
+    if (stats.isDirectory()) {
+      files.push(...getAllFiles(pathAbsolute));
+    } else {
+      files.push(pathAbsolute);
+    }
+  }
+  return files;
+}
+
+export async function isPortTaken(port: number): Promise<boolean> {
+  const taken = await new Promise<boolean>((res, rej) => {
+    const tester = net
+      .createServer()
+      .once("error", function (err: NodeJS.ErrnoException) {
+        if (err.code != "EADDRINUSE") return rej(err);
+        res(true);
+      })
+      .once("listening", function () {
+        tester
+          .once("close", function () {
+            res(false);
+          })
+          .close();
+      })
+      .listen(port);
+  });
+
+  return taken;
+}
+
+export function systemHasCommand(command: string): boolean {
+  const isUsingWindows = process.platform == "win32";
+
+  try {
+    if (isUsingWindows) {
+      childProcess.execSync("where " + command, { stdio: "pipe" });
+    } else {
+      childProcess.execSync(
+        `[[ $(${command} --version) ]] || { exit 1; } && echo "OK"`,
+        {
+          stdio: "pipe",
+          shell: "/bin/bash",
+        },
+      );
+    }
+  } catch (error) {
+    console.log(error);
+    return false;
+  }
+
+  return true;
+}
+
+export const checkDeployConditions = (localConfig: any): void => {
+  if (Object.keys(localConfig.data).length === 0) {
+    throw new Error(
+      "No appwrite.config.json file found in the current directory. Please run this command again in the folder containing your appwrite.config.json file, or run 'appwrite init project' to link current directory to an Appwrite project.",
+    );
+  }
+};
+
+export function showConsoleLink(
+  serviceName: string,
+  action: string,
+  ...ids: string[]
+): void {
+  const projectId = localConfig.getProject().projectId;
+
+  const url = new URL(globalConfig.getEndpoint().replace("/v1", "/console"));
+  url.pathname += `/project-${projectId}`;
+  action = action.toLowerCase();
+
+  switch (serviceName) {
+    case "account":
+      url.pathname = url.pathname.replace(`/project-${projectId}`, "");
+      url.pathname += getAccountPath(action);
+      break;
+    case "databases":
+      url.pathname += getDatabasePath(action, ids);
+      break;
+    case "functions":
+      url.pathname += getFunctionsPath(action, ids);
+      break;
+    case "messaging":
+      url.pathname += getMessagingPath(action, ids);
+      break;
+    case "projects":
+      url.pathname = url.pathname.replace(`/project-${projectId}`, "");
+      url.pathname += getProjectsPath(action, ids);
+      break;
+    case "storage":
+      url.pathname += getBucketsPath(action, ids);
+      break;
+    case "teams":
+      url.pathname += getTeamsPath(action, ids);
+      break;
+    case "organizations":
+      url.pathname += getOrganizationsPath(action, ids);
+      break;
+    case "users":
+      url.pathname += getUsersPath(action, ids);
+      break;
+    default:
+      return;
+  }
+
+  console.log(
+    `${chalk.green.bold("✓ Success:")} ${chalk.green(url.toString())}`,
+  );
+}
+
+function getAccountPath(action: string): string {
+  let path = "/account";
+
+  if (action === "listsessions") {
+    path += "/sessions";
+  }
+
+  return path;
+}
+
+function getDatabasePath(action: string, ids: string[]): string {
+  let path = "/databases";
+
+  if (
+    [
+      "get",
+      "listcollections",
+      "getcollection",
+      "listattributes",
+      "listdocuments",
+      "getdocument",
+      "listindexes",
+      "getdatabaseusage",
+    ].includes(action)
+  ) {
+    path += `/database-${ids[0]}`;
+  }
+
+  if (action === "getdatabaseusage") {
+    path += `/usage`;
+  }
+
+  if (
+    [
+      "getcollection",
+      "listattributes",
+      "listdocuments",
+      "getdocument",
+      "listindexes",
+    ].includes(action)
+  ) {
+    path += `/collection-${ids[1]}`;
+  }
+
+  if (action === "listattributes") {
+    path += "/attributes";
+  }
+  if (action === "listindexes") {
+    path += "/indexes";
+  }
+  if (action === "getdocument") {
+    path += `/document-${ids[2]}`;
+  }
+
+  return path;
+}
+
+function getFunctionsPath(action: string, ids: string[]): string {
+  let path = "/functions";
+
+  if (action !== "list") {
+    path += `/function-${ids[0]}`;
+  }
+
+  if (action === "getdeployment") {
+    path += `/deployment-${ids[1]}`;
+  }
+
+  if (action === "getexecution" || action === "listexecution") {
+    path += `/executions`;
+  }
+  if (action === "getfunctionusage") {
+    path += `/usage`;
+  }
+
+  return path;
+}
+
+function getMessagingPath(action: string, ids: string[]): string {
+  let path = "/messaging";
+
+  if (["getmessage", "listmessagelogs"].includes(action)) {
+    path += `/message-${ids[0]}`;
+  }
+
+  if (["listproviders", "getprovider"].includes(action)) {
+    path += `/providers`;
+  }
+
+  if (action === "getprovider") {
+    path += `/provider-${ids[0]}`;
+  }
+
+  if (["listtopics", "gettopic"].includes(action)) {
+    path += `/topics`;
+  }
+
+  if (action === "gettopic") {
+    path += `/topic-${ids[0]}`;
+  }
+
+  return path;
+}
+
+function getProjectsPath(action: string, ids: string[]): string {
+  let path = "";
+
+  if (action !== "list") {
+    path += `/project-${ids[0]}`;
+  }
+
+  if (["listkeys", "getkey"].includes(action)) {
+    path += "/overview/keys";
+  }
+
+  if (["listplatforms", "getplatform"].includes(action)) {
+    path += "/overview/platforms";
+  }
+
+  if (["listwebhooks", "getwebhook"].includes(action)) {
+    path += "/settings/webhooks";
+  }
+
+  if (["getplatform", "getkey", "getwebhook"].includes(action)) {
+    path += `/${ids[1]}`;
+  }
+
+  return path;
+}
+
+function getBucketsPath(action: string, ids: string[]): string {
+  let path = "/storage";
+
+  if (action !== "listbuckets") {
+    path += `/bucket-${ids[0]}`;
+  }
+
+  if (action === "getbucketusage") {
+    path += `/usage`;
+  }
+
+  if (action === "getfile") {
+    path += `/file-${ids[1]}`;
+  }
+
+  return path;
+}
+
+function getTeamsPath(action: string, ids: string[]): string {
+  let path = "/auth/teams";
+
+  if (action !== "list") {
+    path += `/team-${ids[0]}`;
+  }
+
+  return path;
+}
+
+function getOrganizationsPath(action: string, ids: string[]): string {
+  let path = `/organization-${ids[0]}`;
+
+  if (action === "list") {
+    path = "/account/organizations";
+  }
+
+  return path;
+}
+
+function getUsersPath(action: string, ids: string[]): string {
+  let path = "/auth";
+
+  if (action !== "list") {
+    path += `/user-${ids[0]}`;
+  }
+
+  if (action === "listsessions") {
+    path += "sessions";
+  }
+
+  return path;
+}
+
+export function isCloud(): boolean {
+  const endpoint = globalConfig.getEndpoint() || "https://cloud.appwrite.io/v1";
+  const hostname = new URL(endpoint).hostname;
+  return hostname.endsWith("appwrite.io");
+}

package/lib/validations.ts

@@ -0,0 +1,20 @@
+export const validateRequired = (
+  resource: string,
+  value: any,
+): string | true => {
+  if (Array.isArray(value)) {
+    if (value.length <= 0) {
+      return `Please select at least one ${resource}`;
+    }
+  } else {
+    if (
+      value === undefined ||
+      value === null ||
+      (typeof value === "string" && value.trim() === "")
+    ) {
+      return `${resource} is required`;
+    }
+  }
+
+  return true;
+};