appwrite-cli 6.2.3 → 8.0.0

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

@@ -0,0 +1,156 @@
+/** @typedef {import('../attribute').Attribute} Attribute */
+const { AttributeType } = require('../attribute');
+const { LanguageMeta } = require("./language");
+
+class Swift 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 = "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 = `[${type}]`;
+        }
+        break;
+      default:
+        throw new Error(`Unknown attribute type: ${attribute.type}`);
+    }
+    if (attribute.array) {
+      type = "[" + type + "]";
+    }
+    if (!attribute.required) {
+      type += "?";
+    }
+    return type;
+  }
+
+  getTemplate() {
+    return `import Foundation
+
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.format === 'enum') { -%>
+public enum <%- toPascalCase(attribute.key) %>: String, Codable, CaseIterable {
+<% for (const [index, element] of Object.entries(attribute.elements)) { -%>
+  case <%- element %> = "<%- element %>"
+<% } -%>
+}
+
+<% } -%>
+<% } -%>
+public class <%- toPascalCase(collection.name) %>: Codable {
+<% for (const attribute of collection.attributes) { -%>
+    public let <%- toCamelCase(attribute.key) %>: <%- getType(attribute) %>
+<% } %>
+    enum CodingKeys: String, CodingKey {
+<% for (const attribute of collection.attributes) { -%>
+        case <%- toCamelCase(attribute.key) %> = "<%- attribute.key %>"
+<% } -%>
+    }
+
+    init(
+<% for (const attribute of collection.attributes) { -%>
+        <%- toCamelCase(attribute.key) %>: <%- getType(attribute) %><% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+<% } -%>
+    ) {
+<% for (const attribute of collection.attributes) { -%>
+        self.<%- toCamelCase(attribute.key) %> = <%- toCamelCase(attribute.key) %>
+<% } -%>
+    }
+
+    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) %>)
+<% } else { -%>
+        self.<%- toCamelCase(attribute.key) %> = try container.decodeIfPresent(<%- getType(attribute).replace('?', '') %>.self, forKey: .<%- toCamelCase(attribute.key) %>)
+<% } -%>
+<% } -%>
+    }
+
+    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) %>)
+<% } else { -%>
+        try container.encodeIfPresent(<%- toCamelCase(attribute.key) %>, forKey: .<%- toCamelCase(attribute.key) %>)
+<% } -%>
+<% } -%>
+    }
+
+    public func toMap() -> [String: Any] {
+        return [
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.type === 'relationship') { -%>
+            "<%- attribute.key %>": <%- toCamelCase(attribute.key) %> as Any<% if (attribute !== collection.attributes[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]) { %>,<% } %>
+<% } else { -%>
+            "<%- attribute.key %>": <%- toCamelCase(attribute.key) %> as Any<% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+<% } -%>
+<% } -%>
+        ]
+    }
+
+    public static func from(map: [String: Any]) -> <%- toPascalCase(collection.name) %> {
+        return <%- toPascalCase(collection.name) %>(
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.type === 'relationship') { -%>
+            <%- toCamelCase(attribute.key) %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> <%- toPascalCase(attribute.relatedCollection) %><% if (attribute !== collection.attributes[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]) { %>,<% } %>
+<% } 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]) { %>,<% } %>
+<% } 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]) { %>,<% } %>
+<% } 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]) { %>,<% } %>
+<% } 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]) { %>,<% } %>
+<% } -%>
+<% } else { -%>
+<% if (attribute.type === 'string' || attribute.type === 'email' || attribute.type === 'datetime' || attribute.type === 'enum') { -%>
+            <%- toCamelCase(attribute.key) %>: map["<%- attribute.key %>"] as<% if (!attribute.required) { %>?<% } else { %>!<% } %> String<% if (attribute !== collection.attributes[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]) { %>,<% } %>
+<% } 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]) { %>,<% } %>
+<% } 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]) { %>,<% } %>
+<% } else { -%>
+            <%- toCamelCase(attribute.key) %>: <%- toPascalCase(attribute.type) %>.from(map: map["<%- attribute.key %>"] as! [String: Any])<% if (attribute !== collection.attributes[collection.attributes.length - 1]) { %>,<% } %>
+<% } -%>
+<% } -%>
+<% } -%>
+        )
+    }
+}`;
+  }
+
+  getFileName(collection) {
+    return LanguageMeta.toPascalCase(collection.name) + ".swift";
+  }
+}
+
+module.exports = { Swift };

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

@@ -0,0 +1,95 @@
+/** @typedef {import('../attribute').Attribute} Attribute */
+const fs = require("fs");
+const path = require("path");
+
+const { AttributeType } = require('../attribute');
+const { LanguageMeta } = require("./language");
+
+class TypeScript 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) {
+      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';
+    }
+
+    if (fs.existsSync(path.resolve(process.cwd(), 'deno.json'))) {
+      return "https://deno.land/x/appwrite/mod.ts";
+    }
+
+    return "appwrite";
+  }
+
+  getTemplate() {
+    return `import { Models } from '${this._getAppwriteDependency()}';
+
+<% for (const collection of collections) { -%>
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.format === 'enum') { -%>
+export enum <%- toPascalCase(attribute.key) %> {
+<% for (const [index, element] of Object.entries(attribute.elements)) { -%>
+  <%- element.toUpperCase() %> = "<%- element %>",
+<% } -%>
+}
+<% } -%>
+<% } -%>
+<% } -%>
+<% for (const collection of collections) { %>
+export type <%- toPascalCase(collection.name) %> = Models.Document & {
+<% for (const attribute of collection.attributes) { -%>
+  <%- toCamelCase(attribute.key) %>: <%- getType(attribute) %>;
+<% } -%>
+}
+<% } %>`;
+  }
+
+  getFileName(_) {
+    return "appwrite.d.ts";
+  }
+}
+
+module.exports = { TypeScript };

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": "6.2.3",
+  "version": "8.0.0",
   "license": "BSD-3-Clause",
   "main": "index.js",
   "bin": {
@@ -23,6 +23,7 @@
   },
   "dependencies": {
     "undici": "^5.28.2",
+    "ejs": "^3.1.9",
     "chalk": "4.1.2",
     "cli-progress": "^3.12.0",
     "cli-table3": "^0.6.2",

package/scoop/appwrite.json

@@ -1,12 +1,12 @@
 {
 	"$schema": "https://raw.githubusercontent.com/ScoopInstaller/Scoop/master/schema.json",
-	"version": "6.2.3",
+	"version": "8.0.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/6.2.3/appwrite-cli-win-x64.exe",
+			"url": "https://github.com/appwrite/sdk-for-cli/releases/download/8.0.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/6.2.3/appwrite-cli-win-arm64.exe",
+			"url": "https://github.com/appwrite/sdk-for-cli/releases/download/8.0.0/appwrite-cli-win-arm64.exe",
 			"bin": [
 				[
 					"appwrite-cli-win-arm64.exe",

package/docs/examples/assistant/chat.md

@@ -1,2 +0,0 @@
-appwrite assistant chat \
-        --prompt <PROMPT>

package/docs/examples/functions/get-function-usage.md

@@ -1,3 +0,0 @@
-appwrite functions getFunctionUsage \
-        --functionId <FUNCTION_ID> \
-

package/docs/examples/health/get-queue-stats-usage-dump.md

@@ -1,2 +0,0 @@
-appwrite health getQueueStatsUsageDump \
-

package/docs/examples/proxy/create-rule.md

@@ -1,4 +0,0 @@
-appwrite proxy createRule \
-        --domain '' \
-        --resourceType api \
-

package/lib/commands/assistant.js

@@ -1,85 +0,0 @@
-const fs = require('fs');
-const pathLib = require('path');
-const tar = require("tar");
-const ignore = require("ignore");
-const { promisify } = require('util');
-const libClient = require('../client.js');
-const { getAllFiles, showConsoleLink } = require('../utils.js');
-const { Command } = require('commander');
-const { sdkForProject, sdkForConsole } = require('../sdks')
-const { parse, actionRunner, parseInteger, parseBool, commandDescriptions, success, log } = require('../parser')
-const { localConfig, globalConfig } = require("../config");
-const { File } = require('undici');
-const { ReadableStream } = require('stream/web');
-
-/**
- * @param {fs.ReadStream} readStream
- * @returns {ReadableStream}
- */
-function convertReadStreamToReadableStream(readStream) {
-  return new ReadableStream({
-    start(controller) {
-      readStream.on("data", (chunk) => {
-        controller.enqueue(chunk);
-      });
-      readStream.on("end", () => {
-        controller.close();
-      });
-      readStream.on("error", (err) => {
-        controller.error(err);
-      });
-    },
-    cancel() {
-      readStream.destroy();
-    },
-  });
-}
-
-const assistant = new Command("assistant").description(commandDescriptions['assistant'] ?? '').configureHelp({
-    helpWidth: process.stdout.columns || 80
-})
-
-/**
- * @typedef {Object} AssistantChatRequestParams
- * @property {string} prompt Prompt. A string containing questions asked to the AI assistant.
- * @property {boolean} overrideForCli
- * @property {boolean} parseOutput
- * @property {libClient | undefined} sdk
- */
-
-/**
- * @param {AssistantChatRequestParams} params
- */
-const assistantChat = async ({prompt,parseOutput = true, overrideForCli = false, sdk = undefined}) => {
-    let client = !sdk ? await sdkForProject() :
-    sdk;
-    let apiPath = '/console/assistant';
-    let payload = {};
-    if (typeof prompt !== 'undefined') {
-        payload['prompt'] = prompt;
-    }
-
-    let response = undefined;
-
-    response = await client.call('post', apiPath, {
-        'content-type': 'application/json',
-    }, payload);
-
-    if (parseOutput) {
-        parse(response)
-    }
-
-    return response;
-
-}
-
-assistant
-    .command(`chat`)
-    .description(`Send a prompt to the AI assistant and receive a response. This endpoint allows you to interact with Appwrite's AI assistant by sending questions or prompts and receiving helpful responses in real-time through a server-sent events stream. `)
-    .requiredOption(`--prompt <prompt>`, `Prompt. A string containing questions asked to the AI assistant.`)
-    .action(actionRunner(assistantChat))
-
-module.exports = {
-    assistant,
-    assistantChat
-};