├── .eslintignore
├── .eslintrc.json
├── .github
    └── FUNDING.yml
├── .gitignore
├── JavaScript
    ├── README.md
    ├── applications
    │   ├── application1
    │   │   ├── README.md
    │   │   └── main.js
    │   └── application2
    │   │   └── main.js
    ├── framework.js
    ├── package-lock.json
    ├── package.json
    └── wrapper.js
├── LICENSE
└── README.md


/.eslintignore:
--------------------------------------------------------------------------------
1 | node_modules/
2 | 


--------------------------------------------------------------------------------
/.eslintrc.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "env": {
  3 |     "browser": true,
  4 |     "es6": true,
  5 |     "node": true
  6 |   },
  7 |   "extends": "eslint:recommended",
  8 |   "parserOptions": {
  9 |     "ecmaVersion": "latest"
 10 |   },
 11 |   "globals": {
 12 |     "BigInt": true,
 13 |     "api": true
 14 |   },
 15 |   "rules": {
 16 |     "indent": [
 17 |       "error",
 18 |       2
 19 |     ],
 20 |     "linebreak-style": [
 21 |       "error",
 22 |       "unix"
 23 |     ],
 24 |     "quotes": [
 25 |       "error",
 26 |       "single"
 27 |     ],
 28 |     "semi": [
 29 |       "error",
 30 |       "always"
 31 |     ],
 32 |     "no-loop-func": [
 33 |       "error"
 34 |     ],
 35 |     "block-spacing": [
 36 |       "error",
 37 |       "always"
 38 |     ],
 39 |     "camelcase": [
 40 |       "error"
 41 |     ],
 42 |     "eqeqeq": [
 43 |       "error",
 44 |       "always"
 45 |     ],
 46 |     "strict": [
 47 |       "error",
 48 |       "global"
 49 |     ],
 50 |     "brace-style": [
 51 |       "error",
 52 |       "1tbs",
 53 |       {
 54 |         "allowSingleLine": true
 55 |       }
 56 |     ],
 57 |     "comma-style": [
 58 |       "error",
 59 |       "last"
 60 |     ],
 61 |     "comma-spacing": [
 62 |       "error",
 63 |       {
 64 |         "before": false,
 65 |         "after": true
 66 |       }
 67 |     ],
 68 |     "eol-last": [
 69 |       "error"
 70 |     ],
 71 |     "func-call-spacing": [
 72 |       "error",
 73 |       "never"
 74 |     ],
 75 |     "key-spacing": [
 76 |       "error",
 77 |       {
 78 |         "beforeColon": false,
 79 |         "afterColon": true,
 80 |         "mode": "minimum"
 81 |       }
 82 |     ],
 83 |     "keyword-spacing": [
 84 |       "error",
 85 |       {
 86 |         "before": true,
 87 |         "after": true,
 88 |         "overrides": {
 89 |           "function": {
 90 |             "after": false
 91 |           }
 92 |         }
 93 |       }
 94 |     ],
 95 |     "max-len": [
 96 |       "error",
 97 |       {
 98 |         "code": 80,
 99 |         "ignoreUrls": true
100 |       }
101 |     ],
102 |     "max-nested-callbacks": [
103 |       "error",
104 |       {
105 |         "max": 7
106 |       }
107 |     ],
108 |     "new-cap": [
109 |       "error",
110 |       {
111 |         "newIsCap": true,
112 |         "capIsNew": false,
113 |         "properties": true
114 |       }
115 |     ],
116 |     "new-parens": [
117 |       "error"
118 |     ],
119 |     "no-lonely-if": [
120 |       "error"
121 |     ],
122 |     "no-trailing-spaces": [
123 |       "error"
124 |     ],
125 |     "no-unneeded-ternary": [
126 |       "error"
127 |     ],
128 |     "no-whitespace-before-property": [
129 |       "error"
130 |     ],
131 |     "object-curly-spacing": [
132 |       "error",
133 |       "always"
134 |     ],
135 |     "operator-assignment": [
136 |       "error",
137 |       "always"
138 |     ],
139 |     "operator-linebreak": [
140 |       "error",
141 |       "after"
142 |     ],
143 |     "semi-spacing": [
144 |       "error",
145 |       {
146 |         "before": false,
147 |         "after": true
148 |       }
149 |     ],
150 |     "space-before-blocks": [
151 |       "error",
152 |       "always"
153 |     ],
154 |     "space-before-function-paren": [
155 |       "error",
156 |       {
157 |         "anonymous": "never",
158 |         "named": "never",
159 |         "asyncArrow": "always"
160 |       }
161 |     ],
162 |     "space-in-parens": [
163 |       "error",
164 |       "never"
165 |     ],
166 |     "space-infix-ops": [
167 |       "error"
168 |     ],
169 |     "space-unary-ops": [
170 |       "error",
171 |       {
172 |         "words": true,
173 |         "nonwords": false,
174 |         "overrides": {
175 |           "typeof": false
176 |         }
177 |       }
178 |     ],
179 |     "no-unreachable": [
180 |       "error"
181 |     ],
182 |     "no-global-assign": [
183 |       "error"
184 |     ],
185 |     "no-self-compare": [
186 |       "error"
187 |     ],
188 |     "no-unmodified-loop-condition": [
189 |       "error"
190 |     ],
191 |     "no-constant-condition": [
192 |       "error",
193 |       {
194 |         "checkLoops": false
195 |       }
196 |     ],
197 |     "no-console": [
198 |       "off"
199 |     ],
200 |     "no-useless-concat": [
201 |       "error"
202 |     ],
203 |     "no-useless-escape": [
204 |       "error"
205 |     ],
206 |     "no-shadow-restricted-names": [
207 |       "error"
208 |     ],
209 |     "no-use-before-define": [
210 |       "error",
211 |       {
212 |         "functions": false
213 |       }
214 |     ],
215 |     "arrow-parens": [
216 |       "error",
217 |       "always"
218 |     ],
219 |     "arrow-body-style": [
220 |       "error",
221 |       "as-needed"
222 |     ],
223 |     "arrow-spacing": [
224 |       "error"
225 |     ],
226 |     "no-confusing-arrow": [
227 |       "error",
228 |       {
229 |         "allowParens": true
230 |       }
231 |     ],
232 |     "no-useless-computed-key": [
233 |       "error"
234 |     ],
235 |     "no-useless-rename": [
236 |       "error"
237 |     ],
238 |     "no-var": [
239 |       "error"
240 |     ],
241 |     "object-shorthand": [
242 |       "error",
243 |       "always"
244 |     ],
245 |     "prefer-arrow-callback": [
246 |       "error"
247 |     ],
248 |     "prefer-const": [
249 |       "error"
250 |     ],
251 |     "prefer-numeric-literals": [
252 |       "error"
253 |     ],
254 |     "prefer-rest-params": [
255 |       "error"
256 |     ],
257 |     "prefer-spread": [
258 |       "error"
259 |     ],
260 |     "rest-spread-spacing": [
261 |       "error",
262 |       "never"
263 |     ],
264 |     "template-curly-spacing": [
265 |       "error",
266 |       "never"
267 |     ],
268 |     "consistent-return": [
269 |       "error",
270 |       { "treatUndefinedAsUnspecified": true }
271 |     ]
272 |   }
273 | }
274 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | patreon: tshemsedinov
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | *.log
3 | .DS_Store
4 | 


--------------------------------------------------------------------------------
/JavaScript/README.md:
--------------------------------------------------------------------------------
 1 | ## Dependency Injection
 2 | 
 3 | Purpose: learn how to create sandboxed context for modues to separate them and
 4 | minimize cross-modules code coupling, extracting at least two abstraction layers
 5 | (applied and system) and how to execute applied code in virtual environment,
 6 | changing its behavior using IoC from system layer.
 7 | 
 8 | ## Files
 9 | 
10 | * `framework.js` - small piece of the framework, just to demonstrate IoC
11 | * `application.js` - small piece of the application, also for IoC demonstration
12 | 
13 | ## How to execute
14 | 
15 | From the command line, type: `node ./framework.js` or `node framework`
16 | 
17 | ## Tasks
18 | 
19 | You may select at least one of the following tasks, make a fork of this
20 | repository and implement your solution there. If those tasks are simple
21 | for somebody, please see additional tasks below.
22 | 
23 | 1. Add `setTimeout` and `setInterval` to the application context and use them
24 | printing something from the timer function using `console.log()`
25 | 
26 | 2. Inject a link to `util` library into the application context and make a few
27 | calls to its functions from applied code
28 | 
29 | 3. Implement the ability to run different applications inside framework, using
30 | command line option, e.g.: `node framework <applicationName>`
31 | 
32 | 4. Wrap or intercept `console.log()` call to add more info into console output
33 | in the following format: `<applicationName> <time> <message>`
34 | 
35 | 5. Wrap or intercept `console.log()` in the sandboxed application logging all
36 | console output into a file in the format: `<applicationName> <time> <message>`
37 | 
38 | 6. Give a link to `require` function to the application, add call to it and
39 | wrap it for logging to a file in the format: `<time> <module name>` 
40 | 
41 | 7. Export a hash from `application.js` with multiple functions and variables,
42 | print the list with types from framework
43 | 
44 | 8. Export a function from `application.js` and print its parameter count and
45 | source code from the framework
46 | 
47 | 9. Print a list of everything from the application global context (application
48 | sandbox) with the data types specified
49 | 
50 | 10. Compare an application sandboxed context keys before application loaded and
51 | after, print it from the framework and find a difference (keys added / deleted)
52 | 
53 | ## Additional tasks
54 | 
55 | 11. You can combine several tasks (listed above) in your code, implement a more
56 | complex example of interaction between framework and application, preparing
57 | run-time environment (sandbox) and/or improving CLI (command line interface)
58 | 
59 | 12. Implement a similar example in another programming language
60 | 
61 | 13. Improve and/or optimize Impress Application Server code, specifically
62 | everything related to sandboxing, see:
63 | [/lib/impress.application.js](https://github.com/tshemsedinov/impress/blob/master/lib/impress.application.js)
64 | 
65 | 14. Use IoC and code isolation principles using sandboxed context and/or other
66 | similar technique in your projects (any technological stack) to demonstrate its
67 | use and the effect of such use
68 | 


--------------------------------------------------------------------------------
/JavaScript/applications/application1/README.md:
--------------------------------------------------------------------------------
1 | # Markdown file from appliacation local directory
2 | 


--------------------------------------------------------------------------------
/JavaScript/applications/application1/main.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | // File contains a small piece of the source to demonstrate main module
 4 | // of a sample application to be executed in the sandboxed context by
 5 | // another pice of code from `framework.js`. Read README.md for tasks.
 6 | 
 7 | // Print from the global context of application module
 8 | api.console.log('From application1 global context');
 9 | 
10 | module.exports = () => {
11 |   // Print from the exported function context
12 | 
13 |   api.fs.readFile('../../README.md', (err, data) => {
14 |     if (err) {
15 |       api.console.log(err.message);
16 |       return;
17 |     }
18 |     api.console.log(data.toString());
19 |   });
20 | 
21 |   api.timers.setTimeout(() => {
22 |     api.console.log('From application1 exported function');
23 |   }, 5000);
24 | };
25 | 


--------------------------------------------------------------------------------
/JavaScript/applications/application2/main.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | // File contains a small piece of the source to demonstrate main module
 4 | // of a sample application to be executed in the sandboxed context by
 5 | // another pice of code from `framework.js`. Read README.md for tasks.
 6 | 
 7 | // Print from the global context of application module
 8 | api.console.log('From application2 global context');
 9 | 
10 | module.exports = () => {
11 |   // Print from the exported function context
12 |   api.timers.setTimeout(() => {
13 |     api.console.log('From application2 exported function');
14 |   }, 5000);
15 | };
16 | 


--------------------------------------------------------------------------------
/JavaScript/framework.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | // Example showing us how the framework creates an environment (sandbox) for
 4 | // appication runtime, load an application code and passes a sandbox into app
 5 | // as a global context and receives exported application interface
 6 | 
 7 | // The framework can require core libraries
 8 | const api = {};
 9 | api.fs = require('node:fs');
10 | api.vm = require('node:vm');
11 | api.sandboxedFs = require('sandboxed-fs');
12 | 
13 | const { cloneInterface, wrapFunction } = require('./wrapper.js');
14 | 
15 | const log = (s) => {
16 |   console.log('Prints something from sandbox');
17 |   console.log(s);
18 | };
19 | 
20 | const safeRequire = (name) => {
21 |   if (name === 'fs') {
22 |     const msg = 'You dont have access to fs API';
23 |     console.log(msg);
24 |     return new Error(msg);
25 |   } else {
26 |     return require(name);
27 |   }
28 | };
29 | 
30 | const runSandboxed = (path) => {
31 |   const fileName = path + 'main.js';
32 |   const context = {
33 |     module: {},
34 |     require: safeRequire,
35 |     api: {
36 |       console: { log },
37 |       timers: {
38 |         setTimeout: wrapFunction('setTimeout', setTimeout)
39 |       },
40 |       fs: cloneInterface(api.sandboxedFs.bind(path))
41 |     }
42 |   };
43 |   context.global = context;
44 |   const sandbox = api.vm.createContext(context);
45 |   // Read an application source code from the file
46 |   api.fs.readFile(fileName, (err, src) => {
47 |     // We need to handle errors here
48 | 
49 |     // Run an application in sandboxed context
50 |     const script = new api.vm.Script(src, fileName);
51 |     const f = script.runInNewContext(sandbox);
52 |     if (f) f();
53 | 
54 |     // We can access a link to exported interface from sandbox.module.exports
55 |     // to execute, save to the cache, print to console, etc.
56 |   });
57 | };
58 | 
59 | runSandboxed('./applications/application1/');
60 | runSandboxed('./applications/application2/');
61 | 


--------------------------------------------------------------------------------
/JavaScript/package-lock.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "diExample",
 3 |   "version": "1.0.1",
 4 |   "lockfileVersion": 1,
 5 |   "requires": true,
 6 |   "dependencies": {
 7 |     "sandboxed-fs": {
 8 |       "version": "0.3.2",
 9 |       "resolved": "https://registry.npmjs.org/sandboxed-fs/-/sandboxed-fs-0.3.2.tgz",
10 |       "integrity": "sha512-MVatejmW+hJ5ovkxQkJJO0EsTbdjh9LhvQcGgVRu64NJCchR9yCuUcXLoDSuS4E9bbOyWHa9HZZPCD1bqET3uQ=="
11 |     }
12 |   }
13 | }
14 | 


--------------------------------------------------------------------------------
/JavaScript/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "diExample",
 3 |   "private": true,
 4 |   "version": "1.0.1",
 5 |   "description": "Dependency Injection Example",
 6 |   "license": "MIT",
 7 |   "dependencies": {
 8 |     "sandboxed-fs": "^0.3.2"
 9 |   }
10 | }
11 | 


--------------------------------------------------------------------------------
/JavaScript/wrapper.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const wrapFunction = (key, fn) => {
 4 |   console.log(`Wrap function: ${key}`);
 5 |   return (...args) => {
 6 |     console.log(`Called wrapper for: ${key}`);
 7 |     console.dir({ args });
 8 |     if (args.length > 0) {
 9 |       let callback = args[args.length - 1];
10 |       if (typeof callback === 'function') {
11 |         args[args.length - 1] = (...args) => {
12 |           console.log(`Callback: ${key}`);
13 |           callback(...args);
14 |         };
15 |       } else {
16 |         callback = null;
17 |       }
18 |     }
19 |     console.log(`Call: ${key}`);
20 |     console.dir(args);
21 |     const result = fn(...args);
22 |     console.log(`Ended wrapper for: ${key}`);
23 |     console.dir({ result });
24 |     return result;
25 |   };
26 | };
27 | 
28 | const cloneInterface = (anInterface) => {
29 |   const clone = {};
30 |   for (const key in anInterface) {
31 |     const fn = anInterface[key];
32 |     clone[key] = wrapFunction(key, fn);
33 |   }
34 |   return clone;
35 | };
36 | 
37 | module.exports = { cloneInterface, wrapFunction };
38 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017-2022 How.Programming.Works contributors
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Resolving dependencies with dependency injection
2 | 
3 | [![Инверсия управления и внедрение зависимостей](https://img.youtube.com/vi/Fz86Fdjz-LM/0.jpg)](https://www.youtube.com/watch?v=Fz86Fdjz-LM)
4 | 


--------------------------------------------------------------------------------