chirag-appwrite-cli 0.1.0

package/lib/sdks.js

@@ -0,0 +1,60 @@
+const Client = require("./client");
+const { globalConfig, localConfig } = require("./config");
+
+const sdkForConsole = async (requiresAuth = true) => {
+  let client = new Client();
+  let endpoint = globalConfig.getEndpoint();
+  let cookie = globalConfig.getCookie()
+  let selfSigned = globalConfig.getSelfSigned()
+
+  if (requiresAuth && cookie === "") {
+    throw new Error("Session not found. Please run `appwrite login` to create a session");
+  }
+
+  client
+    .setEndpoint(endpoint)
+    .setCookie(cookie)
+    .setProject("console")
+    .setSelfSigned(selfSigned)
+    .setLocale("en-US");
+
+  return client;
+};
+
+const sdkForProject = async () => {
+  let client = new Client();
+  let endpoint = localConfig.getEndpoint() || globalConfig.getEndpoint();
+  let project = localConfig.getProject().projectId ? localConfig.getProject().projectId : globalConfig.getProject();
+  let key = globalConfig.getKey();
+  let cookie = globalConfig.getCookie()
+  let 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
+    .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.");
+};
+
+module.exports = {
+  sdkForConsole,
+  sdkForProject,
+};

package/lib/spinner.js

@@ -0,0 +1,104 @@
+const progress = require('cli-progress');
+const chalk = require('chalk');
+
+const SPINNER_ARC = 'arc';
+const SPINNER_DOTS = 'dots';
+
+const spinners = {
+    [SPINNER_ARC]: {
+        "interval": 100,
+        "frames": ["◜", "◠", "◝", "◞", "◡", "◟"]
+    },
+    [SPINNER_DOTS]: {
+        "interval": 80,
+        "frames": ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    }
+}
+
+class Spinner {
+    static start(clearOnComplete = true, hideCursor = true) {
+        Spinner.updatesBar = new progress.MultiBar({
+            format: this.#formatter,
+            hideCursor,
+            clearOnComplete,
+            stopOnComplete: true,
+            linewrap: true,
+            noTTYOutput: true
+        });
+    }
+
+    static stop() {
+        Spinner.updatesBar.stop();
+    }
+
+    static #formatter(options, params, payload) {
+        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, start, middle, end, separator = '•') {
+        return `${prefix} ${start} ${separator} ${middle} ${!end ? '' : separator} ${end}`;
+
+    }
+
+    constructor(payload, total = 100, startValue = 0) {
+        this.bar = Spinner.updatesBar.create(total, startValue, payload)
+    }
+
+    update(payload) {
+        this.bar.update(payload);
+        return this;
+    }
+
+    fail(payload) {
+        this.stopSpinner();
+        this.update({ status: 'Error', ...payload });
+    }
+
+    startSpinner(name) {
+        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() {
+        clearInterval(this.spinnerInterval);
+    }
+
+    replaceSpinner(name) {
+        this.stopSpinner();
+        this.startSpinner(name);
+    }
+}
+
+
+module.exports = {
+    Spinner,
+    SPINNER_ARC,
+    SPINNER_DOTS
+}

package/lib/type-generation/attribute.js

@@ -0,0 +1,16 @@
+const AttributeType = {
+    STRING: "string",
+    INTEGER: "integer",
+    FLOAT: "double",
+    BOOLEAN: "boolean",
+    DATETIME: "datetime",
+    EMAIL: "email",
+    IP: "ip",
+    URL: "url",
+    ENUM: "enum",
+    RELATIONSHIP: "relationship",
+};
+
+ module.exports = {
+    AttributeType,
+ };

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

@@ -0,0 +1,196 @@
+/** @typedef {import('../attribute').Attribute} Attribute */
+const { AttributeType } = require('../attribute');
+const { LanguageMeta } = require("./language");
+const fs = require('fs');
+const path = require('path');
+
+class Dart extends LanguageMeta {
+  getPackageName() {
+    const pubspecPath = path.join(this.getCurrentDirectory(), '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 = [];
+            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) {
+    let type = "";
+    switch (attribute.type) {
+      case AttributeType.STRING:
+      case AttributeType.EMAIL:
+      case AttributeType.DATETIME:
+        type = "String";
+        if (attribute.format === AttributeType.ENUM) {
+          type = 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:
+        type = LanguageMeta.toPascalCase(attribute.relatedCollection);
+        if ((attribute.relationType === 'oneToMany' && attribute.side === 'parent') || (attribute.relationType === 'manyToOne' && attribute.side === 'child') || attribute.relationType === 'manyToMany') {
+          type = `List<${type}>`;
+        }
+        break;
+      default:
+        throw new Error(`Unknown attribute type: ${attribute.type}`);
+    }
+    if (attribute.array) {
+      type = `List<${type}>`;
+    }
+    if (!attribute.required) {
+      type += "?";
+    }
+    return type;
+  }
+
+  getCurrentDirectory() {
+    return process.cwd();
+  }
+
+  getTemplate() {
+    return `<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.type === 'relationship') { -%>
+import '<%- toSnakeCase(attribute.relatedCollection) %>.dart';
+
+<% } -%>
+<% } -%>
+/// This file is auto-generated by the Appwrite CLI. 
+/// You can regenerate it by running \`appwrite types -l <%- strict ? '--strict ' : '' %>dart <%- path %>\`.
+
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.format === 'enum') { -%>
+enum <%- 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(collection.attributes)) { -%>
+  <%- getType(attribute) %> <%= strict ? toCamelCase(attribute.key) : attribute.key %>;
+<% } -%>
+
+  <%= toPascalCase(collection.name) %>({
+  <% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+  <% if (attribute.required) { %>required <% } %>this.<%= strict ? toCamelCase(attribute.key) : attribute.key %><% if (index < collection.attributes.length - 1) { %>,<% } %>
+  <% } -%>
+});
+
+  factory <%= toPascalCase(collection.name) %>.fromMap(Map<String, dynamic> map) {
+    return <%= toPascalCase(collection.name) %>(
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+      <%= strict ? toCamelCase(attribute.key) : attribute.key %>: <% if (attribute.type === 'string' || attribute.type === 'email' || attribute.type === 'datetime') { -%>
+<% if (attribute.format === 'enum') { -%>
+<% if (attribute.array) { -%>
+(map['<%= attribute.key %>'] as List<dynamic>?)?.map((e) => <%- toPascalCase(attribute.key) %>.values.firstWhere((element) => element.name == e)).toList()<% if (!attribute.required) { %> ?? []<% } -%>
+<% } else { -%>
+<% if (!attribute.required) { -%>
+map['<%= attribute.key %>'] != null ? <%- toPascalCase(attribute.key) %>.values.where((e) => e.name == map['<%= attribute.key %>']).firstOrNull : null<% } else { -%>
+<%- toPascalCase(attribute.key) %>.values.firstWhere((e) => e.name == map['<%= attribute.key %>'])<% } -%>
+<% } -%>
+<% } else { -%>
+<% if (attribute.array) { -%>
+List<String>.from(map['<%= attribute.key %>'] ?? [])<% if (!attribute.required) { %> ?? []<% } -%>
+<% } else { -%>
+map['<%= attribute.key %>']<% if (!attribute.required) { %>?<% } %>.toString()<% if (!attribute.required) { %> ?? null<% } -%>
+<% } -%>
+<% } -%>
+<% } else if (attribute.type === 'integer') { -%>
+<% if (attribute.array) { -%>
+List<int>.from(map['<%= attribute.key %>'] ?? [])<% if (!attribute.required) { %> ?? []<% } -%>
+<% } else { -%>
+map['<%= attribute.key %>']<% if (!attribute.required) { %> ?? null<% } -%>
+<% } -%>
+<% } else if (attribute.type === 'float') { -%>
+<% if (attribute.array) { -%>
+List<double>.from(map['<%= attribute.key %>'] ?? [])<% if (!attribute.required) { %> ?? []<% } -%>
+<% } else { -%>
+map['<%= attribute.key %>']<% if (!attribute.required) { %> ?? null<% } -%>
+<% } -%>
+<% } else if (attribute.type === 'boolean') { -%>
+<% if (attribute.array) { -%>
+List<bool>.from(map['<%= attribute.key %>'] ?? [])<% if (!attribute.required) { %> ?? []<% } -%>
+<% } else { -%>
+map['<%= attribute.key %>']<% if (!attribute.required) { %> ?? null<% } -%>
+<% } -%>
+<% } else if (attribute.type === '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(attribute.relatedCollection) %>.fromMap(e)).toList()<% if (!attribute.required) { %> ?? []<% } -%>
+<% } else { -%>
+<% if (!attribute.required) { -%>
+map['<%= attribute.key %>'] != null ? <%- toPascalCase(attribute.relatedCollection) %>.fromMap(map['<%= attribute.key %>']) : null<% } else { -%>
+<%- toPascalCase(attribute.relatedCollection) %>.fromMap(map['<%= attribute.key %>'])<% } -%>
+<% } -%>
+<% } -%><% if (index < collection.attributes.length - 1) { %>,<% } %>
+<% } -%>
+    );
+  }
+
+  Map<String, dynamic> toMap() {
+    return {
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+      "<%= attribute.key %>": <% if (attribute.type === '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()<% if (!attribute.required) { %> ?? []<% } -%>
+<% } else { -%>
+<%= strict ? toCamelCase(attribute.key) : attribute.key %><% if (!attribute.required) { %>?<% } %>.toMap()<% if (!attribute.required) { %> ?? {}<% } -%>
+<% } -%>
+<% } else if (attribute.format === 'enum') { -%>
+<% if (attribute.array) { -%>
+<%= strict ? toCamelCase(attribute.key) : attribute.key %><% if (!attribute.required) { %>?<% } %>.map((e) => e.name).toList()<% if (!attribute.required) { %> ?? []<% } -%>
+<% } else { -%>
+<%= strict ? toCamelCase(attribute.key) : attribute.key %><% if (!attribute.required) { %>?<% } %>.name<% if (!attribute.required) { %> ?? null<% } -%>
+<% } -%>
+<% } else { -%>
+<%= strict ? toCamelCase(attribute.key) : attribute.key -%>
+<% } -%><% if (index < collection.attributes.length - 1) { %>,<% } %>
+<% } -%>
+    };
+  }
+}
+`;
+  }
+
+  getFileName(collection) {
+    return LanguageMeta.toSnakeCase(collection.name) + ".dart";
+  }
+}
+
+module.exports = { Dart };

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

@@ -0,0 +1,130 @@
+/** @typedef {import('../attribute').Attribute} Attribute */
+const { AttributeType } = require('../attribute');
+const { LanguageMeta } = require("./language");
+
+class Java extends LanguageMeta {
+  getType(attribute) {
+    let type = "";
+    switch (attribute.type) {
+      case AttributeType.STRING:
+      case AttributeType.EMAIL:
+      case AttributeType.DATETIME:
+        type = "String";
+        if (attribute.format === AttributeType.ENUM) {
+          type = LanguageMeta.toPascalCase(attribute.key);
+        }
+        break;
+      case AttributeType.INTEGER:
+        type = "int";
+        break;
+      case AttributeType.FLOAT:
+        type = "double";
+        break;
+      case AttributeType.BOOLEAN:
+        type = "boolean";
+        break;
+      case AttributeType.RELATIONSHIP:
+        type = LanguageMeta.toPascalCase(attribute.relatedCollection);
+        if ((attribute.relationType === 'oneToMany' && attribute.side === 'parent') || (attribute.relationType === 'manyToOne' && attribute.side === 'child') || attribute.relationType === 'manyToMany') {
+          type = "List<" + type + ">";
+        }
+        break;
+      default:
+        throw new Error(`Unknown attribute type: ${attribute.type}`);
+    }
+    if (attribute.array) {
+      type = "List<" + type + ">";
+    }
+    return type;
+  }
+
+  getCurrentDirectory() {
+    return process.cwd();
+  }
+
+  getTemplate() {
+    return `package io.appwrite.models;
+
+/**
+ * This file is auto-generated by the Appwrite CLI. 
+ * You can regenerate it by running \`appwrite types -l <%- strict ? '--strict ' : '' %>java <%- path %>\`.
+ */
+
+import java.util.Objects;
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.type === 'relationship') { -%>
+import io.appwrite.models.<%- toPascalCase(attribute.relatedCollection) %>;
+
+<% } -%>
+<% } -%>
+public class <%- toPascalCase(collection.name) %> {
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.format === 'enum') { -%>
+
+    public enum <%- 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) %> <%- 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) %> <%= 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) %> get<%- toPascalCase(attribute.key) %>() {
+        return <%= strict ? toCamelCase(attribute.key) : attribute.key %>;
+    }
+
+    public void set<%- toPascalCase(attribute.key) %>(<%- getType(attribute) %> <%= 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) {
+    return LanguageMeta.toPascalCase(collection.name) + ".java";
+  }
+}
+
+module.exports = { Java };

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

@@ -0,0 +1,102 @@
+/** @typedef {import('../attribute').Attribute} Attribute */
+const fs = require("fs");
+const path = require("path");
+
+const { AttributeType } = require('../attribute');
+const { LanguageMeta } = require("./language");
+
+class JavaScript extends LanguageMeta {
+  getType(attribute) {
+    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:
+        type = LanguageMeta.toPascalCase(attribute.relatedCollection);
+        if ((attribute.relationType === 'oneToMany' && attribute.side === 'parent') || (attribute.relationType === 'manyToOne' && attribute.side === 'child') || attribute.relationType === 'manyToMany') {
+          type = `${type}[]`;
+        }
+        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() {
+    return true;
+  }
+
+  _getAppwriteDependency() {
+    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['node-appwrite'] ? 'node-appwrite' : 'appwrite';
+    }
+
+    return "appwrite";
+  }
+
+  getCurrentDirectory() {
+    return process.cwd();
+  }
+
+  getTemplate() {
+    return `
+// This file is auto-generated by the Appwrite CLI. 
+// You can regenerate it by running \`appwrite types -l <%- strict ? '--strict ' : '' %>js <%- path %>\`.
+
+/**
+ * @typedef {import('${this._getAppwriteDependency()}').Models.Document} Document
+ */
+
+<% for (const collection of collections) { -%>
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.format === 'enum') { -%>
+/**
+ * @typedef {"<%- attribute.elements.join('"|"') %>"} <%- toPascalCase(attribute.key) %>
+ */
+
+<% } -%>
+<% } -%>
+<% } -%>
+<% for (const collection of collections) { %>/**
+ * @typedef {Document & {
+<% for (const attribute of collection.attributes) { -%>
+ *   <%- strict ? toCamelCase(attribute.key) : attribute.key %>: <%- getType(attribute) %>;
+<% } -%>
+ * }} <%- toPascalCase(collection.name) %>
+ */
+
+<% } %>`;
+  }
+
+  getFileName(_) {
+    return "appwrite-types.js";
+  }
+}
+
+module.exports = { JavaScript }; 

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

@@ -0,0 +1,84 @@
+/** @typedef {import('../attribute').Attribute} Attribute */
+const { AttributeType } = require('../attribute');
+const { LanguageMeta } = require("./language");
+
+class Kotlin extends LanguageMeta {
+  getType(attribute) {
+    let type = "";
+    switch (attribute.type) {
+      case AttributeType.STRING:
+      case AttributeType.EMAIL:
+      case AttributeType.DATETIME:
+        type = "String";
+        if (attribute.format === AttributeType.ENUM) {
+          type = 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:
+        type = LanguageMeta.toPascalCase(attribute.relatedCollection);
+        if ((attribute.relationType === 'oneToMany' && attribute.side === 'parent') || (attribute.relationType === 'manyToOne' && attribute.side === 'child') || attribute.relationType === 'manyToMany') {
+          type = `List<${type}>`;
+        }
+        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;
+  }
+
+  getCurrentDirectory() {
+    return process.cwd();
+  }
+
+  getTemplate() {
+    return `package io.appwrite.models
+
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.type === 'relationship') { -%>
+import <%- toPascalCase(attribute.relatedCollection) %>
+
+<% } -%>
+<% } -%>
+/**
+ * This file is auto-generated by the Appwrite CLI. 
+ * You can regenerate it by running \`appwrite types -l <%- strict ? '--strict ' : '' %>kotlin <%- path %>\`.
+ */
+
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.format === 'enum') { -%>
+enum class <%- 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) %><% if (index < collection.attributes.length - 1) { %>,<% } %>
+<% } -%>
+)`;
+  }
+
+  getFileName(collection) {
+    return LanguageMeta.toPascalCase(collection.name) + ".kt";
+  }
+}
+
+module.exports = { Kotlin };