alp-node 7.0.0 → 9.0.0

package/dist/{index-node18.mjs → index-node.mjs}

@@ -1,101 +1,19 @@
-import { existsSync, readFileSync, unlinkSync, chmodSync } from 'node:fs';
+import { unlinkSync, chmodSync, readFileSync, existsSync } from 'node:fs';
 import path from 'node:path';
 import { Logger } from 'nightingale-logger';
-import { deprecate } from 'node:util';
 import Koa from 'koa';
 import compress from 'koa-compress';
 import serve from 'koa-static';
-import deepFreeze from 'deep-freeze-es6';
-import minimist from 'minimist';
-import parseJSON from 'parse-json-object-as-map';
 import { STATUS_CODES, createServer as createServer$2 } from 'node:http';
 import ErrorHtmlRenderer from 'error-html';
 import { defineLazyProperty } from 'object-properties';
 import { createServer as createServer$1 } from 'node:https';
 import IntlMessageFormatDefault from 'intl-messageformat';
+import deepFreeze from 'deep-freeze-es6';
+import minimist from 'minimist';
 import { createRouterBuilder } from 'router-segments';
 
-const argv = minimist(process.argv.slice(2));
-function _existsConfigSync(dirname, name) {
-  return existsSync(`${dirname}${name}.json`);
-}
-function _loadConfigSync(dirname, name) {
-  const content = readFileSync(`${dirname}${name}.json`, 'utf8');
-  return parseJSON(content);
-}
-class Config {
-  constructor(dirname, options) {
-    this._map = new Map();
-    this._dirname = dirname.replace(/\/*$/, '/');
-    if (options) {
-      this.loadSync(options);
-    }
-  }
-  loadSync(options = {}) {
-    const env = process.env.CONFIG_ENV || process.env.NODE_ENV || 'development';
-    const {
-      argv: argvOverrides = [],
-      packageConfig,
-      version
-    } = options;
-    this.packageConfig = packageConfig;
-    const config = this.loadConfigSync('common');
-    for (const [key, value] of this.loadConfigSync(env)) {
-      config.set(key, value);
-    }
-    if (this.existsConfigSync('local')) {
-      for (const [key, value] of this.loadConfigSync('local')) {
-        config.set(key, value);
-      }
-    }
-    if (config.has('version')) {
-      throw new Error('Cannot have "version", in config.');
-    }
-    config.set('version', String(version || argv.version || packageConfig?.version));
-    const socketPath = argv.socket || argv['socket-path'] || argv.socketPath;
-    if (socketPath) {
-      config.set('socketPath', socketPath);
-    } else if (argv.port) {
-      config.set('port', argv.port);
-      config.delete('socketPath');
-    } else if (process.env.PORT) {
-      config.set('port', Number(process.env.PORT));
-      config.delete('socketPath');
-    }
-    argvOverrides.forEach(key => {
-      const splitted = key.split('.');
-      const value = splitted.length > 0 &&
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return,unicorn/no-array-reduce, @typescript-eslint/no-shadow
-      splitted.reduce((config, partialKey) => config?.[partialKey], argv);
-      if (value !== undefined) {
-        const last = splitted.pop();
-        const map = splitted.length === 0 ? config :
-        // eslint-disable-next-line unicorn/no-array-reduce
-        splitted.reduce(
-        // eslint-disable-next-line @typescript-eslint/no-shadow
-        (config, partialKey) => config.get(partialKey), config);
-        map.set(last, value);
-      }
-    });
-    this._map = deepFreeze(config);
-    return this;
-  }
-  get(key) {
-    return this._map.get(key);
-  }
-  existsConfigSync(name) {
-    return _existsConfigSync(this._dirname, name);
-  }
-  loadConfigSync(name) {
-    return _loadConfigSync(this._dirname, name);
-  }
-}
-function getConfig(app, config) {
-  return config;
-}
-
-/* eslint-disable complexity */
-const logger$4 = new Logger('alp:errors');
+const logger$4 = new Logger("alp:errors");
 const errorHtmlRenderer = new ErrorHtmlRenderer({
   appPath: `${process.cwd()}/`
 });
@@ -103,29 +21,22 @@ async function alpNodeErrors(ctx, next) {
   try {
     await next();
   } catch (error) {
-    // eslint-disable-next-line no-ex-assign
-    if (!error) error = new Error('Unknown error');
-    // eslint-disable-next-line no-ex-assign
-    if (typeof error === 'string') error = new Error(error);
+    if (!error) error = new Error("Unknown error");
+    if (typeof error === "string") error = new Error(error);
     ctx.status = error.status || 500;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     logger$4.error(error);
-    switch (ctx.request.accepts('html', 'text', 'json')) {
-      case 'json':
-        ctx.type = 'application/json';
-        if (process.env.NODE_ENV !== 'production' || error.expose) {
-          ctx.body = {
-            error: error.message
-          };
+    switch (ctx.request.accepts("html", "text", "json")) {
+      case "json":
+        ctx.type = "application/json";
+        if (process.env.NODE_ENV !== "production" || error.expose) {
+          ctx.body = { error: error.message };
         } else {
-          ctx.body = {
-            error: STATUS_CODES[ctx.status]
-          };
+          ctx.body = { error: STATUS_CODES[ctx.status] };
         }
         break;
-      case 'html':
-        ctx.type = 'text/html';
-        if (process.env.NODE_ENV !== 'production') {
+      case "html":
+        ctx.type = "text/html";
+        if (process.env.NODE_ENV !== "production") {
           ctx.body = errorHtmlRenderer.render(error);
         } else if (error.expose) {
           ctx.body = error.message;
@@ -133,10 +44,11 @@ async function alpNodeErrors(ctx, next) {
           throw error;
         }
         break;
-      case 'text':
+      case "text":
+      case false:
       default:
-        ctx.type = 'text/plain';
-        if (process.env.NODE_ENV !== 'production' || error.expose) {
+        ctx.type = "text/plain";
+        if (process.env.NODE_ENV !== "production" || error.expose) {
           ctx.body = error.message;
         } else {
           throw error;
@@ -148,22 +60,28 @@ async function alpNodeErrors(ctx, next) {
 
 function alpLanguage(app) {
   const config = app.context.config;
-  const availableLanguages = config.get('availableLanguages');
+  const availableLanguages = config.get("availableLanguages");
   if (!availableLanguages) {
     throw new Error('Missing config "availableLanguages"');
   }
-  defineLazyProperty(app.context, 'language', function () {
-    return this.acceptsLanguages(availableLanguages) || availableLanguages[0];
-  });
-  defineLazyProperty(app.context, 'firstAcceptedLanguage', function () {
-    return this.acceptsLanguages()[0] || availableLanguages[0];
-  });
+  defineLazyProperty(
+    app.context,
+    "language",
+    function language() {
+      return this.acceptsLanguages(availableLanguages) || availableLanguages[0] || "en";
+    }
+  );
+  defineLazyProperty(
+    app.context,
+    "firstAcceptedLanguage",
+    function firstAcceptedLanguage() {
+      return this.acceptsLanguages()[0] || availableLanguages[0] || "en";
+    }
+  );
 }
 
-const logger$3 = new Logger('alp:listen');
-const createServer = (callback, socketPath, tls, dirname = ''
-// eslint-disable-next-line @typescript-eslint/max-params
-) => {
+const logger$3 = new Logger("alp:listen");
+const createServer = (callback, socketPath, tls, dirname = "") => {
   const createHttpServer = !socketPath && tls ? createServer$1 : createServer$2;
   if (!tls) {
     return createHttpServer(callback);
@@ -175,35 +93,28 @@ const createServer = (callback, socketPath, tls, dirname = ''
   return createHttpServer(options, callback);
 };
 function alpListen(config, callback, dirname) {
-  return new Promise(resolve => {
-    const socketPath = config.get('socketPath');
-    const port = config.get('port');
-    const hostname = config.get('hostname');
-    const tls = config.get('tls');
-    logger$3.info('Creating server', socketPath ? {
-      socketPath
-    } : {
-      port
-    });
+  return new Promise((resolve) => {
+    const socketPath = config.get("socketPath");
+    const port = config.get("port");
+    const hostname = config.get("hostname");
+    const tls = config.get("tls");
+    logger$3.info("Creating server", socketPath ? { socketPath } : { port });
     const server = createServer(callback, socketPath, tls, dirname);
     if (socketPath) {
       try {
         unlinkSync(socketPath);
-      } catch {}
+      } catch {
+      }
       server.listen(socketPath, () => {
         if (socketPath) {
-          chmodSync(socketPath, '777');
+          chmodSync(socketPath, "777");
         }
-        logger$3.info('Server listening', {
-          socketPath
-        });
+        logger$3.info("Server listening", { socketPath });
         resolve(server);
       });
     } else {
       server.listen(port, hostname, () => {
-        logger$3.info('Server listening', {
-          port
-        });
+        logger$3.info("Server listening", { port });
         resolve(server);
       });
     }
@@ -211,25 +122,22 @@ function alpListen(config, callback, dirname) {
 }
 
 class ParamValidationResult {
+  _errors;
   _error(name, key, value) {
     if (!this._errors) {
       this._errors = {};
     }
-    this._errors[name] = {
-      error: key,
-      value
-    };
+    this._errors[name] = { error: key, value };
   }
   getErrors() {
     return this._errors;
   }
   hasErrors() {
-    return this._errors !== undefined;
+    return this._errors !== void 0;
   }
   isValid() {
-    return this._errors === undefined;
+    return this._errors === void 0;
   }
-
   // string(name: string): ParamValueStringValidator {
   //   return new ParamValueStringValidator(this, name, this.context.param(name));
   // }
@@ -245,18 +153,20 @@ class ParamValidationResult {
 }
 
 class ParamValid extends ParamValidationResult {
+  context;
   constructor(context) {
     super();
     this.context = context;
   }
   _error() {
-    this.context.throw(400, 'Invalid params', {
-      validator: this
-    });
+    this.context.throw(400, "Invalid params", { validator: this });
   }
 }
 
 class ParamValueValidator {
+  validationResult;
+  name;
+  value;
   constructor(validationResult, name, value) {
     this.validationResult = validationResult;
     this.name = name;
@@ -272,30 +182,42 @@ class ParamValueValidator {
 
 class ParamValueStringValidator extends ParamValueValidator {
   notEmpty() {
-    if (this.value == null || this.value.trim() === '') {
-      this._error('notEmpty');
+    if (this.value == null || this.value.trim() === "") {
+      this._error("notEmpty");
     }
     return this;
   }
 }
 
 class ParamValueFromContext {
+  validationResult;
+  context;
   constructor(context, validationResult) {
     this.validationResult = validationResult;
     this.context = context;
   }
   namedParam(name) {
-    return new ParamValueStringValidator(this.validationResult, name, this.context.namedParam(name));
+    return new ParamValueStringValidator(
+      this.validationResult,
+      name,
+      this.context.namedRouteParam(name)
+    );
   }
   otherParam(position) {
-    return new ParamValueStringValidator(this.validationResult, String(position), this.context.otherParam(position));
+    return new ParamValueStringValidator(
+      this.validationResult,
+      String(position),
+      this.context.otherRouteParam(position)
+    );
   }
   queryParam(name) {
-    return new ParamValueStringValidator(this.validationResult, name, this.context.queryParam(name));
+    return new ParamValueStringValidator(
+      this.validationResult,
+      name,
+      this.context.queryParam(name)
+    );
   }
-
   // bodyParam: <T>(name: string): ParamValueValidator<string | undefined> {
-
   // }
 }
 
@@ -311,65 +233,73 @@ function alpParams(app) {
     },
     queryParam(name) {
       const searchParams = this.request.searchParams;
-      return searchParams.get(name) ?? undefined;
+      return searchParams.get(name) ?? void 0;
     },
     bodyParam(name) {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
       return this.body[name];
     }
   });
-  defineLazyProperty(app.request, 'searchParams', function () {
-    return new URLSearchParams(this.search);
-  });
-  defineLazyProperty(app.context, 'params', function () {
-    return new ParamValueFromContext(this, new ParamValidationResult());
-  });
-  defineLazyProperty(app.context, 'validParams', function () {
-    return new ParamValueFromContext(this, new ParamValid(this));
-  });
+  defineLazyProperty(
+    app.request,
+    "searchParams",
+    function searchParams() {
+      return new URLSearchParams(this.search);
+    }
+  );
+  defineLazyProperty(
+    app.context,
+    "params",
+    function params() {
+      return new ParamValueFromContext(this, new ParamValidationResult());
+    }
+  );
+  defineLazyProperty(
+    app.context,
+    "validParams",
+    function validParams() {
+      return new ParamValueFromContext(this, new ParamValid(this));
+    }
+  );
 }
 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-const IntlMessageFormat =
-// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-IntlMessageFormatDefault.default || IntlMessageFormatDefault;
+const IntlMessageFormat = (
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  IntlMessageFormatDefault.default || IntlMessageFormatDefault
+);
 function load(translations, language) {
-  const result = new Map();
-  (function loadMap(map, prefix) {
-    map.forEach((value, key) => {
-      if (typeof value === 'object') {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+  const result = {};
+  (function loadMap(record, prefix) {
+    Object.entries(record).forEach(([key, value]) => {
+      if (typeof value === "object" && value !== null) {
         loadMap(value, `${prefix}${key}.`);
         return;
       }
-
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-      result.set(`${prefix}${key}`, new IntlMessageFormat(value, language));
+      result[`${prefix}${key}`] = new IntlMessageFormat(
+        value,
+        language
+      );
     });
-  })(translations, '');
+  })(translations, "");
   return result;
 }
 
-const logger$2 = new Logger('alp:translate');
+const logger$2 = new Logger("alp:translate");
 function alpTranslate(dirname) {
-  dirname = dirname.replace(/\/*$/, '/');
-  return app => {
-    const appTranslations = new Map();
+  dirname = dirname.replace(/\/*$/, "/");
+  return (app) => {
+    const appTranslations = /* @__PURE__ */ new Map();
     Object.assign(app.context, {
       t(id, args) {
-        const msg = appTranslations.get(this.language).get(id);
+        const msg = appTranslations.get(this.language)?.[id];
         if (!msg) {
-          logger$2.warn('invalid msg', {
-            language: this.language,
-            id
-          });
+          logger$2.warn("invalid msg", { language: this.language, id });
           return id;
         }
         return msg.format(args);
       }
     });
     const config = app.config;
-    config.get('availableLanguages').forEach(language => {
+    config.get("availableLanguages").forEach((language) => {
       const translations = app.loadConfigSync(dirname + language);
       appTranslations.set(language, load(translations, language));
     });
@@ -377,8 +307,14 @@ function alpTranslate(dirname) {
   };
 }
 
-const logger$1 = new Logger('alp');
+const logger$1 = new Logger("alp");
 class AlpNodeApp extends Koa {
+  dirname;
+  certPath;
+  publicPath;
+  config;
+  _server;
+  router;
   /**
    * @param {Object} [options]
    * @param {string} [options.certPath] directory of the ssl certificates
@@ -393,18 +329,13 @@ class AlpNodeApp extends Koa {
   }) {
     super();
     this.dirname = path.normalize(appDirname);
-    Object.defineProperty(this, 'packageDirname', {
-      get: deprecate(() => packageDirname, 'packageDirname'),
-      configurable: false,
-      enumerable: false
-    });
     this.certPath = certPath || `${packageDirname}/config/cert`;
     this.publicPath = publicPath || `${packageDirname}/public/`;
-    this.config = getConfig(this, config);
+    this.config = config;
     this.context.config = this.config;
     alpParams(this);
     alpLanguage(this);
-    alpTranslate('locales')(this);
+    alpTranslate("locales")(this);
     this.use(compress());
   }
   existsConfigSync(name) {
@@ -419,55 +350,135 @@ class AlpNodeApp extends Koa {
     return ctx;
   }
   servePublic() {
-    this.use(serve(this.publicPath)); // static files
+    this.use(serve(this.publicPath));
   }
   catchErrors() {
     this.use(alpNodeErrors);
   }
-
-  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
   listen() {
-    throw new Error('Use start instead');
+    throw new Error("Use start instead");
   }
-
   /**
    * Close server and emit close event
    */
   close() {
     if (this._server) {
       this._server.close();
-      this.emit('close');
+      this.emit("close");
     }
   }
   async start(fn) {
     await fn();
     try {
-      const server = await alpListen(this.config, this.callback(), this.certPath);
+      const server = await alpListen(
+        this.config,
+        this.callback(),
+        this.certPath
+      );
       this._server = server;
-      logger$1.success('started');
-      if (process.send) process.send('ready');
+      logger$1.success("started");
+      if (process.send) process.send("ready");
       return server;
     } catch (error) {
-      logger$1.error('start fail', {
-        err: error
-      });
+      logger$1.error("start fail", { err: error });
       throw error;
     }
   }
 }
 
+const argv = minimist(process.argv.slice(2));
+function _existsConfigSync(dirname, name) {
+  return existsSync(`${dirname}${name}.json`);
+}
+function _loadConfigSync(dirname, name) {
+  const content = readFileSync(`${dirname}${name}.json`, "utf8");
+  return JSON.parse(content);
+}
+class Config {
+  packageConfig;
+  _record;
+  _dirname;
+  constructor(dirname, options) {
+    this._record = {};
+    this._dirname = dirname.replace(/\/*$/, "/");
+    if (options) {
+      this.loadSync(options);
+    }
+  }
+  loadSync(options = {}) {
+    const env = process.env.CONFIG_ENV || process.env.NODE_ENV || "development";
+    const { argv: argvOverrides = [], packageConfig, version } = options;
+    this.packageConfig = packageConfig;
+    const config = _loadConfigSync(this._dirname, "common");
+    for (const [key, value] of Object.entries(
+      _loadConfigSync(this._dirname, env)
+    )) {
+      config[key] = value;
+    }
+    if (this.existsConfigSync("local")) {
+      for (const [key, value] of Object.entries(
+        _loadConfigSync(this._dirname, "local")
+      )) {
+        config[key] = value;
+      }
+    }
+    if (config.version) {
+      throw new Error('Cannot have "version", in config.');
+    }
+    config.version = String(version || argv.version || packageConfig?.version);
+    const socketPath = argv.socket || argv["socket-path"] || argv.socketPath;
+    if (socketPath) {
+      config.socketPath = socketPath;
+    } else if (argv.port) {
+      config.port = argv.port;
+      delete config.socketPath;
+    } else if (process.env.PORT) {
+      config.port = Number(process.env.PORT);
+      delete config.socketPath;
+    }
+    argvOverrides.forEach((key) => {
+      const splitted = key.split(".");
+      const value = splitted.length > 0 && // eslint-disable-next-line @typescript-eslint/no-unsafe-return,unicorn/no-array-reduce
+      splitted.reduce((config2, partialKey) => config2[partialKey], argv);
+      if (value !== void 0) {
+        const last = splitted.pop();
+        const v = splitted.length === 0 ? config : (
+          // eslint-disable-next-line unicorn/no-array-reduce
+          splitted.reduce(
+            (config2, partialKey) => config2[partialKey],
+            config
+          )
+        );
+        v[last] = value;
+      }
+    });
+    this._record = deepFreeze(config);
+    return this;
+  }
+  get(key) {
+    return this._record[key];
+  }
+  existsConfigSync(name) {
+    return _existsConfigSync(this._dirname, name);
+  }
+  loadConfigSync(name) {
+    return _loadConfigSync(this._dirname, name);
+  }
+}
+
 const createAlpRouterBuilder = () => createRouterBuilder();
 function alpRouter(router) {
-  return app => {
+  return (app) => {
     app.router = router;
-    app.context.urlGenerator = function (routeKey, params) {
+    app.context.urlGenerator = function urlGenerator(routeKey, params) {
       return router.toLocalizedPath(this.language, routeKey, params);
     };
-    app.context.redirectTo = function (to, params) {
-      this.redirect(router.toLocalizedPath(this.language, to, params));
+    app.context.redirectTo = function redirectTo(to, params) {
+      this.redirect(
+        router.toLocalizedPath(this.language, to, params)
+      );
     };
-    return async ctx => {
-      // eslint-disable-next-line unicorn/no-array-method-this-argument
+    return async (ctx) => {
       const routeMatch = router.find(ctx.request.path, ctx.language);
       if (!routeMatch) {
         ctx.status = 404;
@@ -479,23 +490,20 @@ function alpRouter(router) {
   };
 }
 
-const logger = new Logger('alp');
-const appDirname = path.resolve('build');
-const packagePath = path.resolve('package.json');
+const logger = new Logger("alp");
+const appDirname = path.resolve("build");
+const packagePath = path.resolve("package.json");
 if (!packagePath) {
   throw new Error(`Could not find package.json: "${String(packagePath)}"`);
 }
 const packageDirname = path.dirname(packagePath);
-logger.debug('init', {
-  appDirname,
-  packageDirname
-});
-const packageConfig = JSON.parse(readFileSync(packagePath, 'utf8'));
+logger.debug("init", { appDirname, packageDirname });
+const packageConfig = JSON.parse(
+  readFileSync(packagePath, "utf8")
+);
 const buildedConfigPath = `${appDirname}/build/config/`;
 const configPath = existsSync(buildedConfigPath) ? buildedConfigPath : `${appDirname}/config/`;
-const config = new Config(configPath).loadSync({
-  packageConfig
-});
+const config = new Config(configPath).loadSync({ packageConfig });
 class App extends AlpNodeApp {
   constructor(options) {
     super({
@@ -508,4 +516,4 @@ class App extends AlpNodeApp {
 }
 
 export { Config, appDirname, config, createAlpRouterBuilder, App as default, packageConfig, packageDirname, alpRouter as router };
-//# sourceMappingURL=index-node18.mjs.map
+//# sourceMappingURL=index-node.mjs.map