chirag-appwrite-cli 0.1.0 → 0.2.0

package/dist/lib/config.js

@@ -0,0 +1,728 @@
+import os from "os";
+import fs from "fs";
+import _path from "path";
+import process from "process";
+import JSONbig from "json-bigint";
+import { createSettingsObject } from "./utils.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 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(value, keys, nestedKeys = {}) {
+    if (Array.isArray(value)) {
+        const newValue = [];
+        for (const item of value) {
+            newValue.push(whitelistKeys(item, keys, nestedKeys));
+        }
+        return newValue;
+    }
+    const newValue = {};
+    Object.keys(value).forEach((key) => {
+        if (keys.has(key)) {
+            if (nestedKeys[key]) {
+                newValue[key] = whitelistKeys(value[key], nestedKeys[key]);
+            }
+            else {
+                newValue[key] = value[key];
+            }
+        }
+    });
+    return newValue;
+}
+class Config {
+    path;
+    data;
+    constructor(path) {
+        this.path = path;
+        this.data = {};
+        this.read();
+    }
+    read() {
+        try {
+            const file = fs.readFileSync(this.path).toString();
+            this.data = JSONBigInt.parse(file);
+        }
+        catch (e) {
+            this.data = {};
+        }
+    }
+    write() {
+        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(key) {
+        return this.data[key];
+    }
+    set(key, value) {
+        this.data[key] = value;
+        this.write();
+    }
+    delete(key) {
+        delete this.data[key];
+        this.write();
+    }
+    clear() {
+        this.data = {};
+        this.write();
+    }
+    has(key) {
+        return this.data[key] !== undefined;
+    }
+    keys() {
+        return Object.keys(this.data);
+    }
+    values() {
+        return Object.values(this.data);
+    }
+    toString() {
+        return JSONBigInt.stringify(this.data, null, 4);
+    }
+    _getDBEntities(entityType) {
+        if (!this.has(entityType)) {
+            return [];
+        }
+        return this.get(entityType);
+    }
+    _getDBEntity(entityType, $id) {
+        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 {};
+    }
+    _addDBEntity(entityType, props, keysSet, nestedKeys = {}) {
+        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 {
+    static CONFIG_FILE_PATH = "appwrite.config.json";
+    static CONFIG_FILE_PATH_LEGACY = "appwrite.json";
+    configDirectoryPath = "";
+    constructor(path = Local.CONFIG_FILE_PATH, legacyPath = 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) {
+        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() {
+        return _path.dirname(this.path);
+    }
+    getEndpoint() {
+        return this.get("endpoint") || "";
+    }
+    setEndpoint(endpoint) {
+        this.set("endpoint", endpoint);
+    }
+    getSites() {
+        if (!this.has("sites")) {
+            return [];
+        }
+        return this.get("sites") ?? [];
+    }
+    getSite($id) {
+        if (!this.has("sites")) {
+            return {};
+        }
+        const sites = this.get("sites") ?? [];
+        for (let i = 0; i < sites.length; i++) {
+            if (sites[i]["$id"] == $id) {
+                return sites[i];
+            }
+        }
+        return {};
+    }
+    addSite(props) {
+        props = whitelistKeys(props, KeysSite, {
+            vars: KeysVars,
+        });
+        if (!this.has("sites")) {
+            this.set("sites", []);
+        }
+        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;
+            }
+        }
+        sites.push(props);
+        this.set("sites", sites);
+    }
+    getFunctions() {
+        if (!this.has("functions")) {
+            return [];
+        }
+        return this.get("functions") ?? [];
+    }
+    getFunction($id) {
+        if (!this.has("functions")) {
+            return {};
+        }
+        const functions = this.get("functions") ?? [];
+        for (let i = 0; i < functions.length; i++) {
+            if (functions[i]["$id"] == $id) {
+                return functions[i];
+            }
+        }
+        return {};
+    }
+    addFunction(props) {
+        props = whitelistKeys(props, KeysFunction, {
+            vars: KeysVars,
+        });
+        if (!this.has("functions")) {
+            this.set("functions", []);
+        }
+        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;
+            }
+        }
+        functions.push(props);
+        this.set("functions", functions);
+    }
+    getCollections() {
+        if (!this.has("collections")) {
+            return [];
+        }
+        return this.get("collections") ?? [];
+    }
+    getCollection($id) {
+        if (!this.has("collections")) {
+            return {};
+        }
+        const collections = this.get("collections") ?? [];
+        for (let i = 0; i < collections.length; i++) {
+            if (collections[i]["$id"] == $id) {
+                return collections[i];
+            }
+        }
+        return {};
+    }
+    addCollection(props) {
+        props = whitelistKeys(props, KeysCollection, {
+            attributes: KeysAttributes,
+            indexes: KeyIndexes,
+        });
+        if (!this.has("collections")) {
+            this.set("collections", []);
+        }
+        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);
+    }
+    getTables() {
+        if (!this.has("tables")) {
+            return [];
+        }
+        return this.get("tables") ?? [];
+    }
+    getTable($id) {
+        if (!this.has("tables")) {
+            return {};
+        }
+        const tables = this.get("tables") ?? [];
+        for (let i = 0; i < tables.length; i++) {
+            if (tables[i]["$id"] == $id) {
+                return tables[i];
+            }
+        }
+        return {};
+    }
+    addTable(props) {
+        props = whitelistKeys(props, KeysTable, {
+            columns: KeysColumns,
+            indexes: KeyIndexesColumns,
+        });
+        if (!this.has("tables")) {
+            this.set("tables", []);
+        }
+        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);
+    }
+    getBuckets() {
+        if (!this.has("buckets")) {
+            return [];
+        }
+        return this.get("buckets") ?? [];
+    }
+    getBucket($id) {
+        if (!this.has("buckets")) {
+            return {};
+        }
+        const buckets = this.get("buckets") ?? [];
+        for (let i = 0; i < buckets.length; i++) {
+            if (buckets[i]["$id"] == $id) {
+                return buckets[i];
+            }
+        }
+        return {};
+    }
+    addBucket(props) {
+        props = whitelistKeys(props, KeysStorage);
+        if (!this.has("buckets")) {
+            this.set("buckets", []);
+        }
+        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);
+    }
+    getMessagingTopics() {
+        if (!this.has("topics")) {
+            return [];
+        }
+        return this.get("topics") ?? [];
+    }
+    getMessagingTopic($id) {
+        if (!this.has("topics")) {
+            return {};
+        }
+        const topics = this.get("topics") ?? [];
+        for (let i = 0; i < topics.length; i++) {
+            if (topics[i]["$id"] == $id) {
+                return topics[i];
+            }
+        }
+        return {};
+    }
+    addMessagingTopic(props) {
+        props = whitelistKeys(props, KeysTopics);
+        if (!this.has("topics")) {
+            this.set("topics", []);
+        }
+        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);
+    }
+    getTablesDBs() {
+        return this._getDBEntities("tablesDB");
+    }
+    getTablesDB($id) {
+        return this._getDBEntity("tablesDB", $id);
+    }
+    addTablesDB(props) {
+        this._addDBEntity("tablesDB", props, KeysDatabase);
+    }
+    getDatabases() {
+        return this._getDBEntities("databases");
+    }
+    getDatabase($id) {
+        return this._getDBEntity("databases", $id);
+    }
+    addDatabase(props) {
+        this._addDBEntity("databases", props, KeysDatabase);
+    }
+    getTeams() {
+        if (!this.has("teams")) {
+            return [];
+        }
+        return this.get("teams") ?? [];
+    }
+    getTeam($id) {
+        if (!this.has("teams")) {
+            return {};
+        }
+        const teams = this.get("teams") ?? [];
+        for (let i = 0; i < teams.length; i++) {
+            if (teams[i]["$id"] == $id) {
+                return teams[i];
+            }
+        }
+        return {};
+    }
+    addTeam(props) {
+        props = whitelistKeys(props, KeysTeams);
+        if (!this.has("teams")) {
+            this.set("teams", []);
+        }
+        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);
+    }
+    getProject() {
+        if (!this.has("projectId")) {
+            return {};
+        }
+        return {
+            projectId: this.get("projectId"),
+            projectName: this.get("projectName"),
+            projectSettings: this.get("settings"),
+        };
+    }
+    setProject(projectId, projectName = "", project) {
+        this.set("projectId", projectId);
+        if (projectName !== "") {
+            this.set("projectName", projectName);
+        }
+        if (project === undefined) {
+            return;
+        }
+        this.set("settings", createSettingsObject(project));
+    }
+}
+class Global extends Config {
+    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 = Global.CONFIG_FILE_PATH) {
+        const homeDir = os.homedir();
+        super(`${homeDir}/${path}`);
+    }
+    getCurrentSession() {
+        if (!this.has(Global.PREFERENCE_CURRENT)) {
+            return "";
+        }
+        return this.get(Global.PREFERENCE_CURRENT);
+    }
+    setCurrentSession(session) {
+        if (session !== undefined) {
+            this.set(Global.PREFERENCE_CURRENT, session);
+        }
+    }
+    getSessionIds() {
+        return Object.keys(this.data).filter((key) => !Global.IGNORE_ATTRIBUTES.includes(key));
+    }
+    getSessions() {
+        const sessions = Object.keys(this.data).filter((key) => !Global.IGNORE_ATTRIBUTES.includes(key));
+        const current = this.getCurrentSession();
+        const sessionMap = new Map();
+        sessions.forEach((sessionId) => {
+            const sessionData = this.data[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, data) {
+        this.set(session, data);
+    }
+    removeSession(session) {
+        this.delete(session);
+    }
+    getEmail() {
+        if (!this.hasFrom(Global.PREFERENCE_EMAIL)) {
+            return "";
+        }
+        return this.getFrom(Global.PREFERENCE_EMAIL);
+    }
+    setEmail(email) {
+        this.setTo(Global.PREFERENCE_EMAIL, email);
+    }
+    getEndpoint() {
+        if (!this.hasFrom(Global.PREFERENCE_ENDPOINT)) {
+            return "";
+        }
+        return this.getFrom(Global.PREFERENCE_ENDPOINT);
+    }
+    setEndpoint(endpoint) {
+        this.setTo(Global.PREFERENCE_ENDPOINT, endpoint);
+    }
+    getSelfSigned() {
+        if (!this.hasFrom(Global.PREFERENCE_SELF_SIGNED)) {
+            return false;
+        }
+        return this.getFrom(Global.PREFERENCE_SELF_SIGNED);
+    }
+    setSelfSigned(selfSigned) {
+        this.setTo(Global.PREFERENCE_SELF_SIGNED, selfSigned);
+    }
+    getCookie() {
+        if (!this.hasFrom(Global.PREFERENCE_COOKIE)) {
+            return "";
+        }
+        return this.getFrom(Global.PREFERENCE_COOKIE);
+    }
+    setCookie(cookie) {
+        this.setTo(Global.PREFERENCE_COOKIE, cookie);
+    }
+    getProject() {
+        if (!this.hasFrom(Global.PREFERENCE_PROJECT)) {
+            return "";
+        }
+        return this.getFrom(Global.PREFERENCE_PROJECT);
+    }
+    setProject(project) {
+        this.setTo(Global.PREFERENCE_PROJECT, project);
+    }
+    getKey() {
+        if (!this.hasFrom(Global.PREFERENCE_KEY)) {
+            return "";
+        }
+        return this.getFrom(Global.PREFERENCE_KEY);
+    }
+    setKey(key) {
+        this.setTo(Global.PREFERENCE_KEY, key);
+    }
+    hasFrom(key) {
+        const current = this.getCurrentSession();
+        if (current) {
+            const config = this.get(current) ?? {};
+            return config[key] !== undefined;
+        }
+        return false;
+    }
+    getFrom(key) {
+        const current = this.getCurrentSession();
+        if (current) {
+            const config = this.get(current) ?? {};
+            return config[key];
+        }
+    }
+    setTo(key, value) {
+        const current = this.getCurrentSession();
+        if (current) {
+            const config = this.get(current);
+            config[key] = value;
+            this.write();
+        }
+    }
+}
+export const localConfig = new Local();
+export const globalConfig = new Global();
+export { KeysAttributes, KeysSite, KeysFunction, KeysTopics, KeysStorage, KeysTeams, KeysCollection, KeysTable, whitelistKeys, };
+//# sourceMappingURL=config.js.map