@makano/rew 1.5.4 → 1.5.7

package/lib/rew/const/default.js

@@ -6,7 +6,7 @@ const sleep = require('../functions/sleep');
 const { match } = require('../functions/match');
 const { map } = require('../functions/map');
 const { typex, typeis, typedef, typei, int, float, num, str, bool, typef } = require('../functions/types');
-const { isEmpty, clone, deepClone, merge, uniqueId, compose, curry, getters, setters, deepMerge } = require('../functions/core');
+const { isEmpty, clone, deepClone, merge, uniqueId, compose, curry, getters, setters, deepMerge, randFrom, pickRandom } = require('../functions/core');
 const { print, input, clear, printf } = require('../functions/stdout');
 const { curl } = require('../functions/curl');
 const { wait } = require('../functions/wait');
@@ -64,4 +64,7 @@ module.exports = {
 	print,
 	printf,
 	input,
+
+	randFrom,
+	pickRandom
 };

package/lib/rew/functions/core.js

@@ -114,7 +114,23 @@ function setters(object, setters) {
 				configurable: true
 			});
 		}
-	}
+	}	
+}
+
+function withOut(object, ...keys){
+	let o = {...object};
+	for(let key of keys) delete o[key];
+	return o;
+}
+
+function randFrom(min,max) {
+  return Math.floor(Math.random()*(max-min+1)+min);
+}
+
+function pickRandom(...stuff){
+	return stuff[
+		randFrom(0, stuff.length - 1)
+	];
 }
 
 module.exports = {
@@ -129,5 +145,8 @@ module.exports = {
 	compose,
 	curry,
 	getters,
-	setters
+	setters,
+	withOut,
+	randFrom,
+	pickRandom
 };

package/lib/rew/functions/curl.js

@@ -10,7 +10,7 @@ module.exports.curl = function curl(options, url){
   if(options.url && !url){
     url = options.url
   }
-  const method = options.x || "GET";
+  const method = options.x || options.method || "GET";
   const f = future.promise(fetch(url, {
     ...options,
     method

package/lib/rew/functions/import.js

@@ -20,7 +20,7 @@ module.exports.cleanCache = () => {
 	while(cachedFiles.length) cachedFiles.pop();
 };
 const lookUpInOtherApps = (fullPath) => {
-	straceLog('===> WARN: LOOKUP SLOWS PROCESS');
+	straceLog('===> WARN: Lookup slows process');
 	const con = conf({});
 	const name = fullPath.indexOf('/') ? fullPath.split('/')[0] : fullPath;
 	let dpath = fullPath.indexOf('/') ? fullPath.split('/')[1] : '';
@@ -41,7 +41,7 @@ const lookUpInOtherApps = (fullPath) => {
 };
 
 module.exports.imp = function (runPath, context) {
-	return function (filename, options = {}) {
+	return function (filename, options = {}, defaultMode) {
 		if (!options) options = {};
 		if(filename == 'std' || filename == '#std') return {};
 		let type = options.type ? options.type : filename.endsWith('.coffee') ? 'coffee' : (
@@ -51,10 +51,10 @@ module.exports.imp = function (runPath, context) {
 		let exports,
 			ispkg = findPackage(filename);
 
-		straceLog('IMPORT for', filename, 'as', type);
+		straceLog('import file', '"' + filename + '"', 'as type', type);
 
 		if (filename.startsWith('@') && context.app) {
-			straceLog('===> FROM APP ROOT');
+			straceLog('===> from app root');
 			filename = filename.replace('@', context.app.path);
 		}
 
@@ -62,7 +62,7 @@ module.exports.imp = function (runPath, context) {
 		if(path.extname(filepath) == '.qrew') options.qrew = true;
 
 		const lookUp = () => {
-			straceLog('===> LOOKUP()');
+			straceLog('===> lookUp()');
 			const otherPath = lookUpInOtherApps(filename);
 			if (!otherPath) throw new Error('Module "' + filename + '" not found');
 			else filepath = otherPath;
@@ -80,7 +80,7 @@ module.exports.imp = function (runPath, context) {
 					typeof ext == 'string' ? existsSync(filepath + ext) : existsSync(filepath + (ext.ext || '')),
 				);
 				if (resolve) {
-					straceLog('===> RESOLVE()');
+					straceLog('===> resolve()');
 					filepath += typeof resolve == 'string' ? resolve : resolve.ext;
 					if (typeof resolve == 'object' && resolve.options) {
 						if (resolve.options.type) type = resolve.options.type;
@@ -91,7 +91,7 @@ module.exports.imp = function (runPath, context) {
 		}
 
 		const exec = (coptions = {}) => {
-			straceLog('===> EXECUTE() IMPORTFILE');
+			straceLog('===> execute(importFile)');
 			const r = runPath(
 				filepath,
 				{
@@ -113,7 +113,7 @@ module.exports.imp = function (runPath, context) {
 		}
 
 		if (ispkg) {
-			straceLog('===> FIND_PACKAGE()');
+			straceLog('===> findPackage()');
 			const pkg = getPackage(filename)(context, options);
 			exports = pkg._onImport ? pkg._onImport() : pkg;
 			if(options.useDefaultForPackages) exports = { default: exports };
@@ -124,10 +124,10 @@ module.exports.imp = function (runPath, context) {
 		} else if (type == 'js') {
 			exports = exec({ compile: false });
 		} else if (type == 'yaml' || type == 'json' || type == 'text') {
-			straceLog('===> GET_RAW_FILE()');
+			straceLog('===> getRawFile()');
 			const f = getFile(filepath);
 			if (type == 'yaml') {
-				straceLog('===> FROM_YAML()');
+				straceLog('===> fromYaml()');
 				exports = _returns(options, importYaml(f.path, f));
 			} else if (type == 'json') {
 				straceLog('===>');
@@ -137,7 +137,7 @@ module.exports.imp = function (runPath, context) {
 					exports = _returns(options, {});
 				}
 			} else {
-				straceLog('===> FROM_TEXT');
+				straceLog('===> fromText()');
 				exports = _returns(options, f.content);
 			}
 		}
@@ -168,6 +168,9 @@ module.exports.imp = function (runPath, context) {
 		/**/ if(options.mock === null) return null;
 		//** 
 
+		//**  Return defaults
+		/**/  if(defaultMode !== true && exports?.default) exports = exports.default;
+
 		return exports;
 	};
 };

package/lib/rew/functions/json.js

@@ -1,4 +1,5 @@
 const jsYaml = require("js-yaml");
+const { yamlFile } = require("../modules/yaml");
 
 
 
@@ -11,8 +12,11 @@ function jsons(thing){
 }
 
 
-function yaml(thing){
-  return jsYaml.loadAll(thing)[0];
+function yaml(thing, ...schema){
+  return yamlFile({
+    content: thing,
+    path: ''
+  }, schema);
 }
 
 function yamls(thing){

package/lib/rew/misc/findAppInfo.js

@@ -6,11 +6,11 @@ const { straceLog } = require('./strace');
 
 module.exports.findAppInfo = function (filepath) {
 	const appPath = findAppPath(path.dirname(filepath));
-	straceLog('FINDAPPINFO() for', filepath);
+	straceLog('findAppInfo() for', filepath);
 	if (appPath) {
 		const config = jsYaml.load(readFileSync(path.join(appPath, 'app.yaml')));
-		straceLog('==> FOUND CONFIG AT', appPath);
-		straceLog('==> APP PACKAGE', config?.manifest?.package);
+		straceLog('==> INFO Found config at:', '"' + appPath + '"');
+		straceLog('==> INFO App Package:', '"' + config?.manifest?.package + '"');
 		return {
 			path: appPath,
 			config,

package/lib/rew/misc/findAppPath.js

@@ -3,23 +3,19 @@ const fs = require('fs'); // Import the 'path' module
 const { straceLog } = require('./strace');
 
 module.exports.findAppPath = (currentDir = __dirname) => {
-	// Check if app.yaml exists in the current directory
-	straceLog('FINDAPP() for', currentDir);
+	straceLog('findApp() for', '"' + currentDir + '"');
 	const appYamlPath = path.join(currentDir, 'app.yaml');
 	if (fs.existsSync(appYamlPath)) {
 
-		straceLog('==> FOUND PATH', appYamlPath);
+		straceLog('==> INFO found path', `"${appYamlPath}"`);
 		return currentDir;
 	}
 
-	// If not found, move up a directory level
 	const parentDir = path.dirname(currentDir);
 
-	// Check if we reached the root directory
 	if (parentDir === currentDir) {
-		return null; // Not found
+		return null;
 	}
 
-	// Recursively call the function on the parent directory
 	return module.exports.findAppPath(parentDir);
 };

package/lib/rew/misc/strace.js

@@ -1,5 +1,5 @@
 module.exports.straceLog = function(...logs){
   if(process.straceMode){
-		console.log(`[${new Date().getHours()}:${new Date().getMinutes()}:${new Date().getSeconds()} ${new Date().getDate()}/${new Date().getMonth()}/${new Date().getFullYear()}] [${process.pid}]`, ...logs);
+		console.log(`[${new Date().toLocaleTimeString()} ${new Date().getDate()}/${new Date().getMonth()}/${new Date().getFullYear()}] [${process.pid}]`, ...logs.map(i => i.replace(/^([=>]+)/, '\x1b[34m$1\x1b[39m').replace(/WARN:/g, '\x1b[30m\x1b[43m WARN \x1b[39m\x1b[49m').replace(/INFO/g, '\x1b[30m\x1b[44m INFO \x1b[39m\x1b[49m').replace(/^"(.+)"$/, '\x1b[32m$1\x1b[39m').replace(/!([A-Z-+]+)/, (_, a) => `\x1b[30m\x1b[4${a.startsWith('-') ? '5' : a.startsWith('+') ? '6' : '2'}m ${a.replace(/^[-+]/, '')} \x1b[39m\x1b[49m`)));
 	}
 }

package/lib/rew/modules/compiler.js

@@ -137,15 +137,15 @@ const fnextToken = (i, tokens, type, value) => {
 function declareAlias(aliases, token) {
   const regex = /^#declare(\*)?\s+(\w+)\s+"([^"]+)"\s*=\s*([\s\S]*);$/;
   const match = token.value.trim().match(regex);
-	straceLog('DECLARECASE()');
-	straceLog('==> EXPERIMENTAL FEATURE DETECTED');
+	straceLog('declareCase()');
+	straceLog('==> WARN: Experimental feature detected');
 
   if (match) {
     const isPublic = !!match[1];
     const type = match[2] == "key" ? 'IDENTIFIER' : match[2];
     let name = match[3];
     let value = match[4].trim();
-		straceLog('==> DECLARE', name, 'as', value);
+		straceLog('==> INFO !DECLARE', name, 'as', value);
 
     let aliasValue = value.startsWith('${')
       ? new Function('token', 'tokens', 'code', 'hooks', 'index', 'setIndex', value.slice(2, -1))
@@ -210,7 +210,7 @@ function declareAlias(aliases, token) {
     aliases[type][name] = aliasValue;
 
 		if(isPublic){
-			straceLog('==>', 'DECLARATION GLOBALIZED');
+			straceLog('==>', 'INFO Declaration Globalized');
 			execOptions._syntaxAliases[type] = execOptions._syntaxAliases[type] || {};
 			execOptions._syntaxAliases[type][name] = aliasValue;
 		}
@@ -234,11 +234,11 @@ const stdTypes = (isPublic) => {
 	return r;
 };
 const includeFile = (includeContent, options) => {
-	straceLog('INCLUDE()', includeContent);
+	straceLog('include()', includeContent);
 	const dontInclude = includeContent.startsWith('*');
 	if(dontInclude) {
 		includeContent = includeContent.slice(1);
-		straceLog('==> IGNORING OUTPUT', includeContent);
+		straceLog('==> INFO ingoring output', includeContent);
 	};
 	const fp = path.resolve(path.dirname(options.filename || ''), includeContent);
 	let packageName = options.filename ? (existsSync(fp) ? fp : includeContent) : includeContent;
@@ -257,13 +257,13 @@ const includeFile = (includeContent, options) => {
 	if(packageName == 'std'){
 		r = _inc(stdTypes(dontInclude), true);
 	} else if (existsSync(packageName)) {
-		straceLog('==> INCLUDE FILE', packageName);
+		straceLog('==> includeFile(', '"'+packageName+'"', ')');
 		r = _inc(packageName);
 	} else {
 		const packageName = includeContent.match('/') ? includeContent.split('/')[0] : includeContent;
 		const headerFile = includeContent.match('/') ? includeContent.replace(packageName+'/', '') : 'main.h.coffee';
 		const pathname = path.join(CONFIG_PATH, packageName, 'app', headerFile);
-		straceLog('==> INCLUDE PACKAGE', packageName);
+		straceLog('==> includePackage(', '"'+packageName+'"');
 		if(existsSync(pathname)) r = _inc(pathname);
 	}
 	if(dontInclude){
@@ -277,12 +277,12 @@ function useImp(token, options){
 		token.value.startsWith('"#') ||
 		token.value.startsWith("'#")
 	)){
-		straceLog('==> IMP Uses HEADER');
+		straceLog('==> INFO imp() Uses HEADER');
 		const dem = token.value.slice(0, 1);
 		const value = token.value.slice(1, -1);
 		let packageName = value.slice(1);
 		token.value = dem+packageName+dem;
-		straceLog('IMP() with HEADER for', packageName);
+		straceLog('imp() with header for', `"${packageName}"`);
 		return includeFile(packageName !== 'std' ? packageName : '*'+packageName, options); 
 	}
 	return '';
@@ -344,7 +344,7 @@ function insertAt(array, index, ...values) {
 }
 
 function compileRewStuff(content, options) {
-	straceLog('TOKENIZE() for CURRENTFILE');
+	straceLog('tokeinze(currentFile)');
 	const tokens = tokenizeCoffeeScript(content);
 	let result = '';
   let multilineDeclareBuffer = [];
@@ -360,11 +360,16 @@ function compileRewStuff(content, options) {
 	for (let i = 0; i < tokens.length; i++) {
 		const token = tokens[i];
 		let { token: nextToken, n } = gnextToken(i, 1, tokens) || {};
+		let { token: prevToken } = gnextToken(i, -2, tokens) || {};
 
 		if(token.type == "COMMENT" && i < 2 && token.value.startsWith('#!')){
 			continue;
 		}
 
+		if(token.type == "IDENTIFIER" && token.value == "fn" && i < 2 && prevToken?.value !== "." && nextToken?.type === "IDENTIFIER"){
+			token.value = "function";
+		}
+
     if ((token.type === "COMMENT" && multilineDeclare) || (token.type !== "COMMENT" && multilineDeclare)) {
       if(token.type === "COMMENT"){
 				multilineDeclareBuffer.push(token.value.startsWith('###') ? token.value.slice(3) : token.value.slice(1));
@@ -412,17 +417,17 @@ function compileRewStuff(content, options) {
 		
 		if (token.type === 'COMMENT' && token.value.slice(1).trim().startsWith('@jsx')) {
 			options.jsx = true;
-			straceLog('JSX() ENABLE WITH COMMENTS');
+			straceLog('jsx().with(comments)');
 			if(token.value.split('@jsx')[1].trim()){
 				options.jsxPragma = token.value.split('@jsx')[1].trim();
-				straceLog('JSX() PRAGMA WITH', options.jsxPragma);
+				straceLog('jsx().withPragma(', `"${options.jsxPragma}"`, ')');
 			}
 		}
 		
     if (token.type === 'COMMENT' && token.value.slice(1).trim() === '@cls') {
 			options.cls = true;
-			straceLog('CLI_SYNTAX() ENABLE');
-			straceLog('===> HIGHLY EXPERIMENTAL FEATURE DETECTED');
+			straceLog('cliSyntax::enable()');
+			straceLog('===> WARN: HIGHLY EXPERIMENTAL FEATURE DETECTED');
 		}
 
     if (options.cls && token.type === 'OTHER' && token.value === '-' && nextToken.value == '-' && tokens[i-1]?.type == 'WHITESPACE') {
@@ -442,12 +447,12 @@ function compileRewStuff(content, options) {
 
 		if (tokens[i-1]?.value !== '.' && token.type === 'IDENTIFIER' && token.value === 'export' && !options.keepImports) {
 			token.value = 'pub';
-			straceLog('EXPORT() => TRANSLATING TO pub');
+			straceLog('INFO !TRANSLATE converting export to pub');
 		}
 		
 		if (tokens[i-1]?.value !== '.' && token.type === 'IDENTIFIER' && token.value === 'package' && nextToken.type == 'STRING') {
 			token.value = 'appPackage';
-			straceLog('APP_PACKAGE_CHANGE()');
+			straceLog('changeAppPackage()');
 		}
 
 		if (
@@ -465,7 +470,7 @@ function compileRewStuff(content, options) {
 		}
 
 		if (tokens[i-1]?.value !== '.' && token.type === 'IDENTIFIER' && token.value === 'using' && !options.disableUse) {
-			straceLog('USING()');
+			straceLog('!+DIRECTIVE using()');
 			const next = nextToken?.value;
 			if(next in USING_DEFAULT) {
 				const { use } = USING_DEFAULT[next];
@@ -475,7 +480,7 @@ function compileRewStuff(content, options) {
 
 				const { token: nextNextToken } = gnextToken(i, 3, tokens) || {};
 				if(nextNextToken.value == "as") nextNextToken.value = ",";
-			} else straceLog('==> UNKNOWN');
+			} else straceLog('==> !-UNKNOWN');
 		}
 
 		if (token.type === 'IDENTIFIER' && token.value === 'as' && !options.keepImports) {
@@ -493,15 +498,15 @@ function compileRewStuff(content, options) {
 
 		if (tokens[i-1]?.value !== '.' && token.type === 'IDENTIFIER' && token.value === 'import' && !options.keepImports) {
 			// console.log(nextToken.type);
-			straceLog('IMPORT()');
-			straceLog('==> WARN: SLOWS DOWN COMPILATION');
+			straceLog('import()');
+			straceLog('==> WARN: Slows compilation');
 			let ind = i + n + 2;
 			let isAs = false;
 			let usedDefault = false;
 
 			let defaultName;
 			if (nextToken.type === 'STRING') {
-				straceLog('==> SIMPLE');
+				straceLog('==> !SIMPLE');
 				if(useImp(nextToken, options)) updateAliases(aliases);
 				result += `inc ${nextToken.value}`;
 				i += n;
@@ -538,7 +543,7 @@ function compileRewStuff(content, options) {
 						.filter((t, i, arr) => !arr[i+1]?.match(':') && !arr[i-1]?.match(':'))
 						.join(', ');
 					
-					straceLog('==>', exports, 'from', nameToken.value);
+					straceLog('==> !COMPLEX', exports, 'from', nameToken.value);
 
 					if(useImp(nameToken, options)) updateAliases(aliases);
 					result += `{ ${exports} } ${options.type == 'coffee' ? '=' : ':='} inc ${nameToken.value}`;
@@ -550,7 +555,7 @@ function compileRewStuff(content, options) {
 					const nameToken = fnextToken(asToken.ti, tokens, 'STRING');
 					const nextToken = fnextToken(asToken.ti + 1, tokens, 'IDENTIFIER');
 					defaultName = nextToken.value;
-					straceLog('==>', defaultName, 'from', nameToken.value);
+					straceLog('==> !COMPLEX', defaultName, 'from', nameToken.value);
 					if(useImp(nameToken, options)) updateAliases(aliases);
 					result += `${defaultName} ${options.type == 'coffee' ? '=' : ':='} inc ${nameToken.value}`;
 					i = ind + 6;
@@ -570,7 +575,7 @@ function compileRewStuff(content, options) {
 							.flat(1)
 							.filter((t, i, arr) => !arr[i+1]?.match(':') && !arr[i-1]?.match(':'))
 							.join(', ');
-						straceLog('==>', defaultName, 'and', exports, 'from', nameToken.value);
+						straceLog('==> !COMPLEX', defaultName, 'and', exports, 'from', nameToken.value);
 						if(useImp(nameToken, options)) updateAliases(aliases);
 						result += `{ default: ${defaultName}, ${exports} } ${options.type == 'coffee' ? '=' : ':='} inc ${nameToken?.value || ''}`;
 						i = closingBraceToken.ti + 4;
@@ -589,7 +594,7 @@ function compileRewStuff(content, options) {
 			if (nextLastToken?.value == 'assert') {
 				result += ', ';
 				const assertionToken = gnextToken(nextLastToken.ti, 2, tokens);
-				straceLog('==> ASSERT', assertionToken);
+				straceLog('==> !ASSERT', assertionToken);
 				if(assertionToken.token.type == 'OTHER' && assertionToken.token.value == '{'){
 					hooks.push({
 						index: assertionToken.token.ti,
@@ -607,7 +612,7 @@ function compileRewStuff(content, options) {
 		}
 
 		if (tokens[i-1]?.value !== '.' && token.type === 'IDENTIFIER' && (token.value === 'imp' || token.value === 'inc')) {
-			straceLog('IMP() Detected');
+			straceLog('!+DIRECTIVE imp()');
 			let { token: t1 } = gnextToken(i, 1, tokens) || {};
 			let { token: t2 } = gnextToken(i, 2, tokens) || {};
 			let r = '';
@@ -634,7 +639,7 @@ function compileRewStuff(content, options) {
 			nextToken.value &&
 			nextToken.value !== 'undefined' && !options.keepImports
 		) {
-			straceLog('PUB() Detected');
+			straceLog('!+DIRECTIVE pub()');
 			let next = {...nextToken}, isClass = false;
 			if(next.value == 'default'){
 				i += 2;
@@ -643,7 +648,14 @@ function compileRewStuff(content, options) {
 				next.value = gnextToken(i, n + 1, tokens)?.token.value || "default";
 				isClass = true;
 			}
-			straceLog('==> PUBLIC', next.value);
+			if(next.value == 'fn' || next.value == 'function'){
+				next.value = gnextToken(i, n + 1, tokens)?.token.value || "default";
+				isClass = true;
+				if(nextToken && nextToken.value == "fn"){
+					nextToken.value = "function";
+				}
+			}
+			straceLog('==> !PUBLIC', next.value);
 			hooks.push({
 				index: i + 1,
 				value: `"${next.value}", ${isClass ? `${next.value} = ` : ''}`,
@@ -653,13 +665,13 @@ function compileRewStuff(content, options) {
 		const aliasType = aliases[token.type];
 		// if(token.value == 'sidewest') console.log(aliases, token.value, token.type);
     if (aliasType && Object.keys(aliasType).includes(token.value)) {
-			straceLog('ALIAS()', token.type);
+			straceLog('!+DIRECTIVE alias()', token.type);
       const aliasValue = aliasType[token.value];
       if (typeof aliasValue === 'function') {
-				straceLog('==> EXECUTE ALIAS', token.value);
+				straceLog('==> INFO Execute alias:', token.value);
         result += aliasValue(token, tokens, result, hooks, i, (n) => i = n) || "";
       } else {
-				straceLog('==> LITERAL ALIAS', token.value);
+				straceLog('==> INFO Literal alias:', token.value);
         result += aliasValue;
       }
       continue;
@@ -697,12 +709,12 @@ function compileRewStuff(content, options) {
 }
 
 const compileCivetStuff = (file, options) => {
-	straceLog('COMPILE_CIVET() for CURRENTFILE');
+	straceLog('compileCivet(currentFile)');
 	const preCompileOptions = {
 		filename: file.path,
 		...options
 	};
-	straceLog('OPTION_PREPARE() for CURRENTFILE as', JSON.stringify(preCompileOptions));
+	straceLog('prepareOptions(currentFile).as(', `"${JSON.stringify(preCompileOptions)}"`, ')');
 	
 	if(options?.type == 'js' || file?.path?.endsWith('.js')){
 		return {
@@ -724,7 +736,7 @@ const compileCivetStuff = (file, options) => {
 	};
 
 	let compiled = options.async ? compileCivet(prepared, compileOptions) : wait(compileCivet, prepared, compileOptions);
-	straceLog('==> CIVET COMPILE <>');
+	straceLog('==> !COMPILER civetCompile(fileContent)');
 
 	return {
 		compiled,
@@ -745,10 +757,10 @@ const cpl = (module.exports.compile = function (file, options = {}) {
 	compiledCode = result.compiled;
 
 	const babelify = (code, options) => {
-		straceLog('BABEL()');
-		if(doJSX) straceLog('==> WITH JSX');
-		if(doTypes) straceLog('==> WITH TYPES');
-		if(doDecorators) straceLog('==> WITH DECORATORS');
+		straceLog('!COMPILER babel()');
+		if(doJSX) straceLog('==> INFO !-WITH JSX');
+		if(doTypes) straceLog('==> INFO !-WITH Types');
+		if(doDecorators) straceLog('==> INFO !-WITH DECORATORS');
 		return babel.transformSync(code, {
 			presets: [
 				...(doJSX ? [[babelReact, { throwIfNamespace: false, pragmaFrag: options.jsxPragmaFrag || execOptions.jsxPragmaFrag, pragma: options.jsxPragma || execOptions.jsxPragma }]] : [])
@@ -782,7 +794,7 @@ const cpl = (module.exports.compile = function (file, options = {}) {
 });
 
 module.exports.compileFile = function (filepath, options = {}) {
-	straceLog('COMPILE() for CURRENTFILE');
+	straceLog('compile(currentFile)');
 	const f = typeof filepath == "object" ? filepath : getFile(filepath);
 	if(typeof filepath == "object") filepath = filepath.path;
 	let qrew = false;
@@ -791,13 +803,13 @@ module.exports.compileFile = function (filepath, options = {}) {
 		qrew = true
 		f.content = from_qrew(readFileSync(f.path), options.package || findAppInfo(filepath)?.config.manifest.package || path.basename(filepath).split('.').slice(0, -1).join('.')).toString();
 		options.type = f.content.split('\n')[0]?.match(/"initFile (.+)"/)?.[1]?.split('.').pop();
-		straceLog('QREW_DECODE() as', options.type, 'for CURRENTFILE');
+		straceLog('decodeCrew(currentFile).as(', `"${options.type}"`,')');
 	}
 
 	let compiled_code =  cpl(f, { ...options });
 
 	if(options.onlyCompile && !qrew){
-		straceLog('WRITE_AND_QUIT() for COMPILEDATA');
+		straceLog('writeAndQuit(compileData)');
 		if(compiled_code instanceof Promise){
 			compiled_code.then((r) => {
 				console.log(r);

package/lib/rew/modules/context.js

@@ -25,7 +25,7 @@ module.exports.prepareContext = function (
   filepath = "",
   runPath = () => {},
 ) {
-  straceLog('PREPARE() NEW CONTEXT');
+  straceLog('!-NEW context()');
   if (mainFile == "") mainFile = filepath;
   /** @type {Record<string, any>} */
   let context = {
@@ -82,7 +82,7 @@ module.exports.prepareContext = function (
           this['@cb'] = cb;
         }
       });
-    }, out: {...process.stdout, cols: process.stdout.columns, rows: process.stdout.rows, put: (...logs) => context.print(...logs), strace: (...logs) => straceLog('==> STRACE_OUT():', ...logs  ), write: (logs) => context.printf(logs+'\n') }, in: {...process.stdin, read: (...args) => context.input(...args)}, define: (name, object) => {
+    }, out: {...process.stdout, cols: process.stdout.columns, rows: process.stdout.rows, put: (...logs) => context.print(...logs), strace: (...logs) => straceLog('==> !+OUT straceOut(): ', ...logs  ), write: (logs) => context.printf(logs+'\n') }, in: {...process.stdin, read: (...args) => context.input(...args)}, define: (name, object) => {
       if(Array.isArray(name) && name.length == 2 && typeof name[0] == 'string'){
         object = name[1];
         name = name[0];
@@ -216,7 +216,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;
@@ -242,14 +242,14 @@ module.exports.prepareContext = function (
   if(context.app?.config?.exec?.['auto import']){
     const autoipath = path.join(context.app.path, context.app.config?.exec?.['auto import']);
     if(autoipath !== filepath){
-      straceLog('==> AUTOIMPORT()', autoipath);
+      straceLog('==> !ACTION autoImport()', autoipath);
       const all = context.imp(path.relative(path.dirname(filepath), autoipath));
       for(let i in all) context[i] = all[i];
     }
   }
 
   if(!context.app){
-    straceLog('==> APP NOT FOUND');
+    straceLog('==> WARN: App not found');
     context.appPackage = (packageName) => context.app = { config: { manifest: { package: packageName } } }
   } else {
     context.appPackage = context.mod = (packageName) => context.module.modset = packageName;
@@ -265,7 +265,7 @@ module.exports.prepareContext = function (
     context.module.main ||
     (options.fromMain == true && options.as == "main")
   ) {
-    straceLog('==> RUNTIME() as MAIN for', filepath);
+    straceLog('==> !MAIN', filepath);
     context.opt = {
       set: (key, value) => (execOptions[key] = value),
       get: (key) => execOptions[key],

package/lib/rew/modules/runtime.js

@@ -21,17 +21,17 @@ module.exports.runPath = function runPath(filepath, options = {}, custom_context
 	if(filepath.endsWith('.coffee')) options.type = 'coffee';
 	if(filepath.endsWith('.qrew')) options.type = 'qrew';
 
-	straceLog('RUN() CURRENTFILE = ', filepath, 'as', options.type || 'UNKNOWN');
+	straceLog('!+DECLARE currentFile =', filepath, 'as', options.type || '!UNKNOWN');
 
 	if(options.import?.async) options.async = true;
-	if(options.async) straceLog('ASYNCMODE() for CURRENTFILE');
+	if(options.async) straceLog('==> !ASYNCMODE currentFile::async()');
 	let { compiled_code, file } = compileFile(options.code ? { content: options.code, path: filepath } : filepath, options);
-	straceLog('COMPILE_DONE() with COMPILEDATA');
+	straceLog('==> INFO Compile done with compileData');
 	// context.module.compiled = compiled_code;
 	// context.process.exit = (int) => process.exit(int);
 
 	const doCode = () => {
-		straceLog('RUNCODE() COMPILEDATA');
+		straceLog('runCode(compileData)');
 		const context = options.import?.takeThisContext ? custom_context : prepareContext(custom_context, options, file.path, runPath);
 	
 		if(context.app){
@@ -51,6 +51,7 @@ module.exports.runPath = function runPath(filepath, options = {}, custom_context
 		let execd = exec(compiled_code, context, file.content);
 
 		if(context.module.main && (context.module.exports?.main || (typeof context.module.exports == "function" && context.module.exports.name == 'main'))){
+			straceLog('call(currentFile::mainFn)');
 			const mainFn = context.module.exports.main ?? context.module.exports;
 			let ctx = context;
 			if(mainFn._class){

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.4",
+  "version": "1.5.7",
   "description": "A simple coffescript runtime and app manager",
   "main": "main.js",
   "directories": {