appwrite-cli 13.0.0-rc.1 → 13.0.0-rc.3

package/lib/config.ts

@@ -1,854 +1,933 @@
-import os = require('os');
-import fs = require('fs');
-import _path = require('path');
-import process = require('process');
-import JSONbig = require('json-bigint');
-import type { ConfigData, SessionData, GlobalConfigData, ProjectConfigData } from './types';
+import os from "os";
+import fs from "fs";
+import _path from "path";
+import process from "process";
+import JSONbig from "json-bigint";
+import type { Models } from "@appwrite.io/console";
+import type {
+  BucketType,
+  CollectionType,
+  FunctionType,
+  ConfigType,
+  SettingsType,
+  SiteType,
+  TableType,
+  TeamType,
+  TopicType,
+} from "./commands/config.js";
+import type {
+  SessionData,
+  ConfigData,
+  Entity,
+  GlobalConfigData,
+} from "./types.js";
+import { createSettingsObject } from "./utils.js";
+import { SDK_TITLE_LOWER } from "./constants.js";
 
 const JSONBigInt = JSONbig({ storeAsString: false });
 
-const KeysVars = new Set(['key', 'value']);
-const KeysSite = new Set(['path', '$id', 'name', 'enabled', 'logging', 'timeout', 'framework', 'buildRuntime', 'adapter', 'installCommand', 'buildCommand', 'outputDirectory', 'fallbackFile', 'specification', 'vars']);
-const KeysFunction = new Set(['path', '$id', 'execute', 'name', 'enabled', 'logging', 'runtime', 'specification', 'scopes', 'events', 'schedule', 'timeout', 'entrypoint', 'commands', 'vars']);
-const KeysDatabase = new Set(['$id', 'name', 'enabled']);
-const KeysCollection = new Set(['$id', '$permissions', 'databaseId', 'name', 'enabled', 'documentSecurity', 'attributes', 'indexes']);
-const KeysTable = new Set(['$id', '$permissions', 'databaseId', 'name', 'enabled', 'rowSecurity', 'columns', 'indexes']);
-const KeysStorage = new Set(['$id', '$permissions', 'fileSecurity', 'name', 'enabled', 'maximumFileSize', 'allowedFileExtensions', 'compression', 'encryption', 'antivirus']);
-const KeysTopics = new Set(['$id', 'name', 'subscribe']);
-const KeysTeams = new Set(['$id', 'name']);
+const KeysVars = new Set(["key", "value"]);
+const KeysSite = new Set([
+  "path",
+  "$id",
+  "name",
+  "enabled",
+  "logging",
+  "timeout",
+  "framework",
+  "buildRuntime",
+  "adapter",
+  "installCommand",
+  "buildCommand",
+  "outputDirectory",
+  "fallbackFile",
+  "specification",
+  "vars",
+]);
+const KeysFunction = new Set([
+  "path",
+  "$id",
+  "execute",
+  "name",
+  "enabled",
+  "logging",
+  "runtime",
+  "specification",
+  "scopes",
+  "events",
+  "schedule",
+  "timeout",
+  "entrypoint",
+  "commands",
+  "vars",
+]);
+const KeysDatabase = new Set(["$id", "name", "enabled"]);
+const KeysCollection = new Set([
+  "$id",
+  "$permissions",
+  "databaseId",
+  "name",
+  "enabled",
+  "documentSecurity",
+  "attributes",
+  "indexes",
+]);
+const KeysTable = new Set([
+  "$id",
+  "$permissions",
+  "databaseId",
+  "name",
+  "enabled",
+  "rowSecurity",
+  "columns",
+  "indexes",
+]);
+const KeysStorage = new Set([
+  "$id",
+  "$permissions",
+  "fileSecurity",
+  "name",
+  "enabled",
+  "maximumFileSize",
+  "allowedFileExtensions",
+  "compression",
+  "encryption",
+  "antivirus",
+]);
+const KeysTopics = new Set(["$id", "name", "subscribe"]);
+const KeysTeams = new Set(["$id", "name"]);
 const KeysAttributes = new Set([
-    'key',
-    'type',
-    'required',
-    'array',
-    'size',
-    'default',
-    // integer and float
-    'min',
-    'max',
-    // email, enum, URL, IP, and datetime
-    'format',
-    // enum
-    'elements',
-    // relationship
-    'relatedCollection',
-    'relationType',
-    'twoWay',
-    'twoWayKey',
-    'onDelete',
-    'side',
-    // Indexes
-    'attributes',
-    'orders',
-    // Strings
-    'encrypt',
+  "key",
+  "type",
+  "required",
+  "array",
+  "size",
+  "default",
+  // integer and float
+  "min",
+  "max",
+  // email, enum, URL, IP, and datetime
+  "format",
+  // enum
+  "elements",
+  // relationship
+  "relatedCollection",
+  "relationType",
+  "twoWay",
+  "twoWayKey",
+  "onDelete",
+  "side",
+  // Indexes
+  "attributes",
+  "orders",
+  // Strings
+  "encrypt",
 ]);
 const KeysColumns = new Set([
-    'key',
-    'type',
-    'required',
-    'array',
-    'size',
-    'default',
-    // integer and float
-    'min',
-    'max',
-    // email, enum, URL, IP, and datetime
-    'format',
-    // enum
-    'elements',
-    // relationship
-    'relatedTable',
-    'relationType',
-    'twoWay',
-    'twoWayKey',
-    'onDelete',
-    'side',
-    // Indexes
-    'columns',
-    'orders',
-    // Strings
-    'encrypt',
+  "key",
+  "type",
+  "required",
+  "array",
+  "size",
+  "default",
+  // integer and float
+  "min",
+  "max",
+  // email, enum, URL, IP, and datetime
+  "format",
+  // enum
+  "elements",
+  // relationship
+  "relatedTable",
+  "relationType",
+  "twoWay",
+  "twoWayKey",
+  "onDelete",
+  "side",
+  // Indexes
+  "columns",
+  "orders",
+  // Strings
+  "encrypt",
+]);
+const KeyIndexes = new Set(["key", "type", "status", "attributes", "orders"]);
+const KeyIndexesColumns = new Set([
+  "key",
+  "type",
+  "status",
+  "columns",
+  "orders",
 ]);
-const KeyIndexes = new Set(['key', 'type', 'status', 'attributes', 'orders']);
-const KeyIndexesColumns = new Set(['key', 'type', 'status', 'columns', 'orders']);
 
 function whitelistKeys<T = any>(
-    value: T,
-    keys: Set<string>,
-    nestedKeys: Record<string, Set<string>> = {}
+  value: T,
+  keys: Set<string>,
+  nestedKeys: Record<string, Set<string>> = {},
 ): T {
-    if (Array.isArray(value)) {
-        const newValue: any[] = [];
-
-        for (const item of value) {
-            newValue.push(whitelistKeys(item, keys, nestedKeys));
-        }
+  if (Array.isArray(value)) {
+    const newValue: any[] = [];
 
-        return newValue as T;
+    for (const item of value) {
+      newValue.push(whitelistKeys(item, keys, nestedKeys));
     }
 
-    const newValue: Record<string, any> = {};
-    Object.keys(value as any).forEach((key) => {
-        if (keys.has(key)) {
-            if (nestedKeys[key]) {
-                newValue[key] = whitelistKeys((value as any)[key], nestedKeys[key]);
-            } else {
-                newValue[key] = (value as any)[key];
-            }
-        }
-    });
     return newValue as T;
+  }
+
+  const newValue: Record<string, any> = {};
+  Object.keys(value as any).forEach((key) => {
+    if (keys.has(key)) {
+      if (nestedKeys[key]) {
+        newValue[key] = whitelistKeys((value as any)[key], nestedKeys[key]);
+      } else {
+        newValue[key] = (value as any)[key];
+      }
+    }
+  });
+  return newValue as T;
 }
 
 class Config<T extends ConfigData = ConfigData> {
-    protected path: string;
-    protected data: T;
+  readonly path: string;
+  protected data: T;
+
+  constructor(path: string) {
+    this.path = path;
+    this.data = {} as T;
+    this.read();
+  }
+
+  read(): void {
+    try {
+      const file = fs.readFileSync(this.path).toString();
+      this.data = JSONBigInt.parse(file);
+    } catch (e) {
+      this.data = {} as T;
+    }
+  }
+
+  write(): void {
+    const dir = _path.dirname(this.path);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(this.path, JSONBigInt.stringify(this.data, null, 4), {
+      mode: 0o600,
+    });
+  }
+
+  get<K extends keyof T>(key: K): T[K];
+  get(key: string): any {
+    return this.data[key as keyof T];
+  }
+
+  set<K extends keyof T>(key: K, value: T[K]): void;
+  set(key: string, value: any): void {
+    (this.data as any)[key] = value;
+    this.write();
+  }
+
+  delete(key: string): void {
+    delete (this.data as any)[key];
+    this.write();
+  }
+
+  clear(): void {
+    this.data = {} as T;
+    this.write();
+  }
+
+  has(key: string): boolean {
+    return this.data[key as keyof T] !== undefined;
+  }
+
+  keys(): string[] {
+    return Object.keys(this.data);
+  }
+
+  values(): unknown[] {
+    return Object.values(this.data);
+  }
+
+  toString(): string {
+    return JSONBigInt.stringify(this.data, null, 4);
+  }
+
+  protected _getDBEntities(entityType: string): Entity[] {
+    if (!this.has(entityType)) {
+      return [];
+    }
+    return this.get(entityType) as Entity[];
+  }
+
+  protected _getDBEntity(
+    entityType: string,
+    $id: string,
+  ): Entity | Record<string, never> {
+    if (!this.has(entityType)) {
+      return {};
+    }
+
+    const entities = this.get(entityType) as Entity[];
+    for (let i = 0; i < entities.length; i++) {
+      if (entities[i]["$id"] == $id) {
+        return entities[i];
+      }
+    }
+
+    return {};
+  }
+
+  protected _addDBEntity(
+    entityType: string,
+    props: Entity,
+    keysSet: Set<string>,
+    nestedKeys: Record<string, Set<string>> = {},
+  ): void {
+    props = whitelistKeys(props, keysSet, nestedKeys);
+
+    if (!this.has(entityType)) {
+      (this.set as (key: string, value: Entity[]) => void)(entityType, []);
+    }
+
+    const entities = this.get(entityType) as Entity[];
+    for (let i = 0; i < entities.length; i++) {
+      if (entities[i]["$id"] == props["$id"]) {
+        entities[i] = props;
+        (this.set as (key: string, value: Entity[]) => void)(
+          entityType,
+          entities,
+        );
+        return;
+      }
+    }
+    entities.push(props);
+    (this.set as (key: string, value: Entity[]) => void)(entityType, entities);
+  }
+}
 
-    constructor(path: string) {
-        this.path = path;
-        this.data = {} as T;
-        this.read();
-    }
+class Local extends Config<ConfigType> {
+  static CONFIG_FILE_PATH = `${SDK_TITLE_LOWER}.config.json`;
+  static CONFIG_FILE_PATH_LEGACY = `${SDK_TITLE_LOWER}.json`;
+  configDirectoryPath = "";
 
-    read(): void {
-        try {
-            const file = fs.readFileSync(this.path).toString();
-            this.data = JSONBigInt.parse(file);
-        } catch (e) {
-            this.data = {} as T;
-        }
-    }
+  constructor(
+    path: string = Local.CONFIG_FILE_PATH,
+    legacyPath: string = Local.CONFIG_FILE_PATH_LEGACY,
+  ) {
+    let absolutePath =
+      Local.findConfigFile(path) || Local.findConfigFile(legacyPath);
 
-    write(): void {
-        const dir = _path.dirname(this.path);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        fs.writeFileSync(this.path, JSONBigInt.stringify(this.data, null, 4), { mode: 0o600 });
+    if (!absolutePath) {
+      absolutePath = `${process.cwd()}/${path}`;
     }
 
-    get<K extends keyof T>(key: K): T[K];
-    get(key: string): any {
-        return this.data[key as keyof T];
-    }
+    super(absolutePath);
+    this.configDirectoryPath = _path.dirname(absolutePath);
+  }
 
-    set<K extends keyof T>(key: K, value: T[K]): void;
-    set(key: string, value: any): void {
-        (this.data as any)[key] = value;
-        this.write();
-    }
+  static findConfigFile(filename: string): string | null {
+    let currentPath = process.cwd();
 
-    delete(key: string): void {
-        delete (this.data as any)[key];
-        this.write();
-    }
+    while (true) {
+      const filePath = `${currentPath}/${filename}`;
 
-    clear(): void {
-        this.data = {} as T;
-        this.write();
-    }
+      if (fs.existsSync(filePath)) {
+        return filePath;
+      }
 
-    has(key: string): boolean {
-        return this.data[key as keyof T] !== undefined;
+      const parentDirectory = _path.dirname(currentPath);
+      if (parentDirectory === currentPath) {
+        break;
+      }
+      currentPath = parentDirectory;
     }
 
-    keys(): string[] {
-        return Object.keys(this.data);
-    }
+    return null;
+  }
 
-    values(): unknown[] {
-        return Object.values(this.data);
-    }
+  getDirname(): string {
+    return _path.dirname(this.path);
+  }
 
-    toString(): string {
-        return JSONBigInt.stringify(this.data, null, 4);
-    }
+  getEndpoint(): string {
+    return this.get("endpoint") || "";
+  }
 
-    protected _getDBEntities(entityType: string): any[] {
-        if (!this.has(entityType)) {
-            return [];
-        }
-        return this.get(entityType);
-    }
-
-    protected _getDBEntity(entityType: string, $id: string): any {
-        if (!this.has(entityType)) {
-            return {};
-        }
-
-        const entities = this.get(entityType);
-        for (let i = 0; i < entities.length; i++) {
-            if (entities[i]['$id'] == $id) {
-                return entities[i];
-            }
-        }
+  setEndpoint(endpoint: string): void {
+    this.set("endpoint", endpoint);
+  }
 
-        return {};
+  getSites(): SiteType[] {
+    if (!this.has("sites")) {
+      return [];
     }
+    return this.get("sites") ?? [];
+  }
 
-    protected _addDBEntity(
-        entityType: string,
-        props: any,
-        keysSet: Set<string>,
-        nestedKeys: Record<string, Set<string>> = {}
-    ): void {
-        props = whitelistKeys(props, keysSet, nestedKeys);
-
-        if (!this.has(entityType)) {
-            this.set(entityType, []);
-        }
-
-        const entities = this.get(entityType);
-        for (let i = 0; i < entities.length; i++) {
-            if (entities[i]['$id'] == props['$id']) {
-                entities[i] = props;
-                this.set(entityType, entities);
-                return;
-            }
-        }
-        entities.push(props);
-        this.set(entityType, entities);
+  getSite($id: string): SiteType | Record<string, never> {
+    if (!this.has("sites")) {
+      return {};
     }
-}
-
-class Local extends Config<ProjectConfigData> {
-    static CONFIG_FILE_PATH = 'appwrite.config.json';
-    static CONFIG_FILE_PATH_LEGACY = 'appwrite.json';
-    configDirectoryPath = '';
-
-    constructor(path: string = Local.CONFIG_FILE_PATH, legacyPath: string = Local.CONFIG_FILE_PATH_LEGACY) {
-        let absolutePath = Local.findConfigFile(path) || Local.findConfigFile(legacyPath);
-
-        if (!absolutePath) {
-            absolutePath = `${process.cwd()}/${path}`;
-        }
 
-        super(absolutePath);
-        this.configDirectoryPath = _path.dirname(absolutePath);
+    const sites = this.get("sites") ?? [];
+    for (let i = 0; i < sites.length; i++) {
+      if (sites[i]["$id"] == $id) {
+        return sites[i];
+      }
     }
 
-    static findConfigFile(filename: string): string | null {
-        let currentPath = process.cwd();
+    return {};
+  }
 
-        while (true) {
-            const filePath = `${currentPath}/${filename}`;
-
-            if (fs.existsSync(filePath)) {
-                return filePath;
-            }
-
-            const parentDirectory = _path.dirname(currentPath);
-            if (parentDirectory === currentPath) {
-                break;
-            }
-            currentPath = parentDirectory;
-        }
+  addSite(props: SiteType): void {
+    props = whitelistKeys(props, KeysSite, {
+      vars: KeysVars,
+    });
 
-        return null;
+    if (!this.has("sites")) {
+      this.set("sites", []);
     }
 
-    getDirname(): string {
-        return _path.dirname(this.path);
+    const sites = this.get("sites") ?? [];
+    for (let i = 0; i < sites.length; i++) {
+      if (sites[i]["$id"] == props["$id"]) {
+        sites[i] = {
+          ...sites[i],
+          ...props,
+        };
+        this.set("sites", sites);
+        return;
+      }
     }
 
-    getEndpoint(): string {
-        return this.get('endpoint' as any) || '';
-    }
+    sites.push(props);
+    this.set("sites", sites);
+  }
 
-    setEndpoint(endpoint: string): void {
-        this.set('endpoint' as any, endpoint);
+  getFunctions(): FunctionType[] {
+    if (!this.has("functions")) {
+      return [];
     }
+    return this.get("functions") ?? [];
+  }
 
-    getSites(): any[] {
-        if (!this.has('sites')) {
-            return [];
-        }
-        return this.get('sites' as any);
+  getFunction($id: string): FunctionType | Record<string, never> {
+    if (!this.has("functions")) {
+      return {};
     }
 
-    getSite($id: string): any {
-        if (!this.has('sites')) {
-            return {};
-        }
-
-        const sites = this.get('sites' as any);
-        for (let i = 0; i < sites.length; i++) {
-            if (sites[i]['$id'] == $id) {
-                return sites[i];
-            }
-        }
-
-        return {};
+    const functions = this.get("functions") ?? [];
+    for (let i = 0; i < functions.length; i++) {
+      if (functions[i]["$id"] == $id) {
+        return functions[i];
+      }
     }
 
-    addSite(props: any): void {
-        props = whitelistKeys(props, KeysSite, {
-            vars: KeysVars,
-        });
-
-        if (!this.has('sites')) {
-            this.set('sites' as any, []);
-        }
+    return {};
+  }
 
-        const sites = this.get('sites' as any);
-        for (let i = 0; i < sites.length; i++) {
-            if (sites[i]['$id'] == props['$id']) {
-                sites[i] = {
-                    ...sites[i],
-                    ...props,
-                };
-                this.set('sites' as any, sites);
-                return;
-            }
-        }
+  addFunction(props: FunctionType): void {
+    props = whitelistKeys(props, KeysFunction, {
+      vars: KeysVars,
+    });
 
-        sites.push(props);
-        this.set('sites' as any, sites);
+    if (!this.has("functions")) {
+      this.set("functions", []);
     }
 
-    getFunctions(): any[] {
-        if (!this.has('functions')) {
-            return [];
-        }
-        return this.get('functions' as any);
+    const functions = this.get("functions") ?? [];
+    for (let i = 0; i < functions.length; i++) {
+      if (functions[i]["$id"] == props["$id"]) {
+        functions[i] = {
+          ...functions[i],
+          ...props,
+        };
+        this.set("functions", functions);
+        return;
+      }
     }
 
-    getFunction($id: string): any {
-        if (!this.has('functions')) {
-            return {};
-        }
+    functions.push(props);
+    this.set("functions", functions);
+  }
 
-        const functions = this.get('functions' as any);
-        for (let i = 0; i < functions.length; i++) {
-            if (functions[i]['$id'] == $id) {
-                return functions[i];
-            }
-        }
+  getCollections(): CollectionType[] {
+    if (!this.has("collections")) {
+      return [];
+    }
+    return this.get("collections") ?? [];
+  }
 
-        return {};
+  getCollection($id: string): CollectionType | Record<string, never> {
+    if (!this.has("collections")) {
+      return {};
     }
 
-    addFunction(props: any): void {
-        props = whitelistKeys(props, KeysFunction, {
-            vars: KeysVars,
-        });
+    const collections = this.get("collections") ?? [];
+    for (let i = 0; i < collections.length; i++) {
+      if (collections[i]["$id"] == $id) {
+        return collections[i];
+      }
+    }
 
-        if (!this.has('functions')) {
-            this.set('functions' as any, []);
-        }
+    return {};
+  }
 
-        const functions = this.get('functions' as any);
-        for (let i = 0; i < functions.length; i++) {
-            if (functions[i]['$id'] == props['$id']) {
-                functions[i] = {
-                    ...functions[i],
-                    ...props,
-                };
-                this.set('functions' as any, functions);
-                return;
-            }
-        }
+  addCollection(props: CollectionType): void {
+    props = whitelistKeys(props, KeysCollection, {
+      attributes: KeysAttributes,
+      indexes: KeyIndexes,
+    });
 
-        functions.push(props);
-        this.set('functions' as any, functions);
+    if (!this.has("collections")) {
+      this.set("collections", []);
     }
 
-    getCollections(): any[] {
-        if (!this.has('collections')) {
-            return [];
-        }
-        return this.get('collections' as any);
+    const collections = this.get("collections") ?? [];
+    for (let i = 0; i < collections.length; i++) {
+      if (
+        collections[i]["$id"] == props["$id"] &&
+        collections[i]["databaseId"] == props["databaseId"]
+      ) {
+        collections[i] = props;
+        this.set("collections", collections);
+        return;
+      }
     }
+    collections.push(props);
+    this.set("collections", collections);
+  }
 
-    getCollection($id: string): any {
-        if (!this.has('collections')) {
-            return {};
-        }
+  getTables(): TableType[] {
+    if (!this.has("tables")) {
+      return [];
+    }
+    return this.get("tables") ?? [];
+  }
 
-        const collections = this.get('collections' as any);
-        for (let i = 0; i < collections.length; i++) {
-            if (collections[i]['$id'] == $id) {
-                return collections[i];
-            }
-        }
+  getTable($id: string): TableType | Record<string, never> {
+    if (!this.has("tables")) {
+      return {};
+    }
 
-        return {};
+    const tables = this.get("tables") ?? [];
+    for (let i = 0; i < tables.length; i++) {
+      if (tables[i]["$id"] == $id) {
+        return tables[i];
+      }
     }
 
-    addCollection(props: any): void {
-        props = whitelistKeys(props, KeysCollection, {
-            attributes: KeysAttributes,
-            indexes: KeyIndexes,
-        });
+    return {};
+  }
 
-        if (!this.has('collections')) {
-            this.set('collections' as any, []);
-        }
+  addTable(props: TableType): void {
+    props = whitelistKeys(props, KeysTable, {
+      columns: KeysColumns,
+      indexes: KeyIndexesColumns,
+    });
 
-        const collections = this.get('collections' as any);
-        for (let i = 0; i < collections.length; i++) {
-            if (collections[i]['$id'] == props['$id'] && collections[i]['databaseId'] == props['databaseId']) {
-                collections[i] = props;
-                this.set('collections' as any, collections);
-                return;
-            }
-        }
-        collections.push(props);
-        this.set('collections' as any, collections);
+    if (!this.has("tables")) {
+      this.set("tables", []);
     }
 
-    getTables(): any[] {
-        if (!this.has('tables')) {
-            return [];
-        }
-        return this.get('tables' as any);
+    const tables = this.get("tables") ?? [];
+    for (let i = 0; i < tables.length; i++) {
+      if (
+        tables[i]["$id"] == props["$id"] &&
+        tables[i]["databaseId"] == props["databaseId"]
+      ) {
+        tables[i] = props;
+        this.set("tables", tables);
+        return;
+      }
     }
+    tables.push(props);
+    this.set("tables", tables);
+  }
 
-    getTable($id: string): any {
-        if (!this.has('tables')) {
-            return {};
-        }
+  getBuckets(): BucketType[] {
+    if (!this.has("buckets")) {
+      return [];
+    }
+    return this.get("buckets") ?? [];
+  }
 
-        const tables = this.get('tables' as any);
-        for (let i = 0; i < tables.length; i++) {
-            if (tables[i]['$id'] == $id) {
-                return tables[i];
-            }
-        }
+  getBucket($id: string): BucketType | Record<string, never> {
+    if (!this.has("buckets")) {
+      return {};
+    }
 
-        return {};
+    const buckets = this.get("buckets") ?? [];
+    for (let i = 0; i < buckets.length; i++) {
+      if (buckets[i]["$id"] == $id) {
+        return buckets[i];
+      }
     }
 
-    addTable(props: any): void {
-        props = whitelistKeys(props, KeysTable, {
-            columns: KeysColumns,
-            indexes: KeyIndexesColumns,
-        });
+    return {};
+  }
 
-        if (!this.has('tables')) {
-            this.set('tables' as any, []);
-        }
+  addBucket(props: BucketType): void {
+    props = whitelistKeys(props, KeysStorage);
 
-        const tables = this.get('tables' as any);
-        for (let i = 0; i < tables.length; i++) {
-            if (tables[i]['$id'] == props['$id'] && tables[i]['databaseId'] == props['databaseId']) {
-                tables[i] = props;
-                this.set('tables' as any, tables);
-                return;
-            }
-        }
-        tables.push(props);
-        this.set('tables' as any, tables);
+    if (!this.has("buckets")) {
+      this.set("buckets", []);
     }
 
-    getBuckets(): any[] {
-        if (!this.has('buckets')) {
-            return [];
-        }
-        return this.get('buckets' as any);
+    const buckets = this.get("buckets") ?? [];
+    for (let i = 0; i < buckets.length; i++) {
+      if (buckets[i]["$id"] == props["$id"]) {
+        buckets[i] = props;
+        this.set("buckets", buckets);
+        return;
+      }
     }
+    buckets.push(props);
+    this.set("buckets", buckets);
+  }
 
-    getBucket($id: string): any {
-        if (!this.has('buckets')) {
-            return {};
-        }
+  getMessagingTopics(): TopicType[] {
+    if (!this.has("topics")) {
+      return [];
+    }
+    return this.get("topics") ?? [];
+  }
 
-        const buckets = this.get('buckets' as any);
-        for (let i = 0; i < buckets.length; i++) {
-            if (buckets[i]['$id'] == $id) {
-                return buckets[i];
-            }
-        }
+  getMessagingTopic($id: string): TopicType | Record<string, never> {
+    if (!this.has("topics")) {
+      return {};
+    }
 
-        return {};
+    const topics = this.get("topics") ?? [];
+    for (let i = 0; i < topics.length; i++) {
+      if (topics[i]["$id"] == $id) {
+        return topics[i];
+      }
     }
 
-    addBucket(props: any): void {
-        props = whitelistKeys(props, KeysStorage);
+    return {};
+  }
 
-        if (!this.has('buckets')) {
-            this.set('buckets' as any, []);
-        }
+  addMessagingTopic(props: TopicType): void {
+    props = whitelistKeys(props, KeysTopics);
 
-        const buckets = this.get('buckets' as any);
-        for (let i = 0; i < buckets.length; i++) {
-            if (buckets[i]['$id'] == props['$id']) {
-                buckets[i] = props;
-                this.set('buckets' as any, buckets);
-                return;
-            }
-        }
-        buckets.push(props);
-        this.set('buckets' as any, buckets);
+    if (!this.has("topics")) {
+      this.set("topics", []);
     }
 
-    getMessagingTopics(): any[] {
-        if (!this.has('topics')) {
-            return [];
-        }
-        return this.get('topics' as any);
+    const topics = this.get("topics") ?? [];
+    for (let i = 0; i < topics.length; i++) {
+      if (topics[i]["$id"] === props["$id"]) {
+        topics[i] = props;
+        this.set("topics", topics);
+        return;
+      }
     }
+    topics.push(props);
+    this.set("topics", topics);
+  }
 
-    getMessagingTopic($id: string): any {
-        if (!this.has('topics')) {
-            return {};
-        }
+  getTablesDBs(): any[] {
+    return this._getDBEntities("tablesDB");
+  }
 
-        const topic = this.get('topics' as any);
-        for (let i = 0; i < topic.length; i++) {
-            if (topic[i]['$id'] == $id) {
-                return topic[i];
-            }
-        }
+  getTablesDB($id: string): any {
+    return this._getDBEntity("tablesDB", $id);
+  }
 
-        return {};
-    }
+  addTablesDB(props: any): void {
+    this._addDBEntity("tablesDB", props, KeysDatabase);
+  }
 
-    addMessagingTopic(props: any): void {
-        props = whitelistKeys(props, KeysTopics);
+  getDatabases(): any[] {
+    return this._getDBEntities("databases");
+  }
 
-        if (!this.has('topics')) {
-            this.set('topics' as any, []);
-        }
+  getDatabase($id: string): any {
+    return this._getDBEntity("databases", $id);
+  }
 
-        const topics = this.get('topics' as any);
-        for (let i = 0; i < topics.length; i++) {
-            if (topics[i]['$id'] === props['$id']) {
-                topics[i] = props;
-                this.set('topics' as any, topics);
-                return;
-            }
-        }
-        topics.push(props);
-        this.set('topics' as any, topics);
-    }
+  addDatabase(props: any): void {
+    this._addDBEntity("databases", props, KeysDatabase);
+  }
 
-    getTablesDBs(): any[] {
-        return this._getDBEntities('tablesDB');
+  getTeams(): TeamType[] {
+    if (!this.has("teams")) {
+      return [];
     }
+    return this.get("teams") ?? [];
+  }
 
-    getTablesDB($id: string): any {
-        return this._getDBEntity('tablesDB', $id);
+  getTeam($id: string): TeamType | Record<string, never> {
+    if (!this.has("teams")) {
+      return {};
     }
 
-    addTablesDB(props: any): void {
-        this._addDBEntity('tablesDB', props, KeysDatabase);
+    const teams = this.get("teams") ?? [];
+    for (let i = 0; i < teams.length; i++) {
+      if (teams[i]["$id"] == $id) {
+        return teams[i];
+      }
     }
 
-    getDatabases(): any[] {
-        return this._getDBEntities('databases');
-    }
+    return {};
+  }
 
-    getDatabase($id: string): any {
-        return this._getDBEntity('databases', $id);
+  addTeam(props: TeamType): void {
+    props = whitelistKeys(props, KeysTeams);
+    if (!this.has("teams")) {
+      this.set("teams", []);
     }
 
-    addDatabase(props: any): void {
-        this._addDBEntity('databases', props, KeysDatabase);
+    const teams = this.get("teams") ?? [];
+    for (let i = 0; i < teams.length; i++) {
+      if (teams[i]["$id"] == props["$id"]) {
+        teams[i] = props;
+        this.set("teams", teams);
+        return;
+      }
     }
+    teams.push(props);
+    this.set("teams", teams);
+  }
 
-    getTeams(): any[] {
-        if (!this.has('teams')) {
-            return [];
-        }
-        return this.get('teams' as any);
+  getProject(): {
+    projectId?: string;
+    projectName?: string;
+    projectSettings?: SettingsType;
+  } {
+    if (!this.has("projectId")) {
+      return {};
     }
 
-    getTeam($id: string): any {
-        if (!this.has('teams')) {
-            return {};
-        }
+    return {
+      projectId: this.get("projectId"),
+      projectName: this.get("projectName"),
+      projectSettings: this.get("settings"),
+    };
+  }
 
-        const teams = this.get('teams' as any);
-        for (let i = 0; i < teams.length; i++) {
-            if (teams[i]['$id'] == $id) {
-                return teams[i];
-            }
-        }
+  setProject(
+    projectId: string,
+    projectName: string = "",
+    project?: Models.Project,
+  ): void {
+    this.set("projectId", projectId);
 
-        return {};
+    if (projectName !== "") {
+      this.set("projectName", projectName);
     }
 
-    addTeam(props: any): void {
-        props = whitelistKeys(props, KeysTeams);
-        if (!this.has('teams')) {
-            this.set('teams' as any, []);
-        }
-
-        const teams = this.get('teams' as any);
-        for (let i = 0; i < teams.length; i++) {
-            if (teams[i]['$id'] == props['$id']) {
-                teams[i] = props;
-                this.set('teams' as any, teams);
-                return;
-            }
-        }
-        teams.push(props);
-        this.set('teams' as any, teams);
+    if (project === undefined) {
+      return;
     }
 
-    getProject(): { projectId?: string; projectName?: string; projectSettings?: any } {
-        if (!this.has('projectId')) {
-            return {};
-        }
-
-        return {
-            projectId: this.get('projectId' as any),
-            projectName: this.get('projectName' as any),
-            projectSettings: this.get('settings' as any),
-        };
-    }
-
-    setProject(projectId: string, projectName: string = '', projectSettings: any = undefined): void {
-        this.set('projectId' as any, projectId);
-
-        if (projectName !== '') {
-            this.set('projectName' as any, projectName);
-        }
-
-        if (projectSettings === undefined) {
-            return;
-        }
-
-        this.set('settings' as any, this.createSettingsObject(projectSettings));
-    }
-
-    createSettingsObject(projectSettings: any): any {
-        return {
-            services: {
-                account: projectSettings.serviceStatusForAccount,
-                avatars: projectSettings.serviceStatusForAvatars,
-                databases: projectSettings.serviceStatusForDatabases,
-                locale: projectSettings.serviceStatusForLocale,
-                health: projectSettings.serviceStatusForHealth,
-                storage: projectSettings.serviceStatusForStorage,
-                teams: projectSettings.serviceStatusForTeams,
-                users: projectSettings.serviceStatusForUsers,
-                sites: projectSettings.serviceStatusForSites,
-                functions: projectSettings.serviceStatusForFunctions,
-                graphql: projectSettings.serviceStatusForGraphql,
-                messaging: projectSettings.serviceStatusForMessaging,
-            },
-            auth: {
-                methods: {
-                    jwt: projectSettings.authJWT,
-                    phone: projectSettings.authPhone,
-                    invites: projectSettings.authInvites,
-                    anonymous: projectSettings.authAnonymous,
-                    'email-otp': projectSettings.authEmailOtp,
-                    'magic-url': projectSettings.authUsersAuthMagicURL,
-                    'email-password': projectSettings.authEmailPassword,
-                },
-                security: {
-                    duration: projectSettings.authDuration,
-                    limit: projectSettings.authLimit,
-                    sessionsLimit: projectSettings.authSessionsLimit,
-                    passwordHistory: projectSettings.authPasswordHistory,
-                    passwordDictionary: projectSettings.authPasswordDictionary,
-                    personalDataCheck: projectSettings.authPersonalDataCheck,
-                    sessionAlerts: projectSettings.authSessionAlerts,
-                    mockNumbers: projectSettings.authMockNumbers,
-                },
-            },
-        };
-    }
+    this.set("settings", createSettingsObject(project));
+  }
 }
 
 class Global extends Config<GlobalConfigData> {
-    static CONFIG_FILE_PATH = '.appwrite/prefs.json';
-
-    static PREFERENCE_CURRENT = 'current';
-    static PREFERENCE_ENDPOINT = 'endpoint';
-    static PREFERENCE_EMAIL = 'email';
-    static PREFERENCE_SELF_SIGNED = 'selfSigned';
-    static PREFERENCE_COOKIE = 'cookie';
-    static PREFERENCE_PROJECT = 'project';
-    static PREFERENCE_KEY = 'key';
-    static PREFERENCE_LOCALE = 'locale';
-    static PREFERENCE_MODE = 'mode';
-
-    static IGNORE_ATTRIBUTES = [
-        Global.PREFERENCE_CURRENT,
-        Global.PREFERENCE_SELF_SIGNED,
-        Global.PREFERENCE_ENDPOINT,
-        Global.PREFERENCE_COOKIE,
-        Global.PREFERENCE_PROJECT,
-        Global.PREFERENCE_KEY,
-        Global.PREFERENCE_LOCALE,
-        Global.PREFERENCE_MODE,
-    ];
-
-    static MODE_ADMIN = 'admin';
-    static MODE_DEFAULT = 'default';
-
-    static PROJECT_CONSOLE = 'console';
-
-    constructor(path: string = Global.CONFIG_FILE_PATH) {
-        const homeDir = os.homedir();
-        super(`${homeDir}/${path}`);
-    }
-
-    getCurrentSession(): string {
-        if (!this.has(Global.PREFERENCE_CURRENT)) {
-            return '';
-        }
-        return this.get(Global.PREFERENCE_CURRENT as any);
-    }
-
-    setCurrentSession(session: string): void {
-        if (session !== undefined) {
-            this.set(Global.PREFERENCE_CURRENT as any, session);
-        }
-    }
-
-    getSessionIds(): string[] {
-        return Object.keys(this.data).filter((key) => !Global.IGNORE_ATTRIBUTES.includes(key));
-    }
-
-    getSessions(): Array<{ id: string; endpoint: string; email: string }> {
-        const sessions = Object.keys(this.data).filter((key) => !Global.IGNORE_ATTRIBUTES.includes(key));
-        const current = this.getCurrentSession();
-
-        const sessionMap = new Map<string, { id: string; endpoint: string; email: string }>();
-
-        sessions.forEach((sessionId) => {
-            const sessionData = (this.data as any)[sessionId];
-            const email = sessionData[Global.PREFERENCE_EMAIL];
-            const endpoint = sessionData[Global.PREFERENCE_ENDPOINT];
-            const key = `${email}|${endpoint}`;
-
-            if (sessionId === current || !sessionMap.has(key)) {
-                sessionMap.set(key, {
-                    id: sessionId,
-                    endpoint: sessionData[Global.PREFERENCE_ENDPOINT],
-                    email: sessionData[Global.PREFERENCE_EMAIL],
-                });
-            }
+  static CONFIG_FILE_PATH = `.${SDK_TITLE_LOWER}/prefs.json`;
+
+  static PREFERENCE_CURRENT = "current" as const;
+  static PREFERENCE_ENDPOINT = "endpoint" as const;
+  static PREFERENCE_EMAIL = "email" as const;
+  static PREFERENCE_SELF_SIGNED = "selfSigned" as const;
+  static PREFERENCE_COOKIE = "cookie" as const;
+  static PREFERENCE_PROJECT = "project" as const;
+  static PREFERENCE_KEY = "key" as const;
+  static PREFERENCE_LOCALE = "locale" as const;
+  static PREFERENCE_MODE = "mode" as const;
+
+  static IGNORE_ATTRIBUTES: readonly string[] = [
+    Global.PREFERENCE_CURRENT,
+    Global.PREFERENCE_SELF_SIGNED,
+    Global.PREFERENCE_ENDPOINT,
+    Global.PREFERENCE_COOKIE,
+    Global.PREFERENCE_PROJECT,
+    Global.PREFERENCE_KEY,
+    Global.PREFERENCE_LOCALE,
+    Global.PREFERENCE_MODE,
+  ];
+
+  static MODE_ADMIN = "admin";
+  static MODE_DEFAULT = "default";
+
+  static PROJECT_CONSOLE = "console";
+
+  constructor(path: string = Global.CONFIG_FILE_PATH) {
+    const homeDir = os.homedir();
+    super(`${homeDir}/${path}`);
+  }
+
+  getCurrentSession(): string {
+    if (!this.has(Global.PREFERENCE_CURRENT)) {
+      return "";
+    }
+    return this.get(Global.PREFERENCE_CURRENT);
+  }
+
+  setCurrentSession(session: string): void {
+    if (session !== undefined) {
+      this.set(Global.PREFERENCE_CURRENT, session);
+    }
+  }
+
+  getSessionIds(): string[] {
+    return Object.keys(this.data).filter(
+      (key) => !Global.IGNORE_ATTRIBUTES.includes(key),
+    );
+  }
+
+  getSessions(): Array<{ id: string; endpoint: string; email: string }> {
+    const sessions = Object.keys(this.data).filter(
+      (key) => !Global.IGNORE_ATTRIBUTES.includes(key),
+    );
+    const current = this.getCurrentSession();
+
+    const sessionMap = new Map<
+      string,
+      { id: string; endpoint: string; email: string }
+    >();
+
+    sessions.forEach((sessionId) => {
+      const sessionData = (this.data as any)[sessionId];
+      const email = sessionData[Global.PREFERENCE_EMAIL];
+      const endpoint = sessionData[Global.PREFERENCE_ENDPOINT];
+      const key = `${email}|${endpoint}`;
+
+      if (sessionId === current || !sessionMap.has(key)) {
+        sessionMap.set(key, {
+          id: sessionId,
+          endpoint: sessionData[Global.PREFERENCE_ENDPOINT],
+          email: sessionData[Global.PREFERENCE_EMAIL],
         });
+      }
+    });
 
-        return Array.from(sessionMap.values());
-    }
-
-    addSession(session: string, data: SessionData): void {
-        this.set(session as any, data as any);
-    }
+    return Array.from(sessionMap.values());
+  }
 
-    removeSession(session: string): void {
-        this.delete(session);
-    }
+  addSession(session: string, data: SessionData): void {
+    this.set(session as any, data as any);
+  }
 
-    getEmail(): string {
-        if (!this.hasFrom(Global.PREFERENCE_EMAIL)) {
-            return '';
-        }
+  removeSession(session: string): void {
+    this.delete(session);
+  }
 
-        return this.getFrom(Global.PREFERENCE_EMAIL);
+  getEmail(): string {
+    if (!this.hasFrom(Global.PREFERENCE_EMAIL)) {
+      return "";
     }
 
-    setEmail(email: string): void {
-        this.setTo(Global.PREFERENCE_EMAIL, email);
-    }
+    return this.getFrom(Global.PREFERENCE_EMAIL);
+  }
 
-    getEndpoint(): string {
-        if (!this.hasFrom(Global.PREFERENCE_ENDPOINT)) {
-            return '';
-        }
+  setEmail(email: string): void {
+    this.setTo(Global.PREFERENCE_EMAIL, email);
+  }
 
-        return this.getFrom(Global.PREFERENCE_ENDPOINT);
+  getEndpoint(): string {
+    if (!this.hasFrom(Global.PREFERENCE_ENDPOINT)) {
+      return "";
     }
 
-    setEndpoint(endpoint: string): void {
-        this.setTo(Global.PREFERENCE_ENDPOINT, endpoint);
-    }
+    return this.getFrom(Global.PREFERENCE_ENDPOINT);
+  }
 
-    getSelfSigned(): boolean {
-        if (!this.hasFrom(Global.PREFERENCE_SELF_SIGNED)) {
-            return false;
-        }
-        return this.getFrom(Global.PREFERENCE_SELF_SIGNED);
-    }
+  setEndpoint(endpoint: string): void {
+    this.setTo(Global.PREFERENCE_ENDPOINT, endpoint);
+  }
 
-    setSelfSigned(selfSigned: boolean): void {
-        this.setTo(Global.PREFERENCE_SELF_SIGNED, selfSigned);
+  getSelfSigned(): boolean {
+    if (!this.hasFrom(Global.PREFERENCE_SELF_SIGNED)) {
+      return false;
     }
+    return this.getFrom(Global.PREFERENCE_SELF_SIGNED);
+  }
 
-    getCookie(): string {
-        if (!this.hasFrom(Global.PREFERENCE_COOKIE)) {
-            return '';
-        }
-        return this.getFrom(Global.PREFERENCE_COOKIE);
-    }
+  setSelfSigned(selfSigned: boolean): void {
+    this.setTo(Global.PREFERENCE_SELF_SIGNED, selfSigned);
+  }
 
-    setCookie(cookie: string): void {
-        this.setTo(Global.PREFERENCE_COOKIE, cookie);
+  getCookie(): string {
+    if (!this.hasFrom(Global.PREFERENCE_COOKIE)) {
+      return "";
     }
+    return this.getFrom(Global.PREFERENCE_COOKIE);
+  }
 
-    getProject(): string {
-        if (!this.hasFrom(Global.PREFERENCE_PROJECT)) {
-            return '';
-        }
-        return this.getFrom(Global.PREFERENCE_PROJECT);
-    }
+  setCookie(cookie: string): void {
+    this.setTo(Global.PREFERENCE_COOKIE, cookie);
+  }
 
-    setProject(project: string): void {
-        this.setTo(Global.PREFERENCE_PROJECT, project);
+  getProject(): string {
+    if (!this.hasFrom(Global.PREFERENCE_PROJECT)) {
+      return "";
     }
+    return this.getFrom(Global.PREFERENCE_PROJECT);
+  }
 
-    getKey(): string {
-        if (!this.hasFrom(Global.PREFERENCE_KEY)) {
-            return '';
-        }
-        return this.getFrom(Global.PREFERENCE_KEY);
-    }
+  setProject(project: string): void {
+    this.setTo(Global.PREFERENCE_PROJECT, project);
+  }
 
-    setKey(key: string): void {
-        this.setTo(Global.PREFERENCE_KEY, key);
+  getKey(): string {
+    if (!this.hasFrom(Global.PREFERENCE_KEY)) {
+      return "";
     }
+    return this.getFrom(Global.PREFERENCE_KEY);
+  }
+
+  setKey(key: string): void {
+    this.setTo(Global.PREFERENCE_KEY, key);
+  }
 
-    hasFrom(key: string): boolean {
-        const current = this.getCurrentSession();
+  hasFrom(key: string): boolean {
+    const current = this.getCurrentSession();
 
-        if (current) {
-            const config = this.get(current as any) ?? {};
+    if (current) {
+      const config = this.get(current as any) ?? {};
 
-            return (config as any)[key] !== undefined;
-        }
-        return false;
+      return (config as any)[key] !== undefined;
     }
+    return false;
+  }
 
-    getFrom(key: string): any {
-        const current = this.getCurrentSession();
+  getFrom(key: string): any {
+    const current = this.getCurrentSession();
 
-        if (current) {
-            const config = this.get(current as any) ?? {};
+    if (current) {
+      const config = this.get(current as any) ?? {};
 
-            return (config as any)[key];
-        }
+      return (config as any)[key];
     }
+  }
 
-    setTo(key: string, value: any): void {
-        const current = this.getCurrentSession();
+  setTo(key: string, value: any): void {
+    const current = this.getCurrentSession();
 
-        if (current) {
-            const config = this.get(current as any);
+    if (current) {
+      const config = this.get(current as any);
 
-            (config as any)[key] = value;
-            this.write();
-        }
+      (config as any)[key] = value;
+      this.write();
     }
+  }
 }
 
 export const localConfig = new Local();
 export const globalConfig = new Global();
 export {
-    KeysAttributes,
-    KeysSite,
-    KeysFunction,
-    KeysTopics,
-    KeysStorage,
-    KeysTeams,
-    KeysCollection,
-    KeysTable,
-    whitelistKeys,
+  KeysAttributes,
+  KeysSite,
+  KeysFunction,
+  KeysTopics,
+  KeysStorage,
+  KeysTeams,
+  KeysCollection,
+  KeysTable,
+  whitelistKeys,
 };