Merge branch 'appwrite:master' into unity-client-sdk

Author: Fellmonkey

templates/android/library/src/main/java/io/package/Client.kt.twig

@@ -507,7 +507,7 @@ class Client @JvmOverloads constructor(
                 val warnings = response.headers["x-{{ spec.title | lower }}-warning"]
                 if (warnings != null) {
                     warnings.split(";").forEach { warning ->
-                        println("Warning: $warning")
+                        System.err.println("Warning: $warning")
                     }
                 }
 

templates/android/library/src/main/java/io/package/Query.kt.twig

@@ -151,6 +151,13 @@ class Query(
          */
         fun orderDesc(attribute: String) = Query("orderDesc", attribute).toJson()
 
+        /**
+         * Sort results randomly.
+         *
+         * @returns The query string.
+         */
+        fun orderRandom() = Query("orderRandom").toJson()
+
         /**
          * Return results before documentId.
          *

templates/apple/Sources/Client.swift.twig

@@ -304,7 +304,7 @@ open class Client {
 
         if let warning = response.headers["x-{{ spec.title | lower }}-warning"].first {
             warning.split(separator: ";").forEach { warning in
-                print("Warning: \(warning)")
+                fputs("Warning: \(warning)\n", stderr)
             }
         }
 

templates/cli/lib/commands/pull.js.twig

@@ -295,15 +295,16 @@ const pullSites = async ({ code, withVariables }) => {
 const pullCollection = async () => {
     warn("appwrite pull collection has been deprecated. Please consider using 'appwrite pull tables' instead");
     log("Fetching collections ...");
-    let total = 0;
+    let totalDatabases = 0;
+    let totalCollections = 0;
 
     const fetchResponse = await databasesList({
         queries: [JSON.stringify({ method: 'limit', values: [1] })],
         parseOutput: false
     });
     if (fetchResponse["databases"].length <= 0) {
         log("No collections found.");
-        success(`Successfully pulled ${chalk.bold(total)} collections.`);
+        success(`Successfully pulled ${chalk.bold(totalCollections)} collections from ${chalk.bold(totalDatabases)} databases.`);
         return;
     }
 
@@ -323,7 +324,7 @@ const pullCollection = async () => {
             parseOutput: false
         });
 
-        total++;
+        totalDatabases++;
         log(`Pulling all collections from ${chalk.bold(database['name'])} database ...`);
 
         localConfig.addDatabase(database);
@@ -334,6 +335,7 @@ const pullCollection = async () => {
         }, 100, 'collections');
 
         for (const collection of collections) {
+            totalCollections++;
             localConfig.addCollection({
                 ...collection,
                 '$createdAt': undefined,
@@ -342,20 +344,21 @@ const pullCollection = async () => {
         }
     }
 
-    success(`Successfully pulled ${chalk.bold(total)} collections.`);
+    success(`Successfully pulled ${chalk.bold(totalCollections)} collections from ${chalk.bold(totalDatabases)} databases.`);
 }
 
 const pullTable = async () => {
     log("Fetching tables ...");
-    let total = 0;
+    let totalTablesDBs = 0;
+    let totalTables = 0;
 
     const fetchResponse = await tablesDBList({
         queries: [JSON.stringify({ method: 'limit', values: [1] })],
         parseOutput: false
     });
     if (fetchResponse["databases"].length <= 0) {
         log("No tables found.");
-        success(`Successfully pulled ${chalk.bold(total)} tables.`);
+        success(`Successfully pulled ${chalk.bold(totalTables)} tables from ${chalk.bold(totalTablesDBs)} tables databases.`);
         return;
     }
 
@@ -375,7 +378,7 @@ const pullTable = async () => {
             parseOutput: false
         });
 
-        total++;
+        totalTablesDBs++;
         log(`Pulling all tables from ${chalk.bold(database['name'])} database ...`);
 
         localConfig.addTablesDB(database);
@@ -386,6 +389,7 @@ const pullTable = async () => {
         }, 100, 'tables');
 
         for (const table of tables) {
+            totalTables++;
             localConfig.addTable({
                 ...table,
                 '$createdAt': undefined,
@@ -394,7 +398,7 @@ const pullTable = async () => {
         }
     }
 
-    success(`Successfully pulled ${chalk.bold(total)} tables.`);
+    success(`Successfully pulled ${chalk.bold(totalTables)} tables from ${chalk.bold(totalTablesDBs)} tables databases.`);
 }
 
 const pullBucket = async () => {
@@ -474,14 +478,16 @@ const pullMessagingTopic = async () => {
 
 const pull = new Command("pull")
     .description(commandDescriptions['pull'])
-    .action(actionRunner(pullResources));
+    .action(actionRunner(() => pullResources({ skipDeprecated: true })));
 
 pull
     .command("all")
     .description("Pull all resource.")
     .action(actionRunner(() => {
         cliConfig.all = true;
-        return pullResources();
+        return pullResources({
+            skipDeprecated: true
+        });
     }));
 
 pull

templates/cli/lib/parser.js.twig

@@ -205,7 +205,8 @@ const commandDescriptions = {
     "account": `The account command allows you to authenticate and manage a user account.`,
     "graphql": `The graphql command allows you to query and mutate any resource type on your Appwrite server.`,
     "avatars": `The avatars command aims to help you complete everyday tasks related to your app image, icons, and avatars.`,
-    "databases": `The databases command allows you to create structured collections of documents and query and filter lists of documents.`,
+    "databases": `(Legacy) The databases command allows you to create structured collections of documents and query and filter lists of documents.`,
+    'tables-db': `The tables-db command allows you to create structured tables of columns and query and filter lists of rows.`,
     "init": `The init command provides a convenient wrapper for creating and initializing projects, functions, collections, buckets, teams, and messaging-topics in  {{ spec.title|caseUcfirst }}.`,
     "push": `The push command provides a convenient wrapper for pushing your functions, collections, buckets, teams, and messaging-topics.`,
     "run": `The run command allows you to run the project locally to allow easy development and quick debugging.`,
@@ -218,6 +219,8 @@ const commandDescriptions = {
     "teams": `The teams command allows you to group users of your project to enable them to share read and write access to your project resources.`,
     "update": `The update command allows you to update the {{ spec.title|caseUcfirst }} CLI to the latest version.`,
     "users": `The users command allows you to manage your project users.`,
+    "projects": `The projects command allows you to manage your projects, add platforms, manage API keys, Dev Keys etc.`,
+    "project": `The project command allows you to manage project related resources like usage, variables, etc.`,
     "client": `The client command allows you to configure your CLI`,
     "login": `The login command allows you to authenticate and manage a user account.`,
     "logout": `The logout command allows you to log out of your {{ spec.title|caseUcfirst }} account.`,

templates/cli/lib/type-generation/languages/dart.js.twig

@@ -83,104 +83,101 @@ class Dart extends LanguageMeta {
   }
 
   getTemplate() {
-    return `<% for (const attribute of collection.attributes) { -%>
-<% if (attribute.type === 'relationship') { -%>
-import '<%- toSnakeCase(collections.find(c => c.$id === attribute.relatedCollection).name) %>.dart';
-
-<% } -%>
-<% } -%>
-/// 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') { -%>
+  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(attribute.key) %> {
 <% for (const [index, element] of Object.entries(attribute.elements)) { -%>
-  <%- strict ? toCamelCase(element) : element %><% if (index < attribute.elements.length - 1) { %>,<% } %>
+  <%- strict ? toCamelCase(element) : element %><% if (index < attribute.elements.length - 1) { -%>,<% } %>
 <% } -%>
 }
 
 <% } -%>
 <% } -%>
 class <%= toPascalCase(collection.name) %> {
-<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+<% for (const [index, attribute] of Object.entries(__attrs)) { -%>
   <%- getType(attribute, collections) %> <%= 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) { %>,<% } %>
+  <% 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(collection.attributes)) { -%>
-      <%= strict ? toCamelCase(attribute.key) : attribute.key %>: <% if (attribute.type === 'string' || attribute.type === 'email' || attribute.type === 'datetime') { -%>
-<% if (attribute.format === 'enum') { -%>
+<% 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(attribute.key) %>.values.firstWhere((element) => element.name == e)).toList()<% if (!attribute.required) { %> ?? []<% } -%>
-<% } else { -%>
+(map['<%= attribute.key %>'] as List<dynamic>?)?.map((e) => <%- toPascalCase(attribute.key) %>.values.firstWhere((element) => element.name == e)).toList()<% } 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<% } -%>
+List<String>.from(map['<%= attribute.key %>'] ?? [])<% } else { -%>
+map['<%= attribute.key %>']<% if (!attribute.required) { %>?<% } %>.toString()<% } -%>
 <% } -%>
-<% } -%>
-<% } else if (attribute.type === 'integer') { -%>
+<% } else if (attribute.type === '${AttributeType.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') { -%>
+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 %>'] ?? [])<% if (!attribute.required) { %> ?? []<% } -%>
-<% } else { -%>
-map['<%= attribute.key %>']<% if (!attribute.required) { %> ?? null<% } -%>
-<% } -%>
-<% } else if (attribute.type === 'boolean') { -%>
+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 %>'] ?? [])<% if (!attribute.required) { %> ?? []<% } -%>
-<% } else { -%>
-map['<%= attribute.key %>']<% if (!attribute.required) { %> ?? null<% } -%>
-<% } -%>
-<% } else if (attribute.type === 'relationship') { -%>
+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()<% if (!attribute.required) { %> ?? []<% } -%>
+(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 < collection.attributes.length - 1) { %>,<% } %>
+<% } -%><% if (index < __attrs.length - 1) { -%>,<% } %>
 <% } -%>
     );
   }
 
   Map<String, dynamic> toMap() {
     return {
-<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
-      "<%= attribute.key %>": <% if (attribute.type === 'relationship') { -%>
+<% 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()<% if (!attribute.required) { %> ?? []<% } -%>
+<%= 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()<% if (!attribute.required) { %> ?? {}<% } -%>
-<% } -%>
-<% } else if (attribute.format === 'enum') { -%>
+<%= 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()<% if (!attribute.required) { %> ?? []<% } -%>
-<% } else { -%>
-<%= strict ? toCamelCase(attribute.key) : attribute.key %><% if (!attribute.required) { %>?<% } %>.name<% if (!attribute.required) { %> ?? null<% } -%>
-<% } -%>
+<%= 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 < collection.attributes.length - 1) { %>,<% } %>
+<% } -%><% if (index < __attrs.length - 1) { -%>,<% } %>
 <% } -%>
     };
   }

templates/cli/lib/type-generation/languages/typescript.js.twig

@@ -69,7 +69,7 @@ class TypeScript extends LanguageMeta {
   }
 
   getTemplate() {
-    return `import { type Models } from '${this._getAppwriteDependency()}';
+    return `import type { Models } from '${this._getAppwriteDependency()}';
 
 // This file is auto-generated by the Appwrite CLI. 
 // You can regenerate it by running \`appwrite ${process.argv.slice(2).join(' ')}\`.

templates/dart/lib/query.dart.twig

@@ -153,6 +153,10 @@ class Query {
   static String orderDesc(String attribute) =>
       Query._('orderDesc', attribute).toString();
 
+  /// Sort results randomly.
+  static String orderRandom() =>
+      Query._('orderRandom').toString();
+
   /// Return results before [id].
   /// 
   /// Refer to the [Cursor Based Pagination]({{sdk.url}}/docs/pagination#cursor-pagination)

templates/dart/test/query_test.dart.twig

@@ -190,6 +190,13 @@ void main() {
     expect(query['method'], 'orderDesc');
   });
 
+  test('returns orderRandom', () {
+    final query = jsonDecode(Query.orderRandom());
+    expect(query['attribute'], null);
+    expect(query['values'], null);
+    expect(query['method'], 'orderRandom');
+  });
+
   test('returns cursorBefore', () {
     final query = jsonDecode(Query.cursorBefore('custom'));
     expect(query['attribute'], null);

templates/deno/src/query.ts.twig

@@ -81,6 +81,9 @@ export class Query {
   static orderAsc = (attribute: string): string =>
     new Query("orderAsc", attribute).toString();
 
+  static orderRandom = (): string =>
+    new Query("orderRandom").toString();
+
   static cursorAfter = (documentId: string): string =>
     new Query("cursorAfter", undefined, documentId).toString();