node-appwrite 11.1.1 → 12.0.0

package/lib/enums/o-auth-provider.js

@@ -0,0 +1,43 @@
+const OAuthProvider = Object.freeze({
+    Amazon: 'amazon' ,
+    Apple: 'apple' ,
+    Auth0: 'auth0' ,
+    Authentik: 'authentik' ,
+    Autodesk: 'autodesk' ,
+    Bitbucket: 'bitbucket' ,
+    Bitly: 'bitly' ,
+    Box: 'box' ,
+    Dailymotion: 'dailymotion' ,
+    Discord: 'discord' ,
+    Disqus: 'disqus' ,
+    Dropbox: 'dropbox' ,
+    Etsy: 'etsy' ,
+    Facebook: 'facebook' ,
+    Github: 'github' ,
+    Gitlab: 'gitlab' ,
+    Google: 'google' ,
+    Linkedin: 'linkedin' ,
+    Microsoft: 'microsoft' ,
+    Notion: 'notion' ,
+    Oidc: 'oidc' ,
+    Okta: 'okta' ,
+    Paypal: 'paypal' ,
+    PaypalSandbox: 'paypalSandbox' ,
+    Podio: 'podio' ,
+    Salesforce: 'salesforce' ,
+    Slack: 'slack' ,
+    Spotify: 'spotify' ,
+    Stripe: 'stripe' ,
+    Tradeshift: 'tradeshift' ,
+    TradeshiftBox: 'tradeshiftBox' ,
+    Twitch: 'twitch' ,
+    Wordpress: 'wordpress' ,
+    Yahoo: 'yahoo' ,
+    Yammer: 'yammer' ,
+    Yandex: 'yandex' ,
+    Zoho: 'zoho' ,
+    Zoom: 'zoom' ,
+    Mock: 'mock' 
+});
+
+module.exports = OAuthProvider;

package/lib/enums/password-hash.js

@@ -0,0 +1,15 @@
+const PasswordHash = Object.freeze({
+    Sha1: 'sha1' ,
+    Sha224: 'sha224' ,
+    Sha256: 'sha256' ,
+    Sha384: 'sha384' ,
+    Sha512224: 'sha512/224' ,
+    Sha512256: 'sha512/256' ,
+    Sha512: 'sha512' ,
+    Sha3224: 'sha3-224' ,
+    Sha3256: 'sha3-256' ,
+    Sha3384: 'sha3-384' ,
+    Sha3512: 'sha3-512' 
+});
+
+module.exports = PasswordHash;

package/lib/enums/relation-mutate.js

@@ -0,0 +1,7 @@
+const RelationMutate = Object.freeze({
+    Cascade: 'cascade' ,
+    Restrict: 'restrict' ,
+    SetNull: 'setNull' 
+});
+
+module.exports = RelationMutate;

package/lib/enums/relationship-type.js

@@ -0,0 +1,8 @@
+const RelationshipType = Object.freeze({
+    OneToOne: 'oneToOne' ,
+    ManyToOne: 'manyToOne' ,
+    ManyToMany: 'manyToMany' ,
+    OneToMany: 'oneToMany' 
+});
+
+module.exports = RelationshipType;

package/lib/enums/runtime.js

@@ -0,0 +1,48 @@
+const Runtime = Object.freeze({
+    Node145: 'node-14.5' ,
+    Node160: 'node-16.0' ,
+    Node180: 'node-18.0' ,
+    Node190: 'node-19.0' ,
+    Node200: 'node-20.0' ,
+    Node210: 'node-21.0' ,
+    Php80: 'php-8.0' ,
+    Php81: 'php-8.1' ,
+    Php82: 'php-8.2' ,
+    Php83: 'php-8.3' ,
+    Ruby30: 'ruby-3.0' ,
+    Ruby31: 'ruby-3.1' ,
+    Ruby32: 'ruby-3.2' ,
+    Ruby33: 'ruby-3.3' ,
+    Python38: 'python-3.8' ,
+    Python39: 'python-3.9' ,
+    Python310: 'python-3.10' ,
+    Python311: 'python-3.11' ,
+    Python312: 'python-3.12' ,
+    Deno140: 'deno-1.40' ,
+    Dart215: 'dart-2.15' ,
+    Dart216: 'dart-2.16' ,
+    Dart217: 'dart-2.17' ,
+    Dart218: 'dart-2.18' ,
+    Dart30: 'dart-3.0' ,
+    Dart31: 'dart-3.1' ,
+    Dart33: 'dart-3.3' ,
+    Dotnet31: 'dotnet-3.1' ,
+    Dotnet60: 'dotnet-6.0' ,
+    Dotnet70: 'dotnet-7.0' ,
+    Java80: 'java-8.0' ,
+    Java110: 'java-11.0' ,
+    Java170: 'java-17.0' ,
+    Java180: 'java-18.0' ,
+    Java210: 'java-21.0' ,
+    Swift55: 'swift-5.5' ,
+    Swift58: 'swift-5.8' ,
+    Swift59: 'swift-5.9' ,
+    Kotlin16: 'kotlin-1.6' ,
+    Kotlin18: 'kotlin-1.8' ,
+    Kotlin19: 'kotlin-1.9' ,
+    Cpp17: 'cpp-17' ,
+    Cpp20: 'cpp-20' ,
+    Bun10: 'bun-1.0' 
+});
+
+module.exports = Runtime;

package/lib/enums/smtp-encryption.js

@@ -0,0 +1,7 @@
+const SmtpEncryption = Object.freeze({
+    None: 'none' ,
+    Ssl: 'ssl' ,
+    Tls: 'tls' 
+});
+
+module.exports = SmtpEncryption;

package/lib/inputFile.js

@@ -1,40 +1,112 @@
-const { Readable } = require('stream');
-const fs = require('fs');
+const fs = require("fs");
+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();
+    },
+  });
+}
+
+/**
+ * @param {Buffer} buffer
+ * @returns {ReadableStream}
+ */
+function bufferToReadableStream(buffer) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(buffer);
+      controller.close();
+    },
+  });
+}
 
 class InputFile {
-  stream; // Content of file, readable stream
-  size; // Total final size of the file content
-  filename; // File name
+  /** @type {ReadableStream} Content of file as a stream */
+  stream;
 
+  /** @type {number} Total final size of the file content */
+  size;
+
+  /** @type {string} File name */
+  filename;
+
+  /**
+   * @param {string} filePath
+   * @param {string} filename
+   * @returns {InputFile}
+   */
   static fromPath = (filePath, filename) => {
-    const stream = fs.createReadStream(filePath);
-    const { size } = fs.statSync(filePath);
+    const nodeStream = fs.createReadStream(filePath);
+    const stream = convertReadStreamToReadableStream(nodeStream);
+    const size = fs.statSync(filePath).size;
     return new InputFile(stream, filename, size);
   };
 
+  /**
+   * @param {Buffer} buffer
+   * @param {string} filename
+   * @returns {InputFile}
+   */
   static fromBuffer = (buffer, filename) => {
-    const stream = Readable.from(buffer);
-    const size = Buffer.byteLength(buffer);
+    const stream = bufferToReadableStream(buffer);
+    const size = buffer.byteLength;
     return new InputFile(stream, filename, size);
   };
 
-  static fromBlob = async (blob, filename) => {
-    const arrayBuffer = await blob.arrayBuffer();
-    const buffer = Buffer.from(arrayBuffer);
+  /**
+   * @param {string} content
+   * @param {string} filename
+   * @returns {InputFile}
+   */
+  static fromPlainText = (content, filename) => {
+    const array = new TextEncoder().encode(content);
+    const buffer = Buffer.from(array);
     return InputFile.fromBuffer(buffer, filename);
   };
 
+  /**
+   * @param {ReadableStream} stream
+   * @param {string} filename
+   * @param {number} size
+   * @returns {InputFile}
+   */
   static fromStream = (stream, filename, size) => {
     return new InputFile(stream, filename, size);
   };
 
-  static fromPlainText = (content, filename) => {
-    const buffer = Buffer.from(content, "utf-8");
-    const stream = Readable.from(buffer);
-    const size = Buffer.byteLength(buffer);
+  /**
+   * @param {Blob} blob
+   * @param {string} filename
+   * @returns {InputFile}
+   */
+  static fromBlob = (blob, filename) => {
+    const stream = blob.stream();
+    const size = blob.size;
     return new InputFile(stream, filename, size);
   };
 
+  /**
+   * @param {ReadableStream} stream
+   * @param {string} filename
+   * @param {number} size
+   */
   constructor(stream, filename, size) {
     this.stream = stream;
     this.filename = filename;

package/lib/query.js

@@ -1,72 +1,90 @@
 class Query {
+  constructor(method, attribute, values) {
+    this.method = method
+    this.attribute = attribute
+
+    if (values !== undefined) {
+      if (Array.isArray(values)) {
+        this.values = values
+      } else {
+        this.values = [values]
+      }
+    }
+  }
+
   static equal = (attribute, value) =>
-    Query.addQuery(attribute, "equal", value);
+    new Query("equal", attribute, value).toString()
 
   static notEqual = (attribute, value) =>
-    Query.addQuery(attribute, "notEqual", value);
+    new Query("notEqual", attribute, value).toString()
 
   static lessThan = (attribute, value) =>
-    Query.addQuery(attribute, "lessThan", value);
+    new Query("lessThan", attribute, value).toString()
 
   static lessThanEqual = (attribute, value) =>
-    Query.addQuery(attribute, "lessThanEqual", value);
+    new Query("lessThanEqual", attribute, value).toString()
 
   static greaterThan = (attribute, value) =>
-    Query.addQuery(attribute, "greaterThan", value);
+    new Query("greaterThan", attribute, value).toString()
 
   static greaterThanEqual = (attribute, value) =>
-    Query.addQuery(attribute, "greaterThanEqual", value);
+    new Query("greaterThanEqual", attribute, value).toString()
 
-  static isNull = (attribute) =>
-    `isNull("${attribute}")`;
+  static isNull = attribute =>
+    new Query("isNull", attribute).toString()
 
-  static isNotNull = (attribute) =>
-    `isNotNull("${attribute}")`;
+  static isNotNull = attribute =>
+    new Query("isNotNull", attribute).toString()
 
   static between = (attribute, start, end) =>
-    `between("${attribute}", ${Query.parseValues(start)}, ${Query.parseValues(end)})`
+    new Query("between", attribute, [start, end]).toString()
 
   static startsWith = (attribute, value) =>
-    Query.addQuery(attribute, "startsWith", value);
+    new Query("startsWith", attribute, value).toString()
 
   static endsWith = (attribute, value) =>
-    Query.addQuery(attribute, "endsWith", value);
+    new Query("endsWith", attribute, value).toString()
 
-  static select = (attributes) =>
-    `select([${attributes.map((attr) => `"${attr}"`).join(",")}])`;
+  static select = attributes =>
+    new Query("select", undefined, attributes).toString()
 
   static search = (attribute, value) =>
-    Query.addQuery(attribute, "search", value);
+    new Query("search", attribute, value).toString()
+
+  static orderDesc = attribute =>
+    new Query("orderDesc", attribute).toString()
 
-  static orderDesc = (attribute) =>
-    `orderDesc("${attribute}")`;
+  static orderAsc = attribute =>
+    new Query("orderAsc", attribute).toString()
 
-  static orderAsc = (attribute) =>
-    `orderAsc("${attribute}")`;
+  static cursorAfter = documentId =>
+    new Query("cursorAfter", undefined, documentId).toString()
 
-  static cursorAfter = (documentId) =>
-    `cursorAfter("${documentId}")`;
+  static cursorBefore = documentId =>
+    new Query("cursorBefore", undefined, documentId).toString()
 
-  static cursorBefore = (documentId) =>
-    `cursorBefore("${documentId}")`;
+  static limit = limit =>
+    new Query("limit", undefined, limit).toString()
 
-  static limit = (limit) =>
-    `limit(${limit})`;
+  static offset = offset =>
+    new Query("offset", undefined, offset).toString()
 
-  static offset = (offset) =>
-    `offset(${offset})`;
+  static contains = (attribute, value) =>
+    new Query("contains", attribute, value).toString()
 
-  static addQuery = (attribute, method, value) =>
-    value instanceof Array
-      ? `${method}("${attribute}", [${value
-          .map((v) => Query.parseValues(v))
-          .join(",")}])`
-      : `${method}("${attribute}", [${Query.parseValues(value)}])`;
+  static or = (queries) =>
+    new Query("or", undefined, queries.map((query) => JSON.parse(query))).toString()
 
-  static parseValues = (value) =>
-    typeof value === "string" || value instanceof String
-      ? `"${value}"`
-      : `${value}`;
+  static and = (queries) =>
+    new Query("and", undefined, queries.map((query) => JSON.parse(query))).toString();
 }
 
+Query.prototype.toString = function () {
+  return JSON.stringify({
+    method: this.method,
+    attribute: this.attribute,
+    values: this.values
+  })
+} 
+
 module.exports = Query;