@appwrite.io/console 0.6.2 → 0.7.0-rc.1

package/src/client.ts

@@ -1,83 +1,274 @@
 import { Models } from './models';
-import { Service } from './service';
 
+/**
+ * Payload type representing a key-value pair with string keys and any values.
+ */
 type Payload = {
     [key: string]: any;
 }
 
+/**
+ * Headers type representing a key-value pair with string keys and string values.
+ */
 type Headers = {
     [key: string]: string;
 }
 
+/**
+ * Realtime response structure with different types.
+ */
 type RealtimeResponse = {
+    /**
+     * Type of the response: 'error', 'event', 'connected', or 'response'.
+     */
     type: 'error' | 'event' | 'connected' | 'response';
+
+    /**
+     * Data associated with the response based on the response type.
+     */
     data: RealtimeResponseAuthenticated | RealtimeResponseConnected | RealtimeResponseError | RealtimeResponseEvent<unknown>;
 }
 
+/**
+ * Realtime request structure for authentication.
+ */
 type RealtimeRequest = {
+    /**
+     * Type of the request: 'authentication'.
+     */
     type: 'authentication';
+
+    /**
+     * Data required for authentication.
+     */
     data: RealtimeRequestAuthenticate;
 }
 
-export type RealtimeResponseEvent<T extends unknown> = {
+/**
+ * Realtime event response structure with generic payload type.
+ */
+type RealtimeResponseEvent<T extends unknown> = {
+    /**
+     * List of event names associated with the response.
+     */
     events: string[];
+
+    /**
+     * List of channel names associated with the response.
+     */
     channels: string[];
+
+    /**
+     * Timestamp indicating the time of the event.
+     */
     timestamp: number;
+
+    /**
+     * Payload containing event-specific data.
+     */
     payload: T;
 }
 
+/**
+ * Realtime response structure for errors.
+ */
 type RealtimeResponseError = {
+    /**
+     * Numeric error code indicating the type of error.
+     */
     code: number;
+
+    /**
+     * Error message describing the encountered error.
+     */
     message: string;
 }
 
+/**
+ * Realtime response structure for a successful connection.
+ */
 type RealtimeResponseConnected = {
+    /**
+     * List of channels the user is connected to.
+     */
     channels: string[];
+
+    /**
+     * User object representing the connected user (optional).
+     */
     user?: object;
 }
 
+/**
+ * Realtime response structure for authenticated connections.
+ */
 type RealtimeResponseAuthenticated = {
+    /**
+     * Destination channel for the response.
+     */
     to: string;
+
+    /**
+     * Boolean indicating the success of the authentication process.
+     */
     success: boolean;
+
+    /**
+     * User object representing the authenticated user.
+     */
     user: object;
 }
 
+/**
+ * Realtime request structure for authentication.
+ */
 type RealtimeRequestAuthenticate = {
+    /**
+     * Session identifier for authentication.
+     */
     session: string;
 }
 
+/**
+ * Realtime interface representing the structure of a realtime communication object.
+ */
 type Realtime = {
+    /**
+     * WebSocket instance for realtime communication.
+     */
     socket?: WebSocket;
+
+    /**
+     * Timeout duration for communication operations.
+     */
     timeout?: number;
+
+    /**
+     * URL for establishing the WebSocket connection.
+     */
     url?: string;
+
+    /**
+     * Last received message from the realtime server.
+     */
     lastMessage?: RealtimeResponse;
+
+    /**
+     * Set of channel names the client is subscribed to.
+     */
     channels: Set<string>;
+
+    /**
+     * Map of subscriptions containing channel names and corresponding callback functions.
+     */
     subscriptions: Map<number, {
         channels: string[];
         callback: (payload: RealtimeResponseEvent<any>) => void
     }>;
+
+    /**
+     * Counter for managing subscriptions.
+     */
     subscriptionsCounter: number;
+
+    /**
+     * Boolean indicating whether automatic reconnection is enabled.
+     */
     reconnect: boolean;
+
+    /**
+     * Number of reconnection attempts made.
+     */
     reconnectAttempts: number;
+
+    /**
+     * Function to get the timeout duration for communication operations.
+     */
     getTimeout: () => number;
+
+    /**
+     * Function to establish a WebSocket connection.
+     */
     connect: () => void;
+
+    /**
+     * Function to create a new WebSocket instance.
+     */
     createSocket: () => void;
+
+    /**
+     * Function to clean up resources associated with specified channels.
+     *
+     * @param {string[]} channels - List of channel names to clean up.
+     */
     cleanUp: (channels: string[]) => void;
+
+    /**
+     * Function to handle incoming messages from the WebSocket connection.
+     *
+     * @param {MessageEvent} event - Event containing the received message.
+     */
     onMessage: (event: MessageEvent) => void;
 }
 
-export type UploadProgress = {
+/**
+ * Type representing upload progress information.
+ */
+type UploadProgress = {
+    /**
+     * Identifier for the upload progress.
+     */
     $id: string;
+
+    /**
+     * Current progress of the upload (in percentage).
+     */
     progress: number;
+
+    /**
+     * Total size uploaded (in bytes) during the upload process.
+     */
     sizeUploaded: number;
+
+    /**
+     * Total number of chunks that need to be uploaded.
+     */
     chunksTotal: number;
+
+    /**
+     * Number of chunks that have been successfully uploaded.
+     */
     chunksUploaded: number;
 }
 
+/**
+ * Exception thrown by the  package
+ */
 class AppwriteException extends Error {
+    /**
+     * The error code associated with the exception.
+     */
     code: number;
+
+    /**
+     * The response string associated with the exception.
+     */
     response: string;
+
+    /**
+     * Error type.
+     * See [Error Types](https://appwrite.io/docs/response-codes#errorTypes) for more information.
+     */
     type: string;
+
+    /**
+     * Initializes a Appwrite Exception.
+     *
+     * @param {string} message - The error message.
+     * @param {number} code - The error code. Default is 0.
+     * @param {string} type - The error type. Default is an empty string.
+     * @param {string} response - The response string. Default is an empty string.
+     */
     constructor(message: string, code: number = 0, type: string = '', response: string = '') {
         super(message);
         this.name = 'AppwriteException';
@@ -88,7 +279,15 @@ class AppwriteException extends Error {
     }
 }
 
+/**
+ * Client that handles requests to Appwrite
+ */
 class Client {
+    static CHUNK_SIZE = 1024 * 1024 * 5;
+
+    /**
+     * Holds configuration such as project.
+     */
     config = {
         endpoint: 'https://cloud.appwrite.io/v1',
         endpointRealtime: '',
@@ -98,12 +297,15 @@ class Client {
         locale: '',
         mode: '',
     };
+    /**
+     * Custom headers for API requests.
+     */
     headers: Headers = {
         'x-sdk-name': 'Console',
         'x-sdk-platform': 'console',
         'x-sdk-language': 'web',
-        'x-sdk-version': '0.6.2',
-        'X-Appwrite-Response-Format': '1.5.0',
+        'x-sdk-version': '0.7.0-rc.1',
+        'X-Appwrite-Response-Format': '1.6.0',
     };
 
     /**
@@ -149,7 +351,6 @@ class Client {
         this.config.project = value;
         return this;
     }
-
     /**
      * Set Key
      *
@@ -164,7 +365,6 @@ class Client {
         this.config.key = value;
         return this;
     }
-
     /**
      * Set JWT
      *
@@ -179,7 +379,6 @@ class Client {
         this.config.jwt = value;
         return this;
     }
-
     /**
      * Set Locale
      *
@@ -192,7 +391,6 @@ class Client {
         this.config.locale = value;
         return this;
     }
-
     /**
      * Set Mode
      *
@@ -206,7 +404,6 @@ class Client {
         return this;
     }
 
-
     private realtime: Realtime = {
         socket: undefined,
         timeout: undefined,
@@ -390,27 +587,18 @@ class Client {
         }
     }
 
-    async call(method: string, url: URL, headers: Headers = {}, params: Payload = {}): Promise<any> {
+    prepareRequest(method: string, url: URL, headers: Headers = {}, params: Payload = {}): { uri: string, options: RequestInit } {
         method = method.toUpperCase();
 
-
         headers = Object.assign({}, this.headers, headers);
 
         let options: RequestInit = {
             method,
             headers,
-            credentials: 'include'
         };
 
-        if (typeof window !== 'undefined' && window.localStorage) {
-            const cookieFallback = window.localStorage.getItem('cookieFallback');
-            if (cookieFallback) {
-                headers['X-Fallback-Cookies'] = cookieFallback;
-            }
-        }
-
         if (method === 'GET') {
-            for (const [key, value] of Object.entries(Service.flatten(params))) {
+            for (const [key, value] of Object.entries(Client.flatten(params))) {
                 url.searchParams.append(key, value);
             }
         } else {
@@ -420,15 +608,17 @@ class Client {
                     break;
 
                 case 'multipart/form-data':
-                    let formData = new FormData();
-
-                    for (const key in params) {
-                        if (Array.isArray(params[key])) {
-                            params[key].forEach((value: any) => {
-                                formData.append(key + '[]', value);
-                            })
+                    const formData = new FormData();
+
+                    for (const [key, value] of Object.entries(params)) {
+                        if (value instanceof File) {
+                            formData.append(key, value, value.name);
+                        } else if (Array.isArray(value)) {
+                            for (const nestedValue of value) {
+                                formData.append(`${key}[]`, nestedValue);
+                            }
                         } else {
-                            formData.append(key, params[key]);
+                            formData.append(key, value);
                         }
                     }
 
@@ -438,40 +628,121 @@ class Client {
             }
         }
 
-        try {
-            let data = null;
-            const response = await fetch(url.toString(), options);
+        return { uri: url.toString(), options };
+    }
 
-            if (response.headers.get('content-type')?.includes('application/json')) {
-                data = await response.json();
-            } else {
-                data = {
-                    message: await response.text()
-                };
-            }
+    async chunkedUpload(method: string, url: URL, headers: Headers = {}, originalPayload: Payload = {}, onProgress: (progress: UploadProgress) => void) {
+        const file = Object.values(originalPayload).find((value) => value instanceof File);
 
-            if (400 <= response.status) {
-                throw new AppwriteException(data?.message, response.status, data?.type, data);
+        if (file.size <= Client.CHUNK_SIZE) {
+            return await this.call(method, url, headers, originalPayload);
+        }
+
+        let start = 0;
+        let response = null;
+
+        while (start < file.size) {
+            let end = start + Client.CHUNK_SIZE; // Prepare end for the next chunk
+            if (end >= file.size) {
+                end = file.size; // Adjust for the last chunk to include the last byte
             }
 
-            const cookieFallback = response.headers.get('X-Fallback-Cookies');
+            headers['content-range'] = `bytes ${start}-${end-1}/${file.size}`;
+            const chunk = file.slice(start, end);
+
+            let payload = { ...originalPayload, file: new File([chunk], file.name)};
 
-            if (typeof window !== 'undefined' && window.localStorage && cookieFallback) {
-                window.console.warn('Appwrite is using localStorage for session management. Increase your security by adding a custom domain as your API endpoint.');
-                window.localStorage.setItem('cookieFallback', cookieFallback);
+            response = await this.call(method, url, headers, payload);
+
+            if (onProgress && typeof onProgress === 'function') {
+                onProgress({
+                    $id: response.$id,
+                    progress: Math.round((end / file.size) * 100),
+                    sizeUploaded: end,
+                    chunksTotal: Math.ceil(file.size / Client.CHUNK_SIZE),
+                    chunksUploaded: Math.ceil(end / Client.CHUNK_SIZE)
+                });
             }
 
-            return data;
-        } catch (e) {
-            if (e instanceof AppwriteException) {
-                throw e;
+            if (response && response.$id) {
+                headers['x-appwrite-id'] = response.$id;
             }
-            throw new AppwriteException((<Error>e).message);
+
+            start = end;
+        }
+
+        return response;
+    }
+
+    async redirect(method: string, url: URL, headers: Headers = {}, params: Payload = {}): Promise<string> {
+        const { uri, options } = this.prepareRequest(method, url, headers, params);
+        
+        const response = await fetch(uri, {
+            ...options,
+            redirect: 'manual'
+        });
+
+        if (response.status !== 301 && response.status !== 302) {
+            throw new AppwriteException('Invalid redirect', response.status);
         }
+
+        return response.headers.get('location') || '';
+    }
+
+    async call(method: string, url: URL, headers: Headers = {}, params: Payload = {}, responseType = 'json'): Promise<any> {
+        const { uri, options } = this.prepareRequest(method, url, headers, params);
+
+        let data: any = null;
+
+        const response = await fetch(uri, options);
+
+        const warnings = response.headers.get('x-appwrite-warning');
+        if (warnings) {
+            warnings.split(';').forEach((warning: string) => console.warn('Warning: ' + warning));
+        }
+
+        if (response.headers.get('content-type')?.includes('application/json')) {
+            data = await response.json();
+        } else if (responseType === 'arrayBuffer') {
+            data = await response.arrayBuffer();
+        } else {
+            data = {
+                message: await response.text()
+            };
+        }
+
+        if (400 <= response.status) {
+            throw new AppwriteException(data?.message, response.status, data?.type, data);
+        }
+
+        const cookieFallback = response.headers.get('X-Fallback-Cookies');
+
+        if (typeof window !== 'undefined' && window.localStorage && cookieFallback) {
+            window.console.warn('Appwrite is using localStorage for session management. Increase your security by adding a custom domain as your API endpoint.');
+            window.localStorage.setItem('cookieFallback', cookieFallback);
+        }
+
+        return data;
+    }
+
+    static flatten(data: Payload, prefix = ''): Payload {
+        let output: Payload = {};
+
+        for (const [key, value] of Object.entries(data)) {
+            let finalKey = prefix ? prefix + '[' + key +']' : key;
+            if (Array.isArray(value)) {
+                output = { ...output, ...Client.flatten(value, finalKey) };
+            } else {
+                output[finalKey] = value;
+            }
+        }
+
+        return output;
     }
 }
 
 export { Client, AppwriteException };
 export { Query } from './query';
-export type { Models, Payload };
+export type { Models, Payload, UploadProgress };
+export type { RealtimeResponseEvent };
 export type { QueryTypes, QueryTypesList } from './query';

package/src/enums/credit-card.ts

@@ -2,7 +2,7 @@ export enum CreditCard {
     AmericanExpress = 'amex',
     Argencard = 'argencard',
     Cabal = 'cabal',
-    Consosud = 'censosud',
+    Cencosud = 'cencosud',
     DinersClub = 'diners',
     Discover = 'discover',
     Elo = 'elo',

package/src/enums/email-template-type.ts

@@ -4,4 +4,6 @@ export enum EmailTemplateType {
     Recovery = 'recovery',
     Invitation = 'invitation',
     Mfachallenge = 'mfachallenge',
+    Sessionalert = 'sessionalert',
+    Otpsession = 'otpsession',
 }

package/src/enums/name.ts

@@ -6,10 +6,9 @@ export enum Name {
     V1functions = 'v1-functions',
     V1usage = 'v1-usage',
     V1usagedump = 'v1-usage-dump',
-    Webhooksv1 = 'webhooksv1',
+    V1webhooks = 'v1-webhooks',
     V1certificates = 'v1-certificates',
     V1builds = 'v1-builds',
     V1messaging = 'v1-messaging',
     V1migrations = 'v1-migrations',
-    Hamsterv1 = 'hamsterv1',
 }

package/src/enums/platform-type.ts

@@ -12,4 +12,6 @@ export enum PlatformType {
     Appletvos = 'apple-tvos',
     Android = 'android',
     Unity = 'unity',
+    Reactnativeios = 'react-native-ios',
+    Reactnativeandroid = 'react-native-android',
 }

package/src/enums/runtime.ts

@@ -19,9 +19,6 @@ export enum Runtime {
     Python311 = 'python-3.11',
     Python312 = 'python-3.12',
     Pythonml311 = 'python-ml-3.11',
-    Deno121 = 'deno-1.21',
-    Deno124 = 'deno-1.24',
-    Deno135 = 'deno-1.35',
     Deno140 = 'deno-1.40',
     Dart215 = 'dart-2.15',
     Dart216 = 'dart-2.16',
@@ -47,4 +44,5 @@ export enum Runtime {
     Cpp17 = 'cpp-17',
     Cpp20 = 'cpp-20',
     Bun10 = 'bun-1.0',
+    Go122 = 'go-1.22',
 }

package/src/id.ts

@@ -1,6 +1,13 @@
+/**
+ * Helper class to generate ID strings for resources.
+ */
 export class ID {
-    // Generate an hex ID based on timestamp
-    // Recreated from https://www.php.net/manual/en/function.uniqid.php
+    /**
+     * Generate an hex ID based on timestamp.
+     * Recreated from https://www.php.net/manual/en/function.uniqid.php
+     *
+     * @returns {string}
+     */
     static #hexTimestamp(): string {
         const now = new Date();
         const sec = Math.floor(now.getTime() / 1000);
@@ -11,10 +18,22 @@ export class ID {
         return hexTimestamp;
     }
 
+    /**
+     * Uses the provided ID as the ID for the resource.
+     *
+     * @param {string} id
+     * @returns {string}
+     */
     public static custom(id: string): string {
         return id
     }
 
+    /**
+     * Have Appwrite generate a unique ID for you.
+     * 
+     * @param {number} padding. Default is 7.
+     * @returns {string}
+     */
     public static unique(padding: number = 7): string {
         // Generate a unique ID with padding to have a longer ID
         const baseId = ID.#hexTimestamp();

package/src/index.ts

@@ -1,3 +1,10 @@
+/**
+ * Appwrite Console SDK
+ *
+ * This SDK is compatible with Appwrite server version 1.6.x. 
+ * For older versions, please check
+ * [previous releases](https://github.com/appwrite/sdk-for-console/releases).
+ */
 export { Client, Query, AppwriteException } from './client';
 export { Account } from './services/account';
 export { Avatars } from './services/avatars';