appwrite-cli 12.0.1 → 13.0.0-rc.1

package/lib/config.ts

@@ -0,0 +1,854 @@
+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';
+
+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 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',
+]);
+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',
+]);
+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>> = {}
+): T {
+    if (Array.isArray(value)) {
+        const newValue: any[] = [];
+
+        for (const item of value) {
+            newValue.push(whitelistKeys(item, keys, nestedKeys));
+        }
+
+        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;
+
+    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): 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];
+            }
+        }
+
+        return {};
+    }
+
+    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);
+    }
+}
+
+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);
+    }
+
+    static findConfigFile(filename: string): string | null {
+        let currentPath = process.cwd();
+
+        while (true) {
+            const filePath = `${currentPath}/${filename}`;
+
+            if (fs.existsSync(filePath)) {
+                return filePath;
+            }
+
+            const parentDirectory = _path.dirname(currentPath);
+            if (parentDirectory === currentPath) {
+                break;
+            }
+            currentPath = parentDirectory;
+        }
+
+        return null;
+    }
+
+    getDirname(): string {
+        return _path.dirname(this.path);
+    }
+
+    getEndpoint(): string {
+        return this.get('endpoint' as any) || '';
+    }
+
+    setEndpoint(endpoint: string): void {
+        this.set('endpoint' as any, endpoint);
+    }
+
+    getSites(): any[] {
+        if (!this.has('sites')) {
+            return [];
+        }
+        return this.get('sites' as any);
+    }
+
+    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 {};
+    }
+
+    addSite(props: any): void {
+        props = whitelistKeys(props, KeysSite, {
+            vars: KeysVars,
+        });
+
+        if (!this.has('sites')) {
+            this.set('sites' as any, []);
+        }
+
+        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;
+            }
+        }
+
+        sites.push(props);
+        this.set('sites' as any, sites);
+    }
+
+    getFunctions(): any[] {
+        if (!this.has('functions')) {
+            return [];
+        }
+        return this.get('functions' as any);
+    }
+
+    getFunction($id: string): any {
+        if (!this.has('functions')) {
+            return {};
+        }
+
+        const functions = this.get('functions' as any);
+        for (let i = 0; i < functions.length; i++) {
+            if (functions[i]['$id'] == $id) {
+                return functions[i];
+            }
+        }
+
+        return {};
+    }
+
+    addFunction(props: any): void {
+        props = whitelistKeys(props, KeysFunction, {
+            vars: KeysVars,
+        });
+
+        if (!this.has('functions')) {
+            this.set('functions' as any, []);
+        }
+
+        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;
+            }
+        }
+
+        functions.push(props);
+        this.set('functions' as any, functions);
+    }
+
+    getCollections(): any[] {
+        if (!this.has('collections')) {
+            return [];
+        }
+        return this.get('collections' as any);
+    }
+
+    getCollection($id: string): any {
+        if (!this.has('collections')) {
+            return {};
+        }
+
+        const collections = this.get('collections' as any);
+        for (let i = 0; i < collections.length; i++) {
+            if (collections[i]['$id'] == $id) {
+                return collections[i];
+            }
+        }
+
+        return {};
+    }
+
+    addCollection(props: any): void {
+        props = whitelistKeys(props, KeysCollection, {
+            attributes: KeysAttributes,
+            indexes: KeyIndexes,
+        });
+
+        if (!this.has('collections')) {
+            this.set('collections' as any, []);
+        }
+
+        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);
+    }
+
+    getTables(): any[] {
+        if (!this.has('tables')) {
+            return [];
+        }
+        return this.get('tables' as any);
+    }
+
+    getTable($id: string): any {
+        if (!this.has('tables')) {
+            return {};
+        }
+
+        const tables = this.get('tables' as any);
+        for (let i = 0; i < tables.length; i++) {
+            if (tables[i]['$id'] == $id) {
+                return tables[i];
+            }
+        }
+
+        return {};
+    }
+
+    addTable(props: any): void {
+        props = whitelistKeys(props, KeysTable, {
+            columns: KeysColumns,
+            indexes: KeyIndexesColumns,
+        });
+
+        if (!this.has('tables')) {
+            this.set('tables' as any, []);
+        }
+
+        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);
+    }
+
+    getBuckets(): any[] {
+        if (!this.has('buckets')) {
+            return [];
+        }
+        return this.get('buckets' as any);
+    }
+
+    getBucket($id: string): any {
+        if (!this.has('buckets')) {
+            return {};
+        }
+
+        const buckets = this.get('buckets' as any);
+        for (let i = 0; i < buckets.length; i++) {
+            if (buckets[i]['$id'] == $id) {
+                return buckets[i];
+            }
+        }
+
+        return {};
+    }
+
+    addBucket(props: any): void {
+        props = whitelistKeys(props, KeysStorage);
+
+        if (!this.has('buckets')) {
+            this.set('buckets' as any, []);
+        }
+
+        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);
+    }
+
+    getMessagingTopics(): any[] {
+        if (!this.has('topics')) {
+            return [];
+        }
+        return this.get('topics' as any);
+    }
+
+    getMessagingTopic($id: string): any {
+        if (!this.has('topics')) {
+            return {};
+        }
+
+        const topic = this.get('topics' as any);
+        for (let i = 0; i < topic.length; i++) {
+            if (topic[i]['$id'] == $id) {
+                return topic[i];
+            }
+        }
+
+        return {};
+    }
+
+    addMessagingTopic(props: any): void {
+        props = whitelistKeys(props, KeysTopics);
+
+        if (!this.has('topics')) {
+            this.set('topics' as any, []);
+        }
+
+        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);
+    }
+
+    getTablesDBs(): any[] {
+        return this._getDBEntities('tablesDB');
+    }
+
+    getTablesDB($id: string): any {
+        return this._getDBEntity('tablesDB', $id);
+    }
+
+    addTablesDB(props: any): void {
+        this._addDBEntity('tablesDB', props, KeysDatabase);
+    }
+
+    getDatabases(): any[] {
+        return this._getDBEntities('databases');
+    }
+
+    getDatabase($id: string): any {
+        return this._getDBEntity('databases', $id);
+    }
+
+    addDatabase(props: any): void {
+        this._addDBEntity('databases', props, KeysDatabase);
+    }
+
+    getTeams(): any[] {
+        if (!this.has('teams')) {
+            return [];
+        }
+        return this.get('teams' as any);
+    }
+
+    getTeam($id: string): any {
+        if (!this.has('teams')) {
+            return {};
+        }
+
+        const teams = this.get('teams' as any);
+        for (let i = 0; i < teams.length; i++) {
+            if (teams[i]['$id'] == $id) {
+                return teams[i];
+            }
+        }
+
+        return {};
+    }
+
+    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);
+    }
+
+    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,
+                },
+            },
+        };
+    }
+}
+
+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],
+                });
+            }
+        });
+
+        return Array.from(sessionMap.values());
+    }
+
+    addSession(session: string, data: SessionData): void {
+        this.set(session as any, data as any);
+    }
+
+    removeSession(session: string): void {
+        this.delete(session);
+    }
+
+    getEmail(): string {
+        if (!this.hasFrom(Global.PREFERENCE_EMAIL)) {
+            return '';
+        }
+
+        return this.getFrom(Global.PREFERENCE_EMAIL);
+    }
+
+    setEmail(email: string): void {
+        this.setTo(Global.PREFERENCE_EMAIL, email);
+    }
+
+    getEndpoint(): string {
+        if (!this.hasFrom(Global.PREFERENCE_ENDPOINT)) {
+            return '';
+        }
+
+        return this.getFrom(Global.PREFERENCE_ENDPOINT);
+    }
+
+    setEndpoint(endpoint: string): void {
+        this.setTo(Global.PREFERENCE_ENDPOINT, endpoint);
+    }
+
+    getSelfSigned(): boolean {
+        if (!this.hasFrom(Global.PREFERENCE_SELF_SIGNED)) {
+            return false;
+        }
+        return this.getFrom(Global.PREFERENCE_SELF_SIGNED);
+    }
+
+    setSelfSigned(selfSigned: boolean): void {
+        this.setTo(Global.PREFERENCE_SELF_SIGNED, selfSigned);
+    }
+
+    getCookie(): string {
+        if (!this.hasFrom(Global.PREFERENCE_COOKIE)) {
+            return '';
+        }
+        return this.getFrom(Global.PREFERENCE_COOKIE);
+    }
+
+    setCookie(cookie: string): void {
+        this.setTo(Global.PREFERENCE_COOKIE, cookie);
+    }
+
+    getProject(): string {
+        if (!this.hasFrom(Global.PREFERENCE_PROJECT)) {
+            return '';
+        }
+        return this.getFrom(Global.PREFERENCE_PROJECT);
+    }
+
+    setProject(project: string): void {
+        this.setTo(Global.PREFERENCE_PROJECT, project);
+    }
+
+    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();
+
+        if (current) {
+            const config = this.get(current as any) ?? {};
+
+            return (config as any)[key] !== undefined;
+        }
+        return false;
+    }
+
+    getFrom(key: string): any {
+        const current = this.getCurrentSession();
+
+        if (current) {
+            const config = this.get(current as any) ?? {};
+
+            return (config as any)[key];
+        }
+    }
+
+    setTo(key: string, value: any): void {
+        const current = this.getCurrentSession();
+
+        if (current) {
+            const config = this.get(current as any);
+
+            (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,
+};