chirag-appwrite-cli 0.1.0 → 0.2.0

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

@@ -0,0 +1,217 @@
+import fs from "fs";
+import path from "path";
+import { AttributeType } from "../attribute.js";
+import { LanguageMeta, Attribute, Collection } from "./language.js";
+
+export class Dart extends LanguageMeta {
+  getPackageName(): string {
+    const pubspecPath = path.join(process.cwd(), "pubspec.yaml");
+    if (fs.existsSync(pubspecPath)) {
+      const pubspecContent = fs.readFileSync(pubspecPath, "utf8");
+      const lines = pubspecContent.split("\n");
+
+      const dependenciesIndex = lines.findIndex(
+        (line) => line.trim() === "dependencies:",
+      );
+
+      if (dependenciesIndex !== -1) {
+        const indent = lines[dependenciesIndex].search(/\S|$/);
+        const dependencies: string[] = [];
+        for (let i = dependenciesIndex + 1; i < lines.length; i++) {
+          const line = lines[i];
+          if (line.trim() === "") continue;
+
+          const lineIndent = line.search(/\S|$/);
+          if (lineIndent <= indent && line.trim() !== "") {
+            break;
+          }
+
+          dependencies.push(line.trim());
+        }
+
+        if (dependencies.some((dep) => dep.startsWith("dart_appwrite:"))) {
+          return "dart_appwrite";
+        }
+        if (dependencies.some((dep) => dep.startsWith("appwrite:"))) {
+          return "appwrite";
+        }
+      }
+    }
+
+    return "appwrite";
+  }
+
+  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 = "int";
+        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(" ")}\`.
+<% const __relatedImportsSeen = new Set();
+   const sortedAttributes = collection.attributes.slice().sort((a, b) => {
+     if (a.required === b.required) return 0;
+     return a.required ? -1 : 1;
+   }); -%>
+<% const __attrs = sortedAttributes; -%>
+<% for (const attribute of __attrs) { -%>
+<%   if (attribute.type === '${AttributeType.RELATIONSHIP}') { -%>
+<%     const related = collections.find(c => c.$id === attribute.relatedCollection); -%>
+<%     if (related && !__relatedImportsSeen.has(toSnakeCase(related.name))) { -%>
+import '<%- toSnakeCase(related.name) %>.dart';
+<%       __relatedImportsSeen.add(toSnakeCase(related.name)); -%>
+<%     } -%>
+<%   } -%>
+<% } -%>
+
+<% for (const attribute of __attrs) { -%>
+<% if (attribute.format === '${AttributeType.ENUM}') { -%>
+enum <%- toPascalCase(collection.name) %><%- toPascalCase(attribute.key) %> {
+<% for (const [index, element] of Object.entries(attribute.elements)) { -%>
+  <%- strict ? toCamelCase(element) : element %><% if (index < attribute.elements.length - 1) { -%>,<% } %>
+<% } -%>
+}
+
+<% } -%>
+<% } -%>
+class <%= toPascalCase(collection.name) %> {
+<% for (const [index, attribute] of Object.entries(__attrs)) { -%>
+  <%- getType(attribute, collections, collection.name) %> <%= strict ? toCamelCase(attribute.key) : attribute.key %>;
+<% } -%>
+
+  <%= toPascalCase(collection.name) %>({
+  <% for (const [index, attribute] of Object.entries(__attrs)) { -%>
+  <% if (attribute.required) { %>required <% } %>this.<%= strict ? toCamelCase(attribute.key) : attribute.key %><% if (index < __attrs.length - 1) { -%>,<% } %>
+  <% } -%>
+});
+
+  factory <%= toPascalCase(collection.name) %>.fromMap(Map<String, dynamic> map) {
+    return <%= toPascalCase(collection.name) %>(
+<% for (const [index, attribute] of Object.entries(__attrs)) { -%>
+  <%= strict ? toCamelCase(attribute.key) : attribute.key %>: <% if (attribute.type === '${AttributeType.STRING}' || attribute.type === '${AttributeType.EMAIL}' || attribute.type === '${AttributeType.DATETIME}') { -%>
+<% if (attribute.format === '${AttributeType.ENUM}') { -%>
+<% if (attribute.array) { -%>
+(map['<%= attribute.key %>'] as List<dynamic>?)?.map((e) => <%- toPascalCase(collection.name) %><%- toPascalCase(attribute.key) %>.values.firstWhere((element) => element.name == e)).toList()<% } else { -%>
+<% if (!attribute.required) { -%>
+map['<%= attribute.key %>'] != null ? <%- toPascalCase(collection.name) %><%- toPascalCase(attribute.key) %>.values.where((e) => e.name == map['<%= attribute.key %>']).firstOrNull : null<% } else { -%>
+<%- toPascalCase(collection.name) %><%- toPascalCase(attribute.key) %>.values.firstWhere((e) => e.name == map['<%= attribute.key %>'])<% } -%>
+<% } -%>
+<% } else { -%>
+<% if (attribute.array) { -%>
+List<String>.from(map['<%= attribute.key %>'] ?? [])<% } else { -%>
+map['<%= attribute.key %>']<% if (!attribute.required) { %>?<% } %>.toString()<% } -%>
+<% } -%>
+<% } else if (attribute.type === '${AttributeType.INTEGER}') { -%>
+<% if (attribute.array) { -%>
+List<int>.from(map['<%= attribute.key %>'] ?? [])<% } else { -%>
+map['<%= attribute.key %>']<% } -%>
+<% } else if (attribute.type === '${AttributeType.FLOAT}') { -%>
+<% if (attribute.array) { -%>
+List<double>.from(map['<%= attribute.key %>'] ?? [])<% } else { -%>
+map['<%= attribute.key %>']<% } -%>
+<% } else if (attribute.type === '${AttributeType.BOOLEAN}') { -%>
+<% if (attribute.array) { -%>
+List<bool>.from(map['<%= attribute.key %>'] ?? [])<% } else { -%>
+map['<%= attribute.key %>']<% } -%>
+<% } else if (attribute.type === '${AttributeType.RELATIONSHIP}') { -%>
+<% if ((attribute.relationType === 'oneToMany' && attribute.side === 'parent') || (attribute.relationType === 'manyToOne' && attribute.side === 'child') || attribute.relationType === 'manyToMany') { -%>
+(map['<%= attribute.key %>'] as List<dynamic>?)?.map((e) => <%- toPascalCase(collections.find(c => c.$id === attribute.relatedCollection).name) %>.fromMap(e)).toList()
+<% } else { -%>
+<% if (!attribute.required) { -%>
+map['<%= attribute.key %>'] != null ? <%- toPascalCase(collections.find(c => c.$id === attribute.relatedCollection).name) %>.fromMap(map['<%= attribute.key %>']) : null<% } else { -%>
+<%- toPascalCase(collections.find(c => c.$id === attribute.relatedCollection).name) %>.fromMap(map['<%= attribute.key %>'])<% } -%>
+<% } -%>
+<% } -%><% if (index < __attrs.length - 1) { -%>,<% } %>
+<% } -%>
+    );
+  }
+
+  Map<String, dynamic> toMap() {
+    return {
+<% for (const [index, attribute] of Object.entries(__attrs)) { -%>
+  '<%= attribute.key %>': <% if (attribute.type === '${AttributeType.RELATIONSHIP}') { -%>
+<% if ((attribute.relationType === 'oneToMany' && attribute.side === 'parent') || (attribute.relationType === 'manyToOne' && attribute.side === 'child') || attribute.relationType === 'manyToMany') { -%>
+<%= strict ? toCamelCase(attribute.key) : attribute.key %><% if (!attribute.required) { %>?<% } %>.map((e) => e.toMap()).toList()
+<% } else { -%>
+<%= strict ? toCamelCase(attribute.key) : attribute.key %><% if (!attribute.required) { %>?<% } %>.toMap()<% } -%>
+<% } else if (attribute.format === '${AttributeType.ENUM}') { -%>
+<% if (attribute.array) { -%>
+<%= strict ? toCamelCase(attribute.key) : attribute.key %><% if (!attribute.required) { %>?<% } %>.map((e) => e.name).toList()<% } else { -%>
+<%= strict ? toCamelCase(attribute.key) : attribute.key %><% if (!attribute.required) { %>?<% } %>.name<% } -%>
+<% } else { -%>
+<%= strict ? toCamelCase(attribute.key) : attribute.key -%>
+<% } -%><% if (index < __attrs.length - 1) { -%>,<% } %>
+<% } -%>
+    };
+  }
+}
+`;
+  }
+
+  getFileName(collection: Collection): string {
+    return LanguageMeta.toSnakeCase(collection.name) + ".dart";
+  }
+}

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

@@ -0,0 +1,152 @@
+import { AttributeType } from "../attribute.js";
+import { LanguageMeta, Attribute, Collection } from "./language.js";
+
+export class Java 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 = "Integer";
+        break;
+      case AttributeType.FLOAT:
+        type = "Double";
+        break;
+      case AttributeType.BOOLEAN:
+        type = "Boolean";
+        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 + ">";
+    }
+    return type;
+  }
+
+  getTemplate(): string {
+    return `package io.appwrite.models;
+
+/**
+ * This file is auto-generated by the Appwrite CLI. 
+ * You can regenerate it by running \`appwrite ${process.argv.slice(2).join(" ")}\`.
+ */
+
+import java.util.Objects;
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.type === 'relationship') { -%>
+import io.appwrite.models.<%- toPascalCase(collections.find(c => c.$id === attribute.relatedCollection).name) %>;
+<% } -%>
+<% } -%>
+
+public class <%- toPascalCase(collection.name) %> {
+<% 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)) { -%>
+        <%- strict ? toUpperSnakeCase(element) : element %><%- index < attribute.elements.length - 1 ? ',' : ';' %>
+<% } -%>
+    }
+
+<% } -%>
+<% } -%>
+<% for (const attribute of collection.attributes) { -%>
+    private <%- getType(attribute, collections, collection.name) %> <%- strict ? toCamelCase(attribute.key) : attribute.key %>;
+<% } -%>
+
+    public <%- toPascalCase(collection.name) %>() {
+    }
+
+    public <%- toPascalCase(collection.name) %>(
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+        <%- getType(attribute, collections, collection.name) %> <%= strict ? toCamelCase(attribute.key) : attribute.key %><%- index < collection.attributes.length - 1 ? ',' : '' %>
+<% } -%>
+    ) {
+<% for (const attribute of collection.attributes) { -%>
+        this.<%= strict ? toCamelCase(attribute.key) : attribute.key %> = <%= strict ? toCamelCase(attribute.key) : attribute.key %>;
+<% } -%>
+    }
+
+<% for (const attribute of collection.attributes) { -%>
+    public <%- getType(attribute, collections, collection.name) %> get<%- toPascalCase(attribute.key) %>() {
+        return <%= strict ? toCamelCase(attribute.key) : attribute.key %>;
+    }
+
+    public void set<%- toPascalCase(attribute.key) %>(<%- getType(attribute, collections, collection.name) %> <%= strict ? toCamelCase(attribute.key) : attribute.key %>) {
+        this.<%= strict ? toCamelCase(attribute.key) : attribute.key %> = <%= strict ? toCamelCase(attribute.key) : attribute.key %>;
+    }
+
+<% } -%>
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        <%- toPascalCase(collection.name) %> that = (<%- toPascalCase(collection.name) %>) obj;
+        return <% collection.attributes.forEach((attr, index) => { %>Objects.equals(<%= toCamelCase(attr.key) %>, that.<%= toCamelCase(attr.key) %>)<% if (index < collection.attributes.length - 1) { %> &&
+          <% } }); %>;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(<%= collection.attributes.map(attr => toCamelCase(attr.key)).join(', ') %>);
+    }
+
+    @Override
+    public String toString() {
+        return "<%- toPascalCase(collection.name) %>{" +
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+                "<%= strict ? toCamelCase(attribute.key) : attribute.key %>=" + <%= strict ? toCamelCase(attribute.key) : attribute.key %> +<% if (index < collection.attributes.length - 1) { %> ", " +<% } %>
+<% } -%>
+                '}';
+    }
+}
+`;
+  }
+
+  getFileName(collection: Collection): string {
+    return LanguageMeta.toPascalCase(collection.name) + ".java";
+  }
+}

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

@@ -0,0 +1,122 @@
+import fs from "fs";
+import path from "path";
+import { AttributeType } from "../attribute.js";
+import { LanguageMeta, Attribute, Collection } from "./language.js";
+
+export class JavaScript extends LanguageMeta {
+  getType(attribute: Attribute, collections?: Collection[]): string {
+    let type = "";
+    switch (attribute.type) {
+      case AttributeType.STRING:
+      case AttributeType.EMAIL:
+      case AttributeType.DATETIME:
+      case AttributeType.IP:
+      case AttributeType.URL:
+        type = "string";
+        if (attribute.format === AttributeType.ENUM) {
+          type = LanguageMeta.toPascalCase(attribute.key);
+        }
+        break;
+      case AttributeType.INTEGER:
+        type = "number";
+        break;
+      case AttributeType.FLOAT:
+        type = "number";
+        break;
+      case AttributeType.BOOLEAN:
+        type = "boolean";
+        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 = `${type}[]`;
+        }
+        break;
+      case AttributeType.POINT:
+        type = "number[]";
+        break;
+      case AttributeType.LINESTRING:
+        type = "number[][]";
+        break;
+      case AttributeType.POLYGON:
+        type = "number[][][]";
+        break;
+      default:
+        throw new Error(`Unknown attribute type: ${attribute.type}`);
+    }
+    if (attribute.array) {
+      type += "[]";
+    }
+    if (!attribute.required && attribute.default === null) {
+      type += " | null";
+    }
+    return type;
+  }
+
+  isSingleFile(): boolean {
+    return true;
+  }
+
+  private _getAppwriteDependency(): string {
+    if (fs.existsSync(path.resolve(process.cwd(), "package.json"))) {
+      const packageJsonRaw = fs.readFileSync(
+        path.resolve(process.cwd(), "package.json"),
+      );
+      const packageJson = JSON.parse(packageJsonRaw.toString("utf-8"));
+      return packageJson.dependencies &&
+        packageJson.dependencies["node-appwrite"]
+        ? "node-appwrite"
+        : "appwrite";
+    }
+
+    return "appwrite";
+  }
+
+  getTemplate(): string {
+    return `/**
+ * @typedef {import('${this._getAppwriteDependency()}').Models.Row} Row
+ */
+
+// This file is auto-generated by the Appwrite CLI.
+// You can regenerate it by running \`appwrite ${process.argv.slice(2).join(" ")}\`.
+
+<% for (const collection of collections) { -%>
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.format === 'enum') { -%>
+/**
+ * @typedef {"<%- attribute.elements.join('"|"') %>"} <%- toPascalCase(attribute.key) %>
+ */
+
+<% } -%>
+<% } -%>
+<% } -%>
+<% for (const [index, collection] of Object.entries(collections)) { %>/**
+ * @typedef {Row & {
+<% for (const attribute of collection.attributes) { -%>
+ *   <%- strict ? toCamelCase(attribute.key) : attribute.key %>: <%- getType(attribute, collections) %>;
+<% } -%>
+ * }} <%- toPascalCase(collection.name) %>
+ */
+<% if (index < collections.length - 1) { %>
+<% } -%>
+<% } %>`;
+  }
+
+  getFileName(_: Collection | undefined): string {
+    return "appwrite-types.js";
+  }
+}

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

@@ -0,0 +1,107 @@
+import { AttributeType } from "../attribute.js";
+import { LanguageMeta, Attribute, Collection } from "./language.js";
+
+export class Kotlin 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 = "Int";
+        break;
+      case AttributeType.FLOAT:
+        type = "Float";
+        break;
+      case AttributeType.BOOLEAN:
+        type = "Boolean";
+        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 && attribute.default === null) {
+      type += "?";
+    }
+    return type;
+  }
+
+  getTemplate(): string {
+    return `package io.appwrite.models
+
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.type === 'relationship') { -%>
+import <%- toPascalCase(collections.find(c => c.$id === attribute.relatedCollection).name) %>
+
+<% } -%>
+<% } -%>
+/**
+ * This file is auto-generated by the Appwrite CLI. 
+ * You can regenerate it by running \`appwrite ${process.argv.slice(2).join(" ")}\`.
+ */
+
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.format === 'enum') { -%>
+enum class <%- toPascalCase(collection.name) %><%- toPascalCase(attribute.key) %> {
+<% for (const [index, element] of Object.entries(attribute.elements)) { -%>
+    <%- strict ? toUpperSnakeCase(element) : element %><%- index < attribute.elements.length - 1 ? ',' : '' %>
+<% } -%>
+}
+
+<% } -%>
+<% } -%>
+data class <%- toPascalCase(collection.name) %>(
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+    val <%- strict ? toCamelCase(attribute.key) : attribute.key %>: <%- getType(attribute, collections, collection.name) %><% if (index < collection.attributes.length - 1) { %>,<% } %>
+<% } -%>
+)
+`;
+  }
+
+  getFileName(collection: Collection): string {
+    return LanguageMeta.toPascalCase(collection.name) + ".kt";
+  }
+}