@makano/rew 1.1.73 → 1.1.81

package/lib/rew/pkgs/modules/ui/classes.js

@@ -6,122 +6,130 @@ module.exports.uiClasses = (context, options, send, recieve, hook, rmHook) => {
   const _sanitizeOptions = (options) => {
     return {
       ...options,
-      children: options.children.map(i => i.options)
-    }
-  }
+      children: options.children.map((i) => i.options),
+    };
+  };
   const RemWidgetOptions = struct({
-    element: 'div',
-    class: '',
+    element: "div",
+    class: "",
     attr: {},
-    id: '',
+    id: "",
     data: {
-      text: ''
+      text: "",
     },
     children: [],
-    uuid: '',
-    parent: '!any',
-    style: {}
+    uuid: "",
+    parent: "!any",
+    style: {},
   });
 
   const CreatedElements = [];
 
   class RewWidget {
     _emitter = emitter();
-    on(event, callback){
-      const hookID = this.uuid+'_'+generateRandomID(4);
+    on(event, callback) {
+      const hookID = this.uuid + "_" + generateRandomID(4);
       this._emitter.on(event, callback, { hookID });
-      hook(hookID, 'event_'+event, (data) => {
-        this.emit(event, data);
-      }, false);
-      send({ action: 'eventListen', data: { uuid: this.uuid, event, hookID } })
+      hook(
+        hookID,
+        "event_" + event,
+        (data) => {
+          this.emit(event, data);
+        },
+        false,
+      );
+      send({ action: "eventListen", data: { uuid: this.uuid, event, hookID } });
       return this;
     }
-    off(event, callback){
+    off(event, callback) {
       this._emitter.off(event, callback, (e) => rmHook(e.hookID));
       return this;
     }
-    emit(event, callback){
+    emit(event, callback) {
       this._emitter.emit(event, callback);
       return this;
     }
 
     options = RemWidgetOptions();
-    constructor(options = RemWidgetOptions()){
+    constructor(options = RemWidgetOptions()) {
       const config = RemWidgetOptions(options);
       config.uuid = generateRandomID();
       this.options = config;
-      this.options.children.forEach(child => child.parent = this);
+      this.options.children.forEach((child) => (child.parent = this));
       this.init();
       CreatedElements.push(this);
     }
 
-    init(){
-      send({ action: 'createElement', data: _sanitizeOptions(this.options) })
+    init() {
+      send({ action: "createElement", data: _sanitizeOptions(this.options) });
     }
 
     parent = null;
 
-    get uuid(){
+    get uuid() {
       return this.options.uuid;
     }
 
-    get id(){
+    get id() {
       return this.options.id;
     }
 
-    get children(){
+    get children() {
       return this.options.children;
     }
 
-    find(id, recursive = true){
-      let childFound = this.children.find(e => e.id == id) || this.children.find(e => e.uuid == id);
-      if(childFound) return childFound;
-      else if(!recursive) return null;
-      for(let child of this.children){
+    find(id, recursive = true) {
+      let childFound =
+        this.children.find((e) => e.id == id) ||
+        this.children.find((e) => e.uuid == id);
+      if (childFound) return childFound;
+      else if (!recursive) return null;
+      for (let child of this.children) {
         let subchild = child.find(id);
-        if(subchild) {
+        if (subchild) {
           return subchild;
         }
       }
     }
 
-    update(){
-      send({ action: 'updateElement', data: _sanitizeOptions(this.options) });
+    update() {
+      send({ action: "updateElement", data: _sanitizeOptions(this.options) });
       return this;
     }
 
-    text(text){
+    text(text) {
       this.options.data.text = text;
       return this.update();
     }
 
-    data(key, value){
-      if(!value) return this.options.data[key];
+    data(key, value) {
+      if (!value) return this.options.data[key];
       this.options.data[key] = value;
-      return this.update(); 
+      return this.update();
     }
 
-    attr(attr, reset = false){
-      if(reset) this.options.attr = attr;
+    attr(attr, reset = false) {
+      if (reset) this.options.attr = attr;
       else this.options.attr = { ...this.options.attr, ...attr };
       return this.update();
     }
 
-    style(style, reset = false){
-      if(reset) this.options.style = style;
+    style(style, reset = false) {
+      if (reset) this.options.style = style;
       else this.options.style = { ...this.options.style, ...style };
       return this.update();
     }
 
-    add(child){
+    add(child) {
       this.options.children.push(child);
       return this.update();
     }
 
-    remove(childId, recursive = true){
-      const child = typeof childId == "string" ? this.find(childId, recursive) : childId;
-      if(!child) return this;
-      if(recursive && child.parent !== this){
+    remove(childId, recursive = true) {
+      const child =
+        typeof childId == "string" ? this.find(childId, recursive) : childId;
+      if (!child) return this;
+      if (recursive && child.parent !== this) {
         child.parent.remove(child);
       } else {
         this.options.children.splice(this.options.children.indexOf(child), 1);
@@ -129,31 +137,30 @@ module.exports.uiClasses = (context, options, send, recieve, hook, rmHook) => {
       }
       return this;
     }
-
   }
 
   class RewTextWidget extends RewWidget {
-    constructor(text = '', options = RemWidgetOptions({})){
+    constructor(text = "", options = RemWidgetOptions({})) {
       super({
         ...options,
-        data: { ...(options.data), text }
+        data: { ...options.data, text },
       });
     }
   }
 
   class StyleSheet {
-    constructor(css = ''){
-      send({ action: 'addStyleSheet', data: css });
+    constructor(css = "") {
+      send({ action: "addStyleSheet", data: css });
     }
   }
 
-  function findElement(id){
+  function findElement(id) {
     return new Promise((r) => {
       const rid = generateRandomID();
-      hook(rid, 'findElement', (data) => {
-        r(CreatedElements.find(e => e.uuid == data.uuid) || data);
+      hook(rid, "findElement", (data) => {
+        r(CreatedElements.find((e) => e.uuid == data.uuid) || data);
       });
-      send({ action: 'findElement', data: { id, rid } });
+      send({ action: "findElement", data: { id, rid } });
     });
   }
 
@@ -165,9 +172,9 @@ module.exports.uiClasses = (context, options, send, recieve, hook, rmHook) => {
   // }, false);
 
   const Transmitter = {
-    send: (data) => send({ action: 'message', data }),
-    recieve: (cb) => recieve((data) => cb(data.data))
-  }
+    send: (data) => send({ action: "message", data }),
+    recieve: (cb) => recieve((data) => cb(data.data)),
+  };
 
   return {
     Widget: RewWidget,
@@ -175,6 +182,6 @@ module.exports.uiClasses = (context, options, send, recieve, hook, rmHook) => {
     WidgetOptions: RemWidgetOptions,
     findElement,
     StyleSheet: StyleSheet,
-    Transmitter
-  }
-}
+    Transmitter,
+  };
+};

package/lib/rew/pkgs/pkgs.js

@@ -1,13 +1,12 @@
 const path = require("path");
 const fs = require("fs");
 
-
 module.exports = {
   findPackage(pkg) {
-    if(pkg == 'pkgs') return false;
-    return fs.existsSync(path.resolve(__dirname, './'+pkg+'.js'));
+    if (pkg == "pkgs") return false;
+    return fs.existsSync(path.resolve(__dirname, "./" + pkg + ".js"));
+  },
+  getPackage(pkg) {
+    return require("./" + pkg);
   },
-  getPackage(pkg){
-    return require('./'+pkg);
-  }
 };

package/lib/rew/pkgs/rune.js

@@ -0,0 +1,437 @@
+const fs = require("fs");
+const { v4: uuidv4 } = require("uuid");
+const path = require("path");
+const msgpack = require("tiny-msgpack");
+const crypto = require("crypto");
+const { CONFIG_PATH } = require("../const/config_path");
+
+const ENCRYPTION_KEY =
+  "e6ad8b0792b9e0472ea44d1f3adfd1d503182efcce25991b05cc5ef83f307ffc";
+
+class Change {
+  constructor(values) {
+    this.values = values;
+  }
+}
+
+class PopChange extends Change {}
+
+class PushChange extends Change {}
+
+const runePush = (...values) => new PushChange(values);
+const runePop = (...values) => new PopChange(values);
+
+function makeRef(value, props = "") {
+  if (!value["@rune.id"]) return null;
+  const collection = getCollectionFromID(value["@rune.id"]);
+  const ref = collection + "." + value["@rune.id"];
+  return "@rune.ref " + ref + props;
+}
+
+const eid = (s, diff) =>
+  s
+    .split("")
+    .map((i) => {
+      let charCode = i.charCodeAt(0) + diff;
+      if (charCode > 122) {
+        charCode -= 26;
+      }
+      return String.fromCharCode(charCode);
+    })
+    .join("");
+
+function generateID(id, collection) {
+  return eid(collection, 5) + "+" + id;
+}
+
+function getCollectionFromID(id) {
+  return eid(id.split("+")[0], -5);
+}
+
+const createDB = (dbName, dirname, dbData = {}, encryptionKey) => {
+  const dbDirPath = path.join(dirname, dbName);
+  const mainFilePath = path.join(dbDirPath, "main.bin");
+  const algorithm = "aes-256-ctr";
+
+  if (!fs.existsSync(dbDirPath)) {
+    fs.mkdirSync(dbDirPath);
+  }
+
+  const encrypt = (data) => {
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv(
+      algorithm,
+      Buffer.from(encryptionKey, "hex"),
+      iv,
+    );
+    const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
+    return Buffer.concat([iv, encrypted]);
+  };
+
+  const decrypt = (data) => {
+    const iv = data.slice(0, 16);
+    const encryptedData = data.slice(16);
+    const decipher = crypto.createDecipheriv(
+      algorithm,
+      Buffer.from(encryptionKey, "hex"),
+      iv,
+    );
+    const decrypted = Buffer.concat([
+      decipher.update(encryptedData),
+      decipher.final(),
+    ]);
+    return decrypted;
+  };
+
+  const serializeData = (data) => {
+    return msgpack.encode(data);
+  };
+
+  const deserializeData = (buffer) => {
+    return msgpack.decode(decrypt(buffer));
+  };
+
+  const getData = () => {
+    return readMainData().data;
+  };
+  getData.key = (key) => {
+    return getData()[key];
+  };
+
+  const setData = (data) => {
+    const newData = readMainData();
+    for (let i in data) if (data[i] !== undefined) newData.data[i] = data[i];
+    writeMainData(newData);
+  };
+
+  setData.key = (key, value) => {
+    setData({ [key]: value });
+  };
+
+  setData.rm = (key) => {
+    setData({ [key]: undefined });
+  };
+
+  setData.reset = () => {
+    writeMainData({
+      ...readMainData(),
+      data: { ...dbData, name: dbName },
+    });
+  };
+
+  const readMainData = () => {
+    if (!fs.existsSync(mainFilePath)) {
+      writeMainData({
+        collections: [],
+        data: { ...dbData, name: dbName },
+        maps: [],
+      });
+    }
+    const buffer = fs.readFileSync(mainFilePath);
+    return deserializeData(buffer);
+  };
+
+  const writeMainData = (data) => {
+    const buffer = encrypt(serializeData(data));
+    fs.writeFileSync(mainFilePath, buffer);
+  };
+
+  const readDataFile = (filePath) => {
+    const buffer = fs.readFileSync(filePath);
+    return deserializeData(buffer);
+  };
+
+  const writeDataFile = (filePath, data) => {
+    const buffer = encrypt(serializeData(data));
+    fs.writeFileSync(filePath, buffer);
+  };
+
+  const collection = (collectionName) => {
+    const collectionFilePath = path.join(dbDirPath, `${collectionName}.col`);
+
+    const insert = (record) => {
+      const mainData = readMainData();
+      if (!mainData.collections.includes(collectionName)) {
+        mainData.collections.push(collectionName);
+        writeMainData(mainData);
+      }
+
+      let data = [];
+      if (fs.existsSync(collectionFilePath)) {
+        data = readDataFile(collectionFilePath);
+      }
+      const id = uuidv4();
+      record["@rune.id"] = generateID(id, collectionName);
+      data.push(record);
+      writeDataFile(collectionFilePath, data);
+      return record;
+    };
+
+    const read = (id, evaluate = true) => {
+      if (typeof id == "object" && "@rune.id" in id) id = id["@rune.id"];
+      if (!fs.existsSync(collectionFilePath)) return null;
+      const data = readDataFile(collectionFilePath);
+      const record = data.find((record) => record["@rune.id"] === id);
+      if (record) {
+        return evaluateRecord(record);
+      }
+      return null;
+    };
+
+    const evaluateRecord = (record, prevRecord) => {
+      const evaluateValue = (val) => {
+        if (typeof val == "string" && val.startsWith("@rune.ref")) {
+          const ref = val.split("@rune.ref")[1].trim();
+          const refData = findRef(ref, false);
+          if (!refData) {
+            return null;
+          } else {
+            let value = refData;
+            if (refData["@rune.id"]) {
+              value =
+                prevRecord && prevRecord["@rune.id"] == refData["@rune.id"]
+                  ? prevRecord
+                  : evaluateRecord(refData, record);
+            }
+            return value;
+          }
+        }
+        if (Array.isArray(val)) {
+          val = val.map((i) => evaluateValue(i));
+        }
+        return val;
+      };
+      for (let i in record) {
+        const val = record[i];
+        record[i] = evaluateValue(val);
+      }
+      return record;
+    };
+
+    const update = (caseRecord, newRecord) => {
+      let id;
+      if (typeof caseRecord === "string") {
+        id = caseRecord;
+      } else if (typeof caseRecord === "object") {
+        const data = readDataFile(collectionFilePath);
+        const record = data.find((record) => {
+          for (const key in caseRecord) {
+            if (record[key] !== caseRecord[key]) return false;
+          }
+          return true;
+        });
+        if (record) {
+          id = record["@rune.id"];
+        } else {
+          return null; // No matching record found
+        }
+      }
+
+      if (!id) return null;
+
+      const data = readDataFile(collectionFilePath);
+      const index = data.findIndex((record) => record["@rune.id"] === id);
+      if (index !== -1) {
+        const oldRecord = data[index];
+        for (const key in newRecord) {
+          const value = newRecord[key];
+          if (value instanceof PushChange) {
+            if (!oldRecord[key] || !Array.isArray(oldRecord[key])) {
+              oldRecord[key] = [];
+            }
+            oldRecord[key].push(...value.values);
+          } else if (value instanceof PopChange) {
+            if (oldRecord[key] && Array.isArray(oldRecord[key])) {
+              value.values.forEach((val) => {
+                const index = oldRecord[key].indexOf(val);
+                if (index !== -1) {
+                  oldRecord[key].splice(index, 1);
+                }
+              });
+            }
+          } else {
+            oldRecord[key] = value;
+          }
+        }
+        data[index] = oldRecord;
+        writeDataFile(collectionFilePath, data);
+        return data[index];
+      }
+      return null;
+    };
+
+    const find = (criteria) => {
+      if (typeof criteria == "string") return read(criteria);
+      if (!criteria || typeof criteria !== "object") return null;
+
+      const data = readDataFile(collectionFilePath);
+      const record =
+        data.find((record) => {
+          for (const key in criteria) {
+            if (record[key] !== criteria[key]) return false;
+          }
+          return true;
+        }) || null;
+      if (record) {
+        return evaluateRecord(record);
+      }
+      return null;
+    };
+
+    const remove = (id) => {
+      if ("@rune.id" in id) id = id["@rune.id"];
+      if (!fs.existsSync(collectionFilePath)) return false;
+      let data = readDataFile(collectionFilePath);
+      const index = data.findIndex((record) => record["@rune.id"] === id);
+      if (index !== -1) {
+        data.splice(index, 1);
+        writeDataFile(collectionFilePath, data);
+        return true;
+      }
+      return false;
+    };
+
+    const list = () => {
+      if (!fs.existsSync(collectionFilePath)) return [];
+      const data = readDataFile(collectionFilePath);
+      return data.map((rec) => evaluateRecord(rec));
+    };
+
+    const map = (cb, mutate = false) => {
+      const data = readDataFile(collectionFilePath);
+      const mappedData = data.map(cb);
+      if (mutate) {
+        writeDataFile(collectionFilePath, mappedData);
+      }
+      return mappedData;
+    };
+
+    const transform = (cb, mutate = true) => {
+      const data = readDataFile(collectionFilePath);
+      const transformedData = cb(data);
+      if (mutate) {
+        writeDataFile(collectionFilePath, transformedData);
+      }
+      return transformedData;
+    };
+
+    const filter = (cb, mutate = false) => {
+      const data = readDataFile(collectionFilePath);
+      const filteredData = data.filter(cb);
+      if (mutate) {
+        writeDataFile(collectionFilePath, filteredData);
+      }
+      return filteredData;
+    };
+
+    const sort = (cb, mutate = false) => {
+      const data = readDataFile(collectionFilePath);
+      const sortedData = data.sort(cb);
+      if (mutate) {
+        writeDataFile(collectionFilePath, sortedData);
+      }
+      return sortedData;
+    };
+
+    return {
+      insert,
+      read,
+      update,
+      remove,
+      find,
+      map,
+      transform,
+      filter,
+      sort,
+      list,
+    };
+  };
+
+  const findRef = (ref, evaluate = true) => {
+    const [name, id, ...rest] = ref.split(".");
+    const col = collection(name);
+    const record = col.read(id, evaluate);
+    if (rest.length === 0) return record;
+    let value = record;
+    for (const prop of rest) {
+      if (typeof value != "object") break;
+      if (!(prop in value)) return null;
+      value = value[prop];
+    }
+    return value;
+  };
+
+  const map = (mapName) => {
+    const mapFilePath = path.join(dbDirPath, `${mapName}.map`);
+
+    const set = (key, value) => {
+      const mainData = readMainData();
+      if (!mainData.maps.includes(mapName)) {
+        mainData.maps.push(mapName);
+        writeMainData(mainData);
+      }
+
+      let data = {};
+      if (fs.existsSync(mapFilePath)) {
+        data = readDataFile(mapFilePath);
+      }
+      data[key] = value;
+      writeDataFile(mapFilePath, data);
+    };
+
+    const get = (key) => {
+      if (!fs.existsSync(mapFilePath)) return null;
+      const data = readDataFile(mapFilePath);
+      return data[key] || null;
+    };
+
+    const remove = (key) => {
+      if (!fs.existsSync(mapFilePath)) return false;
+      const data = readDataFile(mapFilePath);
+      if (data[key]) {
+        delete data[key];
+        writeDataFile(mapFilePath, data);
+        return true;
+      }
+      return false;
+    };
+
+    const transform = (cb, mutate = false) => {
+      const data = readDataFile(mapFilePath);
+      const transformedData = cb(data);
+      if (mutate) {
+        writeDataFile(mapFilePath, transformedData);
+      }
+      return transformedData;
+    };
+
+    const list = () => {
+      if (!fs.existsSync(mapFilePath)) return {};
+      const data = readDataFile(mapFilePath);
+      return data;
+    };
+
+    return { set, get, remove, list, transform };
+  };
+
+  readMainData();
+
+  return { setData, getData, collection, findRef, makeRef, map };
+};
+
+module.exports = (context) => ({
+  _onImport() {
+    delete this.createDB;
+    return this;
+  },
+  db(dbname, data = {}, encryptionKey) {
+    if (!context.app) throw new Error("rune can only be used in apps");
+    const pkg = path.join(CONFIG_PATH, context.app.config.package, "db");
+    if (!fs.existsSync(pkg)) fs.mkdirSync(pkg, { recursive: true });
+    return createDB(dbname, pkg, data, encryptionKey || ENCRYPTION_KEY);
+  },
+  makeRef,
+  runePop,
+  runePush,
+  createDB,
+});