appwrite-cli 8.1.1 → 8.2.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Change Log
 
+## 8.2.0
+
+* Add `encrypt` attribute support
+* Add improved warnings on attribute recreation and deletion
+* Fix `null` parsing error when using create attribute command
+* Type generation fixes and improvements:
+  * Add `--strict` / `-s` flag to `appwrite types` command to generate types in strict mode. This automatically converts the casing of attributes to match the language's naming conventions
+  * Add automatic package import to `dart` language which uses package detection to import the correct package
+  * Add `Document` class extension to generated types in `dart` and `js` language to support internal attributes like `$id` and `$collectionId` etc.
+  * Add proper enum support to `js` language
+  * Fix indentation in `java`, `kotlin` and `swift` to use 2 spaces instead of 4 for consistency across all languages
+  * Fix doc comments to use correct syntax in various languages (for eg. `///` instead of `/*`)
+  * Update enums in `dart` to use lowerCamelCase in `strict` mode as per [constant_identifier_names](https://dart.dev/tools/diagnostics/constant_identifier_names?utm_source=dartdev&utm_medium=redir&utm_id=diagcode&utm_content=constant_identifier_names)
+
 ## 8.1.1
 
 * Fix circular dependency issue due to usage of `success` method in `utils.js` file from `parser.js` file

package/README.md

@@ -29,7 +29,7 @@ Once the installation is complete, you can verify the install using
 
 ```sh
 $ appwrite -v
-8.1.1
+8.2.0
 ```
 
 ### Install using prebuilt binaries
@@ -60,7 +60,7 @@ $ scoop install https://raw.githubusercontent.com/appwrite/sdk-for-cli/master/sc
 Once the installation completes, you can verify your install using
 ```
 $ appwrite -v
-8.1.1
+8.2.0
 ```
 
 ## Getting Started 

package/install.ps1

@@ -13,8 +13,8 @@
 # You can use "View source" of this page to see the full script.
 
 # REPO
-$GITHUB_x64_URL = "https://github.com/appwrite/sdk-for-cli/releases/download/8.1.1/appwrite-cli-win-x64.exe"
-$GITHUB_arm64_URL = "https://github.com/appwrite/sdk-for-cli/releases/download/8.1.1/appwrite-cli-win-arm64.exe"
+$GITHUB_x64_URL = "https://github.com/appwrite/sdk-for-cli/releases/download/8.2.0/appwrite-cli-win-x64.exe"
+$GITHUB_arm64_URL = "https://github.com/appwrite/sdk-for-cli/releases/download/8.2.0/appwrite-cli-win-arm64.exe"
 
 $APPWRITE_BINARY_NAME = "appwrite.exe"
 

package/install.sh

@@ -97,7 +97,7 @@ printSuccess() {
 downloadBinary() {
     echo "[2/4] Downloading executable for $OS ($ARCH) ..."
 
-    GITHUB_LATEST_VERSION="8.1.1"
+    GITHUB_LATEST_VERSION="8.2.0"
     GITHUB_FILE="appwrite-cli-${OS}-${ARCH}"
     GITHUB_URL="https://github.com/$GITHUB_REPOSITORY_NAME/releases/download/$GITHUB_LATEST_VERSION/$GITHUB_FILE"
 

package/lib/client.js

@@ -16,8 +16,8 @@ class Client {
       'x-sdk-name': 'Command Line',
       'x-sdk-platform': 'console',
       'x-sdk-language': 'cli',
-      'x-sdk-version': '8.1.1',
-      'user-agent' : `AppwriteCLI/8.1.1 (${os.type()} ${os.version()}; ${os.arch()})`,
+      'x-sdk-version': '8.2.0',
+      'user-agent' : `AppwriteCLI/8.2.0 (${os.type()} ${os.version()}; ${os.arch()})`,
       'X-Appwrite-Response-Format' : '1.7.0',
     };
   }

package/lib/commands/push.js

@@ -508,6 +508,7 @@ const createAttribute = (databaseId, collectionId, attribute) => {
                         required: attribute.required,
                         xdefault: attribute.default,
                         array: attribute.array,
+                        encrypt: attribute.encrypt,
                         parseOutput: false
                     })
 
@@ -844,10 +845,14 @@ const attributesToCreate = async (remoteAttributes, localAttributes, collection,
 
     if (!cliConfig.force) {
         if (deleting.length > 0 && !isIndex) {
-            log(`Attribute deletion will cause ${chalk.red('loss of data')}`);
+            console.log(`${chalk.red('-------------------------------------------------------')}`);
+            console.log(`${chalk.red('| WARNING: Attribute deletion may cause loss of data |')}`);
+            console.log(`${chalk.red('-------------------------------------------------------')}`);
         }
         if (conflicts.length > 0 && !isIndex) {
-            log(`Attribute recreation will cause ${chalk.red('loss of data')}`);
+            console.log(`${chalk.red('---------------------------------------------------------')}`);
+            console.log(`${chalk.red('| WARNING: Attribute recreation may cause loss of data |')}`);
+            console.log(`${chalk.red('---------------------------------------------------------')}`);
         }
 
         if ((await getConfirmation()) !== true) {

package/lib/commands/types.js

@@ -58,12 +58,22 @@ const typesLanguageOption = new Option(
   .choices(["auto", "ts", "js", "php", "kotlin", "swift", "java", "dart"])
   .default("auto");
 
-const typesCommand = actionRunner(async (rawOutputDirectory, {language}) => {
+const typesStrictOption = new Option(
+  "-s, --strict",
+  "Enable strict mode to automatically convert field names to follow language conventions"
+)
+  .default(false);
+
+const typesCommand = actionRunner(async (rawOutputDirectory, {language, strict}) => {
   if (language === "auto") {
     language = detectLanguage();
     log(`Detected language: ${language}`);
   }
 
+  if (strict) {
+    log(`Strict mode enabled: Field names will be converted to follow ${language} conventions`);
+  }
+
   const meta = createLanguageMeta(language);
 
   const rawOutputPath = rawOutputDirectory;
@@ -106,6 +116,7 @@ const typesCommand = actionRunner(async (rawOutputDirectory, {language}) => {
   if (meta.isSingleFile()) {
     const content = templater({
       collections,
+      strict,
       ...templateHelpers,
       getType: meta.getType
     });
@@ -118,6 +129,7 @@ const typesCommand = actionRunner(async (rawOutputDirectory, {language}) => {
     for (const collection of collections) {
       const content = templater({
         collection,
+        strict,
         ...templateHelpers,
         getType: meta.getType
       });
@@ -136,6 +148,7 @@ const types = new Command("types")
   .description("Generate types for your Appwrite project")
   .addArgument(typesOutputArgument)
   .addOption(typesLanguageOption)
+  .addOption(typesStrictOption)
   .action(actionRunner(typesCommand));
 
 module.exports = { types };

package/lib/config.js

@@ -35,7 +35,9 @@ const KeysAttributes = new Set([
     "side",
     // Indexes
     "attributes",
-    "orders"
+    "orders",
+    // Strings
+    "encrypt",
 ]);
 const KeyIndexes = new Set(["key", "type", "status", "attributes", "orders"]);
 

package/lib/parser.js

@@ -24,7 +24,9 @@ const parse = (data) => {
     }
 
     for (let key in data) {
-        if (Array.isArray(data[key])) {
+        if (data[key] === null) {
+            console.log(`${chalk.yellow.bold(key)} : null`);
+        } else if (Array.isArray(data[key])) {
             console.log(`${chalk.yellow.bold.underline(key)}`);
             if (typeof data[key][0] === 'object') {
                 drawTable(data[key]);
@@ -120,7 +122,7 @@ const parseError = (err) => {
             } catch {
             }
 
-            const version = '8.1.1';
+            const version = '8.2.0';
             const stepsToReproduce = `Running \`appwrite ${cliConfig.reportData.data.args.join(' ')}\``;
             const yourEnvironment = `CLI version: ${version}\nOperation System: ${os.type()}\nAppwrite version: ${appwriteVersion}\nIs Cloud: ${isCloud()}`;
 

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

@@ -1,8 +1,45 @@
 /** @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) {
@@ -46,42 +83,55 @@ class Dart extends LanguageMeta {
   }
 
   getTemplate() {
-    return `<% for (const attribute of collection.attributes) { -%>
+    return `import 'package:${this.getPackageName()}/models.dart';
+<% for (const attribute of collection.attributes) { -%>
 <% if (attribute.type === 'relationship') { -%>
 import '<%- attribute.relatedCollection.toLowerCase() %>.dart';
 
 <% } -%>
 <% } -%>
-/**
- * This file is auto-generated by the Appwrite CLI. 
- * You can regenerate it by running \`appwrite types -l dart ${this.getCurrentDirectory()}\`.
- */
+/// This file is auto-generated by the Appwrite CLI. 
+/// You can regenerate it by running \`appwrite types -l dart ${this.getCurrentDirectory()}\`.
 
 <% for (const attribute of collection.attributes) { -%>
 <% if (attribute.format === 'enum') { -%>
 enum <%- toPascalCase(attribute.key) %> {
 <% for (const [index, element] of Object.entries(attribute.elements)) { -%>
-  <%- toSnakeCase(element) %><% if (index < attribute.elements.length - 1) { %>,<% } %>
+  <%- strict ? toCamelCase(element) : element %><% if (index < attribute.elements.length - 1) { %>,<% } %>
 <% } -%>
 }
 
 <% } -%>
 <% } -%>
-class <%= toPascalCase(collection.name) %> {
+class <%= toPascalCase(collection.name) %> extends Document {
 <% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
-  <%- getType(attribute) %> <%= toCamelCase(attribute.key) %>;
+  <%- getType(attribute) %> <%= strict ? toCamelCase(attribute.key) : attribute.key %>;
 <% } -%>
 
   <%= toPascalCase(collection.name) %>({
+    required super.$id,
+    required super.$collectionId,
+    required super.$databaseId,
+    required super.$createdAt,
+    required super.$updatedAt,
+    required super.$permissions,
+    required super.data,
   <% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
-  <% if (attribute.required) { %>required <% } %>this.<%= toCamelCase(attribute.key) %><% if (index < collection.attributes.length - 1) { %>,<% } %>
+  <% 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) %>(
+      $id: map['\\$id'].toString(),
+      $collectionId: map['\\$collectionId'].toString(),
+      $databaseId: map['\\$databaseId'].toString(),
+      $createdAt: map['\\$createdAt'].toString(),
+      $updatedAt: map['\\$updatedAt'].toString(),
+      $permissions: List<String>.from(map['\\$permissions'] ?? []),
+      data: map,
 <% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
-      <%= toCamelCase(attribute.key) %>: <% if (attribute.type === 'string' || attribute.type === 'email' || attribute.type === 'datetime') { -%>
+      <%= 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) { %> ?? []<% } -%>
@@ -130,21 +180,27 @@ map['<%= attribute.key %>'] != null ? <%- toPascalCase(attribute.relatedCollecti
 
   Map<String, dynamic> toMap() {
     return {
+      "\\$id": $id,
+      "\\$collectionId": $collectionId,
+      "\\$databaseId": $databaseId,
+      "\\$createdAt": $createdAt,
+      "\\$updatedAt": $updatedAt,
+      "\\$permissions": $permissions,
 <% 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') { -%>
-<%= toCamelCase(attribute.key) %><% if (!attribute.required) { %>?<% } %>.map((e) => e.toMap()).toList()<% if (!attribute.required) { %> ?? []<% } -%>
+<%= strict ? toCamelCase(attribute.key) : attribute.key %><% if (!attribute.required) { %>?<% } %>.map((e) => e.toMap()).toList()<% if (!attribute.required) { %> ?? []<% } -%>
 <% } else { -%>
-<%= toCamelCase(attribute.key) %><% if (!attribute.required) { %>?<% } %>.toMap()<% if (!attribute.required) { %> ?? {}<% } -%>
+<%= strict ? toCamelCase(attribute.key) : attribute.key %><% if (!attribute.required) { %>?<% } %>.toMap()<% if (!attribute.required) { %> ?? {}<% } -%>
 <% } -%>
 <% } else if (attribute.format === 'enum') { -%>
 <% if (attribute.array) { -%>
-<%= toCamelCase(attribute.key) %><% if (!attribute.required) { %>?<% } %>.map((e) => e.name).toList()<% if (!attribute.required) { %> ?? []<% } -%>
+<%= strict ? toCamelCase(attribute.key) : attribute.key %><% if (!attribute.required) { %>?<% } %>.map((e) => e.name).toList()<% if (!attribute.required) { %> ?? []<% } -%>
 <% } else { -%>
-<%= toCamelCase(attribute.key) %><% if (!attribute.required) { %>?<% } %>.name<% if (!attribute.required) { %> ?? null<% } -%>
+<%= strict ? toCamelCase(attribute.key) : attribute.key %><% if (!attribute.required) { %>?<% } %>.name<% if (!attribute.required) { %> ?? null<% } -%>
 <% } -%>
 <% } else { -%>
-<%= toCamelCase(attribute.key) -%>
+<%= strict ? toCamelCase(attribute.key) : attribute.key -%>
 <% } -%><% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } -%>
     };

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

@@ -61,63 +61,63 @@ public class <%- toPascalCase(collection.name) %> {
 <% for (const attribute of collection.attributes) { -%>
 <% if (attribute.format === 'enum') { -%>
 
-    public enum <%- toPascalCase(attribute.key) %> {
+  public enum <%- toPascalCase(attribute.key) %> {
 <% for (const [index, element] of Object.entries(attribute.elements)) { -%>
-        <%- toSnakeCase(element) %><%- index < attribute.elements.length - 1 ? ',' : ';' %>
+    <%- strict ? toSnakeCase(element) : element %><%- index < attribute.elements.length - 1 ? ',' : ';' %>
 <% } -%>
-    }
+  }
 
 <% } -%>
 <% } -%>
 <% for (const attribute of collection.attributes) { -%>
-    private <%- getType(attribute) %> <%- toCamelCase(attribute.key) %>;
+  private <%- getType(attribute) %> <%- strict ? toCamelCase(attribute.key) : attribute.key %>;
 <% } -%>
 
-    public <%- toPascalCase(collection.name) %>() {
-    }
+  public <%- toPascalCase(collection.name) %>() {
+  }
 
-    public <%- toPascalCase(collection.name) %>(
+  public <%- toPascalCase(collection.name) %>(
 <% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
-        <%- getType(attribute) %> <%= toCamelCase(attribute.key) %><%- index < collection.attributes.length - 1 ? ',' : '' %>
+    <%- getType(attribute) %> <%= strict ? toCamelCase(attribute.key) : attribute.key %><%- index < collection.attributes.length - 1 ? ',' : '' %>
 <% } -%>
-    ) {
+  ) {
 <% for (const attribute of collection.attributes) { -%>
-        this.<%= toCamelCase(attribute.key) %> = <%= toCamelCase(attribute.key) %>;
+    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 <%= toCamelCase(attribute.key) %>;
-    }
+  public <%- getType(attribute) %> get<%- toPascalCase(attribute.key) %>() {
+    return <%= strict ? toCamelCase(attribute.key) : attribute.key %>;
+  }
 
-    public void set<%- toPascalCase(attribute.key) %>(<%- getType(attribute) %> <%= toCamelCase(attribute.key) %>) {
-        this.<%= toCamelCase(attribute.key) %> = <%= toCamelCase(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 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 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)) { -%>
-                "<%= toCamelCase(attribute.key) %>=" + <%= toCamelCase(attribute.key) %> +
+  @Override
+  public String toString() {
+    return "<%- toPascalCase(collection.name) %>{" +
+<% for (const attribute of collection.attributes) { -%>
+            "<%= strict ? toCamelCase(attribute.key) : attribute.key %>=" + <%= strict ? toCamelCase(attribute.key) : attribute.key %> +
 <% } -%>
-                '}';
-    }
+            '}';
+  }
 }
 `;
   }

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

@@ -16,7 +16,7 @@ class JavaScript extends LanguageMeta {
       case AttributeType.URL:
         type = "string";
         if (attribute.format === AttributeType.ENUM) {
-          type = `"${attribute.elements.join('"|"')}"`;
+          type = LanguageMeta.toPascalCase(attribute.key);
         }
         break;
       case AttributeType.INTEGER:
@@ -31,7 +31,7 @@ class JavaScript extends LanguageMeta {
       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 = `Array<${type}>`;
+          type = `${type}[]`;
         }
         break;
       default:
@@ -65,21 +65,32 @@ class JavaScript extends LanguageMeta {
   }
 
   getTemplate() {
-    return `/**
+    return `
+// This file is auto-generated by the Appwrite CLI. 
+// You can regenerate it by running \`appwrite types -l js ${this.getCurrentDirectory()}\`.
+
+/**
  * @typedef {import('${this._getAppwriteDependency()}').Models.Document} Document
  */
 
+<% for (const collection of collections) { -%>
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.format === 'enum') { -%>
 /**
- * This file is auto-generated by the Appwrite CLI. 
- * You can regenerate it by running \`appwrite types -l js ${this.getCurrentDirectory()}\`.
+ * @typedef {"<%- attribute.elements.join('"|"') %>"} <%- toPascalCase(attribute.key) %>
  */
-<% for (const collection of collections) { %>
-/**
- * @typedef {Object} <%- toPascalCase(collection.name) %>
+
+<% } -%>
+<% } -%>
+<% } -%>
+<% for (const collection of collections) { %>/**
+ * @typedef {Document & {
 <% for (const attribute of collection.attributes) { -%>
- * @property {<%- getType(attribute) %>} <%- toCamelCase(attribute.key) %>
+ *   <%- strict ? toCamelCase(attribute.key) : attribute.key %>: <%- getType(attribute) %>;
 <% } -%>
+ * }} <%- toPascalCase(collection.name) %>
  */
+
 <% } %>`;
   }
 

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

@@ -63,7 +63,7 @@ import <%- toPascalCase(attribute.relatedCollection) %>
 <% if (attribute.format === 'enum') { -%>
 enum class <%- toPascalCase(attribute.key) %> {
 <% for (const [index, element] of Object.entries(attribute.elements)) { -%>
-    <%- toUpperSnakeCase(element) %><%- index < attribute.elements.length - 1 ? ',' : '' %>
+  <%- strict ? toUpperSnakeCase(element) : element %><%- index < attribute.elements.length - 1 ? ',' : '' %>
 <% } -%>
 }
 
@@ -71,7 +71,7 @@ enum class <%- toPascalCase(attribute.key) %> {
 <% } -%>
 data class <%- toPascalCase(collection.name) %>(
 <% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
-    val <%- toCamelCase(attribute.key) %>: <%- getType(attribute) %><% if (index < collection.attributes.length - 1) { %>,<% } %>
+  val <%- strict ? toCamelCase(attribute.key) : attribute.key %>: <%- getType(attribute) %><% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } -%>
 )`;
   }

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

@@ -49,10 +49,8 @@ class PHP extends LanguageMeta {
     return `<?php
 namespace Appwrite\\Models;
 
-/**
- * This file is auto-generated by the Appwrite CLI. 
- * You can regenerate it by running \`appwrite types -l php ${this.getCurrentDirectory()}\`.
- */
+// This file is auto-generated by the Appwrite CLI. 
+// You can regenerate it by running \`appwrite types -l php ${this.getCurrentDirectory()}\`.
 
 <% for (const attribute of collection.attributes) { -%>
 <% if (attribute.type === 'relationship' && !(attribute.relationType === 'manyToMany') && !(attribute.relationType === 'oneToMany' && attribute.side === 'parent')) { -%>
@@ -64,7 +62,7 @@ use Appwrite\\Models\\<%- toPascalCase(attribute.relatedCollection) %>;
 <% if (attribute.format === 'enum') { -%>
 enum <%- toPascalCase(attribute.key) %>: string {
 <% for (const [index, element] of Object.entries(attribute.elements)) { -%>
-  case <%- toUpperSnakeCase(element) %> = '<%- element %>';
+  case <%- strict ? toUpperSnakeCase(element) : element %> = '<%- element %>';
 <% } -%>
 }
 
@@ -72,31 +70,33 @@ enum <%- toPascalCase(attribute.key) %>: string {
 <% } -%>
 class <%- toPascalCase(collection.name) %> {
 <% for (const attribute of collection.attributes ){ -%>
-  private <%- getType(attribute) %> $<%- toCamelCase(attribute.key) %>;
+  private <%- getType(attribute) %> $<%- strict ? toCamelCase(attribute.key) : attribute.key %>;
 <% } -%>
 
   public function __construct(
 <% for (const attribute of collection.attributes ){ -%>
 <% if (attribute.required) { -%>
-    <%- getType(attribute).replace('|null', '') %> $<%- toCamelCase(attribute.key) %><% if (collection.attributes.indexOf(attribute) < collection.attributes.length - 1) { %>,<% } %>
+    <%- getType(attribute).replace('|null', '') %> $<%- strict ? toCamelCase(attribute.key) : attribute.key %><% if (collection.attributes.indexOf(attribute) < collection.attributes.length - 1) { %>,<% } %>
 <% } else { -%>
-    ?<%- getType(attribute).replace('|null', '') %> $<%- toCamelCase(attribute.key) %> = null<% if (collection.attributes.indexOf(attribute) < collection.attributes.length - 1) { %>,<% } %>
+    ?<%- getType(attribute).replace('|null', '') %> $<%- strict ? toCamelCase(attribute.key) : attribute.key %> = null<% if (collection.attributes.indexOf(attribute) < collection.attributes.length - 1) { %>,<% } %>
 <% } -%>
 <% } -%>
   ) {
 <% for (const attribute of collection.attributes ){ -%>
-    $this-><%- toCamelCase(attribute.key) %> = $<%- toCamelCase(attribute.key) %>;
+    $this-><%- strict ? toCamelCase(attribute.key) : attribute.key %> = $<%- strict ? toCamelCase(attribute.key) : attribute.key %>;
 <% } -%>
   }
 
-<% for (const attribute of collection.attributes ){ -%>
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
   public function get<%- toPascalCase(attribute.key) %>(): <%- getType(attribute) %> {
-    return $this-><%- toCamelCase(attribute.key) %>;
+    return $this-><%- strict ? toCamelCase(attribute.key) : attribute.key %>;
   }
 
-  public function set<%- toPascalCase(attribute.key) %>(<%- getType(attribute) %> $<%- toCamelCase(attribute.key) %>): void {
-    $this-><%- toCamelCase(attribute.key) %> = $<%- toCamelCase(attribute.key) %>;
+  public function set<%- toPascalCase(attribute.key) %>(<%- getType(attribute) %> $<%- strict ? toCamelCase(attribute.key) : attribute.key %>): void {
+    $this-><%- strict ? toCamelCase(attribute.key) : attribute.key %> = $<%- strict ? toCamelCase(attribute.key) : attribute.key %>;
   }
+<% if (index < collection.attributes.length - 1) { %>
+<% } -%>
 <% } -%>
 }`;
   }

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

@@ -55,7 +55,7 @@ class Swift extends LanguageMeta {
 <% if (attribute.format === 'enum') { -%>
 public enum <%- toPascalCase(attribute.key) %>: String, Codable, CaseIterable {
 <% for (const [index, element] of Object.entries(attribute.elements)) { -%>
-  case <%- toSnakeCase(element) %> = "<%- element %>"
+  case <%- strict ? toCamelCase(element) : element %> = "<%- element %>"
 <% } -%>
 }
 
@@ -63,101 +63,101 @@ public enum <%- toPascalCase(attribute.key) %>: String, Codable, CaseIterable {
 <% } -%>
 public class <%- toPascalCase(collection.name) %>: Codable {
 <% for (const attribute of collection.attributes) { -%>
-    public let <%- toCamelCase(attribute.key) %>: <%- getType(attribute) %>
+  public let <%- strict ? toCamelCase(attribute.key) : attribute.key %>: <%- getType(attribute) %>
 <% } %>
-    enum CodingKeys: String, CodingKey {
+  enum CodingKeys: String, CodingKey {
 <% for (const attribute of collection.attributes) { -%>
-        case <%- toCamelCase(attribute.key) %> = "<%- attribute.key %>"
+    case <%- strict ? toCamelCase(attribute.key) : attribute.key %> = "<%- attribute.key %>"
 <% } -%>
-    }
+  }
 
-    init(
-<% for (const attribute of collection.attributes) { -%>
-        <%- toCamelCase(attribute.key) %>: <%- getType(attribute) %><% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+  init(
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+    <%- strict ? toCamelCase(attribute.key) : attribute.key %>: <%- getType(attribute) %><% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } -%>
-    ) {
+  ) {
 <% for (const attribute of collection.attributes) { -%>
-        self.<%- toCamelCase(attribute.key) %> = <%- toCamelCase(attribute.key) %>
+    self.<%- strict ? toCamelCase(attribute.key) : attribute.key %> = <%- strict ? toCamelCase(attribute.key) : attribute.key %>
 <% } -%>
-    }
+  }
 
-    public required init(from decoder: Decoder) throws {
-        let container = try decoder.container(keyedBy: CodingKeys.self)
+  public required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: CodingKeys.self)
 
 <% for (const attribute of collection.attributes) { -%>
 <% if (attribute.required) { -%>
-        self.<%- toCamelCase(attribute.key) %> = try container.decode(<%- getType(attribute).replace('?', '') %>.self, forKey: .<%- toCamelCase(attribute.key) %>)
+    self.<%- strict ? toCamelCase(attribute.key) : attribute.key %> = try container.decode(<%- getType(attribute).replace('?', '') %>.self, forKey: .<%- strict ? toCamelCase(attribute.key) : attribute.key %>)
 <% } else { -%>
-        self.<%- toCamelCase(attribute.key) %> = try container.decodeIfPresent(<%- getType(attribute).replace('?', '') %>.self, forKey: .<%- toCamelCase(attribute.key) %>)
+    self.<%- strict ? toCamelCase(attribute.key) : attribute.key %> = try container.decodeIfPresent(<%- getType(attribute).replace('?', '') %>.self, forKey: .<%- strict ? toCamelCase(attribute.key) : attribute.key %>)
 <% } -%>
 <% } -%>
-    }
+  }
 
-    public func encode(to encoder: Encoder) throws {
-        var container = encoder.container(keyedBy: CodingKeys.self)
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
 
 <% for (const attribute of collection.attributes) { -%>
 <% if (attribute.required) { -%>
-        try container.encode(<%- toCamelCase(attribute.key) %>, forKey: .<%- toCamelCase(attribute.key) %>)
+    try container.encode(<%- strict ? toCamelCase(attribute.key) : attribute.key %>, forKey: .<%- strict ? toCamelCase(attribute.key) : attribute.key %>)
 <% } else { -%>
-        try container.encodeIfPresent(<%- toCamelCase(attribute.key) %>, forKey: .<%- toCamelCase(attribute.key) %>)
+    try container.encodeIfPresent(<%- strict ? toCamelCase(attribute.key) : attribute.key %>, forKey: .<%- strict ? toCamelCase(attribute.key) : attribute.key %>)
 <% } -%>
 <% } -%>
-    }
+  }
 
-    public func toMap() -> [String: Any] {
-        return [
-<% for (const attribute of collection.attributes) { -%>
+  public func toMap() -> [String: Any] {
+    return [
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
 <% if (attribute.type === 'relationship') { -%>
-            "<%- attribute.key %>": <%- toCamelCase(attribute.key) %> as Any<% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+      "<%- attribute.key %>": <%- strict ? toCamelCase(attribute.key) : attribute.key %> as Any<% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } else if (attribute.array && attribute.type !== 'string' && attribute.type !== 'integer' && attribute.type !== 'float' && attribute.type !== 'boolean') { -%>
-            "<%- attribute.key %>": <%- toCamelCase(attribute.key) %>?.map { $0.toMap() } as Any<% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+      "<%- attribute.key %>": <%- strict ? toCamelCase(attribute.key) : attribute.key %>?.map { $0.toMap() } as Any<% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } else { -%>
-            "<%- attribute.key %>": <%- toCamelCase(attribute.key) %> as Any<% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+      "<%- attribute.key %>": <%- strict ? toCamelCase(attribute.key) : attribute.key %> as Any<% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } -%>
 <% } -%>
-        ]
-    }
+    ]
+  }
 
-    public static func from(map: [String: Any]) -> <%- toPascalCase(collection.name) %> {
-        return <%- toPascalCase(collection.name) %>(
-<% for (const attribute of collection.attributes) { -%>
+  public static func from(map: [String: Any]) -> <%- toPascalCase(collection.name) %> {
+    return <%- toPascalCase(collection.name) %>(
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
 <% if (attribute.type === 'relationship') { -%>
 <% if ((attribute.relationType === 'oneToMany' && attribute.side === 'parent') || (attribute.relationType === 'manyToOne' && attribute.side === 'child') || attribute.relationType === 'manyToMany') { -%>
-            <%- toCamelCase(attribute.key) %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> [<%- toPascalCase(attribute.relatedCollection) %>]<% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+      <%- strict ? toCamelCase(attribute.key) : attribute.key %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> [<%- toPascalCase(attribute.relatedCollection) %>]<% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } else { -%>
-            <%- toCamelCase(attribute.key) %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> <%- toPascalCase(attribute.relatedCollection) %><% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+      <%- strict ? toCamelCase(attribute.key) : attribute.key %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> <%- toPascalCase(attribute.relatedCollection) %><% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } -%>
 <% } else if (attribute.array) { -%>
 <% if (attribute.type === 'string') { -%>
-            <%- toCamelCase(attribute.key) %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> [String]<% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+      <%- strict ? toCamelCase(attribute.key) : attribute.key %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> [String]<% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } else if (attribute.type === 'integer') { -%>
-            <%- toCamelCase(attribute.key) %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> [Int]<% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+      <%- strict ? toCamelCase(attribute.key) : attribute.key %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> [Int]<% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } else if (attribute.type === 'float') { -%>
-            <%- toCamelCase(attribute.key) %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> [Double]<% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+      <%- strict ? toCamelCase(attribute.key) : attribute.key %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> [Double]<% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } else if (attribute.type === 'boolean') { -%>
-            <%- toCamelCase(attribute.key) %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> [Bool]<% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+      <%- strict ? toCamelCase(attribute.key) : attribute.key %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> [Bool]<% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } else { -%>
-            <%- toCamelCase(attribute.key) %>: (map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> [[String: Any]])<% if (!attribute.required) { %>?<% } %>.map { <%- toPascalCase(attribute.type) %>.from(map: $0) }<% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+      <%- strict ? toCamelCase(attribute.key) : attribute.key %>: (map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> [[String: Any]])<% if (!attribute.required) { %>?<% } %>.map { <%- toPascalCase(attribute.type) %>.from(map: $0) }<% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } -%>
 <% } else { -%>
 <% if ((attribute.type === 'string' || attribute.type === 'email' || attribute.type === 'datetime') && attribute.format !== 'enum') { -%>
-            <%- toCamelCase(attribute.key) %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> String<% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+      <%- strict ? toCamelCase(attribute.key) : attribute.key %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> String<% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } else if (attribute.type === 'string' && attribute.format === 'enum') { -%>
-            <%- toCamelCase(attribute.key) %>: <%- toPascalCase(attribute.key) %>(rawValue: map["<%- attribute.key %>"] as! String)!<% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+      <%- strict ? toCamelCase(attribute.key) : attribute.key %>: <%- toPascalCase(attribute.key) %>(rawValue: map["<%- attribute.key %>"] as! String)!<% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } else if (attribute.type === 'integer') { -%>
-            <%- toCamelCase(attribute.key) %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> Int<% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+      <%- strict ? toCamelCase(attribute.key) : attribute.key %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> Int<% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } else if (attribute.type === 'float') { -%>
-            <%- toCamelCase(attribute.key) %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> Double<% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+      <%- strict ? toCamelCase(attribute.key) : attribute.key %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> Double<% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } else if (attribute.type === 'boolean') { -%>
-            <%- toCamelCase(attribute.key) %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> Bool<% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+      <%- strict ? toCamelCase(attribute.key) : attribute.key %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> Bool<% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } else { -%>
-            <%- toCamelCase(attribute.key) %>: <%- toPascalCase(attribute.type) %>.from(map: map["<%- attribute.key %>"] as! [String: Any])<% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+      <%- strict ? toCamelCase(attribute.key) : attribute.key %>: <%- toPascalCase(attribute.type) %>.from(map: map["<%- attribute.key %>"] as! [String: Any])<% if (index < collection.attributes.length - 1) { %>,<% } %>
 <% } -%>
 <% } -%>
 <% } -%>
-        )
-    }
+    )
+  }
 }`;
   }
 

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

@@ -71,10 +71,8 @@ class TypeScript extends LanguageMeta {
   getTemplate() {
     return `import { type Models } from '${this._getAppwriteDependency()}';
 
-/**
- * This file is auto-generated by the Appwrite CLI. 
- * You can regenerate it by running \`appwrite types -l ts ${this.getCurrentDirectory()}\`.
- */
+// This file is auto-generated by the Appwrite CLI. 
+// You can regenerate it by running \`appwrite types -l ts ${this.getCurrentDirectory()}\`.
 
 <% for (const collection of collections) { -%>
 <% for (const attribute of collection.attributes) { -%>
@@ -92,7 +90,7 @@ export enum <%- toPascalCase(attribute.key) %> {
 <% for (const collection of collections) { -%>
 export type <%- toPascalCase(collection.name) %> = Models.Document & {
 <% for (const attribute of collection.attributes) { -%>
-  <%- toCamelCase(attribute.key) %>: <%- getType(attribute) %>;
+  <%- strict ? toCamelCase(attribute.key) : attribute.key %>: <%- getType(attribute) %>;
 <% } -%>
 }
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "appwrite-cli",
   "homepage": "https://appwrite.io/support",
   "description": "Appwrite is an open-source self-hosted backend server that abstract and simplify complex and repetitive development tasks behind a very simple REST API",
-  "version": "8.1.1",
+  "version": "8.2.0",
   "license": "BSD-3-Clause",
   "main": "index.js",
   "bin": {

package/scoop/appwrite.json

@@ -1,12 +1,12 @@
 {
 	"$schema": "https://raw.githubusercontent.com/ScoopInstaller/Scoop/master/schema.json",
-	"version": "8.1.1",
+	"version": "8.2.0",
 	"description": "The Appwrite CLI is a command-line application that allows you to interact with Appwrite and perform server-side tasks using your terminal.",
 	"homepage": "https://github.com/appwrite/sdk-for-cli",
 	"license": "BSD-3-Clause",
 	"architecture": {
 		"64bit": {
-			"url": "https://github.com/appwrite/sdk-for-cli/releases/download/8.1.1/appwrite-cli-win-x64.exe",
+			"url": "https://github.com/appwrite/sdk-for-cli/releases/download/8.2.0/appwrite-cli-win-x64.exe",
 			"bin": [
 				[
 					"appwrite-cli-win-x64.exe",
@@ -15,7 +15,7 @@
 			]
 		},
 		"arm64": {
-			"url": "https://github.com/appwrite/sdk-for-cli/releases/download/8.1.1/appwrite-cli-win-arm64.exe",
+			"url": "https://github.com/appwrite/sdk-for-cli/releases/download/8.2.0/appwrite-cli-win-arm64.exe",
 			"bin": [
 				[
 					"appwrite-cli-win-arm64.exe",