About JumboJS

JumboJS is fast modern enterprise level MVC framework for Node.js which focuses on object-oriented programming, Inversion of Control and Separation of Concerns.

Main Features of JumboJS

• No require hell! Global lazy-loading namespace exists,
• native async & await support,
• integrated Node.js clustering - multi core/CPU support,
• advanced dynamic routing system (just one route enough for most apps),
• Inversion of Control - constructor Dependency Injection,
• code can be changed while runtime,
• unexpected errors are catched and logged, then process is restarted,
• client-side micro framework automatically creating SPA without any client-side programming,
• fully configurable logging with log levels,
• subdomains! More "modules" in one application accessible via subdomains,
• code-first ORM/ODM with migrations (UniMapperJS),
• automatic sessions,
• memory and disk cache,
• integrated email sender (soon),
• high performance - 3 900 requests per second with one worker (2,33 GHz core),
• low dependecy,
• integrated globalization,
• and more...

Framework structure

In the picture below you can see basic framework structure and data flow. Some things are abstracted and joined to keep diagram clear.

Node.js and Npm

JumboJS is built upon Node.js so you need Node.js in version 8.10.x or higher and its package manager npm.

Node.js® is a JavaScript runtime built on Chrome's V8 JavaScript engine. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient. Node.js' package ecosystem, npm, is the largest ecosystem of open source libraries in the world. (taken from nodejs.org)

Installation

The best way how to start with JumboJS is to install jumbo-developer package and use it to create new project. So first install jumbo-developer via npm npm install jumbo-developer -g.

Now you can create your first project. Enable jumbo-developer, type jumbo-developer to console/terminal and developer tool will start. First you must specify your project location, it'll do nothing, it just save your location and all future actions will be processed over that location. Then you should finally create your project. Type create project, and your first project is going to be created in directory you specified in previous step.

Now you should run your application. Go to your project directory and run it via npm start. Your application should run on address http://127.0.0.1 on port 30000. If you want to change default port, edit app.js file, and change parameter of runWhenReady(port, ...).

If you want to use framework's subdomains, you should edit your local hosts file and add some domain for your application.

Project Structure

    - adapters # Adapters for components
    - app # Your main folder
        - controllers # Place controllers here
        - facades # Place facades here
        - models # Place models here
        - services # Place services here
        - sub-apps # Folder for subapps which will be accessible via subdomains
            - Example # Subdomain name
                - controllers
                - models
                - ...
        - templates # Place view templates here
					
    - bootstrap # Folder for init scripts (registering routes, dependency, etc.)
    - data
        - errors # Error HTML pages
        - logs # Logs are saved here
        - uploads # All uploaded files are placed here
    - public # Everything inside is accessible at /public/
        - images
        - scripts
        - styles
    - temp
        - cache # Cached templates
        - session # Stored session data
    - app.js # Main script
    - config.js # App configuration
            

Autoloaded Namespaces

In JumboJS there is no need to use requires/imports with complicated relative paths (require-hell). Yes, you must require Node.js modules or your custom 3rd party stuff but framework classes are autoloaded to global namespaces.

There are global Objects Jumbo and App. These Objects contain all classes from framework which are autoloaded when you start app. These Objects create namespaces and structure of namespaces is copied from folder structure. Namespace Jumbo point to framework core. Namespace App points to folder /app/. Eg. /app/controllers/HomeController.js file is accessible via App.Controllers.HomeController.

Classes in namespaces are defined as getters and are required just in time so global namespaces are lazy, same as calling require(). Inside getters there is require() call so after first get it's cached thanks to require cache.

Configuration

For basic configuration there is file /config.js. It's JS file so you can use IDE's completition. And you can add custom properties into config object too. This config is globally readonly accessible via Jumbo.config.

const $cfg = require("jumbo-core/config-options").Configurations;
const $umjs = require("unimapperjs");
const MySqlAdapter = require("unimapperjs/adapters/MySqlAdapter");

/**
 * @name ApplicationConfig
 */
const applicationConfig = {
	/**
	 * Used for styles of Error reporting
	 * In development mode Errors will be shown in browser (browser errors not implemented yet) and in console
	 * In production mode Errors will be logged just to file if log enabled
	 */
	deployment: $cfg.Deployment.Development,

	/**
	 * For debuging; disable clustering and run app in one debugable process
	 */
	// debugMode: false,

	/**
	 * Protocol setting
	 * If you set HTTPS protocol specify privateKey and certificate paths
	 */
	protocol: {
		/**
		 * @default Http
		 */
		protocol: $cfg.Protocols.Http,

		/**
		 * Private key path
		 */
		privateKey: "data/private.key",

		/**
		 * Certificate path
		 */
		certificate: "data/certificate.crt",

		/**
		 * Or just PFX archive certificate
		 */
		pfx: "",

		/**
		 * Certifice passphrase
		 */
		passphrase: null
	},

	/**
	 * Multi-core support
	 */
	clustering: {
		/**
		 * 0 for automatic clustering driven by number of CPU's cores
		 * @default 0
		 */
		numberOfWorkers: 0
	},

	/**
	 * Enable template cache and define memory limit
	 */
	cache: {
		/**
		 * @default true
		 */
		enabled: true,

		/**
		 * Size limit for templates saved in memory
		 * JumboJS store often used templates in memory
		 * @default 10 MB
		 */
		memoryCacheSizeLimit: 10e6
	},

	/**
	 * Session configuration
	 */
	session: {
		/**
		 * Name of cookie which stores users's session ID
		 */
		sessionsCookieName: "JUMBOSESID",

		/**
		 * Length of session's life in days. It'll be deleted from disk after that time
		 * @type {Number} Number of days
		 * @default 30
		 */
		sessionLifetime: 30,

		/**
		 * Limit size of data saved in memory
		 * Not implemented yet
		 */
		memorySizeLimit: 20e6,

		/**
		 * Disable sessions saving to disk - speed boost
		 * When true, memorySizeLimit is ignored
		 * @default false
		 */
		justInMemory: false,
	},

	/**
	 * Enable log and set log level
	 */
	log: {
		/**
		 * @default true
		 */
		enabled: true,

		/**
		 * @default Warning
		 */
		level: $cfg.LogLevels.Warning
	},

	/**
	 * Maximal allowed number of requests per second. You can limit server stress.
	 * If more than specified request count will come, new requests in rest of one second obtain 429 code.
	 * Static files are counted into this number of requests
	 * @default null
	 * @type { Number || null }
	 */
	maxRequestPerSecond: null,

	/**
	 * Enable prevention of (D)DOS attacks
	 * It internally enable requests monitoring which will count number of requests per IP
	 * If IP makes more request per second new requests from that IP will be refused with code 403.
	 * Requests will be still accepted by server but framework will refuse to continue and save resources which
	 * proccessing of that request can framework take.
	 */
	DOSPrevention: {
		/**
		 * @default false
		 */
		enabled: false,

		/**
		 * The limit of request per second from same IP
		 * @description Warn! If you use framework static server and your index page have
		 * more than 100 links (scripts, styles, images etc.) client will be blocked!
		 * @default 100
		 */
		maxRequestPerIP: 100,

		/**
		 * Duration of IP blocking [in seconds]
		 * @default 3600
		 */
		blockTime: 3600
	},

	/**
	 * Allows you to use more languages (defined in URL right after first slash; eg. domain.tld/en-us/page/article/1)
	 */
	globalization: {
		/**
		 * Allow using languages
		 */
		enabled: true
	},

	/**
	 * Maximal size of POST data
	 * @default 5 MB
	 */
	maxPostDataSize: 5e6,

	/**
	 * Object with domains
	 */
	domains: {
		"default": $umjs.createDomain(MySqlAdapter, {
			host: "localhost",
			user: "test",
			password: "test",
			database: "node-task-manager"
		})
	}

	// You can define your own settings here,.. it'll be available via global Jumbo.config
};

module.exports = applicationConfig;

/**
 * Application initial script
 */

// Get application from jumbo-core
let application = require("jumbo-core").application;

// Call route config for registering locations
require("./bootstrap/locator-config")(application.getLocator());

// Call DI registrar
require("./bootstrap/di-registrar")(application.getDIContainer());

// Register template adater - not needed if you want to use default adapter
// application.setTemplateAdapter(Jumbo.Adapters.TemplateAdapter);

// Register application for run at port 80; It'll run after framework do all async jobs
application.runWhenReady(80, function() {
	// You can do something after start
});

Routing

JumboJS has advanced routing system (called Locator) which allows you to define powerful dynamic routes (locations). In base project there is file /bootstrap/locator-config.js where locations are registered.

See API: Application: Locator for more information.

/**
 * Locator configuration - setting host, sub-domains and locations
 * @param {Locator} locator
 */
module.exports = function(locator) {
	const types = locator.constructor.ParamType;

	/*
	 * DOMAINS
	 **************************************************************************************************/
	// Default sub-domain which will route to base app;
	// both urls with and without www will work
	locator.setMainSubdomain("www");

	// Create admin.yourdomain.tld which will route to /app/sub-apps/admin folder
	locator.addSubdomain("admin");


	/*
	 * LOCATIONS
	 **************************************************************************************************/
	// Allows you to change url delimiter from "/" to whatever you want
	// In this case "-" gonna be used, eg. /controllerexample-actionname-foo?bar=5&baz=0
	// But you still define locations with "/"
	locator.setDelimiter("-");

	// example; rewrite action name; limit id with RegExp
	locator.addLocation("locationName", "$controller/delete/$id", {
		"action": "deleteEntity", // no $action in location, so "deleteEntity" gonna be used
		"$id": /[0-9]+/,
		params: {
			parentId: 1 // this param is gonna be added to request with given value; as some default data
		}
	});

	// example2; specific URL pointing to HomeController.actionIndex
	// with optional parameter foo limited with RegExp
	locator.addLocation("locationName2", "Specific-url-what-ever-you-want[/$foo]", {
		"$foo": /[0-9]+/,
		"controller": "Home", // route to this controller
		"action": "index" // and this action
	});

	// Default route - let it last
	locator.addDefaultLocation("[$controller[/$action[/$id]]]");


	/*
	 * URL ALIASES
	 **************************************************************************************************/
	locator.addUrlAlias("/public/favicon.ico", "/favicon.ico"); // URL '/public/favicon.ico' has alias '/favicon.ico'
};

Controllers

Controllers are some kind of entry points to your application. Controller's methods, which should be accessible from web, are called actions and must begin with keyword "action", "get", "post", "put" or "delete". This words tell framework you want let clients access this method from browser. Keyword "action" means all requests with all methods. The other words then stands for HTTP methods.

Controllers must be placed in /app/controllers/. Name convention is PascalCase and name must ends with keyword "Controller". Controller should be exported ES6 class and all actions must be async.

Default controller name is HomeController and default action name is actionIndex. Default action or controller name means that those names aren't used in URL. So yourweb.tld/ points to HomeController::actionIndex(). If you use long format URL with default names you'll be redirected to short format URL. It prevents duplicate content from occurring.

If some method in framework requires controller or action name, it's its name but without keyword. Eg. ExampleController's name is Example; actionLogout's name is logout.

Actions

What actions are is written in paragraphs above. Name convention is lowerCamelCase and name must starts with keyword "action" or lowercased method name. Actions must be async (ES7).

Action Parameters

All parameters (query params and location's params under defined names) from requested URL are injected to actions as parameters under their names in order you define them in action. Eg. if you request for /articles/delete/5?foo=bar, two params exist. First parameter is 5 which is defined in default location as id and second parameter is bar as foo. These two params will be injected to your action actionDelete(id, foo) {} to match names you defined. In that action you wait for id and foo. If these parameters exist in request, action will be called with that parameters in right order, matched by parameters names.

Returning methods

Returning methods are methods implemented in class Jumbo.Base.Controller and these methods end requests and return data or errors. See API: Base: Controller.

/**
 * // TODO: Describe your controller
 * @class ExampleController
 * @memberOf App.Controllers
 */
class ExampleController extends App.Controllers.BaseController {
	/**
	 * Default view action
	 */
	async actionIndex() {
		return "Hello world!";
	}

	async getSomeObject() {
		return { // JSON response
			foo: "bar"
		};
	}

	async getView() {
		return this.view({ optional: "data object" });
	}
}

module.exports = ExampleController;

Sequence diagram

There is some sequence diagram which show you how are actions called in controllers.

When request from client comes to server, Application handle that, verify request target and do some other stuff. Then if everything is ok, Application let ControllerFactory create ExampleController instance for given request.

When instance of ExampleController is created, internal _initController() method is called and request, response, session and diScope parameters are set to controller. Request and response are not accessible in controller's constructor.

Now it's time for calling action. But first there is beforeActions() method which you can use to verify user or initialize something or whatever else. This method can hadle the request and return result if you want, then action is not gonna be called. If you not return enything, the corresponding action's gonna be called. This method must be async too.

Dependency Injection

In JumboJS there is implemented constructor injection which allows you to obtain instances of your services in constructors and other classes. For example you have UserAuthService service which do some user auth stuff. You want instance of this service in controller so you must create its instance but UserAuthService need eg. 3 next services or some other class's instances. Without DI you must create all on your own. With DI, you just register your services and that's all. You write service name as parameter of constructor and framework resolve its instance for you.

Example codes are just examples.

class ExampleController {
	constructor() {
		this.userAuthService = new App.Services.UserAuthService(
			new UserRepository(
				new Jumbo.Orm.EntityManager(
					new Jumbo.Orm.DBContext(Jumbo.Config.Database.default)
				)
			),
			new UserAccountRepository(
				new Jumbo.Orm.EntityManager(
					new Jumbo.Orm.DBContext(Jumbo.Config.Database.default)
				)
			),
			new SomeThirdNeededService(
				new SomeClass()
			)
		);

		this.someOtherService = new SomeOtherService(
			new EnterpriseRepository(
				new Jumbo.Orm.EntityManager(
					new Jumbo.Orm.DBContext(Jumbo.Config.Database.default)
				)
			),
			new CompanyRepository(
				new Jumbo.Orm.EntityManager(
					new Jumbo.Orm.DBContext(Jumbo.Config.Database.default)
				)
			),
			new SomeThirdNeededService(
				new SomeClass()
			)
		);
	}

	async beforeActions() {
		var user = await this.userAuthService.findUser(this.session.userId);

		if (user == null) {
			this.returnError(null, 403);
			return;
		}

		// Do something with user
	}
}

class ExampleController {
	constructor(UserAuthService, SomeOtherService) {
		this.userAuthService = UserAuthService;
		this.someOtherService = SomeOtherService;
	}

	async beforeActions() {
		var user = await this.userAuthService.findUser(this.session.userId);

		if (user == null) {
			return this.error("This string is logged message", 403);
		}

		// Do something with user
	}
}

/**
 * Dependency registrar - registration of servics
 * @param {Jumbo.Ioc.DIContainer} container
 */
module.exports = function(container) {
	const LifetimeScope = Jumbo.Ioc.DIContainer.LifetimeScope;

	container.register(() => Jumbo.Config.Database.default, "DBConn",
		LifetimeScope.SingleInstance);

	container.register(Jumbo.Orm.DBContext,
		"DBContext", LifetimeScope.SingleInstance);

	container.register(Jumbo.Orm.EntityManager,
		"EntityManager", LifetimeScope.SingleInstance);

	container.register(App.Services.EnterpriseRepository,
		"EnterpriseRepository", LifetimeScope.ScopeInstance);

	container.register(App.Services.CompanyRepository,
		"CompanyRepository", LifetimeScope.ScopeInstance);

	container.register(App.Services.UserAccountRepository,
		"UserAccountRepository", LifetimeScope.ScopeInstance);

	container.register(App.Services.UserAuthService,
		"UserAuthService", LifetimeScope.ScopeInstance);

	container.register(App.Services.SomeThirdNeededService,
		"SomeThirdNeededService", LifetimeScope.ScopeInstance);

	container.register(App.Services.SomeOtherService,
		"SomeOtherService", LifetimeScope.ScopeInstance);
};

CLI

JumboJS has special package jumbo-developer which was created to support developing. It's console app which helps you with creating projects, controllers and their actions, services and more.

You can download jumbo-developer via npm npm install jumbo-developer -g. It'll be installed as system command so then just type in console jumbo-developer. With cmd help you will see list of available commands

Jumbo.Adapters

JumboJS is quite modular framework, it integrates many features but almost everything can be changed thanks adapters. Adapters are some classes which makes interfaces over some features.

For example template adapter. It's class which must implements 3 methods (render, preCompile and renderPreCompiled). You should use whatever template engine you want but you must create adapter for that engine, it means that you must implement those 3 methods which returns what framework wants. Then you just register your adapter in configuration and it's done.

Template Adapter

/**
 * Integrated template adapter for Jumplate
 */
var TemplateAdapter = {

	render: async function render(templatePath, layoutPath, dynamicLayout, data, context) {
		return "Basic function. Compile and render view and return complete result.";
	},

	preCompile: async function preCompile(templatePath, layoutPath, dynamicLayout) {
		return "If template engine contains precompilation which can be cached on disk and reused later, return precompiled code.";
	},

	renderPreCompiled: async function renderPreCompiled(compiledTemplate, data, context) {
		return "Process precompiled template and return final render.";
	},

	/**
	 * Extension of template files
	 */
	extension: ".jshtml",

	/**
	 * Tells that you implement preCompile and renderPreCompiled methods
	 */
	preCompilation: true
};

module.exports = TemplateAdapter;

Jumbo.Application_namespace

Namespace with core classes.

class Locator {
	static get ParamTypes: RegExp
	static get instance: Locator

    setHost(host);
    setDelimiter(delimiter);
    setMainSubdomain(subName);
    addSubdomain(subName);
    addLocation(locationName, location, [options = null, [subApp = null]]);
    addDefaultLocation(location);
    addUrlAlias(url, alias);
}

class Request {
    request: http.IncomingMessage;
    subApp: string;
    location: ILocation;
    controller: string; // Name of subapp
    controllerFullName: string;
    action: string; // Name of action
    actionFullName: string;
    params: { // URL params
        [key: string]: any;
    };
    body: {{fields: {}, files: {}}};
    noCache: boolean;
    sessionId: string;
    locale: string; // Requested locale
    beginTime: number; // Request begin time
    method: string; // Requested HTTP method

    isXhr();
    getCookies();
    getCookie(name);
	getIP();
}

class Response {
	response: http.ServerResponse;
	headers: {
		[headerProp: string]: any;
	};

	setCookie(name, value[, expire[, domain[, path]]]);
	unsetCookie(name);
	redirectURL(url[, code]);
}

Jumbo.Base_namespace

class Controller {
	static clientMessagesId: string
	request: Jumbo.Application.Request
	response: Jumbo.Application.Response
	scope: Jumbo.Ioc.Scope
	session: { [key: string]: any; }
	crossRequestData: { [key: string]: any; }
	url: Jumbo.Utils.Url

	addMessage(message[, messageType]);
	exit();
	view([viewOrData[, data]]);
	renderView([viewOrData[, data]]);
	partialView([partialView[, data]]);
	template([view]);
	data(data[, type]);
	json(jsonObj);
	error(message[, statusCode]);
	fileDownload(filePath[, newName[, contentType]]);
	redirect(url);
}

Jumbo.Ioc_namespace

class DIContainer {
	static get LifetimeScope: Jumbo.Ioc.DIContainer.LifetimeScope;
	static get instance: Jumbo.Ioc.DIContainer

	register(expr, as);
	resolve(name);
	resolveUnregistered(type);
}

class Scope {
	resolve(name);
	resolveUnregistered(type);
}

Jumbo.Logging_namespace

JumboJS contain fully configurable logging with log levels. Messages are logged to files, each LogType has own file.

Log_class

Log is static class which give you ability log your messages. It accessible from global variable via Jumbo.Logging.Log.

Class synopsis

class Log {
	static get LogTypes();
	static get LogLevels();
	static level: { Error, Warning, Normal, Talkative }
	static error(message[, type[, level]]);
	static warning(message[, type[, level]]);
	static line(message[, type[, level]]);
}

Jumbo.Utils_namespace

Url_class

Url is class which helps you create URLs. It copy locale, protocol, host and controller from given request.

Class synopsis

class Url {
	constructor(request);
    action(action[, controller[, params]]);
    controller(controller);
    subApp(subApp);
    params(params);
    locale(locale);
    location(location);
    getUrl();
}

Jumplate

Jumplate is JumboJS's default template engine.

It's one of the fastest (faster than Jade, EJS, Handlebars.js, Underscore) Node.js template engine with cacheable precompilation. Jumplate is able to compile 16 000 templates in one second and render 400 000 precompiled templates in one second in one 2,33 Ghz core.

Template code is compiled to native JavaScript (can be cached), then it can be rendered with given set of data into final HTML.

Variables

Comments

Jumplate has block coment which looks like this {{* Command brackets with asterisks *}}

Block

Define

Defined

Include

Cycles

There are two cycles. {{for $x = 0; $x < $count; $x++}} For content {{/for}} and {{for $item of $list}} Foreach content {{/for}}

In case of for..of there is special variable `$itemKey` which is accessible inside cycle block and contains key of current item.

In both cycles you can use commands {{first}}Will be rendered if this iteration is first{{/first}} {{last}}Will be rendered if this iteration is last{{/last}} {{even}}Will be rendered if this iteration is even{{/even}} {{odd}}Will be rendered if this iteration is odd{{/odd}}

Conditions

{{if $x == "condition"}}
	if condition true...
{{elseif $x == "else if conditio"}}
	if else if condition true...
{{else}}
	else...
{{/if}}

Localization

You can register localization hadler to Jumplate and then use command {{loc key.for.requested.translation}} which will call your handler with given key as parameter.

Jumplate.registerLocalizator(function (key, locale) {
	return SOME_EXAMPLE_MAP[locale][key];
});

Jumplate.registerHelper("link", function(text, url) {
	return `<a href="${url}">${text}</a>`;
});

{{block menu}}
	{{for $item of $menuItems}}
		{{link($item.text, $item.url)}}
	{{/for}}
{{/block}}

{{block content}}
	<h1>Registration</h1>
	{{form}}
		<input type="text" name="email">
		<input type="password" name="pass">
		<input type="submit" name="send" value="Sign Up">
	{{/form}}
{/block}

{{block menu}}
	{{for $item of $menuItems}}
		{{* Will create eg. /page/nodejs -> PageController.actionNodejs() *}}
		<a href='{{link($item.section, "Page")}}'>{{$item.text}}</a>
	{{/for}}
{{/block}}

{{block menu}}
	{{for $item of $menuItems}}
		{{* Will create eg. /page/nodejs -> PageController.actionNodejs() by location registered as "default" *}}
		<a href='{{link("default", $item.section, "Page")}}'>{{$item.text}}</a>
	{{/for}}
{{/block}}

{{block adminMenu}}
	{{* Will create eg. admin.domain.tld/page/new -> PageController.actionNew() in admin subapp *}}
	<a href='{{applink("admin", "new", "Page")}}'>Create new page</a>
	<a href='{{applink("admin", "list", "User")}}'>List all users</a>
{{/block}}

uJumbo

uJumbo is client part of JumboJS. This micro-framework allows you to automate client side SPA creation. You just create uJumbo.Controller, give it content selector and that's all, your web is now SPA. See uJumbo Repository

Example Controller

(function(scope) {
	if (scope.AppController) return;

	var AppController = scope.AppController = class extends uJumbo.Controller {
		constructor() {
			super("body"); // Context selector
		}

		onInit() {
			console.log("Called on app init", arguments);
		}

		onBeforeNavigate(headers) {
			console.log("Called before navigatin", arguments)
			// return false; -> as prevent default
		}

		onNavigate(error, response) {
			if (error) {
				console.error(error);
				alert(error.message);
			}

			console.log("Called after navigation", arguments)
		}

		onPopState(state) {
			console.log("Called on browser BACK", arguments)
		}

		onBeforeFormSubmit(data, headers) {
			console.log("Called before form submit", arguments)
			// return false; -> as prevent default
		}

		onFormSubmit(error, response) {
			if (error) {
				alert(error.message);
			}

			console.log("Called after form response received", arguments)
		}

		myAction(hello) {
			alert(hello);
		}
	};

	scope.appCtrl = new AppController();
})(window);

As you can see, there are some on[Something] methods in the controller. That's optional handlers. There is method myAction too. It's yours defined method, which can be called from controller itself or from view by data-j-on events.

View Example

<form>
	<button data-j-onClick="myAction('Hello World')">Say Hello.</button>
</form>

UniMapperJS

UniMapperJS is JumboJS's default ORM. This ORM is based on Entity Framework from .NET. For queries you use JS functions and expressions same as you do with Array. See UniMapperJS.

Example query

// Students their name starts with 'P' or ends with 's'
let startsWith = "P";
let students = await Student.getAll()
	.filter(s => s.name.startsWith($) || s.name.endsWith("s"), startsWith)
	.sort(s => s.name)
	.slice(3, 8) // limit 5, skip 3
	.map(s => ({
		id: s.id,
		name: s.name
	}))
	.exec();