@appwrite.io/console 2.1.2 → 2.1.3

package/dist/iife/sdk.js

@@ -44,10 +44,10 @@
     (function (globalObject) {
 
     	/*
-    	 *      bignumber.js v9.3.1
+    	 *      bignumber.js v9.0.0
     	 *      A JavaScript library for arbitrary-precision arithmetic.
     	 *      https://github.com/MikeMcl/bignumber.js
-    	 *      Copyright (c) 2025 Michael Mclaughlin <M8ch88l@gmail.com>
+    	 *      Copyright (c) 2019 Michael Mclaughlin <M8ch88l@gmail.com>
     	 *      MIT Licensed.
     	 *
     	 *      BigNumber.prototype methods     |  BigNumber methods
@@ -187,7 +187,7 @@
 
     	      // The maximum number of significant digits of the result of the exponentiatedBy operation.
     	      // If POW_PRECISION is 0, there will be unlimited significant digits.
-    	      POW_PRECISION = 0,                       // 0 to MAX
+    	      POW_PRECISION = 0,                    // 0 to MAX
 
     	      // The format specification used by the BigNumber.prototype.toFormat method.
     	      FORMAT = {
@@ -197,15 +197,14 @@
     	        groupSeparator: ',',
     	        decimalSeparator: '.',
     	        fractionGroupSize: 0,
-    	        fractionGroupSeparator: '\xA0',        // non-breaking space
+    	        fractionGroupSeparator: '\xA0',      // non-breaking space
     	        suffix: ''
     	      },
 
     	      // The alphabet used for base conversion. It must be at least 2 characters long, with no '+',
     	      // '-', '.', whitespace, or repeated character.
     	      // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'
-    	      ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz',
-    	      alphabetHasNormalDecimalDigits = true;
+    	      ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';
 
 
     	    //------------------------------------------------------------------------------------------
@@ -295,7 +294,7 @@
 
     	        // Allow exponential notation to be used with base 10 argument, while
     	        // also rounding to DECIMAL_PLACES as with other bases.
-    	        if (b == 10 && alphabetHasNormalDecimalDigits) {
+    	        if (b == 10) {
     	          x = new BigNumber(v);
     	          return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);
     	        }
@@ -584,10 +583,9 @@
     	          if (obj.hasOwnProperty(p = 'ALPHABET')) {
     	            v = obj[p];
 
-    	            // Disallow if less than two characters,
+    	            // Disallow if only one character,
     	            // or if it contains '+', '-', '.', whitespace, or a repeated character.
-    	            if (typeof v == 'string' && !/^.?$|[+\-.\s]|(.).*\1/.test(v)) {
-    	              alphabetHasNormalDecimalDigits = v.slice(0, 10) == '0123456789';
+    	            if (typeof v == 'string' && !/^.$|[+-.\s]|(.).*\1/.test(v)) {
     	              ALPHABET = v;
     	            } else {
     	              throw Error
@@ -679,7 +677,7 @@
     	     * arguments {number|string|BigNumber}
     	     */
     	    BigNumber.maximum = BigNumber.max = function () {
-    	      return maxOrMin(arguments, -1);
+    	      return maxOrMin(arguments, P.lt);
     	    };
 
 
@@ -689,7 +687,7 @@
     	     * arguments {number|string|BigNumber}
     	     */
     	    BigNumber.minimum = BigNumber.min = function () {
-    	      return maxOrMin(arguments, 1);
+    	      return maxOrMin(arguments, P.gt);
     	    };
 
 
@@ -948,7 +946,7 @@
 
     	        // xc now represents str converted to baseOut.
 
-    	        // The index of the rounding digit.
+    	        // THe index of the rounding digit.
     	        d = e + dp + 1;
 
     	        // The rounding digit: the digit to the right of the digit that may be rounded up.
@@ -1312,7 +1310,7 @@
 
     	        // Fixed-point notation.
     	        } else {
-    	          i -= ne + (id === 2 && e > ne);
+    	          i -= ne;
     	          str = toFixedPoint(str, e, '0');
 
     	          // Append zeros?
@@ -1333,20 +1331,24 @@
 
 
     	    // Handle BigNumber.max and BigNumber.min.
-    	    // If any number is NaN, return NaN.
-    	    function maxOrMin(args, n) {
-    	      var k, y,
+    	    function maxOrMin(args, method) {
+    	      var n,
     	        i = 1,
-    	        x = new BigNumber(args[0]);
+    	        m = new BigNumber(args[0]);
 
     	      for (; i < args.length; i++) {
-    	        y = new BigNumber(args[i]);
-    	        if (!y.s || (k = compare(x, y)) === n || k === 0 && x.s === n) {
-    	          x = y;
+    	        n = new BigNumber(args[i]);
+
+    	        // If any number is NaN, return NaN.
+    	        if (!n.s) {
+    	          m = n;
+    	          break;
+    	        } else if (method.call(m, n)) {
+    	          m = n;
     	        }
     	      }
 
-    	      return x;
+    	      return m;
     	    }
 
 
@@ -1465,7 +1467,7 @@
     	            n = xc[ni = 0];
 
     	            // Get the rounding digit at index j of n.
-    	            rd = mathfloor(n / pows10[d - j - 1] % 10);
+    	            rd = n / pows10[d - j - 1] % 10 | 0;
     	          } else {
     	            ni = mathceil((i + 1) / LOG_BASE);
 
@@ -1496,7 +1498,7 @@
     	              j = i - LOG_BASE + d;
 
     	              // Get the rounding digit at index j of n.
-    	              rd = j < 0 ? 0 : mathfloor(n / pows10[d - j - 1] % 10);
+    	              rd = j < 0 ? 0 : n / pows10[d - j - 1] % 10 | 0;
     	            }
     	          }
 
@@ -1744,7 +1746,7 @@
 
     	        // The sign of the result of pow when x is negative depends on the evenness of n.
     	        // If +n overflows to ±Infinity, the evenness of n would be not be known.
-    	        y = new BigNumber(Math.pow(+valueOf(x), nIsBig ? n.s * (2 - isOdd(n)) : +valueOf(n)));
+    	        y = new BigNumber(Math.pow(+valueOf(x), nIsBig ? 2 - isOdd(n) : +valueOf(n)));
     	        return m ? y.mod(m) : y;
     	      }
 
@@ -2045,12 +2047,7 @@
     	      }
 
     	      // x < y? Point xc to the array of the bigger number.
-    	      if (xLTy) {
-    	        t = xc;
-    	        xc = yc;
-    	        yc = t;
-    	        y.s = -y.s;
-    	      }
+    	      if (xLTy) t = xc, xc = yc, yc = t, y.s = -y.s;
 
     	      b = (j = yc.length) - (i = xc.length);
 
@@ -2204,14 +2201,7 @@
     	      ycL = yc.length;
 
     	      // Ensure xc points to longer array and xcL to its length.
-    	      if (xcL < ycL) {
-    	        zc = xc;
-    	        xc = yc;
-    	        yc = zc;
-    	        i = xcL;
-    	        xcL = ycL;
-    	        ycL = i;
-    	      }
+    	      if (xcL < ycL) zc = xc, xc = yc, yc = zc, i = xcL, xcL = ycL, ycL = i;
 
     	      // Initialise the result array with zeros.
     	      for (i = xcL + ycL, zc = []; i--; zc.push(0));
@@ -2332,12 +2322,7 @@
     	      b = yc.length;
 
     	      // Point xc to the longer array, and b to the shorter length.
-    	      if (a - b < 0) {
-    	        t = yc;
-    	        yc = xc;
-    	        xc = t;
-    	        b = a;
-    	      }
+    	      if (a - b < 0) t = yc, yc = xc, xc = t, b = a;
 
     	      // Only start adding at yc.length - 1 as the further digits of xc can be ignored.
     	      for (a = 0; b;) {
@@ -2453,7 +2438,7 @@
     	        e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);
 
     	        if (s == 1 / 0) {
-    	          n = '5e' + e;
+    	          n = '1e' + e;
     	        } else {
     	          n = s.toExponential();
     	          n = n.slice(0, n.indexOf('e') + 1) + e;
@@ -2623,12 +2608,7 @@
     	          intDigits = isNeg ? intPart.slice(1) : intPart,
     	          len = intDigits.length;
 
-    	        if (g2) {
-    	          i = g1;
-    	          g1 = g2;
-    	          g2 = i;
-    	          len -= i;
-    	        }
+    	        if (g2) i = g1, g1 = g2, g2 = i, len -= i;
 
     	        if (g1 > 0 && len > 0) {
     	          i = len % g1 || g1;
@@ -2780,7 +2760,7 @@
     	          str = e <= TO_EXP_NEG || e >= TO_EXP_POS
     	           ? toExponential(coeffToString(n.c), e)
     	           : toFixedPoint(coeffToString(n.c), e, '0');
-    	        } else if (b === 10 && alphabetHasNormalDecimalDigits) {
+    	        } else if (b === 10) {
     	          n = round(new BigNumber(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);
     	          str = toFixedPoint(coeffToString(n.c), n.e, '0');
     	        } else {
@@ -2960,6 +2940,8 @@
     	})(commonjsGlobal);
     } (bignumber));
 
+    var BigNumber$1 = bignumber.exports;
+
     (function (module) {
     	var BigNumber = bignumber.exports;
 
@@ -3848,6 +3830,14 @@
      * @returns {string}
      */
     Query.notEqual = (attribute, value) => new Query("notEqual", attribute, value).toString();
+    /**
+     * Filter resources where attribute matches a regular expression pattern.
+     *
+     * @param {string} attribute The attribute to filter on.
+     * @param {string} pattern The regular expression pattern to match.
+     * @returns {string}
+     */
+    Query.regex = (attribute, pattern) => new Query("regex", attribute, pattern).toString();
     /**
      * Filter resources where attribute is less than value.
      *
@@ -3894,6 +3884,20 @@
      * @returns {string}
      */
     Query.isNotNull = (attribute) => new Query("isNotNull", attribute).toString();
+    /**
+     * Filter resources where the specified attributes exist.
+     *
+     * @param {string[]} attributes The list of attributes that must exist.
+     * @returns {string}
+     */
+    Query.exists = (attributes) => new Query("exists", undefined, attributes).toString();
+    /**
+     * Filter resources where the specified attributes do not exist.
+     *
+     * @param {string[]} attributes The list of attributes that must not exist.
+     * @returns {string}
+     */
+    Query.notExists = (attributes) => new Query("notExists", undefined, attributes).toString();
     /**
      * Filter resources where attribute is between start and end (inclusive).
      *
@@ -4091,6 +4095,14 @@
      * @returns {string}
      */
     Query.and = (queries) => new Query("and", undefined, queries.map((query) => JSONbig$1.parse(query))).toString();
+    /**
+     * Filter array elements where at least one element matches all the specified queries.
+     *
+     * @param {string} attribute The attribute containing the array to filter on.
+     * @param {string[]} queries The list of query strings to match against array elements.
+     * @returns {string}
+     */
+    Query.elemMatch = (attribute, queries) => new Query("elemMatch", attribute, queries.map((query) => JSONbig$1.parse(query))).toString();
     /**
      * Filter resources where attribute is at a specific distance from the given coordinates.
      *
@@ -4196,7 +4208,47 @@
      */
     Query.notTouches = (attribute, values) => new Query("notTouches", attribute, [values]).toString();
 
-    const JSONbig = jsonBigint.exports({ useNativeBigInt: true });
+    const JSONbigParser = jsonBigint.exports({ storeAsString: false });
+    const JSONbigSerializer = jsonBigint.exports({ useNativeBigInt: true });
+    /**
+     * Converts BigNumber objects from json-bigint to native types.
+     * - Integer BigNumbers → BigInt (if unsafe) or number (if safe)
+     * - Float BigNumbers → number
+     * - Strings remain strings (never converted to BigNumber by json-bigint)
+     */
+    const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+    const MIN_SAFE = BigInt(Number.MIN_SAFE_INTEGER);
+    function convertBigNumbers(value) {
+        if (value === null || value === undefined)
+            return value;
+        if (Array.isArray(value)) {
+            return value.map(convertBigNumbers);
+        }
+        if (BigNumber$1.isBigNumber(value)) {
+            if (value.isInteger()) {
+                const str = value.toFixed();
+                const bi = BigInt(str);
+                if (bi >= MIN_SAFE && bi <= MAX_SAFE) {
+                    return Number(str);
+                }
+                return bi;
+            }
+            // float
+            return value.toNumber();
+        }
+        if (typeof value === 'object') {
+            const result = {};
+            for (const [k, v] of Object.entries(value)) {
+                result[k] = convertBigNumbers(v);
+            }
+            return result;
+        }
+        return value;
+    }
+    const JSONbig = {
+        parse: (text) => convertBigNumbers(JSONbigParser.parse(text)),
+        stringify: JSONbigSerializer.stringify
+    };
     /**
      * Exception thrown by the  package
      */
@@ -4246,7 +4298,7 @@
                 'x-sdk-name': 'Console',
                 'x-sdk-platform': 'console',
                 'x-sdk-language': 'web',
-                'x-sdk-version': '2.1.2',
+                'x-sdk-version': '2.1.3',
                 'X-Appwrite-Response-Format': '1.8.0',
             };
             this.realtime = {
@@ -4548,8 +4600,8 @@
          * @deprecated Use the Realtime service instead.
          * @see Realtime
          *
-         * @param {string|string[]} channels
-         * Channel to subscribe - pass a single channel as a string or multiple with an array of strings.
+         * @param {string|string[]|Channel<any>|ActionableChannel|ResolvedChannel|(Channel<any>|ActionableChannel|ResolvedChannel)[]} channels
+         * Channel to subscribe - pass a single channel as a string or Channel builder instance, or multiple with an array.
          *
          * Possible channels are:
          * - account
@@ -4567,21 +4619,40 @@
          * - teams.[ID]
          * - memberships
          * - memberships.[ID]
+         *
+         * You can also use Channel builders:
+         * - Channel.database('db').collection('col').document('doc').create()
+         * - Channel.bucket('bucket').file('file').update()
+         * - Channel.function('func').execution('exec').delete()
+         * - Channel.team('team').create()
+         * - Channel.membership('membership').update()
          * @param {(payload: RealtimeMessage) => void} callback Is called on every realtime update.
          * @returns {() => void} Unsubscribes from events.
          */
         subscribe(channels, callback) {
-            let channelArray = typeof channels === 'string' ? [channels] : channels;
-            channelArray.forEach(channel => this.realtime.channels.add(channel));
+            const channelArray = Array.isArray(channels) ? channels : [channels];
+            // Convert Channel instances to strings
+            const channelStrings = channelArray.map(ch => {
+                if (typeof ch === 'string') {
+                    return ch;
+                }
+                // All Channel instances have toString() method
+                if (ch && typeof ch.toString === 'function') {
+                    return ch.toString();
+                }
+                // Fallback to generic string conversion
+                return String(ch);
+            });
+            channelStrings.forEach(channel => this.realtime.channels.add(channel));
             const counter = this.realtime.subscriptionsCounter++;
             this.realtime.subscriptions.set(counter, {
-                channels: channelArray,
+                channels: channelStrings,
                 callback
             });
             this.realtime.connect();
             return () => {
                 this.realtime.subscriptions.delete(counter);
-                this.realtime.cleanUp(channelArray);
+                this.realtime.cleanUp(channelStrings);
                 this.realtime.connect();
             };
         }
@@ -28681,11 +28752,31 @@
         sleep(ms) {
             return new Promise(resolve => setTimeout(resolve, ms));
         }
+        /**
+         * Convert a channel value to a string
+         *
+         * @private
+         * @param {string | Channel<any> | ActionableChannel | ResolvedChannel} channel - Channel value (string or Channel builder instance)
+         * @returns {string} Channel string representation
+         */
+        channelToString(channel) {
+            if (typeof channel === 'string') {
+                return channel;
+            }
+            // All Channel instances have toString() method
+            if (channel && typeof channel.toString === 'function') {
+                return channel.toString();
+            }
+            return String(channel);
+        }
         subscribe(channelsOrChannel, callback) {
             return __awaiter(this, void 0, void 0, function* () {
-                const channels = Array.isArray(channelsOrChannel)
-                    ? new Set(channelsOrChannel)
-                    : new Set([channelsOrChannel]);
+                const channelArray = Array.isArray(channelsOrChannel)
+                    ? channelsOrChannel
+                    : [channelsOrChannel];
+                // Convert all channels to strings
+                const channelStrings = channelArray.map(ch => this.channelToString(ch));
+                const channels = new Set(channelStrings);
                 this.subscriptionsCounter++;
                 const count = this.subscriptionsCounter;
                 for (const channel of channels) {
@@ -28989,6 +29080,96 @@
         return hexTimestamp;
     };
 
+    function normalize(id) {
+        const trimmed = id.trim();
+        return trimmed === "" ? "*" : trimmed;
+    }
+    class Channel {
+        constructor(segments) {
+            this.segments = segments;
+        }
+        next(segment, id = "*") {
+            return new Channel([...this.segments, segment, normalize(id)]);
+        }
+        resolve(action) {
+            return new Channel([...this.segments, action]);
+        }
+        toString() {
+            return this.segments.join(".");
+        }
+        // --- DATABASE ROUTE ---
+        // Only available on Channel<Database>
+        collection(id = "*") {
+            return this.next("collections", id);
+        }
+        // Only available on Channel<Collection>
+        document(id = "*") {
+            return this.next("documents", id);
+        }
+        // --- TABLESDB ROUTE ---
+        table(id = "*") {
+            return this.next("tables", id);
+        }
+        row(id = "*") {
+            return this.next("rows", id);
+        }
+        // --- BUCKET ROUTE ---
+        file(id = "*") {
+            return this.next("files", id);
+        }
+        // --- FUNCTION ROUTE ---
+        execution(id = "*") {
+            return this.next("executions", id);
+        }
+        // --- TERMINAL ACTIONS ---
+        // Restricted to the Actionable union
+        create() {
+            return this.resolve("create");
+        }
+        update() {
+            return this.resolve("update");
+        }
+        delete() {
+            return this.resolve("delete");
+        }
+        // --- ROOT FACTORIES ---
+        static database(id = "*") {
+            return new Channel(["databases", normalize(id)]);
+        }
+        static tablesdb(id = "*") {
+            return new Channel(["tablesdb", normalize(id)]);
+        }
+        static bucket(id = "*") {
+            return new Channel(["buckets", normalize(id)]);
+        }
+        static function(id = "*") {
+            return new Channel(["functions", normalize(id)]);
+        }
+        static team(id = "*") {
+            return new Channel(["teams", normalize(id)]);
+        }
+        static membership(id = "*") {
+            return new Channel(["memberships", normalize(id)]);
+        }
+        static account(userId = "") {
+            const id = normalize(userId);
+            return id === "*" ? "account" : `account.${id}`;
+        }
+        // Global events
+        static get documents() {
+            return "documents";
+        }
+        static get rows() {
+            return "rows";
+        }
+        static get files() {
+            return "files";
+        }
+        static get executions() {
+            return "executions";
+        }
+    }
+
     exports.Condition = void 0;
     (function (Condition) {
         Condition["Equal"] = "equal";
@@ -30817,6 +30998,7 @@
     exports.Assistant = Assistant;
     exports.Avatars = Avatars;
     exports.Backups = Backups;
+    exports.Channel = Channel;
     exports.Client = Client;
     exports.Console = Console;
     exports.Databases = Databases;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@appwrite.io/console",
   "homepage": "https://appwrite.io/support",
   "description": "Appwrite is an open-source self-hosted backend server that abstracts and simplifies complex and repetitive development tasks behind a very simple REST API",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "license": "BSD-3-Clause",
   "main": "dist/cjs/sdk.js",
   "exports": {
@@ -25,7 +25,8 @@
     "build:libs": "rollup -c"
   },
   "dependencies": {
-    "json-bigint": "1.0.0"
+    "json-bigint": "1.0.0",
+    "bignumber.js": "9.0.0"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "22.0.0",

package/src/channel.ts

@@ -0,0 +1,134 @@
+interface Root {}
+interface Database { _db: any }
+interface Collection { _coll: any }
+interface Document { _doc: any }
+interface TablesDB { _tdb: any }
+interface Table { _tbl: any }
+interface Row { _row: any }
+interface Bucket { _bkt: any }
+interface File { _file: any }
+interface Func { _fn: any }
+interface Execution { _exec: any }
+interface Team { _team: any }
+interface Membership { _mem: any }
+interface Resolved { _res: any }
+
+type Actionable = Document | Row | File | Execution | Team | Membership;
+
+function normalize(id: string): string {
+  const trimmed = id.trim();
+  return trimmed === "" ? "*" : trimmed;
+}
+
+export class Channel<T> {
+  declare _type: T;
+
+  private constructor(private readonly segments: string[]) {}
+
+  private next<N>(segment: string, id: string = "*"): Channel<N> {
+    return new Channel<N>([...this.segments, segment, normalize(id)]) as any;
+  }
+
+  private resolve(action: string): Channel<Resolved> {
+    return new Channel<Resolved>([...this.segments, action]) as any;
+  }
+
+  toString(): string {
+    return this.segments.join(".");
+  }
+
+  // --- DATABASE ROUTE ---
+  // Only available on Channel<Database>
+  collection(this: Channel<Database>, id: string = "*"): Channel<Collection> {
+    return this.next<Collection>("collections", id);
+  }
+
+  // Only available on Channel<Collection>
+  document(this: Channel<Collection>, id: string = "*"): Channel<Document> {
+    return this.next<Document>("documents", id);
+  }
+
+  // --- TABLESDB ROUTE ---
+  table(this: Channel<TablesDB>, id: string = "*"): Channel<Table> {
+    return this.next<Table>("tables", id);
+  }
+
+  row(this: Channel<Table>, id: string = "*"): Channel<Row> {
+    return this.next<Row>("rows", id);
+  }
+
+  // --- BUCKET ROUTE ---
+  file(this: Channel<Bucket>, id: string = "*"): Channel<File> {
+    return this.next<File>("files", id);
+  }
+
+  // --- FUNCTION ROUTE ---
+  execution(this: Channel<Func>, id: string = "*"): Channel<Execution> {
+    return this.next<Execution>("executions", id);
+  }
+
+  // --- TERMINAL ACTIONS ---
+  // Restricted to the Actionable union
+  create(this: Channel<Actionable>): Channel<Resolved> {
+    return this.resolve("create");
+  }
+
+  update(this: Channel<Actionable>): Channel<Resolved> {
+    return this.resolve("update");
+  }
+
+  delete(this: Channel<Actionable>): Channel<Resolved> {
+    return this.resolve("delete");
+  }
+
+  // --- ROOT FACTORIES ---
+  static database(id: string = "*") {
+    return new Channel<Database>(["databases", normalize(id)]);
+  }
+
+  static tablesdb(id: string = "*") {
+    return new Channel<TablesDB>(["tablesdb", normalize(id)]);
+  }
+
+  static bucket(id: string = "*") {
+    return new Channel<Bucket>(["buckets", normalize(id)]);
+  }
+
+  static function(id: string = "*") {
+    return new Channel<Func>(["functions", normalize(id)]);
+  }
+
+  static team(id: string = "*") {
+    return new Channel<Team>(["teams", normalize(id)]);
+  }
+
+  static membership(id: string = "*") {
+    return new Channel<Membership>(["memberships", normalize(id)]);
+  }
+
+  static account(userId: string = ""): string {
+    const id = normalize(userId);
+    return id === "*" ? "account" : `account.${id}`;
+  }
+
+  // Global events
+  static get documents(): string {
+    return "documents";
+  }
+
+  static get rows(): string {
+    return "rows";
+  }
+
+  static get files(): string {
+    return "files";
+  }
+
+  static get executions(): string {
+    return "executions";
+  }
+}
+
+// Export types for backward compatibility with realtime
+export type ActionableChannel = Channel<Document> | Channel<Row> | Channel<File> | Channel<Execution> | Channel<Team> | Channel<Membership>;
+export type ResolvedChannel = Channel<Resolved>;