22 |
51 |
52 |
53 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Node.js Starter Kit
2 |
3 | ## Concept
4 |
5 | You can begin development from this Starter Kit, but it is not for production
6 | usage. The purpose of this Starter Kit is to show simplicity, basic concepts,
7 | give structure and architecture examples. All parts of this implementation are
8 | optimized for readability and understanding, but not for performance and
9 | scalability.
10 |
11 | So it is good for development and education. However, for production deployment,
12 | you may need the [Metarhia Example App](https://github.com/metarhia/Example) an
13 | open-source application server on the top of [Node.js](https://nodejs.org/en/).
14 |
15 | ## Feature list
16 |
17 | - Pure node.js and framework-agnostic approach
18 | - Minimum code size and dependencies
19 | - Layered architecture: core, domain, API, client
20 | - Protocol-agnostic API with auto-routing, HTTP(S), WS(S)
21 | - Graceful shutdown
22 | - Code sandboxing for security, dependency injection and context isolation
23 | - Serve multiple ports
24 | - Serve static files with memory cache
25 | - Application configuration
26 | - Simple logger
27 | - Database access layer (Postgresql)
28 | - Persistent sessions
29 | - Unit-tests and API tests example
30 | - Request queue with timeout and size
31 | - Execution timeout and error handling
32 |
33 | ## Requirements
34 |
35 | - Node.js v16 or later
36 | - Linux (tested on Fedora, Ubuntu, and CentOS)
37 | - Postgresql 9.5 or later (v12 preferred)
38 | - OpenSSL v1.1.1 or later
39 | - [certbot](https://github.com/certbot/certbot) (recommended but optional)
40 |
41 | ## Usage
42 |
43 | 1. Fork and clone this repository (optionally subscribe to repo changes)
44 | 2. Remove unneeded dependencies if your project doesn't require them
45 | 3. Run `npm ci --production` to install dependencies and generate certificate
46 | 4. Add your license to `LICENSE` file but don't remove starter kit license
47 | 5. Start your project by modifying this starter kit
48 | 6. Run project with `node server.js` and stop with Ctrl+C
49 |
50 | ## Help
51 |
52 | Ask questions at https://t.me/nodeua and post issues on
53 | [github](https://github.com/HowProgrammingWorks/NodejsStarterKit/issues).
54 |
55 | ## License
56 |
57 | Copyright (c) 2020-2023 How.Programming.Works contributors.
58 | This starter kit is [MIT licensed](./LICENSE).
59 |
--------------------------------------------------------------------------------
/lib/security.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const { crypto } = require('./dependencies.js').node;
4 |
5 | const serializeHash = (hash, salt, params) => {
6 | const paramString = Object.entries(params)
7 | .map(([key, value]) => `${key}=${value}`)
8 | .join(',');
9 | const saltString = salt.toString('base64').split('=')[0];
10 | const hashString = hash.toString('base64').split('=')[0];
11 | return `$scrypt$${paramString}$${saltString}$${hashString}`;
12 | };
13 |
14 | const deserializeHash = (phcString) => {
15 | const parsed = phcString.split('$');
16 | parsed.shift();
17 | if (parsed[0] !== 'scrypt') {
18 | throw new Error('Node.js crypto module only supports scrypt');
19 | }
20 | const params = Object.fromEntries(
21 | parsed[1].split(',').map((p) => {
22 | const kv = p.split('=');
23 | kv[1] = Number(kv[1]);
24 | return kv;
25 | }),
26 | );
27 | const salt = Buffer.from(parsed[2], 'base64');
28 | const hash = Buffer.from(parsed[3], 'base64');
29 | return { params, salt, hash };
30 | };
31 |
32 | const SALT_LEN = 32;
33 | const KEY_LEN = 64;
34 |
35 | // Only change these if you know what you're doing
36 | const SCRYPT_PARAMS = {
37 | N: 32768,
38 | r: 8,
39 | p: 1,
40 | maxmem: 64 * 1024 * 1024,
41 | };
42 |
43 | const hashPassword = (password) =>
44 | new Promise((resolve, reject) => {
45 | crypto.randomBytes(SALT_LEN, (err, salt) => {
46 | if (err) {
47 | reject(err);
48 | return;
49 | }
50 | crypto.scrypt(password, salt, KEY_LEN, SCRYPT_PARAMS, (err, hash) => {
51 | if (err) {
52 | reject(err);
53 | return;
54 | }
55 | resolve(serializeHash(hash, salt, SCRYPT_PARAMS));
56 | });
57 | });
58 | });
59 |
60 | let defaultHash;
61 | hashPassword('').then((hash) => {
62 | defaultHash = hash;
63 | });
64 |
65 | const validatePassword = (password, hash = defaultHash) =>
66 | new Promise((resolve, reject) => {
67 | const parsedHash = deserializeHash(hash);
68 | const len = parsedHash.hash.length;
69 | crypto.scrypt(
70 | password,
71 | parsedHash.salt,
72 | len,
73 | parsedHash.params,
74 | (err, hashedPassword) => {
75 | if (err) {
76 | reject(err);
77 | return;
78 | }
79 | resolve(crypto.timingSafeEqual(hashedPassword, parsedHash.hash));
80 | },
81 | );
82 | });
83 |
84 | module.exports = { hashPassword, validatePassword };
85 |
--------------------------------------------------------------------------------
/lib/database.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const { npm } = require('./dependencies.js');
4 | const { pg } = npm;
5 | const application = require('./application.js');
6 |
7 | const OPERATORS = ['>=', '<=', '<>', '>', '<'];
8 |
9 | const where = (conditions, firstArgIndex = 1) => {
10 | const clause = [];
11 | const args = [];
12 | let i = firstArgIndex;
13 | const keys = Object.keys(conditions);
14 | for (const key of keys) {
15 | let operator = '=';
16 | let value = conditions[key];
17 | if (typeof value === 'string') {
18 | for (const op of OPERATORS) {
19 | const len = op.length;
20 | if (value.startsWith(op)) {
21 | operator = op;
22 | value = value.substring(len);
23 | }
24 | }
25 | if (value.includes('*') || value.includes('?')) {
26 | operator = 'LIKE';
27 | value = value.replace('*', '%').replace('?', '_');
28 | }
29 | }
30 | clause.push(`${key} ${operator} $${i++}`);
31 | args.push(value);
32 | }
33 | return { clause: clause.join(' AND '), args };
34 | };
35 |
36 | const updates = (delta, firstArgIndex = 1) => {
37 | const clause = [];
38 | const args = [];
39 | let i = firstArgIndex;
40 | const keys = Object.keys(delta);
41 | for (const key of keys) {
42 | const value = delta[key].toString();
43 | clause.push(`${key} = $${i++}`);
44 | args.push(value);
45 | }
46 | return { clause: clause.join(', '), args };
47 | };
48 |
49 | class Database {
50 | constructor(config) {
51 | this.pool = new pg.Pool(config);
52 | }
53 |
54 | query(sql, values) {
55 | const data = values ? values.join(',') : '';
56 | application.logger.log(`${sql}\t[${data}]`);
57 | return this.pool.query(sql, values);
58 | }
59 |
60 | insert(table, record) {
61 | const keys = Object.keys(record);
62 | const nums = new Array(keys.length);
63 | const data = new Array(keys.length);
64 | let i = 0;
65 | for (const key of keys) {
66 | data[i] = record[key];
67 | nums[i] = `$${++i}`;
68 | }
69 | const fields = keys.join(', ');
70 | const params = nums.join(', ');
71 | const sql = `INSERT INTO ${table} (${fields}) VALUES (${params})`;
72 | return this.query(sql, data);
73 | }
74 |
75 | async select(table, fields = ['*'], conditions = null) {
76 | const keys = fields.join(', ');
77 | const sql = `SELECT ${keys} FROM ${table}`;
78 | let whereClause = '';
79 | let args = [];
80 | if (conditions) {
81 | const whereData = where(conditions);
82 | whereClause = ' WHERE ' + whereData.clause;
83 | args = whereData.args;
84 | }
85 | const res = await this.query(sql + whereClause, args);
86 | return res.rows;
87 | }
88 |
89 | delete(table, conditions = null) {
90 | const { clause, args } = where(conditions);
91 | const sql = `DELETE FROM ${table} WHERE ${clause}`;
92 | return this.query(sql, args);
93 | }
94 |
95 | update(table, delta = null, conditions = null) {
96 | const upd = updates(delta);
97 | const cond = where(conditions, upd.args.length + 1);
98 | const sql = `UPDATE ${table} SET ${upd.clause} WHERE ${cond.clause}`;
99 | const args = [...upd.args, ...cond.args];
100 | return this.query(sql, args);
101 | }
102 |
103 | close() {
104 | this.pool.end();
105 | }
106 | }
107 |
108 | module.exports = Database;
109 |
--------------------------------------------------------------------------------
/application/static/console.css:
--------------------------------------------------------------------------------
1 | * {
2 | padding: 0;
3 | margin: 0;
4 | outline: none;
5 | cursor: default;
6 | -moz-user-select: inherit;
7 | }
8 | a, a * {
9 | cursor: pointer;
10 | }
11 | html, body {
12 | padding: 0;
13 | margin: 0;
14 | font-family: 'Share Tech Mono', monospace;
15 | font-size: 11pt;
16 | overflow: hidden;
17 | height: 100%;
18 | background: #000;
19 | color: #FFF;
20 | }
21 | body {
22 | height: 100%;
23 | }
24 | input, textarea {
25 | -webkit-border-radius: 0;
26 | -webkit-touch-callout: text;
27 | -webkit-user-select: text;
28 | -khtml-user-select: text;
29 | -moz-user-select: text;
30 | -ms-user-select: text;
31 | user-select: text;
32 | }
33 | ul,ol {
34 | padding: 0 0 0 30px;
35 | }
36 | #screenConsole {
37 | height: 100%;
38 | }
39 | #screenConsole > div {
40 | overflow: hidden;
41 | }
42 | #panelColors {
43 | height: 100%;
44 | width: 8px;
45 | float: left;
46 | background: #FF0000;
47 | }
48 | .colorA { background: #AA0077; height: 40px; }
49 | .colorB { background: #552277; }
50 | .colorC { background: #2222BB; }
51 | .colorD { background: #0033DD; }
52 | .colorE { background: #006699; }
53 | .colorF { background: #009933; }
54 | .colorG { background: #7FD900; }
55 | .colorH { background: #F2F200; }
56 | .colorI { background: #FFBF00; }
57 | .colorJ { background: #FF8C00; }
58 | .colorK { background: #FF3300; }
59 | .colorL { background: #FF0000; height: 40px; }
60 | #panelLogo {
61 | margin: 4px;
62 | position: absolute;
63 | top: 0;
64 | left: 8px;
65 | right: 8px;
66 | background: #000;
67 | }
68 | #panelConsole {
69 | position: absolute;
70 | left: 8px;
71 | right: 8px;
72 | top: 8px;
73 | bottom: 0;
74 | }
75 | #panelScroll {
76 | height: 100%;
77 | width: 8px;
78 | float: right;
79 | background: #262626;
80 | }
81 | #controlScroll {
82 | background: #009933;
83 | position: absolute;
84 | width: 8px;
85 | height: 25px;
86 | bottom: 0px;
87 | }
88 | #panelColors > div {
89 | height: 25pt;
90 | }
91 | #controlShadow {
92 | position: absolute;
93 | top: -10px;
94 | left: 0;
95 | right: 0;
96 | height: 10px;
97 | box-shadow: 0px 0px 20px 6px rgba(0,0,0,1);
98 | z-index: 1;
99 | }
100 | #controlBrowse {
101 | padding: 4px;
102 | color: #009933;
103 | overflow-x: hidden;
104 | overflow-y: scroll;
105 | position: absolute;
106 | left: 0;
107 | right: 0;
108 | top: 0;
109 | bottom: 0;
110 | }
111 | #controlBrowse td {
112 | padding: 2px 4px;
113 | }
114 | #controlBrowse th {
115 | padding: 2px 4px;
116 | font-weight: bold;
117 | color: #FFBF00;
118 | }
119 | #controlBrowse tr:nth-child(even) {
120 | background: #101010;
121 | }
122 | #controlBrowse tr:nth-child(odd) {
123 | background: #262626;
124 | }
125 | #controlInput {
126 | color: #009933;
127 | }
128 | #controlInput span {
129 | animation: blinker 1s ease-out infinite;
130 | margin-left: 2px;
131 | }
132 | @keyframes blinker {
133 | 50% { opacity: 0.0; }
134 | }
135 | #controlKeyboard {
136 | background: #000;
137 | position: absolute;
138 | bottom: 0;
139 | right: 0;
140 | left: 0;
141 | }
142 | #controlKeyboard .key {
143 | font-size: 1.4em;
144 | background: #262626;
145 | display: inline-block;
146 | text-align: center;
147 | width: 10%;
148 | height: 25px;
149 | }
150 | .caps {
151 | text-transform: uppercase;
152 | }
153 | ::-webkit-scrollbar {
154 | display: none;
155 | }
156 | #controlBrowseSpacer {
157 | height: 100%;
158 | }
159 |
--------------------------------------------------------------------------------
/lib/server.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const { node, npm } = require('./dependencies.js');
4 | const { http, https } = node;
5 | const { common, ws } = npm;
6 | const { Channel } = require('./channel.js');
7 | const { application } = require('./application.js');
8 |
9 | const SHUTDOWN_TIMEOUT = 5000;
10 | const SHORT_TIMEOUT = 500;
11 | const LONG_RESPONSE = 30000;
12 |
13 | const receiveBody = async (req) => {
14 | const buffers = [];
15 | for await (const chunk of req) {
16 | buffers.push(chunk);
17 | }
18 | return Buffer.concat(buffers).toString();
19 | };
20 |
21 | class Server {
22 | constructor(config) {
23 | this.config = config;
24 | this.channels = new Map();
25 | const { port, host, protocol, cert } = config;
26 | this.port = port;
27 | this.host = host;
28 | this.protocol = protocol;
29 | const transport = protocol === 'http' ? http : https;
30 | const listener = this.listener.bind(this);
31 | this.server = transport.createServer(cert, listener);
32 | this.ws = new ws.Server({ server: this.server });
33 | this.ws.on('connection', async (connection, req) => {
34 | const channel = await new Channel(req, null, connection, application);
35 | connection.on('message', (data) => {
36 | channel.message(data);
37 | });
38 | });
39 | this.server.listen(this.port, host);
40 | }
41 |
42 | async listener(req, res) {
43 | let finished = false;
44 | const { url, connection } = req;
45 | const channel = await new Channel(req, res, null, application);
46 | this.channels.set(connection, channel);
47 |
48 | const timer = setTimeout(() => {
49 | if (finished) return;
50 | finished = true;
51 | this.channels.delete(connection);
52 | channel.error(504);
53 | }, LONG_RESPONSE);
54 |
55 | res.on('close', () => {
56 | if (finished) return;
57 | finished = true;
58 | clearTimeout(timer);
59 | this.channels.delete(connection);
60 | });
61 |
62 | if (url.startsWith('/api')) this.request(channel);
63 | else channel.static();
64 | }
65 |
66 | request(channel) {
67 | const { req } = channel;
68 | if (req.method === 'OPTIONS') {
69 | channel.options();
70 | return;
71 | }
72 | if (req.method !== 'POST') {
73 | channel.error(403);
74 | return;
75 | }
76 | const body = receiveBody(req);
77 | if (req.url === '/api') {
78 | body.then((data) => {
79 | channel.message(data);
80 | });
81 | } else {
82 | body.then((data) => {
83 | const { pathname, searchParams } = new URL('http://' + req.url);
84 | const [, interfaceName, methodName] = pathname.split('/');
85 | const args = data ? JSON.parse(data) : Object.fromEntries(searchParams);
86 | channel.rpc(-1, interfaceName, methodName, args);
87 | });
88 | }
89 | body.catch((err) => {
90 | channel.error(500, err);
91 | });
92 | }
93 |
94 | closeChannels() {
95 | const { channels } = this;
96 | for (const [connection, channel] of channels.entries()) {
97 | channels.delete(connection);
98 | channel.error(503);
99 | connection.destroy();
100 | }
101 | }
102 |
103 | async close() {
104 | this.server.close((err) => {
105 | if (err) application.logger.error(err.stack);
106 | });
107 | if (this.channels.size === 0) {
108 | await common.timeout(SHORT_TIMEOUT);
109 | return;
110 | }
111 | await common.timeout(SHUTDOWN_TIMEOUT);
112 | this.closeChannels();
113 | }
114 | }
115 |
116 | module.exports = Server;
117 |
--------------------------------------------------------------------------------
/.eslintrc.json:
--------------------------------------------------------------------------------
1 | {
2 | "env": {
3 | "browser": true,
4 | "es6": true,
5 | "node": true
6 | },
7 | "extends": "eslint:recommended",
8 | "parserOptions": {
9 | "ecmaVersion": 2020
10 | },
11 | "globals": {
12 | "BigInt": true
13 | },
14 | "rules": {
15 | "indent": ["error", 2],
16 | "linebreak-style": ["error", "unix"],
17 | "quotes": ["error", "single"],
18 | "semi": ["error", "always"],
19 | "no-loop-func": ["error"],
20 | "block-spacing": ["error", "always"],
21 | "camelcase": ["error"],
22 | "eqeqeq": ["error", "always"],
23 | "strict": ["error", "global"],
24 | "brace-style": [
25 | "error",
26 | "1tbs",
27 | {
28 | "allowSingleLine": true
29 | }
30 | ],
31 | "comma-style": ["error", "last"],
32 | "comma-spacing": [
33 | "error",
34 | {
35 | "before": false,
36 | "after": true
37 | }
38 | ],
39 | "eol-last": ["error"],
40 | "func-call-spacing": ["error", "never"],
41 | "key-spacing": [
42 | "error",
43 | {
44 | "beforeColon": false,
45 | "afterColon": true,
46 | "mode": "minimum"
47 | }
48 | ],
49 | "keyword-spacing": [
50 | "error",
51 | {
52 | "before": true,
53 | "after": true,
54 | "overrides": {
55 | "function": {
56 | "after": false
57 | }
58 | }
59 | }
60 | ],
61 | "max-len": [
62 | "error",
63 | {
64 | "code": 80,
65 | "ignoreUrls": true
66 | }
67 | ],
68 | "max-nested-callbacks": [
69 | "error",
70 | {
71 | "max": 7
72 | }
73 | ],
74 | "new-cap": [
75 | "error",
76 | {
77 | "newIsCap": true,
78 | "capIsNew": false,
79 | "properties": true
80 | }
81 | ],
82 | "new-parens": ["error"],
83 | "no-lonely-if": ["error"],
84 | "no-trailing-spaces": ["error"],
85 | "no-unneeded-ternary": ["error"],
86 | "no-whitespace-before-property": ["error"],
87 | "object-curly-spacing": ["error", "always"],
88 | "operator-assignment": ["error", "always"],
89 | "operator-linebreak": ["error", "after"],
90 | "semi-spacing": [
91 | "error",
92 | {
93 | "before": false,
94 | "after": true
95 | }
96 | ],
97 | "space-before-blocks": ["error", "always"],
98 | "space-before-function-paren": [
99 | "error",
100 | {
101 | "anonymous": "never",
102 | "named": "never",
103 | "asyncArrow": "always"
104 | }
105 | ],
106 | "space-in-parens": ["error", "never"],
107 | "space-infix-ops": ["error"],
108 | "space-unary-ops": [
109 | "error",
110 | {
111 | "words": true,
112 | "nonwords": false,
113 | "overrides": {
114 | "typeof": false
115 | }
116 | }
117 | ],
118 | "no-unreachable": ["error"],
119 | "no-global-assign": ["error"],
120 | "no-self-compare": ["error"],
121 | "no-unmodified-loop-condition": ["error"],
122 | "no-constant-condition": [
123 | "error",
124 | {
125 | "checkLoops": false
126 | }
127 | ],
128 | "no-console": ["off"],
129 | "no-useless-concat": ["error"],
130 | "no-useless-escape": ["error"],
131 | "no-shadow-restricted-names": ["error"],
132 | "no-use-before-define": [
133 | "error",
134 | {
135 | "functions": false
136 | }
137 | ],
138 | "arrow-parens": ["error", "always"],
139 | "arrow-body-style": ["error", "as-needed"],
140 | "arrow-spacing": ["error"],
141 | "no-confusing-arrow": [
142 | "error",
143 | {
144 | "allowParens": true
145 | }
146 | ],
147 | "no-useless-computed-key": ["error"],
148 | "no-useless-rename": ["error"],
149 | "no-var": ["error"],
150 | "object-shorthand": ["error", "always"],
151 | "prefer-arrow-callback": ["error"],
152 | "prefer-const": ["error"],
153 | "prefer-numeric-literals": ["error"],
154 | "prefer-rest-params": ["error"],
155 | "prefer-spread": ["error"],
156 | "rest-spread-spacing": ["error", "never"],
157 | "template-curly-spacing": ["error", "never"]
158 | }
159 | }
160 |
--------------------------------------------------------------------------------
/lib/auth.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const { node, npm } = require('./dependencies.js');
4 | const { crypto } = node;
5 | const { common } = npm;
6 | const application = require('./application.js');
7 |
8 | const BYTE = 256;
9 | const TOKEN = 'token';
10 | const TOKEN_LENGTH = 32;
11 | const ALPHA_UPPER = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
12 | const ALPHA_LOWER = 'abcdefghijklmnopqrstuvwxyz';
13 | const ALPHA = ALPHA_UPPER + ALPHA_LOWER;
14 | const DIGIT = '0123456789';
15 | const ALPHA_DIGIT = ALPHA + DIGIT;
16 | const EPOCH = 'Thu, 01 Jan 1970 00:00:00 GMT';
17 | const FUTURE = 'Fri, 01 Jan 2100 00:00:00 GMT';
18 | const LOCATION = 'Path=/; Domain';
19 | const COOKIE_DELETE = `${TOKEN}=deleted; Expires=${EPOCH}; ${LOCATION}=`;
20 | const COOKIE_HOST = `Expires=${FUTURE}; ${LOCATION}`;
21 |
22 | const sessions = new Map();
23 | const cache = new WeakMap();
24 |
25 | const generateToken = () => {
26 | const base = ALPHA_DIGIT.length;
27 | const bytes = crypto.randomBytes(base);
28 | let key = '';
29 | for (let i = 0; i < TOKEN_LENGTH; i++) {
30 | const index = ((bytes[i] * base) / BYTE) | 0;
31 | key += ALPHA_DIGIT[index];
32 | }
33 | return key;
34 | };
35 |
36 | const parseCookies = (cookie) => {
37 | const values = {};
38 | const items = cookie.split(';');
39 | for (const item of items) {
40 | const parts = item.split('=');
41 | const key = parts[0].trim();
42 | const val = parts[1] || '';
43 | values[key] = val.trim();
44 | }
45 | return values;
46 | };
47 |
48 | module.exports = () => {
49 | const { db } = application;
50 |
51 | const save = (token, context) => {
52 | const data = JSON.stringify(context);
53 | db.update('Session', { data }, { token });
54 | };
55 |
56 | class Session {
57 | constructor(token, contextData = { token }) {
58 | const contextHandler = {
59 | get: (data, key) => {
60 | if (key === 'token') return this.token;
61 | return Reflect.get(data, key);
62 | },
63 | set: (data, key, value) => {
64 | const res = Reflect.set(data, key, value);
65 | save(token, this.data);
66 | return res;
67 | },
68 | };
69 | this.token = token;
70 | this.data = contextData;
71 | this.context = new Proxy(contextData, contextHandler);
72 | }
73 | }
74 |
75 | const start = (client, userId) => {
76 | const token = generateToken();
77 | const host = common.parseHost(client.req.headers.host);
78 | const ip = client.req.connection.remoteAddress;
79 | const cookie = `${TOKEN}=${token}; ${COOKIE_HOST}=${host}; HttpOnly`;
80 | const session = new Session(token);
81 | sessions.set(token, session);
82 | cache.set(client.req, session);
83 | const data = JSON.stringify(session.data);
84 | db.insert('Session', { userId, token, ip, data });
85 | if (client.res) client.res.setHeader('Set-Cookie', cookie);
86 | return session;
87 | };
88 |
89 | const restore = async (client) => {
90 | const cachedSession = cache.get(client.req);
91 | if (cachedSession) return cachedSession;
92 | const { cookie } = client.req.headers;
93 | if (!cookie) return null;
94 | const cookies = parseCookies(cookie);
95 | const { token } = cookies;
96 | if (!token) return null;
97 | let session = sessions.get(token);
98 | if (!session) {
99 | const [record] = await db.select('Session', ['Data'], { token });
100 | if (record && record.data) {
101 | const data = JSON.parse(record.data);
102 | session = new Session(token, data);
103 | sessions.set(token, session);
104 | }
105 | }
106 | if (!session) return null;
107 | cache.set(client.req, session);
108 | return session;
109 | };
110 |
111 | const remove = (client, token) => {
112 | const host = common.parseHost(client.req.headers.host);
113 | client.res.setHeader('Set-Cookie', COOKIE_DELETE + host);
114 | sessions.delete(token);
115 | db.delete('Session', { token });
116 | };
117 |
118 | const registerUser = (login, password, fullName) => {
119 | db.insert('SystemUser', { login, password, fullName });
120 | };
121 |
122 | const getUser = (login) =>
123 | db
124 | .select('SystemUser', ['Id', 'Password'], { login })
125 | .then(([user]) => user);
126 |
127 | return { start, restore, remove, save, registerUser, getUser };
128 | };
129 |
--------------------------------------------------------------------------------
/application/static/metacom.js:
--------------------------------------------------------------------------------
1 | class MetacomError extends Error {
2 | constructor(message, code) {
3 | super(message);
4 | this.code = code;
5 | }
6 | }
7 |
8 | class MetacomInterface {
9 | constructor() {
10 | this._events = new Map();
11 | }
12 |
13 | on(name, fn) {
14 | const event = this._events.get(name);
15 | if (event) event.add(fn);
16 | else this._events.set(name, new Set([fn]));
17 | }
18 |
19 | emit(name, ...args) {
20 | const event = this._events.get(name);
21 | if (!event) return;
22 | for (const fn of event.values()) fn(...args);
23 | }
24 | }
25 |
26 | export class Metacom {
27 | constructor(url) {
28 | this.url = url;
29 | this.socket = new WebSocket(url);
30 | this.api = {};
31 | this.callId = 0;
32 | this.calls = new Map();
33 | this.socket.addEventListener('message', ({ data }) => {
34 | this.message(data);
35 | });
36 | }
37 |
38 | message(data) {
39 | let packet;
40 | try {
41 | packet = JSON.parse(data);
42 | } catch (err) {
43 | console.error(err);
44 | return;
45 | }
46 | const [callType, target] = Object.keys(packet);
47 | const callId = packet[callType];
48 | const args = packet[target];
49 | if (callId && args) {
50 | if (callType === 'callback') {
51 | const promised = this.calls.get(callId);
52 | if (!promised) return;
53 | const [resolve, reject] = promised;
54 | if (packet.error) {
55 | const { message, code } = packet.error;
56 | const error = new MetacomError(message, code);
57 | reject(error);
58 | return;
59 | }
60 | resolve(args);
61 | return;
62 | }
63 | if (callType === 'event') {
64 | const [interfaceName, eventName] = target.split('/');
65 | const metacomInterface = this.api[interfaceName];
66 | metacomInterface.emit(eventName, args);
67 | }
68 | }
69 | }
70 |
71 | ready() {
72 | return new Promise((resolve) => {
73 | if (this.socket.readyState === WebSocket.OPEN) resolve();
74 | else this.socket.addEventListener('open', resolve);
75 | });
76 | }
77 |
78 | async load(...interfaces) {
79 | const introspect = this.httpCall('system')('introspect');
80 | const introspection = await introspect(interfaces);
81 | const available = Object.keys(introspection);
82 | for (const interfaceName of interfaces) {
83 | if (!available.includes(interfaceName)) continue;
84 | const methods = new MetacomInterface();
85 | const iface = introspection[interfaceName];
86 | const request = this.socketCall(interfaceName);
87 | const methodNames = Object.keys(iface);
88 | for (const methodName of methodNames) {
89 | methods[methodName] = request(methodName);
90 | }
91 | this.api[interfaceName] = methods;
92 | }
93 | }
94 |
95 | httpCall(iname, ver) {
96 | return (methodName) =>
97 | (args = {}) => {
98 | const callId = ++this.callId;
99 | const interfaceName = ver ? `${iname}.${ver}` : iname;
100 | const target = interfaceName + '/' + methodName;
101 | const packet = { call: callId, [target]: args };
102 | const dest = new URL(this.url);
103 | const protocol = dest.protocol === 'ws:' ? 'http' : 'https';
104 | const url = `${protocol}://${dest.host}/api`;
105 | return fetch(url, {
106 | method: 'POST',
107 | headers: { 'Content-Type': 'application/json' },
108 | body: JSON.stringify(packet),
109 | }).then((res) => {
110 | const { status } = res;
111 | if (status === 200) return res.json().then(({ result }) => result);
112 | throw new Error(`Status Code: ${status}`);
113 | });
114 | };
115 | }
116 |
117 | socketCall(iname, ver) {
118 | return (methodName) =>
119 | async (args = {}) => {
120 | const callId = ++this.callId;
121 | const interfaceName = ver ? `${iname}.${ver}` : iname;
122 | const target = interfaceName + '/' + methodName;
123 | await this.ready();
124 | return new Promise((resolve, reject) => {
125 | this.calls.set(callId, [resolve, reject]);
126 | const packet = { call: callId, [target]: args };
127 | this.socket.send(JSON.stringify(packet));
128 | });
129 | };
130 | }
131 | }
132 |
--------------------------------------------------------------------------------
/lib/channel.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const { http, path } = require('./dependencies.js').node;
4 |
5 | const MIME_TYPES = {
6 | html: 'text/html; charset=UTF-8',
7 | json: 'application/json; charset=UTF-8',
8 | js: 'application/javascript; charset=UTF-8',
9 | css: 'text/css',
10 | png: 'image/png',
11 | ico: 'image/x-icon',
12 | svg: 'image/svg+xml',
13 | };
14 |
15 | const HEADERS = {
16 | 'X-XSS-Protection': '1; mode=block',
17 | 'X-Content-Type-Options': 'nosniff',
18 | 'Strict-Transport-Security': 'max-age=31536000; includeSubdomains; preload',
19 | 'Access-Control-Allow-Origin': '*',
20 | 'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
21 | 'Access-Control-Allow-Headers': 'Content-Type',
22 | 'Content-Security-Policy': [
23 | "default-src 'self' ws:",
24 | "style-src 'self' https://fonts.googleapis.com",
25 | "font-src 'self' https://fonts.gstatic.com",
26 | ].join('; '),
27 | };
28 |
29 | class Client {
30 | constructor(connection) {
31 | this.callId = 0;
32 | this.connection = connection;
33 | }
34 |
35 | emit(name, data) {
36 | const packet = { event: --this.callId, [name]: data };
37 | this.connection.send(JSON.stringify(packet));
38 | }
39 | }
40 |
41 | class Channel {
42 | constructor(req, res, connection, application) {
43 | this.req = req;
44 | this.res = res;
45 | this.ip = req.socket.remoteAddress;
46 | this.connection = connection;
47 | this.application = application;
48 | this.client = new Client(connection);
49 | this.session = null;
50 | return this.init();
51 | }
52 |
53 | async init() {
54 | this.session = await this.application.auth.restore(this);
55 | return this;
56 | }
57 |
58 | static() {
59 | const {
60 | req: { url, method },
61 | res,
62 | ip,
63 | application,
64 | } = this;
65 | const filePath = url === '/' ? '/index.html' : url;
66 | const fileExt = path.extname(filePath).substring(1);
67 | const mimeType = MIME_TYPES[fileExt] || MIME_TYPES.html;
68 | res.writeHead(200, { ...HEADERS, 'Content-Type': mimeType });
69 | if (res.writableEnded) return;
70 | const data = application.getStaticFile(filePath);
71 | if (data) {
72 | res.end(data);
73 | application.logger.access(`${ip}\t${method}\t${url}`);
74 | return;
75 | }
76 | this.error(404);
77 | }
78 |
79 | redirect(location) {
80 | const { res } = this;
81 | if (res.headersSent) return;
82 | res.writeHead(302, { Location: location, ...HEADERS });
83 | res.end();
84 | }
85 |
86 | options() {
87 | const { res } = this;
88 | if (res.headersSent) return;
89 | res.writeHead(200, HEADERS);
90 | res.end();
91 | }
92 |
93 | error(code, err, callId = err) {
94 | const {
95 | req: { url, method },
96 | res,
97 | connection,
98 | ip,
99 | application,
100 | } = this;
101 | const status = http.STATUS_CODES[code];
102 | if (typeof err === 'number') err = undefined;
103 | const reason = err ? err.stack : status;
104 | application.logger.error(`${ip}\t${method}\t${url}\t${code}\t${reason}`);
105 | const { Error } = this.application;
106 | const message = err instanceof Error ? err.message : status;
107 | const error = { message, code };
108 | if (connection) {
109 | connection.send(JSON.stringify({ callback: callId, error }));
110 | return;
111 | }
112 | if (res.writableEnded) return;
113 | res.writeHead(code, { 'Content-Type': MIME_TYPES.json, ...HEADERS });
114 | res.end(JSON.stringify({ error }));
115 | }
116 |
117 | message(data) {
118 | let packet;
119 | try {
120 | packet = JSON.parse(data);
121 | } catch (err) {
122 | this.error(500, new Error('JSON parsing error'));
123 | return;
124 | }
125 | const [callType, target] = Object.keys(packet);
126 | const callId = packet[callType];
127 | const args = packet[target];
128 | if (callId && args) {
129 | const [interfaceName, methodName] = target.split('/');
130 | this.rpc(callId, interfaceName, methodName, args);
131 | return;
132 | }
133 | this.error(500, new Error('Packet structure error'));
134 | }
135 |
136 | async rpc(callId, interfaceName, methodName, args) {
137 | const { res, connection, ip, application, session, client } = this;
138 | const [iname, ver = '*'] = interfaceName.split('.');
139 | try {
140 | const context = session ? session.context : { client };
141 | const proc = application.getMethod(iname, ver, methodName, context);
142 | if (!proc) {
143 | this.error(404, callId);
144 | return;
145 | }
146 | if (!this.session && proc.access !== 'public') {
147 | this.error(403, callId);
148 | return;
149 | }
150 | const result = await proc.method(args);
151 | if (result instanceof Error) {
152 | this.error(result.code, result, callId);
153 | return;
154 | }
155 | const userId = result ? result.userId : undefined;
156 | if (!this.session && userId && proc.access === 'public') {
157 | this.session = application.auth.start(this, userId);
158 | result.token = this.session.token;
159 | }
160 | const data = JSON.stringify({ callback: callId, result });
161 | if (connection) {
162 | connection.send(data);
163 | } else {
164 | res.writeHead(200, { 'Content-Type': MIME_TYPES.json, ...HEADERS });
165 | res.end(data);
166 | }
167 | const token = this.session ? this.session.token : 'anonymous';
168 | const record = `${ip}\t${token}\t${interfaceName}/${methodName}`;
169 | application.logger.access(record);
170 | } catch (err) {
171 | this.error(500, err, callId);
172 | }
173 | }
174 | }
175 |
176 | module.exports = Channel;
177 |
--------------------------------------------------------------------------------
/lib/application.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const { node, npm } = require('./dependencies.js');
4 | const { path, events, vm, fs, fsp } = node;
5 | const { common } = npm;
6 | const security = require('./security.js');
7 |
8 | const SCRIPT_OPTIONS = { timeout: 5000 };
9 | const EMPTY_CONTEXT = Object.freeze({});
10 | const MODULE = 2;
11 |
12 | class Application extends events.EventEmitter {
13 | constructor() {
14 | super();
15 | this.initialization = true;
16 | this.finalization = false;
17 | this.namespaces = ['db'];
18 | this.api = {};
19 | this.static = new Map();
20 | this.root = process.cwd();
21 | this.path = path.join(this.root, 'application');
22 | this.apiPath = path.join(this.path, 'api');
23 | this.libPath = path.join(this.path, 'lib');
24 | this.domainPath = path.join(this.path, 'domain');
25 | this.staticPath = path.join(this.path, 'static');
26 | this.starts = [];
27 | }
28 |
29 | async init() {
30 | this.createSandbox();
31 | await Promise.allSettled([
32 | this.loadPlace('static', this.staticPath),
33 | this.loadPlace('api', this.apiPath),
34 | (async () => {
35 | await this.loadPlace('lib', this.libPath);
36 | await this.loadPlace('domain', this.domainPath);
37 | })(),
38 | ]);
39 | await Promise.allSettled(this.starts.map((fn) => fn()));
40 | this.starts = null;
41 | this.initialization = true;
42 | }
43 |
44 | async shutdown() {
45 | this.finalization = true;
46 | await this.stopPlace('domain');
47 | await this.stopPlace('lib');
48 | if (this.server) await this.server.close();
49 | await this.logger.close();
50 | }
51 |
52 | async stopPlace(name) {
53 | const place = this.sandbox[name];
54 | for (const moduleName of Object.keys(place)) {
55 | const module = place[moduleName];
56 | if (module.stop) await this.execute(module.stop);
57 | }
58 | }
59 |
60 | createSandbox() {
61 | const { config, namespaces, server: { host, port, protocol } = {} } = this;
62 | const introspect = async (interfaces) => this.introspect(interfaces);
63 | const worker = { id: 'W' + node.worker.threadId.toString() };
64 | const server = { host, port, protocol };
65 | const application = { security, introspect, worker, server };
66 | const api = {};
67 | const lib = {};
68 | const domain = {};
69 | for (const name of namespaces) application[name] = this[name];
70 | const sandbox = {
71 | Buffer,
72 | URL,
73 | URLSearchParams,
74 | Error: this.Error,
75 | console: this.logger,
76 | application,
77 | node,
78 | npm,
79 | api,
80 | lib,
81 | domain,
82 | config,
83 | setTimeout,
84 | setImmediate,
85 | setInterval,
86 | clearTimeout,
87 | clearImmediate,
88 | clearInterval,
89 | };
90 | this.sandbox = vm.createContext(sandbox);
91 | }
92 |
93 | sandboxInject(name, module) {
94 | this[name] = Object.freeze(module);
95 | this.namespaces.push(name);
96 | }
97 |
98 | async createScript(fileName) {
99 | try {
100 | const code = await fsp.readFile(fileName, 'utf8');
101 | if (!code) return null;
102 | const src = `'use strict';\n(context) => ${code}`;
103 | const options = { filename: fileName, lineOffset: -1 };
104 | const script = new vm.Script(src, options);
105 | return script.runInContext(this.sandbox, SCRIPT_OPTIONS);
106 | } catch (err) {
107 | if (err.code !== 'ENOENT') {
108 | this.logger.error(err.stack);
109 | }
110 | return null;
111 | }
112 | }
113 |
114 | getMethod(iname, ver, methodName, context) {
115 | const iface = this.api[iname];
116 | if (!iface) return null;
117 | const version = ver === '*' ? iface.default : parseInt(ver);
118 | const methods = iface[version.toString()];
119 | if (!methods) return null;
120 | const method = methods[methodName];
121 | if (!method) return null;
122 | const exp = method(context);
123 | return typeof exp === 'object' ? exp : { access: 'logged', method: exp };
124 | }
125 |
126 | async loadMethod(fileName) {
127 | const rel = fileName.substring(this.apiPath.length + 1);
128 | if (!rel.includes('/')) return;
129 | const [interfaceName, methodFile] = rel.split('/');
130 | if (!methodFile.endsWith('.js')) return;
131 | const name = path.basename(methodFile, '.js');
132 | const [iname, ver] = interfaceName.split('.');
133 | const version = parseInt(ver, 10);
134 | const script = await this.createScript(fileName);
135 | if (!script) return;
136 | let iface = this.api[iname];
137 | const { api } = this.sandbox;
138 | let internalInterface = api[iname];
139 | if (!iface) {
140 | this.api[iname] = iface = { default: version };
141 | api[iname] = internalInterface = {};
142 | }
143 | let methods = iface[ver];
144 | if (!methods) iface[ver] = methods = {};
145 | methods[name] = script;
146 | internalInterface[name] = script(EMPTY_CONTEXT);
147 | if (version > iface.default) iface.default = version;
148 | }
149 |
150 | async loadModule(fileName) {
151 | const rel = fileName.substring(this.path.length + 1);
152 | if (!rel.endsWith('.js')) return;
153 | const script = await this.createScript(fileName);
154 | const name = path.basename(rel, '.js');
155 | const namespaces = rel.split(path.sep);
156 | namespaces[namespaces.length - 1] = name;
157 | const exp = script ? script(EMPTY_CONTEXT) : null;
158 | const container = typeof exp === 'function' ? { method: exp } : exp;
159 | const iface = {};
160 | if (container !== null) {
161 | const methods = Object.keys(container);
162 | for (const method of methods) {
163 | const fn = container[method];
164 | if (typeof fn === 'function') {
165 | container[method] = iface[method] = fn.bind(container);
166 | }
167 | }
168 | }
169 | let level = this.sandbox;
170 | const last = namespaces.length - 1;
171 | for (let depth = 0; depth <= last; depth++) {
172 | const namespace = namespaces[depth];
173 | let next = level[namespace];
174 | if (next) {
175 | if (depth === MODULE && namespace === 'stop') {
176 | if (exp === null && level.stop) await this.execute(level.stop);
177 | }
178 | } else {
179 | next = depth === last ? iface : {};
180 | level[namespace] = iface.method || iface;
181 | container.parent = level;
182 | if (depth === MODULE && namespace === 'start') {
183 | this.starts.push(iface.method);
184 | }
185 | }
186 | level = next;
187 | }
188 | }
189 |
190 | async execute(fn) {
191 | try {
192 | await fn();
193 | } catch (err) {
194 | this.logger.error(err.stack);
195 | }
196 | }
197 |
198 | async loadFile(filePath) {
199 | const key = filePath.substring(this.staticPath.length);
200 | try {
201 | const data = await fsp.readFile(filePath);
202 | this.static.set(key, data);
203 | } catch (err) {
204 | if (err.code !== 'ENOENT') {
205 | this.logger.error(err.stack);
206 | }
207 | }
208 | }
209 |
210 | async loadPlace(place, placePath) {
211 | const files = await fsp.readdir(placePath, { withFileTypes: true });
212 | for (const file of files) {
213 | if (file.name.startsWith('.')) continue;
214 | const filePath = path.join(placePath, file.name);
215 | if (file.isDirectory()) await this.loadPlace(place, filePath);
216 | else if (place === 'api') await this.loadMethod(filePath);
217 | else if (place === 'static') await this.loadFile(filePath);
218 | else await this.loadModule(filePath);
219 | }
220 | this.watch(place, placePath);
221 | }
222 |
223 | watch(place, placePath) {
224 | fs.watch(placePath, async (event, fileName) => {
225 | if (fileName.startsWith('.')) return;
226 | const filePath = path.join(placePath, fileName);
227 | try {
228 | const stat = await node.fsp.stat(filePath);
229 | if (stat.isDirectory()) {
230 | this.loadPlace(place, filePath);
231 | return;
232 | }
233 | } catch {
234 | return;
235 | }
236 | if (node.worker.threadId === 1) {
237 | const relPath = filePath.substring(this.path.length);
238 | this.logger.debug('Reload: ' + relPath);
239 | }
240 | if (place === 'api') this.loadMethod(filePath);
241 | else if (place === 'static') this.loadFile(filePath);
242 | else this.loadModule(filePath);
243 | });
244 | }
245 |
246 | introspect(interfaces) {
247 | const intro = {};
248 | for (const interfaceName of interfaces) {
249 | const [iname, ver = '*'] = interfaceName.split('.');
250 | const iface = this.api[iname];
251 | if (!iface) continue;
252 | const version = ver === '*' ? iface.default : parseInt(ver);
253 | const methods = iface[version.toString()];
254 | const methodNames = Object.keys(methods);
255 | const interfaceMethods = (intro[iname] = {});
256 | for (const methodName of methodNames) {
257 | const exp = methods[methodName](EMPTY_CONTEXT);
258 | const fn = typeof exp === 'object' ? exp.method : exp;
259 | const src = fn.toString();
260 | const signature = common.between(src, '({', '})');
261 | if (signature === '') {
262 | interfaceMethods[methodName] = [];
263 | continue;
264 | }
265 | const args = signature.split(',').map((s) => s.trim());
266 | interfaceMethods[methodName] = args;
267 | }
268 | }
269 | return intro;
270 | }
271 |
272 | getStaticFile(fileName) {
273 | return this.static.get(fileName);
274 | }
275 | }
276 |
277 | const application = new Application();
278 |
279 | application.Error = class extends Error {
280 | constructor(message, code) {
281 | super(message);
282 | this.code = code;
283 | }
284 | };
285 |
286 | module.exports = application;
287 |
--------------------------------------------------------------------------------
/application/static/console.js:
--------------------------------------------------------------------------------
1 | import { Metacom } from './metacom.js';
2 |
3 | const protocol = location.protocol === 'http:' ? 'ws' : 'wss';
4 | const metacom = new Metacom(`${protocol}://${location.host}`);
5 | const { api } = metacom;
6 | window.api = api;
7 |
8 | const ALPHA_UPPER = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
9 | const ALPHA_LOWER = 'abcdefghijklmnopqrstuvwxyz';
10 | const ALPHA = ALPHA_UPPER + ALPHA_LOWER;
11 | const DIGIT = '0123456789';
12 | const CHARS = ALPHA + DIGIT;
13 | const TIME_LINE = 300;
14 | const TIME_CHAR = 20;
15 |
16 | const KEY_CODE = {
17 | BACKSPACE: 8,
18 | TAB: 9,
19 | ENTER: 13,
20 | PAUSE: 19,
21 | ESC: 27,
22 | SPACE: 32,
23 | PGUP: 33,
24 | PGDN: 34,
25 | END: 35,
26 | HOME: 36,
27 | LT: 37,
28 | UP: 38,
29 | RT: 39,
30 | DN: 40,
31 | INS: 45,
32 | DEL: 46,
33 | F1: 112,
34 | F2: 113,
35 | F3: 114,
36 | F4: 115,
37 | F5: 116,
38 | F6: 117,
39 | F7: 118,
40 | F8: 119,
41 | F9: 120,
42 | F10: 121,
43 | F11: 122,
44 | F12: 123,
45 | ACCENT: 192,
46 | };
47 |
48 | const KEY_NAME = {};
49 | for (const keyName in KEY_CODE) KEY_NAME[KEY_CODE[keyName]] = keyName;
50 |
51 | let controlKeyboard, panelScroll;
52 | let controlInput, controlBrowse, controlScroll;
53 |
54 | const pad = (padChar, length) => new Array(length + 1).join(padChar);
55 |
56 | const { userAgent } = navigator;
57 |
58 | const isMobile = () =>
59 | userAgent.match(/Android/i) ||
60 | userAgent.match(/webOS/i) ||
61 | userAgent.match(/iPhone/i) ||
62 | userAgent.match(/iPad/i) ||
63 | userAgent.match(/iPod/i) ||
64 | userAgent.match(/BlackBerry/i) ||
65 | userAgent.match(/Windows Phone/i);
66 |
67 | let viewportHeight, viewableRatio;
68 | let contentHeight, scrollHeight;
69 | let thumbHeight, thumbPosition;
70 |
71 | const refreshScroll = () => {
72 | viewportHeight = controlBrowse.offsetHeight;
73 | contentHeight = controlBrowse.scrollHeight;
74 | viewableRatio = viewportHeight / contentHeight;
75 | scrollHeight = panelScroll.offsetHeight;
76 | thumbHeight = scrollHeight * viewableRatio;
77 | thumbPosition = (controlBrowse.scrollTop * thumbHeight) / viewportHeight;
78 | controlScroll.style.top = thumbPosition + 'px';
79 | controlScroll.style.height = thumbHeight + 'px';
80 | };
81 |
82 | const scrollBottom = () => {
83 | refreshScroll();
84 | controlBrowse.scrollTop = controlBrowse.scrollHeight;
85 | };
86 |
87 | const initScroll = () => {
88 | controlBrowse.scrollTop = controlBrowse.scrollHeight;
89 | controlBrowse.addEventListener('scroll', refreshScroll);
90 | window.addEventListener('orientationchange', () => {
91 | setTimeout(scrollBottom, 0);
92 | });
93 | };
94 |
95 | const showKeyboard = () => {
96 | if (!isMobile()) return;
97 | controlKeyboard.style.display = 'block';
98 | controlBrowse.style.bottom = controlKeyboard.offsetHeight + 'px';
99 | };
100 |
101 | const inputSetValue = (value) => {
102 | controlInput.inputValue = value;
103 | if (controlInput.inputType === 'masked') {
104 | value = pad('*', value.length);
105 | }
106 | value = value.replace(/ /g, ' ');
107 | controlInput.innerHTML =
108 | controlInput.inputPrompt + value + '█';
109 | };
110 |
111 | const input = (type, prompt, callback) => {
112 | showKeyboard();
113 | controlInput.style.display = 'none';
114 | controlBrowse.removeChild(controlInput);
115 | controlInput.inputActive = true;
116 | controlInput.inputPrompt = prompt;
117 | inputSetValue('');
118 | controlInput.inputType = type;
119 | controlInput.inputCallback = callback;
120 | controlBrowse.appendChild(controlInput);
121 | controlInput.style.display = 'block';
122 | setTimeout(scrollBottom, 0);
123 | };
124 |
125 | const clear = () => {
126 | const elements = controlBrowse.children;
127 | for (let i = elements.length - 2; i > 1; i--) {
128 | const element = elements[i];
129 | controlBrowse.removeChild(element);
130 | }
131 | };
132 |
133 | const print = (s) => {
134 | const list = Array.isArray(s);
135 | let line = list ? s.shift() : s;
136 | if (!line) line = '';
137 | const element = document.createElement('div');
138 | if (!line) line = '\xa0';
139 | if (line.charAt(0) === '<') {
140 | element.innerHTML += line;
141 | } else {
142 | const timer = setInterval(() => {
143 | const char = line.charAt(0);
144 | element.innerHTML += char;
145 | line = line.substr(1);
146 | if (!line) clearInterval(timer);
147 | controlBrowse.scrollTop = controlBrowse.scrollHeight;
148 | scrollBottom();
149 | }, TIME_CHAR);
150 | }
151 | if (list && s.length) setTimeout(print, TIME_LINE, s);
152 | controlBrowse.insertBefore(element, controlInput);
153 | controlBrowse.scrollTop = controlBrowse.scrollHeight;
154 | scrollBottom();
155 | };
156 |
157 | const inputKeyboardEvents = {
158 | ESC() {
159 | clear();
160 | inputSetValue('');
161 | },
162 | BACKSPACE() {
163 | inputSetValue(controlInput.inputValue.slice(0, -1));
164 | },
165 | ENTER() {
166 | let value = controlInput.inputValue;
167 | if (controlInput.inputType === 'masked') {
168 | value = pad('*', value.length);
169 | }
170 | print(controlInput.inputPrompt + value);
171 | controlInput.style.display = 'none';
172 | controlInput.inputActive = false;
173 | controlInput.inputCallback(null, value);
174 | },
175 | CAPS() {
176 | if (controlKeyboard.className === 'caps') {
177 | controlKeyboard.className = '';
178 | } else {
179 | controlKeyboard.className = 'caps';
180 | }
181 | },
182 | KEY(char) {
183 | // Alpha or Digit
184 | if (controlKeyboard.className === 'caps') {
185 | char = char.toUpperCase();
186 | }
187 | inputSetValue(controlInput.inputValue + char);
188 | },
189 | };
190 |
191 | const keyboardClick = (e) => {
192 | let char = e.target.inputChar;
193 | if (char === '_') char = ' ';
194 | let keyName = 'KEY';
195 | if (char === '<') keyName = 'BACKSPACE';
196 | if (char === '>') keyName = 'ENTER';
197 | if (char === '^') keyName = 'CAPS';
198 | const fn = inputKeyboardEvents[keyName];
199 | if (fn) fn(char);
200 | e.stopPropagation();
201 | return false;
202 | };
203 |
204 | const initKeyboard = () => {
205 | if (!isMobile()) return;
206 | controlKeyboard.style.display = 'block';
207 | const KEYBOARD_LAYOUT = [
208 | '1234567890',
209 | 'qwertyuiop',
210 | 'asdfghjkl<',
211 | '^zxcvbnm_>',
212 | ];
213 | for (let i = 0; i < KEYBOARD_LAYOUT.length; i++) {
214 | const keyboardLine = KEYBOARD_LAYOUT[i];
215 | const elementLine = document.createElement('div');
216 | controlKeyboard.appendChild(elementLine);
217 | for (let j = 0; j < keyboardLine.length; j++) {
218 | let char = keyboardLine[j];
219 | if (char === ' ') char = ' ';
220 | const elementKey = document.createElement('div');
221 | elementKey.innerHTML = char;
222 | elementKey.inputChar = char;
223 | elementKey.className = 'key';
224 | elementKey.style.opacity = (i + j) % 2 ? 0.8 : 1;
225 | elementKey.addEventListener('click', keyboardClick);
226 | elementLine.appendChild(elementKey);
227 | }
228 | }
229 | controlBrowse.style.bottom = controlKeyboard.offsetHeight + 'px';
230 | };
231 |
232 | document.onkeydown = (event) => {
233 | if (controlInput.inputActive) {
234 | const keyName = KEY_NAME[event.keyCode];
235 | const fn = inputKeyboardEvents[keyName];
236 | if (fn) {
237 | fn();
238 | return false;
239 | }
240 | }
241 | };
242 |
243 | document.onkeypress = (event) => {
244 | if (controlInput.inputActive) {
245 | const fn = inputKeyboardEvents['KEY'];
246 | const char = String.fromCharCode(event.keyCode);
247 | if (CHARS.includes(char) && fn) {
248 | fn(char);
249 | return false;
250 | }
251 | }
252 | };
253 |
254 | const blobToBase64 = (blob) => {
255 | const reader = new FileReader();
256 | reader.readAsDataURL(blob);
257 | return new Promise((resolve) => {
258 | reader.onloadend = () => {
259 | resolve(reader.result);
260 | };
261 | });
262 | };
263 |
264 | const uploadFile = (file, done) => {
265 | blobToBase64(file).then((url) => {
266 | const data = url.substring(url.indexOf(',') + 1);
267 | api.example.uploadFile({ name: file.name, data }).then(done);
268 | });
269 | };
270 |
271 | const upload = () => {
272 | const element = document.createElement('form');
273 | element.style.visibility = 'hidden';
274 | element.innerHTML = '';
275 | document.body.appendChild(element);
276 | const fileSelect = document.getElementById('fileSelect');
277 | fileSelect.click();
278 | fileSelect.onchange = () => {
279 | const files = Array.from(fileSelect.files);
280 | print('Uploading ' + files.length + ' file(s)');
281 | files.sort((a, b) => a.size - b.size);
282 | let i = 0;
283 | const uploadNext = () => {
284 | const file = files[i];
285 | uploadFile(file, () => {
286 | print(`name: ${file.name}, size: ${file.size} done`);
287 | i++;
288 | if (i < files.length) {
289 | return uploadNext();
290 | }
291 | document.body.removeChild(element);
292 | commandLoop();
293 | });
294 | };
295 | uploadNext();
296 | };
297 | };
298 |
299 | const exec = async (line) => {
300 | const args = line.split(' ');
301 | if (args[0] === 'upload') {
302 | upload();
303 | } else {
304 | const data = await api.cms.content(args);
305 | print(data);
306 | }
307 | commandLoop();
308 | };
309 |
310 | function commandLoop() {
311 | input('command', '.', (err, line) => {
312 | exec(line);
313 | commandLoop();
314 | });
315 | }
316 |
317 | const signIn = async () => {
318 | try {
319 | await metacom.load('auth');
320 | await api.auth.status();
321 | } catch (err) {
322 | await api.auth.signIn({ login: 'marcus', password: 'marcus' });
323 | }
324 | await metacom.load('example');
325 | api.example.on('resmon', (data) => print(JSON.stringify(data)));
326 | api.example.subscribe();
327 | };
328 |
329 | window.addEventListener('load', () => {
330 | panelScroll = document.getElementById('panelScroll');
331 | controlInput = document.getElementById('controlInput');
332 | controlKeyboard = document.getElementById('controlKeyboard');
333 | controlBrowse = document.getElementById('controlBrowse');
334 | controlScroll = document.getElementById('controlScroll');
335 | initKeyboard();
336 | initScroll();
337 | const path = window.location.pathname.substring(1);
338 | print([
339 | 'Metarhia is a Community, Technology Stack and R&D Center',
340 | 'for Cloud Computing and Distributed Database Systems',
341 | '',
342 | 'Commands: about, fields, team, links, stack, contacts',
343 | ]);
344 | if (path) {
345 | setTimeout(() => {
346 | exec('contacts ' + path);
347 | window.history.replaceState(null, '', '/');
348 | }, TIME_LINE * 3);
349 | }
350 | signIn();
351 | commandLoop();
352 | });
353 |
--------------------------------------------------------------------------------
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
50 |
44 | 
45 |
46 |
47 |
48 |
49 |