@leonid-shutov/uncommonjs 1.0.0-alpha.5 → 1.0.0-alpha.6

package/README.md

@@ -1 +1,41 @@
-Loader
+# uncommon‑js ⚙️
+
+**uncommon‑js** — a utility library for Node.js that provides a custom module system based on code sandboxing, using isolated V8 contexts.
+
+# Example
+
+```js
+({
+  create: {
+    description: 'Creating a book',
+    method: repository.book.create,
+    expectedErrors: {
+      BOOK_ALREADY_EXISTS: PASS,
+    },
+  },
+  getByCode: {
+    description: 'Getting a book by code',
+    method: async (code) => {
+      const book = await repository.book.getByCode(code);
+      if (book === null) throw NotFoundError.from('book', { meta: { code } });
+      return book;
+    },
+    expectedErrors: {
+      BOOK_NOT_FOUND: PASS,
+    },
+  },
+});
+```
+
+```js
+({
+  create: {
+    method: ({ code, name }) => db.pg.query(`INSERT INTO "public"."Book" (code, name) VALUES ($1, $2)`, [code, name]),
+    expectedErrors: {
+      23505: AlreadyExistsError.from('book'),
+    },
+  },
+  getByCode: async (code) =>
+    (await db.pg.query(`SELECT * FROM "public"."Book" WHERE code = $1`, [code])).rows[0] ?? null,
+});
+```

package/eslint.config.js

@@ -2,4 +2,22 @@
 
 const init = require('eslint-config-metarhia');
 
-module.exports = [...init, { rules: { 'no-extra-parens': 'off' } }];
+module.exports = [
+  ...init,
+  {
+    files: ['lib/**/*.js', 'test/**/*.js'],
+    rules: {
+      strict: 'off',
+      'max-len': ['error', { code: 120, ignoreUrls: true }],
+      'no-nested-ternary': 'off',
+      camelcase: 'off',
+      curly: 'off',
+    },
+    languageOptions: {
+      globals: {
+        self: true,
+        $: true,
+      },
+    },
+  },
+];

package/lib/deps.js

@@ -9,10 +9,7 @@ const loadNpm = () => {
   return Object.fromEntries(modules.map((module) => [module, require(module)]));
 };
 
-const loadInternals = () =>
-  Object.fromEntries(
-    builtinModules.map((name) => [name, require(`node:${name}`)]),
-  );
+const loadInternals = () => Object.fromEntries(builtinModules.map((name) => [name, require(`node:${name}`)]));
 
 const loadModules = () => ({
   npm: loadNpm(),

package/lib/errors.js

@@ -25,8 +25,7 @@ const UnexpectedError = createDomainError('UnexpectedError', {
   message: 'Unexpected Error',
   code: 'UNEXPECTED_ERROR',
 });
-UnexpectedError.from = (description) =>
-  new UnexpectedError(`Unexpected error while ${description.toLowerCase()}`);
+UnexpectedError.from = (description) => new UnexpectedError(`Unexpected error while ${description.toLowerCase()}`);
 
 const NotFoundError = createDomainError('NotFoundError', {
   message: 'Not Found',

package/lib/loader.js

@@ -7,22 +7,45 @@ const { isService, loadService } = require('./service.js');
 
 const removeIndex = (key) => key.replace(/^\d+-/, '');
 
-const loadFile = async (context, container, filePath, key) => {
-  key ??= path.basename(filePath, '.js');
+const runInContext = async (filePath, context) => {
   const src = await fsp.readFile(filePath, 'utf8');
   const code = `'use strict';\n${src}`;
   const script = new vm.Script(code);
-  const sandbox = { ...context, module: container };
-  const result = await script.runInContext(vm.createContext(sandbox));
+  return await script.runInContext(vm.createContext(context));
+};
+
+const loadEntry = (definition, context) => {
+  if (isService(definition)) return loadService(definition, context);
+  else return definition;
+};
+
+const loadGetter = async (context, container, filePath, name) => {
+  const sandbox = { ...context, $: container };
+  const fun = await runInContext(filePath, sandbox);
+  if (fun === undefined) return;
+  Object.assign(container, {
+    get [name]() {
+      return fun();
+    },
+  });
+};
+
+const loadFile = async (context, container, filePath, key) => {
+  key ??= path.basename(filePath, '.js');
+
+  const sandbox = { ...context, $: container };
+  const result = await runInContext(filePath, sandbox);
+
   if (result === undefined) return;
+
   for (const [method, definition] of Object.entries(result)) {
-    if (isService(definition, context)) {
-      result[method] = loadService(definition, context);
-    }
+    result[method] = loadEntry(definition, context);
   }
+
   if (container[key] === undefined) container[key] = result;
   else Object.assign(container[key], result);
   sandbox.self = container[key];
+  sandbox._ = container[key];
 };
 
 const loadDir = async (context, container, dirPath, key) => {
@@ -42,7 +65,8 @@ const loadDir = async (context, container, dirPath, key) => {
     const location = path.join(dirPath, name);
     let basename = path.basename(name, '.js');
     basename = removeIndex(basename);
-    if (basename === key) await loadFile(context, container, location, key);
+    if (key === 'getters') await loadGetter(context, container, location, basename);
+    else if (basename === key) await loadFile(context, container, location, key);
     else await loadFile(context, nextContainer, location, basename);
   }
 

package/lib/rest.js

@@ -2,12 +2,7 @@
 
 const { Schema } = require('metaschema');
 
-const {
-  NotFoundError,
-  AlreadyExistsError,
-  ConstraintViolationError,
-  AuthorizationError,
-} = require('./errors.js');
+const { NotFoundError, AlreadyExistsError, ConstraintViolationError, AuthorizationError } = require('./errors.js');
 const { loadApplication } = require('./application.js');
 
 class ValidationError extends AggregateError {}

package/lib/service.js

@@ -1,14 +1,12 @@
 'use strict';
 
-const isService = (definition, context) =>
-  definition?.method !== undefined && context.PASS !== undefined;
+const isService = (definition) => definition?.method !== undefined;
 
 const loadService = (definition, context) => {
   const { description, method } = definition;
   const logger = context.logger ?? context.console ?? { info: () => {} };
   return (...args) => {
-    const interpolatedDesc =
-      typeof description === 'function' ? description(...args) : description;
+    const interpolatedDesc = typeof description === 'function' ? description(...args) : description;
     logger.info(interpolatedDesc);
 
     const handleError = (error) => {
@@ -17,9 +15,7 @@ const loadService = (definition, context) => {
       if (domainError === context.PASS) throw error;
       if (domainError === undefined) {
         domainError =
-          description !== undefined
-            ? context.UnexpectedError.from(interpolatedDesc)
-            : new context.UnexpectedError();
+          description !== undefined ? context.UnexpectedError.from(interpolatedDesc) : new context.UnexpectedError();
       }
       domainError.cause = error;
       throw domainError;

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@leonid-shutov/uncommonjs",
-  "version": "1.0.0-alpha.5",
+  "version": "1.0.0-alpha.6",
   "author": "Leonid Shutov <leonid.shutov.main@gmail.com>",
   "license": "MIT",
   "homepage": "https://github.com/leonid-shutov/uncommonjs#readme",
   "main": "uncommon.js",
   "scripts": {
-    "lint": "eslint lib/"
+    "lint": "eslint .",
+    "fmt": "prettier --write ."
   },
   "repository": {
     "type": "git",
@@ -17,8 +18,9 @@
   },
   "devDependencies": {
     "@types/node": "^20.17.30",
-    "eslint": "^9.31.0",
-    "eslint-config-metarhia": "^9.1.1",
+    "typescript": "^5.9.3",
+    "eslint": "^9.36.0",
+    "eslint-config-metarhia": "^9.1.3",
     "prettier": "^3.6.2"
   },
   "dependencies": {

package/prettier.config.js

@@ -1,7 +1,7 @@
 'use strict';
 
 module.exports = {
-  printWidth: 80,
+  printWidth: 120,
   singleQuote: true,
   trailingComma: 'all',
   tabWidth: 2,

package/test/application/chestnut/chestnut.js

@@ -2,5 +2,9 @@
 
 ({
   age: 0,
+  isRotten: false,
   isRipe: () => self.age === 1,
+  rot: {
+    method: () => (self.isRotten = true),
+  },
 });

package/test/application/chestnut/getters/isEdible.js

@@ -0,0 +1,3 @@
+'use strict';
+
+() => $.age < 3 && !$.isRotten;

package/test/application/chestnut/methods/grow.js

@@ -1,3 +1,3 @@
 'use strict';
 
-() => module.age++;
+() => $.age++;

package/test/test.js

@@ -16,3 +16,19 @@ test('Methods', async () => {
   chestnut.grow();
   assert.strictEqual(chestnut.isRipe(), true);
 });
+
+test('Getters', async () => {
+  const context = vm.createContext({});
+  await loadDir(context, context, PATH_TO_APPLICATION);
+  const chestnut = context.application.chestnut;
+  assert.strictEqual(chestnut.isEdible, true);
+});
+
+test('Service', async () => {
+  const context = vm.createContext({});
+  await loadDir(context, context, PATH_TO_APPLICATION);
+  const chestnut = context.application.chestnut;
+  assert.strictEqual(chestnut.isRotten, false);
+  chestnut.rot();
+  assert.strictEqual(chestnut.isRotten, true);
+});