// Copyright 2012-2018 (c) Peter Širka <petersirka@gmail.com>

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the

// "Software"), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to permit

// persons to whom the Software is furnished to do so, subject to the

// following conditions:

//

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

// USE OR OTHER DEALINGS IN THE SOFTWARE.

/**

* @module Framework

* @version 3.0.0

*/

'use strict';

const Qs = require('querystring');

const Os = require('os');

const Fs = require('fs');

const Zlib = require('zlib');

const Path = require('path');

const Crypto = require('crypto');

const Parser = require('url');

const Child = require('child_process');

const Util = require('util');

const http = require('http');

const ENCODING = 'utf8';

const HEADER_CACHE = 'Cache-Control';

const HEADER_TYPE = 'Content-Type';

const HEADER_LENGTH = 'Content-Length';

const CT_TEXT = 'text/plain';

const CT_HTML = 'text/html';

const CT_JSON = 'application/json';

const COMPRESSION = { 'text/plain': true, 'text/javascript': true, 'text/css': true, 'text/jsx': true, 'application/javascript': true, 'application/x-javascript': true, 'application/json': true, 'text/xml': true, 'image/svg+xml': true, 'text/x-markdown': true, 'text/html': true };

const COMPRESSIONSPECIAL = { 'js': 1, 'css': 1 };

const REG_TEMPORARY = /\//g;

const REG_MOBILE = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini|Mobile|Tablet/i;

const REG_ROBOT = /search|agent|bot|crawler|spider/i;

const REG_VERSIONS = /(href|src)="[a-zA-Z0-9/:\-.]+\.(jpg|js|css|png|apng|gif|svg|html|ico|json|less|sass|scss|swf|txt|webp|heif|heic|jpeg|woff|woff2|xls|xlsx|xml|xsl|xslt|zip|rar|csv|doc|docx|eps|gzip|jpe|jpeg|manifest|mov|mp3|flac|mp4|ogg|package|pdf)"/gi;

const REG_COMPILECSS = /url\(.*?\)/g;

const REG_ROUTESTATIC = /^(\/\/|https:|http:)+/;

const REG_NEWIMPL = /^(async\s)?function(\s)?([a-zA-Z$][a-zA-Z0-9$]+)?(\s)?\([a-zA-Z0-9$]+\)|^function anonymous\(\$/;

const REG_RANGE = /bytes=/;

const REG_EMPTY = /\s/g;

const REG_ACCEPTCLEANER = /\s|\./g;

const REG_SANITIZE_BACKSLASH = /\/\//g;

const REG_WEBSOCKET_ERROR = /ECONNRESET|EHOSTUNREACH|EPIPE|is closed/i;

const REG_WINDOWSPATH = /\\/g;

const REG_SCRIPTCONTENT = /<|>|;/;

const REG_HTTPHTTPS = /^(\/)?(http|https):\/\//i;

const REG_NOCOMPRESS = /[.|-]+min(@[a-z0-9]*)?\.(css|js)$/i;

const REG_TEXTAPPLICATION = /text|application/;

const REG_ENCODINGCLEANER = /[;\s]charset=utf-8/g;

const REG_SKIPERROR = /epipe|invalid\sdistance/i;

const REG_UTF8 = /[^\x20-\x7E]+/;

const FLAGS_INSTALL = ['get'];

const FLAGS_DOWNLOAD = ['get', 'dnscache'];

const QUERYPARSEROPTIONS = { maxKeys: 69 };

const EMPTYARRAY = [];

const EMPTYOBJECT = {};

const EMPTYREQUEST = { uri: {} };

const SINGLETONS = {};

const REPOSITORY_HEAD = '$head';

const REPOSITORY_META_TITLE = '$title';

const REPOSITORY_META_DESCRIPTION = '$description';

const REPOSITORY_META_KEYWORDS = '$keywords';

const REPOSITORY_META_AUTHOR = '$author';

const REPOSITORY_META_IMAGE = '$image';

const REPOSITORY_PLACE = '$place';

const REPOSITORY_SITEMAP = '$sitemap';

const ATTR_END = '"';

const ETAG = '858';

const CONCAT = [null, null];

const CLUSTER_CACHE_SET = { TYPE: 'cache-set' };

const CLUSTER_CACHE_REMOVE = { TYPE: 'cache-remove' };

const CLUSTER_CACHE_REMOVEALL = { TYPE: 'cache-remove-all' };

const CLUSTER_CACHE_CLEAR = { TYPE: 'cache-clear' };

const GZIPFILE = { memLevel: 9 };

const GZIPSTREAM = { memLevel: 1 };

const MODELERROR = {};

const IMAGES = { jpg: 1, png: 1, gif: 1, apng: 1, jpeg: 1, heif: 1, heic: 1, webp: 1 };

var PATHMODULES = require.resolve('./index');

PATHMODULES = PATHMODULES.substring(0, PATHMODULES.length - 8);

Object.freeze(EMPTYOBJECT);

Object.freeze(EMPTYARRAY);

Object.freeze(EMPTYREQUEST);

global.EMPTYOBJECT = EMPTYOBJECT;

global.EMPTYARRAY = EMPTYARRAY;

global.NOW = new Date();

var PROTORES, PROTOREQ;

var RANGE = { start: 0, end: 0 };

var HEADERS = {};

var SUCCESSHELPER = { success: true };

// Cached headers for repeated usage

HEADERS.responseCode = {};

HEADERS.responseCode[HEADER_TYPE] = CT_TEXT;

HEADERS.responseCode['X-Powered-By'] = 'Total.js';

HEADERS.redirect = {};

HEADERS.redirect[HEADER_TYPE] = CT_HTML + '; charset=utf-8';

HEADERS.redirect[HEADER_LENGTH] = '0';

HEADERS.sse = {};

HEADERS.sse[HEADER_CACHE] = 'private, no-cache, no-store, max-age=0';

HEADERS.sse['Pragma'] = 'no-cache';

HEADERS.sse['Expires'] = '-1';

HEADERS.sse[HEADER_TYPE] = 'text/event-stream';

HEADERS.sse['X-Powered-By'] = 'Total.js';

HEADERS.file_lastmodified = {};

HEADERS.file_lastmodified['Access-Control-Allow-Origin'] = '*';

HEADERS.file_lastmodified[HEADER_CACHE] = 'public, max-age=11111111';

HEADERS.file_lastmodified['X-Powered-By'] = 'Total.js';

HEADERS.file_release_compress = {};

HEADERS.file_release_compress[HEADER_CACHE] = 'public, max-age=11111111';

HEADERS.file_release_compress['Vary'] = 'Accept-Encoding';

HEADERS.file_release_compress['Access-Control-Allow-Origin'] = '*';

HEADERS.file_release_compress['Last-Modified'] = 'Mon, 01 Jan 2001 08:00:00 GMT';

HEADERS.file_release_compress['Content-Encoding'] = 'gzip';

HEADERS.file_release_compress['X-Powered-By'] = 'Total.js';

HEADERS.file_release_compress_range = {};

HEADERS.file_release_compress_range['Accept-Ranges'] = 'bytes';

HEADERS.file_release_compress_range[HEADER_CACHE] = 'public, max-age=11111111';

HEADERS.file_release_compress_range['Vary'] = 'Accept-Encoding';

HEADERS.file_release_compress_range['Access-Control-Allow-Origin'] = '*';

HEADERS.file_release_compress_range['Last-Modified'] = 'Mon, 01 Jan 2001 08:00:00 GMT';

HEADERS.file_release_compress_range['Content-Encoding'] = 'gzip';

HEADERS.file_release_compress_range[HEADER_LENGTH] = '0';

HEADERS.file_release_compress_range['Content-Range'] = '';

HEADERS.file_release_compress_range['X-Powered-By'] = 'Total.js';

HEADERS.file_release = {};

HEADERS.file_release[HEADER_CACHE] = 'public, max-age=11111111';

HEADERS.file_release['Vary'] = 'Accept-Encoding';

HEADERS.file_release['Access-Control-Allow-Origin'] = '*';

HEADERS.file_release['Last-Modified'] = 'Mon, 01 Jan 2001 08:00:00 GMT';

HEADERS.file_release['X-Powered-By'] = 'Total.js';

HEADERS.file_release_range = {};

HEADERS.file_release_range['Accept-Ranges'] = 'bytes';

HEADERS.file_release_range[HEADER_CACHE] = 'public, max-age=11111111';

HEADERS.file_release_range['Vary'] = 'Accept-Encoding';

HEADERS.file_release_range['Access-Control-Allow-Origin'] = '*';

HEADERS.file_release_range['Last-Modified'] = 'Mon, 01 Jan 2001 08:00:00 GMT';

HEADERS.file_release_range[HEADER_LENGTH] = '0';

HEADERS.file_release_range['Content-Range'] = '';

HEADERS.file_release_range['X-Powered-By'] = 'Total.js';

HEADERS.file_debug_compress = {};

HEADERS.file_debug_compress[HEADER_CACHE] = 'private, no-cache, no-store, max-age=0';

HEADERS.file_debug_compress['Vary'] = 'Accept-Encoding';

HEADERS.file_debug_compress['Access-Control-Allow-Origin'] = '*';

HEADERS.file_debug_compress['Pragma'] = 'no-cache';

HEADERS.file_debug_compress['Expires'] = '-1';

HEADERS.file_debug_compress['Content-Encoding'] = 'gzip';

HEADERS.file_debug_compress['X-Powered-By'] = 'Total.js';

HEADERS.file_debug_compress_range = {};

HEADERS.file_debug_compress_range['Accept-Ranges'] = 'bytes';

HEADERS.file_debug_compress_range[HEADER_CACHE] = 'private, no-cache, no-store, max-age=0';

HEADERS.file_debug_compress_range['Vary'] = 'Accept-Encoding';

HEADERS.file_debug_compress_range['Access-Control-Allow-Origin'] = '*';

HEADERS.file_debug_compress_range['Content-Encoding'] = 'gzip';

HEADERS.file_debug_compress_range['Pragma'] = 'no-cache';

HEADERS.file_debug_compress_range['Expires'] = '-1';

HEADERS.file_debug_compress_range[HEADER_LENGTH] = '0';

HEADERS.file_debug_compress_range['Content-Range'] = '';

HEADERS.file_debug_compress_range['X-Powered-By'] = 'Total.js';

HEADERS.file_debug = {};

HEADERS.file_debug[HEADER_CACHE] = 'private, no-cache, no-store, max-age=0';

HEADERS.file_debug['Vary'] = 'Accept-Encoding';

HEADERS.file_debug['Pragma'] = 'no-cache';

HEADERS.file_debug['Expires'] = '-1';

HEADERS.file_debug['Access-Control-Allow-Origin'] = '*';

HEADERS.file_debug['X-Powered-By'] = 'Total.js';

HEADERS.file_debug_range = {};

HEADERS.file_debug_range['Accept-Ranges'] = 'bytes';

HEADERS.file_debug_range[HEADER_CACHE] = 'private, no-cache, no-store, max-age=0';

HEADERS.file_debug_range['Vary'] = 'Accept-Encoding';

HEADERS.file_debug_range['Access-Control-Allow-Origin'] = '*';

HEADERS.file_debug_range['Pragma'] = 'no-cache';

HEADERS.file_debug_range['Expires'] = '-1';

HEADERS.file_debug_range[HEADER_LENGTH] = '0';

HEADERS.file_debug_range['Content-Range'] = '';

HEADERS.file_debug_range['X-Powered-By'] = 'Total.js';

HEADERS.content_mobile_release = {};

HEADERS.content_mobile_release[HEADER_CACHE] = 'private, no-cache, no-store, max-age=0';

HEADERS.content_mobile_release['Vary'] = 'Accept-Encoding, User-Agent';

HEADERS.content_mobile_release['Content-Encoding'] = 'gzip';

HEADERS.content_mobile_release['Expires'] = '-1';

HEADERS.content_mobile_release['X-Powered-By'] = 'Total.js';

HEADERS.content_mobile = {};

HEADERS.content_mobile[HEADER_CACHE] = 'private, no-cache, no-store, max-age=0';

HEADERS.content_mobile['Vary'] = 'Accept-Encoding, User-Agent';

HEADERS.content_mobile['Expires'] = '-1';

HEADERS.content_mobile['X-Powered-By'] = 'Total.js';

HEADERS.content_compress = {};

HEADERS.content_compress[HEADER_CACHE] = 'private, no-cache, no-store, max-age=0';

HEADERS.content_compress['Vary'] = 'Accept-Encoding';

HEADERS.content_compress['Content-Encoding'] = 'gzip';

HEADERS.content_compress['Expires'] = '-1';

HEADERS.content_compress['X-Powered-By'] = 'Total.js';

HEADERS.content = {};

HEADERS.content[HEADER_CACHE] = 'private, no-cache, no-store, max-age=0';

HEADERS.content['Vary'] = 'Accept-Encoding';

HEADERS.content['Expires'] = '-1';

HEADERS.content['X-Powered-By'] = 'Total.js';

HEADERS.stream_release_compress = {};

HEADERS.stream_release_compress[HEADER_CACHE] = 'public, max-age=11111111';

HEADERS.stream_release_compress['Access-Control-Allow-Origin'] = '*';

HEADERS.stream_release_compress['Content-Encoding'] = 'gzip';

HEADERS.stream_release_compress['X-Powered-By'] = 'Total.js';

HEADERS.stream_release = {};

HEADERS.stream_release[HEADER_CACHE] = 'public, max-age=11111111';

HEADERS.stream_release['Access-Control-Allow-Origin'] = '*';

HEADERS.stream_release['X-Powered-By'] = 'Total.js';

HEADERS.stream_debug_compress = {};

HEADERS.stream_debug_compress[HEADER_CACHE] = 'private, no-cache, no-store, max-age=0';

HEADERS.stream_debug_compress['Pragma'] = 'no-cache';

HEADERS.stream_debug_compress['Expires'] = '-1';

HEADERS.stream_debug_compress['Access-Control-Allow-Origin'] = '*';

HEADERS.stream_debug_compress['Content-Encoding'] = 'gzip';

HEADERS.stream_debug_compress['X-Powered-By'] = 'Total.js';

HEADERS.stream_debug = {};

HEADERS.stream_debug[HEADER_CACHE] = 'private, no-cache, no-store, max-age=0';

HEADERS.stream_debug['Pragma'] = 'no-cache';

HEADERS.stream_debug['Expires'] = '-1';

HEADERS.stream_debug['Access-Control-Allow-Origin'] = '*';

HEADERS.stream_debug['X-Powered-By'] = 'Total.js';

HEADERS.binary_compress = {};

HEADERS.binary_compress[HEADER_CACHE] = 'private, no-cache, no-store, max-age=0';

HEADERS.binary_compress['Content-Encoding'] = 'gzip';

HEADERS.binary_compress['X-Powered-By'] = 'Total.js';

HEADERS.binary = {};

HEADERS.binary[HEADER_CACHE] = 'public';

HEADERS.binary['X-Powered-By'] = 'Total.js';

HEADERS.authorization = { user: '', password: '', empty: true };

HEADERS.fsStreamRead = { flags: 'r', mode: '0666', autoClose: true };

HEADERS.fsStreamReadRange = { flags: 'r', mode: '0666', autoClose: true, start: 0, end: 0 };

HEADERS.workers = { cwd: '' };

HEADERS.responseLocalize = {};

HEADERS.responseNotModified = {};

HEADERS.responseNotModified[HEADER_CACHE] = 'public, max-age=11111111';

HEADERS.responseNotModified['X-Powered-By'] = 'Total.js';

HEADERS.response503 = {};

HEADERS.response503[HEADER_CACHE] = 'private, no-cache, no-store, max-age=0';

HEADERS.response503[HEADER_TYPE] = CT_HTML;

HEADERS.response503['X-Powered-By'] = 'Total.js';

HEADERS.notModifiedEtag = {};

HEADERS.notModifiedEtag['X-Powered-By'] = 'Total.js';

HEADERS.notModifiedLastModifiedDate = {};

HEADERS.notModifiedLastModifiedDate['X-Powered-By'] = 'Total.js';

Object.freeze(HEADERS.authorization);

var IMAGEMAGICK = false;

var _controller = '';

var _owner = '';

var _flags;

var _prefix;

// GO ONLINE MODE

!global.framework_internal && (global.framework_internal = require('./internal'));

!global.framework_builders && (global.framework_builders = require('./builders'));

!global.framework_utils && (global.framework_utils = require('./utils'));

!global.framework_mail && (global.framework_mail = require('./mail'));

!global.framework_image && (global.framework_image = require('./image'));

!global.framework_nosql && (global.framework_nosql = require('./nosql'));

global.Builders = framework_builders;

var U = global.Utils = global.utils = global.U = global.framework_utils;

global.Mail = framework_mail;

global.WTF = (message, name, uri) => F.problem(message, name, uri);

global.NOBIN = global.NOSQLBINARY = (name) => F.nosql(name).binary;

global.NOSQLSTORAGE = (name) => F.nosql(name).storage;

global.NOCOUNTER = global.NOSQLCOUNTER = (name) => F.nosql(name).counter;

global.NOMEM = global.NOSQLMEMORY = (name, view) => global.framework_nosql.inmemory(name, view);

global.CONFIG = function(name, val) {

return arguments.length === 1 ? F.config[name] : (F.config[name] = val);

};

global.UPTODATE = (type, url, options, interval, callback) => F.uptodate(type, url, options, interval, callback);

global.INSTALL = (type, name, declaration, options, callback) => F.install(type, name, declaration, options, callback);

global.UNINSTALL = (type, name, options) => F.uninstall(type, name, options);

global.RESOURCE = (name, key) => F.resource(name, key);

global.TRANSLATE = (name, key) => F.translate(name, key);

global.TRANSLATOR = (name, text) => F.translator(name, text);

global.TRACE = (message, name, uri, ip) => F.trace(message, name, uri, ip);

global.$$$ = global.GETSCHEMA = (group, name, fn, timeout) => framework_builders.getschema(group, name, fn, timeout);

global.CREATE = (group, name) => framework_builders.getschema(group, name).default();

global.SCRIPT = (body, value, callback, param) => F.script(body, value, callback, param);

global.SINGLETON = (name, def) => SINGLETONS[name] || (SINGLETONS[name] = (new Function('return ' + (def || '{}')))());

global.FUNCTION = (name) => F.functions[name] || NOOP;

global.ROUTING = (name) => F.routing(name);

global.SCHEDULE = (date, each, fn, param) => F.schedule(date, each, fn, param);

global.FINISHED = framework_internal.onFinished;

global.DESTROY = framework_internal.destroyStream;

global.FILESTORAGE = function(name) {

var key = 'storage_' + name;

return F.databases[key] ? F.databases[key] : (F.databases[key] = new framework_nosql.DatabaseBinary({ name: name }, F.path.databases('fs-' + name + '/'), '.file'));

};

global.UID = function(type) {

var index;

if (type) {

if (UIDGENERATOR.types[type])

index = UIDGENERATOR.types[type] = UIDGENERATOR.types[type] + 1;

else {

UIDGENERATOR.multiple = true;

index = UIDGENERATOR.types[type] = 1;

}

} else

index = UIDGENERATOR.index++;

return UIDGENERATOR.date + index.padLeft(4, '0') + UIDGENERATOR.instance + (index % 2 ? 1 : 0);

};

global.AUTH = function(fn) {

F.onAuthorize = fn;

};

global.WEBSOCKETCLIENT = function(callback) {

var ws = require('./websocketclient').create();

callback && callback.call(ws, ws);

return ws;

};

global.$CREATE = function(schema) {

schema = parseSchema(schema);

var o = framework_builders.getschema(schema[0], schema[1]);

return o ? o.default() : null;

};

global.$MAKE = function(schema, model, filter, callback, novalidate, argument) {

schema = parseSchema(schema);

var o = framework_builders.getschema(schema[0], schema[1]);

return o ? o.make(model, filter, callback, argument, novalidate) : undefined;

};

global.$QUERY = function(schema, options, callback, controller) {

schema = parseSchema(schema);

var o = framework_builders.getschema(schema[0], schema[1]);

if (o)

o.query(options, callback, controller);

else

callback && callback(new Error('Schema "{0}" not found.'.format(getSchemaName(schema))));

return !!o;

};

global.$GET = function(schema, options, callback, controller) {

schema = parseSchema(schema);

var o = framework_builders.getschema(schema[0], schema[1]);

if (o)

o.get(options, callback, controller);

else

callback && callback(new Error('Schema "{0}" not found.'.format(getSchemaName(schema))));

return !!o;

};

global.$WORKFLOW = function(schema, name, options, callback, controller) {

schema = parseSchema(schema);

var o = framework_builders.getschema(schema[0], schema[1]);

if (o)

o.workflow2(name, options, callback, controller);

else

callback && callback(new Error('Schema "{0}" not found.'.format(getSchemaName(schema))));

return !!o;

};

global.$TRANSFORM = function(schema, name, options, callback, controller) {

schema = parseSchema(schema);

var o = framework_builders.getschema(schema[0], schema[1]);

if (o)

o.transform2(name, options, callback, controller);

else

callback && callback(new Error('Schema "{0}" not found.'.format(getSchemaName(schema))));

return !!o;

};

global.$REMOVE = function(schema, options, callback, controller) {

schema = parseSchema(schema);

var o = framework_builders.getschema(schema[0], schema[1]);

if (typeof(options) === 'function') {

controller = callback;

callback = options;

options = EMPTYOBJECT;

}

if (o)

o.remove(options, callback, controller);

else

callback && callback(new Error('Schema "{0}" not found.'.format(getSchemaName(schema))));

return !!o;

};

global.$SAVE = function(schema, model, options, callback, controller) {

return performschema('$save', schema, model, options, callback, controller);

};

global.$INSERT = function(schema, model, options, callback, controller) {

return performschema('$insert', schema, model, options, callback, controller);

};

global.$UPDATE = function(schema, model, options, callback, controller) {

return performschema('$update', schema, model, options, callback, controller);

};

// type, schema, model, options, callback, controller

function performschema(type, schema, model, options, callback, controller) {

if (typeof(options) === 'function') {

controller = callback;

callback = options;

options = null;

}

schema = parseSchema(schema);

var o = framework_builders.getschema(schema[0], schema[1]);

if (!o) {

callback && callback(new Error('Schema "{0}" not found.'.format(getSchemaName(schema))));

return false;

}

o.make(model, function(err, model) {

if (err) {

callback && callback(err);

} else {

model.$$controller = controller;

model[type](options, callback);

}

});

return !!o;

}

global.$ASYNC = function(schema, callback, index, controller) {

if (index && typeof(index) === 'object') {

controller = index;

index = undefined;

}

schema = parseSchema(schema);

var o = framework_builders.getschema(schema[0], schema[1]).default();

if (!o) {

callback && callback(new Error('Schema "{0}" not found.'.format(getSchemaName(schema))));

return EMPTYOBJECT;

}

controller && (o.$$controller = controller);

return o.$async(callback, index);

};

global.$OPERATION = function(schema, name, options, callback, controller) {

schema = parseSchema(schema);

var o = framework_builders.getschema(schema[0], schema[1]);

if (o)

o.operation2(name, options, callback, controller);

else

callback && callback(new Error('Schema "{0}" not found.'.format(getSchemaName(schema))));

return !!o;

};

global.DB = global.DATABASE = function(a, b, c, d) {

return typeof(F.database) === 'object' ? F.database : F.database(a, b, c, d);

};

global.OFF = function() {

return arguments.length > 1 ? F.removeListener.apply(F, arguments) : F.removeAllListeners.apply(F, arguments);

};

global.NEWSCHEMA = function(group, name, make) {

if (typeof(name) === 'function') {

make = name;

name = undefined;

}

if (!name) {

var arr = group.split('/');

if (arr.length === 2) {

name = arr[1];

group = arr[0];

} else {

name = group;

group = 'default';

}

}

var schema = framework_builders.newschema(group, name);

make && make.call(schema, schema);

return schema;

};

global.CLEANUP = function(stream, callback) {

FINISHED(stream, function() {

DESTROY(stream);

if (callback) {

callback();

callback = null;

}

});

};

global.SUCCESS = function(success, value) {

if (typeof(success) === 'function') {

return function(err, value) {

success(err, SUCCESS(err, value));

};

}

var err;

if (success instanceof Error) {

err = success.toString();

success = false;

} else if (success instanceof framework_builders.ErrorBuilder) {

if (success.hasError()) {

err = success.output();

success = false;

} else

success = true;

} else if (success == null)

success = true;

SUCCESSHELPER.success = !!success;

SUCCESSHELPER.value = value == null ? undefined : (framework_builders.isSchema(value) ? value.$clean() : value);

SUCCESSHELPER.error = err ? err : undefined;

return SUCCESSHELPER;

};

global.TRY = function(fn, err) {

try {

fn();

return true;

} catch (e) {

err && err(e);

return false;

}

};

global.OBSOLETE = function(name, message) {

console.log(NOW.format('yyyy-MM-dd HH:mm:ss') + ' :: OBSOLETE / IMPORTANT ---> "' + name + '"', message);

if (global.F)

F.stats.other.obsolete++;

};

global.DEBUG = false;

global.TEST = false;

global.RELEASE = false;

global.is_client = false;

global.is_server = true;

var directory = U.$normalize(require.main ? Path.dirname(require.main.filename) : process.cwd());

// F.service() changes the values below:

var DATE_EXPIRES = new Date().add('y', 1).toUTCString();

const WEBSOCKET_COMPRESS = U.createBuffer([0x00, 0x00, 0xFF, 0xFF]);

const WEBSOCKET_COMPRESS_OPTIONS = { windowBits: Zlib.Z_DEFAULT_WINDOWBITS };

const UIDGENERATOR = { date: new Date().format('yyMMddHHmm'), instance: 'abcdefghijklmnoprstuwxy'.split('').random().join('').substring(0, 3), index: 1, types: {} };

const EMPTYBUFFER = U.createBufferSize(0);

global.EMPTYBUFFER = EMPTYBUFFER;

const controller_error_status = function(controller, status, problem) {

if (status !== 500 && problem)

controller.problem(problem);

if (controller.res.success || controller.res.headersSent || !controller.isConnected)

return controller;

controller.precache && controller.precache(null, null, null);

controller.req.path = EMPTYARRAY;

controller.req.$total_success();

controller.req.$total_route = F.lookup(controller.req, '#' + status, EMPTYARRAY, 0);

controller.req.$total_exception = problem;

controller.req.$total_execute(status, true);

return controller;

};

var PERF = {};

function Framework() {

this.$id = null; // F.id ==> property

this.version = 3000;

this.version_header = '3.0.0';

this.version_node = process.version.toString();

this.syshash = (Os.hostname() + '-' + Os.platform() + '-' + Os.arch() + '-' + Os.release() + '-' + Os.tmpdir()).md5();

this.config = {

debug: true,

trace: true,

'trace-console': true,

name: 'Total.js',

version: '1.0.0',

author: '',

secret: this.syshash,

'secret-uid': this.syshash.substring(10),

'security.txt': 'Contact: mailto:support@totaljs.com\nContact: https://www.totaljs.com/contact/',

'etag-version': '',

'directory-src': '/.src/',

'directory-bundles': '/bundles/',

'directory-controllers': '/controllers/',

'directory-components': '/components/',

'directory-views': '/views/',

'directory-definitions': '/definitions/',

'directory-temp': '/tmp/',

'directory-models': '/models/',

'directory-schemas': '/schemas/',

'directory-operations': '/operations/',

'directory-resources': '/resources/',

'directory-public': '/public/',

'directory-public-virtual': '/app/',

'directory-modules': '/modules/',

'directory-source': '/source/',

'directory-logs': '/logs/',

'directory-tests': '/tests/',

'directory-databases': '/databases/',

'directory-workers': '/workers/',

'directory-packages': '/packages/',

'directory-private': '/private/',

'directory-isomorphic': '/isomorphic/',

'directory-configs': '/configs/',

'directory-services': '/services/',

'directory-themes': '/themes/',

// all HTTP static request are routed to directory-public

'static-url': '',

'static-url-script': '/js/',

'static-url-style': '/css/',

'static-url-image': '/img/',

'static-url-video': '/video/',

'static-url-font': '/fonts/',

'static-url-download': '/download/',

'static-url-components': '/components.',

'static-accepts': { flac: true, jpg: true, jpeg: true, png: true, gif: true, ico: true, js: true, css: true, txt: true, xml: true, woff: true, woff2: true, otf: true, ttf: true, eot: true, svg: true, zip: true, rar: true, pdf: true, docx: true, xlsx: true, doc: true, xls: true, html: true, htm: true, appcache: true, manifest: true, map: true, ogv: true, ogg: true, mp4: true, mp3: true, webp: true, webm: true, swf: true, package: true, json: true, md: true, m4v: true, jsx: true, heif: true, heic: true },

// 'static-accepts-custom': [],

'default-xpoweredby': 'Total.js',

'default-layout': 'layout',

'default-theme': '',

'default-proxy': '',

// default maximum request size / length

// default 10 kB

'default-request-maxlength': 10,

'default-websocket-maxlength': 2,

'default-websocket-encodedecode': true,

'default-maxopenfiles': 0,

'default-timezone': '',

'default-root': '',

'default-response-maxage': '11111111',

'default-errorbuilder-status': 200,

// Seconds (2 minutes)

'default-cors-maxage': 120,

// in milliseconds

'default-request-timeout': 3000,

'default-dependency-timeout': 1500,

// otherwise is used ImageMagick (Heroku supports ImageMagick)

// gm = graphicsmagick or im = imagemagick

'default-image-converter': 'gm',

'default-image-quality': 93,

'default-image-consumption': 30,

'allow-static-files': true,

'allow-gzip': true,

'allow-websocket': true,

'allow-websocket-compression': true,

'allow-compile': true,

'allow-compile-script': true,

'allow-compile-style': true,

'allow-compile-html': true,

'allow-compile-build': true,

'allow-performance': false,

'allow-custom-titles': false,

'allow-cache-snapshot': false,

'allow-cache-cluster': true,

'allow-debug': false,

'allow-head': false,

'allow-filter-errors': true,

'allow-clear-temp': true,

'allow-ssc-validation': false,

'nosql-worker': false,

'nosql-inmemory': null, // String Array

'nosql-cleaner': 1440,

'nosql-logger': true,

// Used in F.service()

// All values are in minutes

'default-interval-clear-resources': 20,

'default-interval-clear-cache': 10,

'default-interval-clear-dnscache': 120,

'default-interval-precompile-views': 61,

'default-interval-websocket-ping': 3,

'default-interval-uptodate': 5

};

global.G = this.global = {};

this.$bundling = true;

this.resources = {};

this.connections = {};

this.functions = {};

this.themes = {};

this.versions = null;

this.workflows = {};

this.uptodates = null;

this.schedules = [];

this.isDebug = true;

this.isTest = false;

this.isLoaded = false;

this.isWorker = true;

this.isCluster = process.env.PASSENGER_APP_ENV ? false : require('cluster').isWorker;

this.routes = {

sitemap: null,

web: [],

system: {},

files: [],

cors: [],

corsall: false,

websockets: [],

middleware: {},

redirects: {},

resize: {},

request: [],

views: {},

merge: {},

mapping: {},

packages: {},

blocks: {},

resources: {}

};

this.owners = [];

this.modificators = null;

this.helpers = {};

this.modules = {};

this.models = {};

this.sources = {};

this.controllers = {};

this.dependencies = {};

this.isomorphic = {};

this.components = { has: false, css: false, js: false, views: {}, instances: {}, version: null, links: '', groups: {}, files: {} };

this.convertors = [];

this.convertors2 = null;

this.tests = [];

this.errors = [];

this.problems = [];

this.changes = [];

this.server = null;

this.port = 0;

this.ip = '';

this.validators = {

email: new RegExp('^[a-zA-Z0-9-_.+]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$'),

url: /^(https?:\/\/(?:www\.|(?!www))[^\s.#!:?+=&@!$'~*,;/()[\]]+\.[^\s#!?+=&@!$'~*,;()[\]\\]{2,}\/?|www\.[^\s#!:.?+=&@!$'~*,;/()[\]]+\.[^\s#!?+=&@!$'~*,;()[\]\\]{2,}\/?)/i,

phone: /^[+]?[(]?[0-9]{3}[)]?[-\s.]?[0-9]{3}[-\s.]?[0-9]{4,6}$/im,

zip: /^\d{5}(?:[-\s]\d{4})?$/,

uid: /^\d{14,}[a-z]{3}[01]{1}$/

};

this.workers = {};

this.databases = {};

this.databasescleaner = {};

this.directory = HEADERS.workers.cwd = directory;

this.isLE = Os.endianness ? Os.endianness() === 'LE' : true;

this.isHTTPS = false;

// It's hidden

// this.waits = {};

this.temporary = {

path: {},

notfound: {},

processing: {},

range: {},

views: {},

versions: {},

dependencies: {}, // temporary for module dependencies

other: {},

internal: {}, // controllers/modules names for the routing

owners: {},

ready: {},

service: { redirect: 0, request: 0, file: 0 }

};

this.stats = {

performance: {

request: 0,

file: 0

},

other: {

websocketPing: 0,

websocketCleaner: 0,

obsolete: 0,

mail: 0

},

request: {

request: 0,

pending: 0,

web: 0,

xhr: 0,

file: 0,

websocket: 0,

get: 0,

options: 0,

head: 0,

post: 0,

put: 0,

path: 0,

upload: 0,

schema: 0,

blocked: 0,

'delete': 0,

mobile: 0,

desktop: 0

},

response: {

view: 0,

json: 0,

websocket: 0,

timeout: 0,

custom: 0,

binary: 0,

pipe: 0,

file: 0,

image: 0,

destroy: 0,

stream: 0,

streaming: 0,

plain: 0,

empty: 0,

redirect: 0,

forward: 0,

notModified: 0,

sse: 0,

errorBuilder: 0,

error400: 0,

error401: 0,

error403: 0,

error404: 0,

error408: 0,

error409: 0,

error431: 0,

error500: 0,

error501: 0,

error503: 0

}

};

// intialize cache

this.cache = new FrameworkCache();

this.path = new FrameworkPath();

this._request_check_redirect = false;

this._request_check_referer = false;

this._request_check_POST = false;

this._request_check_robot = false;

this._request_check_mobile = false;

this._length_middleware = 0;

this._length_request_middleware = 0;

this._length_files = 0;

this._length_wait = 0;

this._length_themes = 0;

this._length_cors = 0;

this._length_subdomain_web = 0;

this._length_subdomain_websocket = 0;

this._length_convertors = 0;

this.isVirtualDirectory = false;

this.isTheme = false;

this.isWindows = Os.platform().substring(0, 3).toLowerCase() === 'win';

this.$events = {};

}

// ======================================================

// PROTOTYPES

// ======================================================

Framework.prototype = {

get datetime() {

return global.NOW;

},

set datetime(val) {

global.NOW = val;

},

get cluster() {

return require('./cluster');

},

get id() {

return F.$id;

},

set id(value) {

CLUSTER_CACHE_SET.id = value;

CLUSTER_CACHE_REMOVE.id = value;

CLUSTER_CACHE_REMOVEALL.id = value;

CLUSTER_CACHE_CLEAR.id = value;

F.$id = value;

return F.$id;

},

get onLocate() {

return this.onLocale;

},

set onLocate(value) {

OBSOLETE('F.onLocate', 'Rename "F.onLocate" method for "F.onLocale".');

this.onLocale = value;

}

};

var framework = new Framework();

global.framework = global.F = module.exports = framework;

F.dir = function(path) {

F.directory = path;

directory = path;

};

F.prototypes = function(fn) {

var proto = {};

proto.Chunker = framework_utils.Chunker.prototype;

proto.Controller = Controller.prototype;

proto.Database = framework_nosql.Database.prototype;

proto.DatabaseBinary = framework_nosql.DatabaseBinary.prototype;

proto.DatabaseBuilder = framework_nosql.DatabaseBuilder.prototype;

proto.DatabaseBuilder2 = framework_nosql.DatabaseBuilder2.prototype;

proto.DatabaseCounter = framework_nosql.DatabaseCounter.prototype;

proto.DatabaseStorage = framework_nosql.DatabaseStorage.prototype;

proto.DatabaseTable = framework_nosql.DatabaseTable.prototype;

proto.ErrorBuilder = framework_builders.ErrorBuilder.prototype;

proto.HttpFile = framework_internal.HttpFile.prototype;

proto.HttpRequest = PROTOREQ;

proto.HttpResponse = PROTORES;

proto.Image = framework_image.Image.prototype;

proto.Message = Mail.Message.prototype;

proto.MiddlewareOptions = MiddlewareOptions;

proto.OperationOptions = framework_builders.OperationOptions.prototype;

proto.Page = framework_builders.Page.prototype;

proto.Pagination = framework_builders.Pagination.prototype;

proto.RESTBuilder = framework_builders.RESTBuilder.prototype;

proto.RESTBuilderResponse = framework_builders.RESTBuilderResponse.prototype;

proto.SchemaBuilder = framework_builders.SchemaBuilder.prototype;

proto.SchemaOptions = framework_builders.SchemaOptions.prototype;

proto.UrlBuilder = framework_builders.UrlBuilder.prototype;

proto.WebSocket = WebSocket.prototype;

proto.WebSocketClient = WebSocketClient.prototype;

fn.call(proto, proto);

return F;

};

global.ON = F.on = function(name, fn) {

if (name === 'init' || name === 'ready' || name === 'load') {

if (F.isLoaded) {

fn.call(F);

return;

}

} else if (name.indexOf('#') !== -1) {

var arr = name.split('#');

switch (arr[0]) {

case 'middleware':

F.temporary.ready[name] && fn.call(F);

break;

case 'component':

F.temporary.ready[name] && fn.call(F);

break;

case 'model':

F.temporary.ready[name] && fn.call(F, F.models[arr[1]]);

break;