chirag-appwrite-cli 0.1.0 → 0.2.0

package/lib/sdks.ts

@@ -0,0 +1,84 @@
+import { globalConfig, localConfig } from "./config.js";
+import { Client } from "@appwrite.io/console";
+import os from "os";
+
+export const sdkForConsole = async (
+  requiresAuth: boolean = true,
+): Promise<Client> => {
+  const client = new Client();
+  const endpoint = globalConfig.getEndpoint() || "https://cloud.appwrite.io/v1";
+  const cookie = globalConfig.getCookie();
+  const selfSigned = globalConfig.getSelfSigned();
+
+  if (requiresAuth && cookie === "") {
+    throw new Error(
+      "Session not found. Please run `appwrite login` to create a session",
+    );
+  }
+
+  client.headers = {
+    "x-sdk-name": "Command Line",
+    "x-sdk-platform": "console",
+    "x-sdk-language": "cli",
+    "x-sdk-version": "13.0.0-rc.3",
+    "user-agent": `AppwriteCLI/13.0.0-rc.3 (${os.type()} ${os.version()}; ${os.arch()})`,
+  };
+
+  client
+    .setEndpoint(endpoint)
+    .setProject("console")
+    .setCookie(cookie)
+    .setSelfSigned(selfSigned)
+    .setLocale("en-US");
+
+  return client;
+};
+
+export const sdkForProject = async (): Promise<Client> => {
+  const client = new Client();
+
+  const endpoint =
+    localConfig.getEndpoint() ||
+    globalConfig.getEndpoint() ||
+    "https://cloud.appwrite.io/v1";
+
+  const project = localConfig.getProject().projectId
+    ? localConfig.getProject().projectId
+    : globalConfig.getProject();
+
+  const key = globalConfig.getKey();
+  const cookie = globalConfig.getCookie();
+  const selfSigned = globalConfig.getSelfSigned();
+
+  if (!project) {
+    throw new Error(
+      "Project is not set. Please run `appwrite init project` to initialize the current directory with an Appwrite project.",
+    );
+  }
+
+  client.headers = {
+    "x-sdk-name": "Command Line",
+    "x-sdk-platform": "console",
+    "x-sdk-language": "cli",
+    "x-sdk-version": "13.0.0-rc.3",
+    "user-agent": `AppwriteCLI/13.0.0-rc.3 (${os.type()} ${os.version()}; ${os.arch()})`,
+  };
+
+  client
+    .setEndpoint(endpoint)
+    .setProject(project)
+    .setSelfSigned(selfSigned)
+    .setLocale("en-US");
+
+  if (cookie) {
+    return client.setCookie(cookie).setMode("admin");
+  }
+
+  if (key) {
+    return client.setKey(key).setMode("default");
+  }
+
+  throw new Error(
+    "Session not found. Please run `appwrite login` to create a session.",
+  );
+};

package/lib/services.ts

@@ -0,0 +1,72 @@
+import { sdkForConsole, sdkForProject } from "./sdks.js";
+import {
+  Client,
+  Console,
+  Databases,
+  Functions,
+  Messaging,
+  Organizations,
+  Projects,
+  Proxy,
+  Sites,
+  Storage,
+  TablesDB,
+  Teams,
+} from "@appwrite.io/console";
+
+export const getConsoleService = async (sdk?: Client): Promise<Console> => {
+  const client = !sdk ? await sdkForProject() : sdk;
+  return new Console(client);
+};
+
+export const getDatabasesService = async (sdk?: Client): Promise<Databases> => {
+  const client = !sdk ? await sdkForProject() : sdk;
+  return new Databases(client);
+};
+
+export const getFunctionsService = async (sdk?: Client): Promise<Functions> => {
+  const client = !sdk ? await sdkForProject() : sdk;
+  return new Functions(client);
+};
+
+export const getMessagingService = async (sdk?: Client): Promise<Messaging> => {
+  const client = !sdk ? await sdkForProject() : sdk;
+  return new Messaging(client);
+};
+
+export const getOrganizationsService = async (
+  sdk?: Client,
+): Promise<Organizations> => {
+  const client = !sdk ? await sdkForProject() : sdk;
+  return new Organizations(client);
+};
+
+export const getProjectsService = async (sdk?: Client): Promise<Projects> => {
+  const client = !sdk ? await sdkForConsole() : sdk;
+  return new Projects(client);
+};
+
+export const getProxyService = async (sdk?: Client): Promise<Proxy> => {
+  const client = !sdk ? await sdkForProject() : sdk;
+  return new Proxy(client);
+};
+
+export const getSitesService = async (sdk?: Client): Promise<Sites> => {
+  const client = !sdk ? await sdkForProject() : sdk;
+  return new Sites(client);
+};
+
+export const getStorageService = async (sdk?: Client): Promise<Storage> => {
+  const client = !sdk ? await sdkForProject() : sdk;
+  return new Storage(client);
+};
+
+export const getTablesDBService = async (sdk?: Client): Promise<TablesDB> => {
+  const client = !sdk ? await sdkForProject() : sdk;
+  return new TablesDB(client);
+};
+
+export const getTeamsService = async (sdk?: Client): Promise<Teams> => {
+  const client = !sdk ? await sdkForProject() : sdk;
+  return new Teams(client);
+};

package/lib/spinner.ts

@@ -0,0 +1,131 @@
+import progress from "cli-progress";
+import chalk from "chalk";
+
+const SPINNER_ARC = "arc";
+const SPINNER_DOTS = "dots";
+
+interface SpinnerConfig {
+  interval: number;
+  frames: string[];
+}
+
+interface SpinnerPayload {
+  status: string;
+  resource: string;
+  id: string;
+  prefix?: string;
+  end?: string;
+  errorMessage?: string;
+}
+
+const spinners: Record<string, SpinnerConfig> = {
+  [SPINNER_ARC]: {
+    interval: 100,
+    frames: ["◜", "◠", "◝", "◞", "◡", "◟"],
+  },
+  [SPINNER_DOTS]: {
+    interval: 80,
+    frames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+  },
+};
+
+class Spinner {
+  static updatesBar: progress.MultiBar;
+  private bar: progress.SingleBar;
+  private spinnerInterval?: NodeJS.Timeout;
+
+  static start(
+    clearOnComplete: boolean = true,
+    hideCursor: boolean = true,
+  ): void {
+    Spinner.updatesBar = new progress.MultiBar({
+      format: this.formatter,
+      hideCursor,
+      clearOnComplete,
+      stopOnComplete: true,
+      linewrap: true,
+      noTTYOutput: true,
+    });
+  }
+
+  static stop(): void {
+    Spinner.updatesBar.stop();
+  }
+
+  static formatter(options: any, params: any, payload: SpinnerPayload): string {
+    const status = payload.status.padEnd(12);
+    const middle = `${payload.resource} (${payload.id})`.padEnd(40);
+
+    let prefix = chalk.cyan(payload.prefix ?? "⧗");
+    let start = chalk.cyan(status);
+    let end = chalk.yellow(payload.end ?? "");
+
+    if (status.toLowerCase().trim() === "pushed") {
+      start = chalk.greenBright.bold(status);
+      prefix = chalk.greenBright.bold("✓");
+      end = "";
+    } else if (status.toLowerCase().trim() === "deploying") {
+      start = chalk.cyanBright.bold(status);
+    } else if (status.toLowerCase().trim() === "deployed") {
+      start = chalk.green.bold(status);
+      prefix = chalk.green.bold("✓");
+    } else if (status.toLowerCase().trim() === "error") {
+      start = chalk.red.bold(status);
+      prefix = chalk.red.bold("✗");
+      end = chalk.red(payload.errorMessage ?? "");
+    }
+
+    return Spinner.line(prefix, start, middle, end);
+  }
+
+  static line(
+    prefix: string,
+    start: string,
+    middle: string,
+    end: string,
+    separator: string = "•",
+  ): string {
+    return `${prefix} ${start} ${separator} ${middle} ${!end ? "" : separator} ${end}`;
+  }
+
+  constructor(
+    payload: SpinnerPayload,
+    total: number = 100,
+    startValue: number = 0,
+  ) {
+    this.bar = Spinner.updatesBar.create(total, startValue, payload);
+  }
+
+  update(payload: Partial<SpinnerPayload>): this {
+    this.bar.update(payload);
+    return this;
+  }
+
+  fail(payload: Partial<SpinnerPayload>): void {
+    this.stopSpinner();
+    this.update({ status: "Error", ...payload });
+  }
+
+  startSpinner(name: string): void {
+    let spinnerFrame = 1;
+    const spinner = spinners[name] ?? spinners["dots"];
+
+    this.spinnerInterval = setInterval(() => {
+      if (spinnerFrame === spinner.frames.length) spinnerFrame = 1;
+      this.bar.update({ prefix: spinner.frames[spinnerFrame++] });
+    }, spinner.interval);
+  }
+
+  stopSpinner(): void {
+    if (this.spinnerInterval) {
+      clearInterval(this.spinnerInterval);
+    }
+  }
+
+  replaceSpinner(name: string): void {
+    this.stopSpinner();
+    this.startSpinner(name);
+  }
+}
+
+export { Spinner, SPINNER_ARC, SPINNER_DOTS };

package/lib/type-generation/attribute.ts

@@ -0,0 +1,18 @@
+export const AttributeType = {
+  STRING: "string",
+  INTEGER: "integer",
+  FLOAT: "double",
+  BOOLEAN: "boolean",
+  DATETIME: "datetime",
+  EMAIL: "email",
+  IP: "ip",
+  URL: "url",
+  ENUM: "enum",
+  RELATIONSHIP: "relationship",
+  POINT: "point",
+  LINESTRING: "linestring",
+  POLYGON: "polygon",
+} as const;
+
+export type AttributeTypeValue =
+  (typeof AttributeType)[keyof typeof AttributeType];

package/lib/type-generation/languages/csharp.ts

@@ -0,0 +1,192 @@
+import { AttributeType } from "../attribute.js";
+import { LanguageMeta, Attribute, Collection } from "./language.js";
+
+export class CSharp extends LanguageMeta {
+  getType(
+    attribute: Attribute,
+    collections?: Collection[],
+    collectionName?: string,
+  ): string {
+    let type = "";
+    switch (attribute.type) {
+      case AttributeType.STRING:
+      case AttributeType.EMAIL:
+      case AttributeType.DATETIME:
+        type = "string";
+        if (attribute.format === AttributeType.ENUM) {
+          type =
+            LanguageMeta.toPascalCase(collectionName!) +
+            LanguageMeta.toPascalCase(attribute.key);
+        }
+        break;
+      case AttributeType.INTEGER:
+        type = "long";
+        break;
+      case AttributeType.FLOAT:
+        type = "double";
+        break;
+      case AttributeType.BOOLEAN:
+        type = "bool";
+        break;
+      case AttributeType.RELATIONSHIP:
+        const relatedCollection = collections?.find(
+          (c) => c.$id === attribute.relatedCollection,
+        );
+        if (!relatedCollection) {
+          throw new Error(
+            `Related collection with ID '${attribute.relatedCollection}' not found.`,
+          );
+        }
+        type = LanguageMeta.toPascalCase(relatedCollection.name);
+        if (
+          (attribute.relationType === "oneToMany" &&
+            attribute.side === "parent") ||
+          (attribute.relationType === "manyToOne" &&
+            attribute.side === "child") ||
+          attribute.relationType === "manyToMany"
+        ) {
+          type = `List<${type}>`;
+        }
+        break;
+      case AttributeType.POINT:
+        type = "List<double>";
+        break;
+      case AttributeType.LINESTRING:
+        type = "List<List<double>>";
+        break;
+      case AttributeType.POLYGON:
+        type = "List<List<List<double>>>";
+        break;
+      default:
+        throw new Error(`Unknown attribute type: ${attribute.type}`);
+    }
+    if (attribute.array) {
+      type = `List<${type}>`;
+    }
+    if (!attribute.required) {
+      type += "?";
+    }
+    return type;
+  }
+
+  getTemplate(): string {
+    return `/// This file is auto-generated by the Appwrite CLI. 
+/// You can regenerate it by running \`appwrite ${process.argv.slice(2).join(" ")}\`.
+
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json.Serialization;
+
+namespace Appwrite.Models
+{
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.format === 'enum') { -%>
+
+public enum <%- toPascalCase(collection.name) %><%- toPascalCase(attribute.key) %> {
+<% for (const [index, element] of Object.entries(attribute.elements) ) { -%>
+    [JsonPropertyName("<%- element %>")]
+    <%- toPascalCase(element) %><% if (index < attribute.elements.length - 1) { %>,<% } %>
+<% } -%>
+}
+<% } -%>
+<% } %>
+public class <%= toPascalCase(collection.name) %>
+{
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+    [JsonPropertyName("<%- attribute.key %>")]
+    public <%- getType(attribute, collections, collection.name) %> <%= toPascalCase(attribute.key) %> { get; private set; }
+
+<% } -%>
+
+    public <%= toPascalCase(collection.name) %>(
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+        <%- getType(attribute, collections, collection.name) %> <%= toCamelCase(attribute.key) %><% if (index < collection.attributes.length - 1) { %>,<% } %>
+<% } -%>
+    )
+    {
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+        <%= toPascalCase(attribute.key) %> = <%= toCamelCase(attribute.key) %>;
+<% } -%>
+    }
+
+    public static <%= toPascalCase(collection.name) %> From(Dictionary<string, object> map) => new <%= toPascalCase(collection.name) %>(
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+        <%- toCamelCase(attribute.key) %>: <%
+            // ENUM
+            if (attribute.format === 'enum') {
+                if (attribute.array) {
+                    -%>((IEnumerable<object>)map["<%- attribute.key %>"]).Select(e => Enum.Parse<Models.<%- toPascalCase(collection.name) %><%- toPascalCase(attribute.key) %>>(e.ToString()!, true)).ToList()<%
+                } else {
+                    -%>Enum.Parse<Models.<%- toPascalCase(collection.name) %><%- toPascalCase(attribute.key) %>>(map["<%- attribute.key %>"].ToString()!, true)<%
+                }
+            // RELATIONSHIP
+            } else if (attribute.type === 'relationship') {
+                const relatedClass = toPascalCase(collections.find(c => c.$id === attribute.relatedCollection).name);
+                if ((attribute.relationType === 'oneToMany' && attribute.side === 'parent') || (attribute.relationType === 'manyToOne' && attribute.side === 'child') || attribute.relationType === 'manyToMany' || attribute.array) {
+                    -%>((IEnumerable<object>)map["<%- attribute.key %>"]).Select(it => Models.<%- relatedClass %>.From((Dictionary<string, object>)it)).ToList()<%
+                } else {
+                    -%>Models.<%- relatedClass %>.From((Dictionary<string, object>)map["<%- attribute.key %>"])<%
+                }
+            // ARRAY TYPES
+            } else if (attribute.array) {
+                if (attribute.type === 'string' || attribute.type === 'datetime' || attribute.type === 'email') {
+                    -%>((IEnumerable<object>)map["<%- attribute.key %>"]).Select(x => x?.ToString())<%- attribute.required ? '.Where(x => x != null)' : '' %>.ToList()!<%
+                } else if (attribute.type === 'integer') {
+                    -%>((IEnumerable<object>)map["<%- attribute.key %>"]).Select(x => <%- !attribute.required ? 'x == null ? (long?)null : ' : '' %>Convert.ToInt64(x)).ToList()<%
+                } else if (attribute.type === 'double') {
+                    -%>((IEnumerable<object>)map["<%- attribute.key %>"]).Select(x => <%- !attribute.required ? 'x == null ? (double?)null : ' : '' %>Convert.ToDouble(x)).ToList()<%
+                } else if (attribute.type === 'boolean') {
+                    -%>((IEnumerable<object>)map["<%- attribute.key %>"]).Select(x => <%- !attribute.required ? 'x == null ? (bool?)null : ' : '' %>(bool)x).ToList()<%
+                }
+            // SINGLE VALUE TYPES
+            } else if (attribute.type === 'integer') {
+                -%><%- !attribute.required ? 'map["' + attribute.key + '"] == null ? null : ' : '' %>Convert.ToInt64(map["<%- attribute.key %>"])<%
+            } else if (attribute.type === 'double') {
+                -%><%- !attribute.required ? 'map["' + attribute.key + '"] == null ? null : ' : '' %>Convert.ToDouble(map["<%- attribute.key %>"])<%
+            } else if (attribute.type === 'boolean') {
+                -%>(<%- getType(attribute, collections, collection.name) %>)map["<%- attribute.key %>"]<%
+            } else if (attribute.type === 'string' || attribute.type === 'datetime' || attribute.type === 'email') {
+                -%>map["<%- attribute.key %>"]<%- !attribute.required ? '?' : '' %>.ToString()<%- attribute.required ? '!' : ''%><%
+            } else {
+                -%>default<%
+            }
+            -%><% if (index < collection.attributes.length - 1) { %>,<% } %>
+<% } -%>
+    );
+
+    public Dictionary<string, object?> ToMap() => new Dictionary<string, object?>()
+    {
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+        { "<%- attribute.key %>", <%
+        // ENUM
+        if (attribute.format === 'enum') {
+            if (attribute.array) {
+                -%><%= toPascalCase(attribute.key) %>?.Select(e => e.ToString()).ToList()<%
+            } else {
+                -%><%= toPascalCase(attribute.key) %>?.ToString()<%
+            }
+        // RELATIONSHIP
+        } else if (attribute.type === 'relationship') {
+            if ((attribute.relationType === 'oneToMany' && attribute.side === 'parent') || (attribute.relationType === 'manyToOne' && attribute.side === 'child') || attribute.relationType === 'manyToMany' || attribute.array) {
+                -%><%= toPascalCase(attribute.key) %>?.Select(e => e.ToMap()).ToList()<%
+            } else {
+                -%><%= toPascalCase(attribute.key) %>?.ToMap()<%
+            }
+        // OTHER
+        } else {
+            -%><%= toPascalCase(attribute.key) %><%
+        }
+        -%> }<% if (index < collection.attributes.length - 1) { %>,<% } %>
+<% } -%>
+    };
+}
+}
+`;
+  }
+
+  getFileName(collection: Collection): string {
+    return LanguageMeta.toPascalCase(collection.name) + ".cs";
+  }
+}