@makano/rew 1.5.5 → 1.5.8

package/lib/rew/modules/context.js

@@ -177,6 +177,7 @@ module.exports.prepareContext = function (
     get prototype(){
       const globals = context.app?.config?.assets?.globals ?? '_';
       const p = context.pjoin(context.app ? context.app.path : context.dirname(context.module.filename), globals);
+      // console.log(context.app);
       if(!context.exists(p)) return {};
       const files = context.ls(p);
       const pr = {};
@@ -216,7 +217,7 @@ module.exports.prepareContext = function (
     try {
       if (package.startsWith("node:") || package.startsWith("pkg:"))
         throw new Error("");
-      return context.imp(package, asserts);
+      return context.imp(package, asserts, true);
     } catch (e) {
       if(e.message.match('Module') && e.message.match('not found')){
         let pname = package.startsWith("pkg:") ? package.split("pkg:")[1] : package;

package/lib/rew/modules/yaml.js

@@ -1,8 +1,9 @@
 const yaml = require('js-yaml');
 const path = require('path');
 const { getFile } = require('./fs');
+const { withOut } = require('../functions/core');
 
-function yamlFile(file) {
+function yamlFile(file, schemaProps) {
 	const schema = new yaml.Schema([
 		new yaml.Type('!import', {
 			kind: 'scalar',
@@ -20,11 +21,17 @@ function yamlFile(file) {
 			kind: 'scalar',
 			construct: (data) => (data == 'true' ? true : false),
 		}),
-	]);
+	].concat(
+		(schemaProps || []).map((item) => new yaml.Type(item.key, {
+			...withOut(item, 'key')
+		}))
+	));
 
 	return file.content.startsWith('---') ? yaml.loadAll(file.content, { schema })[0] : yaml.load(file.content, { schema });
 }
 
+module.exports.yamlFile = yamlFile;
+
 const importYaml = (module.exports.importYaml = function importYaml(filepath, file) {
 	if (!file) {
 		file = getFile(filepath);

package/lib/rew/pkgs/alpha.js

@@ -0,0 +1,18 @@
+const { pickRandom } = require("../const/default")
+
+const alphabets = 'abcdefghijklmnopqrstuvwxyz';
+const numericals = '0123456789';
+
+module.exports = () => ({
+  alphabets,
+  numericals,
+  rn(length = 1){
+    return Array(length || 1).fill(0).map(() => pickRandom(...numericals.split(''))).join('');
+  },
+  rl(length = 1){
+    return Array(length || 1).fill(0).map(() => pickRandom(...alphabets.split(''))).join('');
+  },
+  rnl(length = 1){
+    return Array(length || 1).fill(0).map(() => pickRandom(...(alphabets + numericals).split(''))).join('');
+  }
+})

package/lib/rew/pkgs/conf.js

@@ -3,6 +3,7 @@ const jsYaml = require('js-yaml');
 const path = require('path');
 const { CONFIG_PATH } = require('../const/config_path');
 const { seededID } = require('../misc/seededid');
+const { Usage } = require('../const/usage');
 
 const createPackageRoot = (packageName) => {
 	const rootPath = path.join(CONFIG_PATH, packageName);
@@ -30,18 +31,22 @@ module.exports = (context) => ({
 		};
 
 		const setData = (optionCenter, key, value) => {
+			if(conf[optionCenter.name] === undefined) conf[optionCenter.name] = {};
+			// console.log(conf, optionCenter.name, key, value);
 			conf[optionCenter.name][key] = value;
 			fs.writeFileSync(optionCenter.root, dumpYaml(conf[optionCenter.name]));
 			return true;
 		};
 
 		const removeData = (optionCenter, key) => {
+			if(conf[optionCenter.name] === undefined) conf[optionCenter.name] = {};
 			delete conf[optionCenter.name][key];
 			fs.writeFileSync(optionCenter.root, dumpYaml(conf[optionCenter.name]));
 			return true;
 		};
 
 		const getData = (optionCenter, key) => {
+			if(conf[optionCenter.name] === undefined) conf[optionCenter.name] = {};
 			return conf[optionCenter.name][key];
 		};
 
@@ -88,7 +93,7 @@ module.exports = (context) => ({
 				get: (key, defaultValue) => getData(optionCenter, key) ?? defaultValue,
 				set: (key, value) => setData(optionCenter, key, value),
 				remove: (key) => removeData(optionCenter, key),
-				reset: () => fs.writeFileSync(optionCenter.root, dumpYaml(defaults)) && (conf[name] = defaults),
+				reset: () => { fs.writeFileSync(optionCenter.root, dumpYaml(defaults)); conf[name] = defaults;},
 				getAll: (str = false) => (str ? dumpYaml(conf[name]) : conf[name]),
 				...optionCenter,
 			};
@@ -96,7 +101,7 @@ module.exports = (context) => ({
 
 		const defaultCenter = createOptionCenter('_default', { default: true });
 
-		return {
+		const confNamespace = {
 			optionCenter: createOptionCenter,
 			staticFile: staticFile,
 			set: (key, value) => defaultCenter.set(key, value),
@@ -104,7 +109,19 @@ module.exports = (context) => ({
 			remove: (key) => defaultCenter.remove(key),
 			root: rootPath,
 			package: packageName,
-			loadYaml: (file) => jsYaml.load(fs.readFileSync(file, { encoding: 'utf-8' }))
+			loadYaml: (file) => jsYaml.load(fs.readFileSync(file, { encoding: 'utf-8' })),
+			prototype: {
+				class: (name, defaults = {}) => new Usage('conf::class', (cb) => {
+					const optionCenter = createOptionCenter(name, defaults);
+					return cb.call(confNamespace, optionCenter);
+				}),
+				center: (name, defaults = {}) => (cb) => new Usage('conf::class', () => {
+					const optionCenter = createOptionCenter(name, defaults);
+					return cb.call(confNamespace, optionCenter);
+				})
+			}
 		};
+
+		return confNamespace;
 	},
 });

package/lib/rew/pkgs/modules/rune/db.js

@@ -0,0 +1,9 @@
+
+
+module.exports = class RuneDB {
+  constructor(attrs){
+    for(let i in attrs){
+      this[i] = attrs[i];
+    }
+  }
+};

package/lib/rew/pkgs/rune.js

@@ -3,8 +3,11 @@ const { v4: uuidv4 } = require('uuid');
 const path = require('path');
 const { CONFIG_PATH } = require('../const/config_path');
 const { serializeData, deserializeData, gen_key } = require('../misc/bin');
+const RuneDB = require('./modules/rune/db');
+const { typeis } = require('../const/default');
 
 const ENCRYPTION_KEY = 'e6ad8b0792b9e0472ea44d1f3adfd1d503182efcce25991b05cc5ef83f307ffc';
+const PAGE_LIMIT = 100;
 
 class Change {
 	constructor(values) {
@@ -46,6 +49,37 @@ function getCollectionFromID(id) {
 	return eid(id.split('+')[0], -5);
 }
 
+function coltypedef(cb) {
+	const typedef = {};
+	const ctx = {
+		opt: (name, type, defaultValue) => {
+			typedef[name] = type;
+			if(typeof defaultValue !== "undefined"){
+				if(!typedef['@rune.default']){
+					typedef['@rune.default'] = {};
+				}
+				typedef['@rune.default'][name] = defaultValue;
+			}
+		},
+		req: (name, type, defaultValue) => {
+			if(!typedef['@rune.required']){
+				typedef['@rune.required'] = {};
+			}
+			typedef['@rune.required'][name] = true;
+			ctx.opt(name, type, defaultValue);
+		},
+		unique: (name, type, defaultValue) => {
+			if(!typedef['@rune.unique']){
+				typedef['@rune.unique'] = {};
+			}
+			typedef['@rune.unique'][name] = true;
+			ctx.req(name, type, defaultValue);
+		}
+	};
+	cb.call(ctx);
+	return typedef;
+}
+
 const createDB = (dbName, dirname, dbData = {}, encryptionKey) => {
 	const dbDirPath = path.join(dirname, dbName);
 	const mainFilePath = path.join(dbDirPath, 'main.bin');
@@ -109,10 +143,76 @@ const createDB = (dbName, dirname, dbData = {}, encryptionKey) => {
 		fs.writeFileSync(filePath, buffer);
 	};
 
-	const collection = (collectionName) => {
+	const collection = (collectionName, {
+		model,
+		exclude
+	} = {}) => {
 		const collectionFilePath = path.join(dbDirPath, `${collectionName}.col`);
 
-		const insert = (record) => {
+		const validateFields = (definition, data, optional = false) => {
+			if(!definition){
+				return data;
+			}
+
+      const validatedData = {};
+      for (const [field, type] of Object.entries(definition)) {
+				if(field.startsWith('@rune.')) continue;
+				if(!data[field] && typeof definition['@rune.default']?.[field] !== "undefined") data[field] = definition['@rune.default']?.[field];
+				
+				if(typeof data[field] == "function"){
+					data[field] = data[field](data, definition);
+				}
+
+        if (data[field] === undefined) {
+					if(optional) continue;
+					else if(definition['@rune.required']){
+						if(definition['@rune.required'][field]){
+							throw new ReferenceError(`Field ${field} is required, yet not provided.`)
+						} else continue;
+					} else continue;
+				}
+
+        const value = data[field];
+        if (!typeis(value, type) && value != type) {
+          throw new TypeError(`Invalid type for field "${field}". Expected ${
+            type?.type?.type || type?.type || type
+          }, got ${typeof value}`);
+        }
+        validatedData[field] = value;
+      }
+      return validatedData;
+    };
+
+		const validateUniqueFields = (record, data) => {
+			if(!model) return null;
+			if(!model['@rune.unique']) return null;
+
+			const uniqueFields = Object.keys(model['@rune.unique']);
+
+			return uniqueFields.find(
+				(field) => data.find(storedRecord => storedRecord[field] == record[field])
+			);
+		}
+
+    const applyFieldSelection = (record, select) => {
+			const newRecord = {...record};
+			if(exclude) for (const key of exclude) {
+				if (record[key]) delete newRecord[key];
+			}
+      if (!select) return newRecord;
+      const selectedRecord = {};
+      for (const key of Array.isArray(select) ? select : Object.keys(select)) {
+        if (record[key]) selectedRecord[key] = record[key];
+      }
+      return selectedRecord;
+    };
+
+		const insert = (record, fields) => {
+
+			if(Array.isArray(record)){
+				return record.map((item) => insert(item));
+			}
+
 			const mainData = readMainData();
 			if (!mainData.collections.includes(collectionName)) {
 				mainData.collections.push(collectionName);
@@ -123,20 +223,27 @@ const createDB = (dbName, dirname, dbData = {}, encryptionKey) => {
 			if (fs.existsSync(collectionFilePath)) {
 				data = readDataFile(collectionFilePath);
 			}
+			if(model){
+				record = validateFields(model, record);
+				const invalidUniqueFields = validateUniqueFields(record, data);
+				if(invalidUniqueFields){
+					throw new ReferenceError(`Duplicate value for field ${invalidUniqueFields}`);
+				}
+			}
 			const id = uuidv4();
 			record['@rune.id'] = generateID(id, collectionName);
 			data.push(record);
 			writeDataFile(collectionFilePath, data);
-			return record;
+			return applyFieldSelection(record, fields);
 		};
 
-		const read = (id, evaluate = true) => {
+		const read = (id, fields) => {
 			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 applyFieldSelection(evaluateRecord(record), fields);
 			}
 			return null;
 		};
@@ -168,34 +275,29 @@ const createDB = (dbName, dirname, dbData = {}, encryptionKey) => {
 			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 update = (caseRecord, newRecord, limit = 0, fields) => {
+			let updatedRecords = [];
 			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];
+			const validatedNewRecord = model ? validateFields(model, newRecord, true) : newRecord;
+			const invalidUniqueFields = validateUniqueFields(validatedNewRecord, data);
+			if(invalidUniqueFields){
+				throw new ReferenceError(`Duplicate value for field ${invalidUniqueFields}`);
+			}
+		
+			const matches = data.filter((record) => {
+				if (typeof caseRecord === 'string') {
+					return record['@rune.id'] === caseRecord;
+				} else if (typeof caseRecord === 'object') {
+					return Object.keys(caseRecord).every((key) => record[key] === caseRecord[key]);
+				}
+				return false;
+			});
+			if (matches.length === 0) return null;
+	
+			matches.forEach((oldRecord, index) => {
+				if(limit > 0 && updatedRecords.length > limit) return;
+				for (const key in validatedNewRecord) {
+					const value = validatedNewRecord[key];
 					if (value instanceof PushChange) {
 						if (!oldRecord[key] || !Array.isArray(oldRecord[key])) {
 							oldRecord[key] = [];
@@ -211,17 +313,17 @@ const createDB = (dbName, dirname, dbData = {}, encryptionKey) => {
 							});
 						}
 					} else {
-						oldRecord[key] = value;
+						oldRecord[key] = typeof value == "function" ? value(oldRecord, index) : value;
 					}
 				}
-				data[index] = oldRecord;
-				writeDataFile(collectionFilePath, data);
-				return data[index];
-			}
-			return null;
+				updatedRecords.push(applyFieldSelection(evaluateRecord(oldRecord), fields));
+			});
+			writeDataFile(collectionFilePath, data);
+		
+			return updatedRecords;		
 		};
 
-		const find = (criteria) => {
+		const find = (criteria, fields, limit = 0, index = 0) => {
 			if (typeof criteria == 'string') return read(criteria);
 			if (!criteria || typeof criteria !== 'object') return null;
 
@@ -230,19 +332,19 @@ const createDB = (dbName, dirname, dbData = {}, encryptionKey) => {
 
 			const data = readDataFile(collectionFilePath);
 			const record =
-				data.find((record) => {
+				data[limit > 0 || limit == -1 ? 'filter' : 'find']((record) => {
 					for (const key in criteria) {
 						if (record[key] !== criteria[key]) return false;
 					}
 					return true;
 				}) || null;
 			if (record) {
-				return evaluateRecord(record);
+				return Array.isArray(record) ? (limit > 0 ? record.slice(index, index + limit) : record).map(i => applyFieldSelection(evaluateRecord(i), fields)) : applyFieldSelection(evaluateRecord(record), fields);
 			}
 			return null;
 		};
 
-		const remove = (id) => {
+		const removeOne = (id) => {
 			if ('@rune.id' in id) id = id['@rune.id'];
 			let data = readDataFile(collectionFilePath);
 			const index = data.findIndex((record) => record['@rune.id'] === id);
@@ -254,10 +356,34 @@ const createDB = (dbName, dirname, dbData = {}, encryptionKey) => {
 			return false;
 		};
 
-		const list = () => {
+		const remove = (criteria, limit = Infinity) => {
+			let data = readDataFile(collectionFilePath);
+			let deletedCount = 0;
+			
+			const filteredData = data.filter((record, index) => {
+				if (deletedCount >= limit) return true;
+		
+				const matches = Object.keys(criteria).every((key) => typeof criteria[key] == 'function' ? criteria[key](record[key], record, index) : record[key] === criteria[key]);
+				if (matches) {
+					deletedCount++;
+					return false;
+				}
+		
+				return true;
+			});
+		
+			if (deletedCount === 0) return false;
+
+			writeDataFile(collectionFilePath, filteredData);
+		
+			return true;
+		};
+		
+
+		const list = (fields) => {
 			if (!fs.existsSync(collectionFilePath)) return [];
 			const data = readDataFile(collectionFilePath);
-			return data.map((rec) => evaluateRecord(rec));
+			return data.map((rec) => applyFieldSelection(evaluateRecord(rec), fields));
 		};
 
 		const map = (cb, mutate = false) => {
@@ -296,6 +422,10 @@ const createDB = (dbName, dirname, dbData = {}, encryptionKey) => {
 			return sortedData;
 		};
 
+		const empty = () => {
+			writeDataFile(collectionFilePath, []);
+		}
+
 		if (!fs.existsSync(collectionFilePath)) writeDataFile(collectionFilePath, []);
 
 		return {
@@ -303,12 +433,14 @@ const createDB = (dbName, dirname, dbData = {}, encryptionKey) => {
 			read,
 			update,
 			remove,
+			removeOne,
 			find,
 			map,
 			transform,
 			filter,
 			sort,
 			list,
+			empty
 		};
 	};
 
@@ -387,9 +519,11 @@ const createDB = (dbName, dirname, dbData = {}, encryptionKey) => {
 		return { set, get, remove, list, transform };
 	};
 
+	collection.type = coltypedef;
+
 	readMainData();
 
-	return { setData, getData, collection, findRef, makeRef, map };
+	return new RuneDB({ setData, getData, collection, findRef, makeRef, map });
 };
 
 module.exports = (context) => ({

package/lib/rew/pkgs/rune.schema.js

@@ -0,0 +1,94 @@
+const { typeis } = require("../const/default");
+const RuneDB = require("./modules/rune/db");
+
+
+
+module.exports = (context) => ({
+  schema(runeDB) {
+    if (!runeDB) throw new ReferenceError('You should pass a rune database for the schema.');
+    if (!(runeDB instanceof RuneDB)) throw new TypeError('First argument is not a Rune database.');
+
+    const models = {};
+
+    const validateFields = (definition, data) => {
+      const validatedData = {};
+      for (const [field, type] of Object.entries(definition)) {
+        if (data[field] === undefined) continue;
+        const value = data[field];
+        if (!typeis(value, type) && value != type) {
+          throw new TypeError(`Invalid type for field "${field}". Expected ${
+            type?.type?.type || type?.type || type
+          }, got ${typeof value}`);
+        }
+        validatedData[field] = value;
+      }
+      return validatedData;
+    };
+
+    const applyFieldSelection = (record, select) => {
+      if (!select) return record;
+      if (Array.isArray(select)) select = Object.fromEntries(select.map(i => [i, true]));
+      const selectedRecord = {};
+      for (const key of Object.keys(select)) {
+        if (select[key]) selectedRecord[key] = record[key];
+      }
+      return selectedRecord;
+    };
+
+    return {
+      model(modelName, definition, options = {}) {
+        if (models[modelName]) throw new Error(`Model "${modelName}" is already defined.`);
+
+        const collection = runeDB.collection(modelName);
+
+        const modelAPI = {
+          create(record) {
+            const validatedRecord = validateFields(definition, record);
+            return collection.insert(validatedRecord);
+          },
+
+          findUnique(id, select) {
+            const record = collection.read(id);
+            if (!record) return null;
+
+            let finalRecord = record;
+            return applyFieldSelection(finalRecord, select);
+          },
+
+          findMany(where, select, cursor, count = 0) {
+            
+            const records = collection.find(where, count == 0 ? -1 : count, cursor);
+
+            return select
+              ? records.map((record) => applyFieldSelection(record, select))
+              : records;
+          },
+
+          update(identifier, updates, limit) {
+            return collection.update(identifier, updates, limit);
+          },
+
+          delete(identifier, limit) {
+            return collection.remove(identifier, limit);
+          },
+
+          list() {
+            return collection.list();
+          },
+
+          empty(){
+            return collection.empty();
+          }
+        };
+
+        models[modelName] = modelAPI;
+        return modelAPI;
+      },
+
+      useModel(modelName) {
+        if (!models[modelName]) throw new Error(`Model "${modelName}" is not defined.`);
+        return models[modelName];
+      },
+    };
+  },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makano/rew",
-  "version": "1.5.5",
+  "version": "1.5.8",
   "description": "A simple coffescript runtime and app manager",
   "main": "main.js",
   "directories": {