@leonid-shutov/uncommonjs 1.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 leonid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+Loader

package/eslint.config.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const init = require('eslint-config-metarhia');
+
+module.exports = [...init, { rules: { 'no-extra-parens': 'off' } }];

package/lib/application.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const fsp = require('node:fs').promises;
+const path = require('node:path');
+const vm = require('node:vm');
+const errors = require('./errors.js');
+const { loadModules } = require('./deps.js');
+const { loadDir } = require('./loader.js');
+
+const getDefaultApplicationPath = () => path.join(process.cwd(), 'application');
+
+const readLayers = (applicationPath) =>
+  fsp
+    .readFile(path.join(applicationPath, '.layers'), 'utf8')
+    .then((data) => data.split(/[\r\n\s]+/).filter((s) => s.length !== 0));
+
+const loadApplication = async (sandbox = {}, options) => {
+  Object.assign(sandbox, errors);
+  const applicationPath = options?.path ?? getDefaultApplicationPath();
+  const promises = [loadModules(), readLayers(applicationPath)];
+  const [modules, layers] = await Promise.all(promises);
+  Object.assign(sandbox, modules);
+  const context = vm.createContext(sandbox);
+  const load = loadDir.bind(undefined, context, context);
+  for (const layer of layers) await load(path.join(applicationPath, layer));
+  return sandbox;
+};
+
+module.exports = { loadApplication };

package/lib/deps.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const { builtinModules } = require('node:module');
+
+const loadNpm = () => {
+  const { dependencies } = require(process.cwd() + '/package.json');
+  if (dependencies === undefined) return {};
+  const modules = Object.keys(dependencies);
+  return Object.fromEntries(modules.map((module) => [module, require(module)]));
+};
+
+const loadInternals = () =>
+  Object.fromEntries(
+    builtinModules.map((name) => [name, require(`node:${name}`)]),
+  );
+
+const loadModules = () => ({
+  npm: loadNpm(),
+  node: loadInternals(),
+});
+
+module.exports = { loadModules };

package/lib/errors.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const PASS = Symbol('pass');
+
+class DomainError extends Error {
+  constructor(message, options) {
+    const { code, ...restOptions } = options;
+    super(message, restOptions);
+    this.code = code;
+    this.name = this.constructor.name;
+  }
+}
+
+const createDomainError = (className, factoryOptions) =>
+  class extends (factoryOptions.parent ?? DomainError) {
+    constructor(message, options) {
+      message ??= factoryOptions.message;
+      const code = options?.code ?? factoryOptions.code;
+      super(message, { ...options, code });
+      this.name = className;
+    }
+  };
+
+const UnexpectedError = createDomainError('UnexpectedError', {
+  message: 'Unexpected Error',
+  code: 'UNEXPECTED_ERROR',
+});
+UnexpectedError.from = (description) =>
+  new UnexpectedError(`Unexpected error while ${description.toLowerCase()}`);
+
+const NotFoundError = createDomainError('NotFoundError', {
+  message: 'Not Found',
+  code: 'NOT_FOUND',
+});
+
+NotFoundError.from = (entity, options) =>
+  new NotFoundError(`${entity} not found`, {
+    ...options,
+    code: options?.code ?? `${entity.toUpperCase()}_NOT_FOUND`,
+  });
+
+const AlreadyExistsError = createDomainError('AlreadyExistsError', {
+  message: 'Already Exists',
+  code: 'ALREADY_EXISTS',
+});
+
+AlreadyExistsError.from = (entity, options) =>
+  new AlreadyExistsError(`${entity} already exists`, {
+    ...options,
+    code: options?.code ?? `${entity.toUpperCase()}_ALREADY_EXISTS`,
+  });
+
+const ConstraintViolationError = createDomainError('ConstraintViolationError', {
+  message: 'Constraint violation',
+  code: 'CONSTRAINT_VIOLATION',
+});
+
+const AuthorizationError = createDomainError('AuthorizationError', {
+  message: 'Authorization Error',
+  code: 'AUTHORIZATION_ERROR',
+});
+
+module.exports = {
+  PASS,
+  DomainError,
+  createDomainError,
+  UnexpectedError,
+  NotFoundError,
+  AlreadyExistsError,
+  ConstraintViolationError,
+  AuthorizationError,
+};

package/lib/loader.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const path = require('node:path');
+const fsp = require('node:fs/promises');
+const vm = require('node:vm');
+const { isService, loadService } = require('./service.js');
+
+const chronology = ['before.js', 'after.js'];
+const isChronological = (filePath) =>
+  chronology.some((file) => filePath.endsWith(file));
+const orderFiles = (files) => {
+  const before = files.find(({ name }) => name === 'before.js');
+  const after = files.find(({ name }) => name === 'after.js');
+  const ordered = files.filter(({ name }) => !chronology.includes(name));
+  ordered.sort();
+  if (before !== undefined) ordered.unshift(before);
+  if (after !== undefined) ordered.push(after);
+  return ordered;
+};
+
+const removeIndex = (key) => key.replace(/^\d+-/, '');
+
+const loadFile = async (context, container, filePath, key) => {
+  const src = await fsp.readFile(filePath, 'utf8');
+  const code = `'use strict';\n${src}`;
+  const script = new vm.Script(code);
+  const sandbox = { ...context };
+  const result = await script.runInContext(vm.createContext(sandbox));
+  if (isChronological(filePath)) return void (await result());
+  for (const [method, definition] of Object.entries(result)) {
+    if (isService(definition, context)) {
+      result[method] = loadService(definition, context);
+    }
+  }
+  sandbox.self = result;
+  if (container[key] === undefined) container[key] = result;
+  else Object.assign(container[key], result);
+};
+
+const loadDir = async (context, container, dirPath, key) => {
+  key ??= dirPath.split('/').at(-1);
+  const nextContainer = container[key] ?? {};
+  container[key] = nextContainer;
+  const files = [];
+  const directories = [];
+  const entries = await fsp.readdir(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile()) files.push(entry);
+    else directories.push(entry);
+  }
+
+  const orderedFiles = orderFiles(files);
+  for (const { name } of orderedFiles) {
+    if (!name.endsWith('.js')) continue;
+    const location = path.join(dirPath, name);
+    let basename = path.basename(name, '.js');
+    basename = removeIndex(basename);
+    if (basename === key) await loadFile(context, container, location, key);
+    else await loadFile(context, nextContainer, location, basename);
+  }
+
+  for (const { name } of directories) {
+    const location = path.join(dirPath, name);
+    if (name === '>') await loadDir(context, container, location, key);
+    else await loadDir(context, nextContainer, location, name);
+  }
+};
+
+module.exports = { loadFile, loadDir };

package/lib/rest.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const { Schema } = require('metaschema');
+
+const {
+  NotFoundError,
+  AlreadyExistsError,
+  ConstraintViolationError,
+  AuthorizationError,
+} = require('./errors.js');
+const { loadApplication } = require('./application.js');
+
+class ValidationError extends AggregateError {}
+
+const validateRequest = (schema = {}, { query, body }) => {
+  const validationErrors = [];
+  if (schema.query !== undefined) {
+    const { errors } = Schema.from(schema.query).check(query);
+    validationErrors.push(...errors);
+  }
+  if (schema.body !== undefined) {
+    const { errors } = Schema.from(schema.body).check(body);
+    validationErrors.push(...errors);
+  }
+  if (validationErrors.length > 0) throw new ValidationError(validationErrors);
+};
+
+const getStatus = (error) => {
+  if (error instanceof ValidationError) return 400;
+  if (error instanceof AuthorizationError) return 401;
+  if (error instanceof NotFoundError) return 404;
+  if (error instanceof AlreadyExistsError) return 409;
+  if (error instanceof ConstraintViolationError) return 422;
+  return 500;
+};
+
+const bodyFromDefinition = (response, definition) => {
+  if (typeof definition.response === 'function') {
+    return definition.response(response);
+  }
+  if (definition.response === undefined) return response;
+  return definition.response ?? null;
+};
+
+const createHandler = (definition) => {
+  const schema = { query: definition.query, body: definition.body };
+  return async ({ path, query, body, ...rest }) => {
+    try {
+      validateRequest(schema, { query, body });
+      const response = await definition.handler({ path, query, body, ...rest });
+      return {
+        status: definition.status ?? 200,
+        body: bodyFromDefinition(response, definition),
+      };
+    } catch (error) {
+      console.error(error);
+      return {
+        status: getStatus(error),
+        body: error instanceof ValidationError ? error.errors : error.message,
+      };
+    }
+  };
+};
+
+const createRouter = (apis) => {
+  const router = {};
+  for (const api of apis) {
+    for (const [path, methods] of Object.entries(api)) {
+      router[path] ??= {};
+      for (const [method, definition] of Object.entries(methods)) {
+        const handler = createHandler(definition);
+        router[path][method] = handler;
+      }
+    }
+  }
+  return router;
+};
+
+const loadRestApplication = async (sandbox = {}, options) => {
+  await loadApplication(sandbox, options);
+  const apis = Object.values(sandbox.api);
+  const router = createRouter(apis);
+  return router;
+};
+
+module.exports = { loadRestApplication };

package/lib/service.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const isService = (definition, context) =>
+  definition?.method !== undefined && context.PASS !== undefined;
+
+const loadService = (definition, context) => {
+  const { description, method, expectedErrors } = definition;
+  const logger = context.logger ?? context.console ?? { info: () => {} };
+  return async (...args) => {
+    const interpolatedDesc =
+      typeof description === 'function' ? description(...args) : description;
+    try {
+      logger.info(interpolatedDesc);
+      return await method(...args);
+    } catch (error) {
+      let domainError = expectedErrors?.[error.code];
+      if (domainError === context.PASS) throw error;
+      if (domainError === undefined) {
+        domainError =
+          description !== undefined
+            ? context.UnexpectedError.from(interpolatedDesc)
+            : new context.UnexpectedError();
+      }
+      domainError.cause = error;
+      throw domainError;
+    }
+  };
+};
+
+module.exports = { isService, loadService };

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@leonid-shutov/uncommonjs",
+  "version": "1.0.0-alpha.0",
+  "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/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leonid-shutov/uncommonjs.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.30",
+    "eslint": "^9.31.0",
+    "eslint-config-metarhia": "^9.1.1",
+    "prettier": "^3.6.2"
+  },
+  "dependencies": {
+    "metaschema": "^2.2.2"
+  }
+}

package/prettier.config.js

@@ -0,0 +1,10 @@
+'use strict';
+
+module.exports = {
+  printWidth: 80,
+  singleQuote: true,
+  trailingComma: 'all',
+  tabWidth: 2,
+  useTabs: false,
+  semi: true,
+};

package/uncommon.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const loader = require('./lib/loader.js');
+const rest = require('./lib/rest.js');
+const errors = require('./lib/errors.js');
+
+module.exports = { ...loader, ...rest, ...errors };