alp-node 7.0.0 → 8.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alp-node",
-  "version": "7.0.0",
+  "version": "8.0.0",
   "description": "framework based on koa 2",
   "keywords": [
     "springbokjs",
@@ -22,10 +22,10 @@
   },
   "type": "module",
   "engines": {
-    "node": ">=18.12.0"
+    "node": ">=20.11.0"
   },
   "sideEffects": false,
-  "main": "./dist/index-node18.mjs",
+  "main": "./dist/index-node20.mjs",
   "types": "./dist/definitions/index.d.ts",
   "typesVersions": {
     ">=3.1": {
@@ -39,13 +39,13 @@
     ".": {
       "types": "./dist/definitions/index.d.ts",
       "node": {
-        "import": "./dist/index-node18.mjs"
+        "import": "./dist/index-node20.mjs"
       }
     },
     "./AlpNodeApp": {
       "types": "./dist/definitions/AlpNodeApp.d.ts",
       "node": {
-        "import": "./dist/AlpNodeApp-node18.mjs"
+        "import": "./dist/AlpNodeApp-node20.mjs"
       }
     }
   },
@@ -59,45 +59,45 @@
     "clean": "yarn clean:build",
     "clean:build": "pob-babel-clean-out dist",
     "lint": "yarn run lint:eslint",
-    "lint:eslint": "yarn ../.. run eslint --report-unused-disable-directives --resolve-plugins-relative-to . --quiet packages/alp-node",
+    "lint:eslint": "yarn ../.. run eslint --quiet packages/alp-node",
     "watch": "yarn clean:build && rollup --config rollup.config.mjs --watch"
   },
   "pob": {
-    "babelEnvs": [
-      {
-        "target": "node",
-        "version": "18"
-      }
-    ],
+    "bundler": "rollup-babel",
     "entries": [
       "index",
       "AlpNodeApp"
+    ],
+    "envs": [
+      {
+        "target": "node",
+        "version": "20"
+      }
     ]
   },
   "prettier": "@pob/root/prettier-config",
   "peerDependencies": {
-    "router-segments": "^9.1.0"
+    "router-segments": "^11.0.0"
   },
   "dependencies": {
-    "@types/koa": "^2.13.1",
-    "@types/node": ">=18.0.0",
-    "deep-freeze-es6": "^3.0.2",
+    "@types/koa": "^3.0.0",
+    "@types/node": ">=20.0.0",
+    "deep-freeze-es6": "^4.0.1",
     "error-html": "^0.3.5",
     "intl-messageformat": "^10.0.0",
-    "koa": "^2.13.1",
-    "koa-compress": "^5.0.0",
+    "koa": "^3.0.1",
+    "koa-compress": "^5.1.1",
     "koa-static": "^5.0.0",
     "minimist": "^1.2.8",
     "nightingale-logger": "^15.0.0",
-    "object-properties": "^8.1.0",
-    "parse-json-object-as-map": "^1.2.0"
+    "object-properties": "^9.0.1"
   },
   "devDependencies": {
-    "@babel/core": "7.23.7",
+    "@babel/core": "7.28.0",
     "@types/koa-compress": "4.0.6",
     "@types/koa-static": "4.0.4",
     "@types/minimist": "1.2.5",
-    "pob-babel": "38.0.2",
-    "typescript": "5.3.3"
+    "pob-babel": "43.7.0",
+    "typescript": "5.8.3"
   }
 }

package/src/AlpNodeApp.ts

@@ -1,36 +1,39 @@
-import type { IncomingMessage, Server, ServerResponse } from 'node:http';
-import path from 'node:path';
-import { deprecate } from 'node:util';
-import Koa from 'koa';
-import type { ParameterizedContext, DefaultState } from 'koa';
-import compress from 'koa-compress';
-import serve from 'koa-static';
-import { Logger } from 'nightingale-logger';
-import type { Router } from 'router-segments';
-import type { Config } from './config';
-import _config from './config';
-import errors from './errors';
-import type { AlpLanguageContext } from './language';
-import language from './language';
-import _listen from './listen';
-import type { AlpParamsContext, AlpParamsRequest } from './params';
-import params from './params';
+import type {
+  IncomingMessage,
+  RequestListener,
+  Server,
+  ServerResponse,
+} from "node:http";
+import path from "node:path";
+import Koa from "koa";
+import type { DefaultState, ParameterizedContext } from "koa";
+import compress from "koa-compress";
+import serve from "koa-static";
+import { Logger } from "nightingale-logger";
+import type { Router } from "router-segments";
+import type { Config } from "./config";
+import errors from "./errors";
+import type { AlpLanguageContext } from "./language";
+import language from "./language";
+import _listen from "./listen";
+import type { AlpParamsContext, AlpParamsRequest } from "./params/index";
+import params from "./params/index";
 import type {
   AlpRouteRef,
   RouterContext as AlpRouterContext,
   UrlGenerator,
-} from './router';
-import type { TranslateBaseContext, TranslateContext } from './translate';
-import translate from './translate';
+} from "./router";
+import type { TranslateBaseContext, TranslateContext } from "./translate/index";
+import translate from "./translate/index";
 import type {
-  NodeApplication,
-  NodeConfig,
   Context as AlpContext,
-  ContextState,
   ContextSanitizedState,
-} from './types';
+  ContextState,
+  NodeApplication,
+  NodeConfig,
+} from "./types";
 
-const logger = new Logger('alp');
+const logger = new Logger("alp");
 
 export interface AlpNodeAppOptions {
   appDirname: string;
@@ -40,8 +43,8 @@ export interface AlpNodeAppOptions {
   publicPath?: string;
 }
 
-declare module 'koa' {
-  // eslint-disable-next-line @typescript-eslint/no-empty-interface, @typescript-eslint/no-shadow
+declare module "koa" {
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   interface DefaultState extends ContextState {}
 
   interface DefaultContext
@@ -58,7 +61,7 @@ declare module 'koa' {
       params?: P,
     ) => void;
   }
-  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   interface BaseRequest extends AlpParamsRequest {}
 }
 
@@ -90,31 +93,24 @@ export class AlpNodeApp extends Koa<ContextState> implements NodeApplication {
     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 = _config(this, config);
+    this.config = config;
     this.context.config = this.config;
 
     params(this);
     language(this);
-    translate('locales')(this);
+    translate("locales")(this);
 
     this.use(compress());
   }
 
-  existsConfigSync(name: string): ReturnType<Config['existsConfigSync']> {
+  existsConfigSync(name: string): ReturnType<Config["existsConfigSync"]> {
     return this.config.existsConfigSync(name);
   }
 
-  loadConfigSync(name: string): ReturnType<Config['loadConfigSync']> {
+  loadConfigSync(name: string): ReturnType<Config["loadConfigSync"]> {
     return this.config.loadConfigSync(name);
   }
 
@@ -123,6 +119,7 @@ export class AlpNodeApp extends Koa<ContextState> implements NodeApplication {
     res: ServerResponse,
   ): ParameterizedContext<StateT> {
     const ctx = super.createContext<StateT>(req, res);
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     ctx.sanitizedState = {} as ContextSanitizedState;
     return ctx;
   }
@@ -135,9 +132,8 @@ export class AlpNodeApp extends Koa<ContextState> implements NodeApplication {
     this.use(errors);
   }
 
-  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
   override listen(): never {
-    throw new Error('Use start instead');
+    throw new Error("Use start instead");
   }
 
   /**
@@ -146,25 +142,29 @@ export class AlpNodeApp extends Koa<ContextState> implements NodeApplication {
   close(): void {
     if (this._server) {
       this._server.close();
-      this.emit('close');
+      this.emit("close");
     }
   }
 
   async start(fn: () => Promise<void> | void): Promise<Server> {
     await fn();
     try {
-      const server = await _listen(this.config, this.callback(), this.certPath);
+      const server = await _listen(
+        this.config,
+        this.callback() as RequestListener,
+        this.certPath,
+      );
       this._server = server;
-      logger.success('started');
-      if (process.send) process.send('ready');
+      logger.success("started");
+      if (process.send) process.send("ready");
       return server;
     } catch (error: unknown) {
-      logger.error('start fail', { err: error });
+      logger.error("start fail", { err: error });
       throw error;
     }
   }
 }
 
-export type { Context } from 'koa';
+export type { Context } from "koa";
 
-export { type NodeApplication } from './types';
+export { type NodeApplication } from "./types";

package/src/config.ts

@@ -1,8 +1,7 @@
-import { existsSync, readFileSync } from 'node:fs';
-import deepFreeze from 'deep-freeze-es6';
-import minimist from 'minimist';
-import parseJSON from 'parse-json-object-as-map';
-import type { NodeApplication, NodeConfig, PackageConfig } from './types';
+import { existsSync, readFileSync } from "node:fs";
+import deepFreeze from "deep-freeze-es6";
+import minimist from "minimist";
+import type { NodeConfig, PackageConfig } from "./types";
 
 const argv = minimist(process.argv.slice(2));
 
@@ -10,9 +9,12 @@ function _existsConfigSync(dirname: string, name: string): boolean {
   return existsSync(`${dirname}${name}.json`);
 }
 
-function _loadConfigSync(dirname: string, name: string): Map<string, unknown> {
-  const content = readFileSync(`${dirname}${name}.json`, 'utf8');
-  return parseJSON(content) as Map<string, unknown>;
+function _loadConfigSync(
+  dirname: string,
+  name: string,
+): Record<string, unknown> {
+  const content = readFileSync(`${dirname}${name}.json`, "utf8");
+  return JSON.parse(content) as Record<string, unknown>;
 }
 
 export interface ConfigOptions {
@@ -24,98 +26,91 @@ export interface ConfigOptions {
 export class Config {
   packageConfig?: PackageConfig;
 
-  private _map: Map<string, unknown>;
+  private _record: Record<string, unknown>;
 
   private readonly _dirname: string;
 
   constructor(dirname: string, options?: ConfigOptions) {
-    this._map = new Map<string, unknown>();
-    this._dirname = dirname.replace(/\/*$/, '/');
+    this._record = {};
+    this._dirname = dirname.replace(/\/*$/, "/");
     if (options) {
       this.loadSync(options);
     }
   }
 
   loadSync(options: ConfigOptions = {}): Config & NodeConfig {
-    const env = process.env.CONFIG_ENV || process.env.NODE_ENV || 'development';
+    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') as Map<string, unknown>;
-    for (const [key, value] of this.loadConfigSync(env)) {
-      config.set(key, value);
+    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 this.loadConfigSync('local')) {
-        config.set(key, value);
+    if (this.existsConfigSync("local")) {
+      for (const [key, value] of Object.entries(
+        _loadConfigSync(this._dirname, "local"),
+      )) {
+        config[key] = value;
       }
     }
 
-    if (config.has('version')) {
+    if (config.version) {
       throw new Error('Cannot have "version", in config.');
     }
 
-    config.set(
-      'version',
-      String(version || argv.version || packageConfig?.version),
-    );
+    config.version = String(version || argv.version || packageConfig?.version);
 
     const socketPath: string | undefined = (argv.socket ||
-      argv['socket-path'] ||
+      argv["socket-path"] ||
       argv.socketPath) as string | undefined;
     if (socketPath) {
-      config.set('socketPath', socketPath);
+      config.socketPath = socketPath;
     } else if (argv.port) {
-      config.set('port', argv.port);
-      config.delete('socketPath');
+      config.port = argv.port;
+      delete config.socketPath;
     } else if (process.env.PORT) {
-      config.set('port', Number(process.env.PORT));
-      config.delete('socketPath');
+      config.port = Number(process.env.PORT);
+      delete config.socketPath;
     }
 
     argvOverrides.forEach((key) => {
-      const splitted = key.split('.');
+      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);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return,unicorn/no-array-reduce
+        splitted.reduce((config, partialKey) => config[partialKey], argv);
       if (value !== undefined) {
         const last = splitted.pop()!;
-        const map =
+        const v =
           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) as Map<string, unknown>,
+                  config[partialKey] as Record<string, unknown>,
                 config,
               );
-        map.set(last, value);
+        v[last] = value;
       }
     });
 
-    this._map = deepFreeze(config);
-    return this as Config & NodeConfig;
+    this._record = deepFreeze(config);
+    return this as unknown as Config & NodeConfig;
   }
 
-  get<T>(key: string): T {
-    return this._map.get(key) as T;
+  get<T>(key: string): Readonly<T> {
+    return this._record[key] as T;
   }
 
   existsConfigSync(name: string): boolean {
     return _existsConfigSync(this._dirname, name);
   }
 
-  loadConfigSync(name: string): ReadonlyMap<string, unknown> {
+  loadConfigSync(name: string): Readonly<Record<string, unknown>> {
     return _loadConfigSync(this._dirname, name);
   }
 }
-
-export default function getConfig(
-  app: NodeApplication,
-  config: Config & NodeConfig,
-): Config & NodeConfig {
-  return config;
-}

package/src/errors.ts

@@ -1,11 +1,10 @@
-/* eslint-disable complexity */
-import { STATUS_CODES } from 'node:http';
-import ErrorHtmlRenderer from 'error-html';
-import { Logger } from 'nightingale-logger';
-import type { Context } from './AlpNodeApp';
-import type { HtmlError } from './types';
+import { STATUS_CODES } from "node:http";
+import ErrorHtmlRenderer from "error-html";
+import { Logger } from "nightingale-logger";
+import type { Context } from "./AlpNodeApp";
+import type { HtmlError } from "./types";
 
-const logger = new Logger('alp:errors');
+const logger = new Logger("alp:errors");
 const errorHtmlRenderer = new ErrorHtmlRenderer({
   appPath: `${process.cwd()}/`,
 });
@@ -18,19 +17,19 @@ export default async function alpNodeErrors(
     await next();
   } catch (error: unknown) {
     // eslint-disable-next-line no-ex-assign
-    if (!error) error = new Error('Unknown error');
+    if (!error) error = new Error("Unknown error");
     // eslint-disable-next-line no-ex-assign
-    if (typeof error === 'string') error = new Error(error);
+    if (typeof error === "string") error = new Error(error);
 
     ctx.status = (error as HtmlError).status || 500;
     // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     logger.error(error as any);
 
-    switch (ctx.request.accepts('html', 'text', 'json')) {
-      case 'json':
-        ctx.type = 'application/json';
+    switch (ctx.request.accepts("html", "text", "json")) {
+      case "json":
+        ctx.type = "application/json";
         if (
-          process.env.NODE_ENV !== 'production' ||
+          process.env.NODE_ENV !== "production" ||
           (error as HtmlError).expose
         ) {
           ctx.body = { error: (error as Error).message };
@@ -40,9 +39,9 @@ export default async function alpNodeErrors(
 
         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 as Error);
         } else if ((error as HtmlError).expose) {
           ctx.body = (error as Error).message;
@@ -52,11 +51,12 @@ export default async function alpNodeErrors(
 
         break;
 
-      case 'text':
+      case "text":
+      case false:
       default:
-        ctx.type = 'text/plain';
+        ctx.type = "text/plain";
         if (
-          process.env.NODE_ENV !== 'production' ||
+          process.env.NODE_ENV !== "production" ||
           (error as HtmlError).expose
         ) {
           ctx.body = (error as Error).message;

package/src/index.ts

@@ -1,9 +1,9 @@
-import { existsSync, readFileSync } from 'node:fs';
-import path from 'node:path';
-import { Logger } from 'nightingale-logger';
-import type { AlpNodeAppOptions } from './AlpNodeApp';
-import { AlpNodeApp } from './AlpNodeApp';
-import { Config } from './config';
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { Logger } from "nightingale-logger";
+import type { AlpNodeAppOptions } from "./AlpNodeApp";
+import { AlpNodeApp } from "./AlpNodeApp";
+import { Config } from "./config";
 
 export type {
   BaseContext,
@@ -11,23 +11,23 @@ export type {
   NodeConfig,
   ContextState,
   ContextSanitizedState,
-} from './types';
-export type { Context } from './AlpNodeApp';
+} from "./types";
+export type { Context } from "./AlpNodeApp";
 
-const logger = new Logger('alp');
+const logger = new Logger("alp");
 
-export const appDirname = path.resolve('build');
+export const appDirname = path.resolve("build");
 
-const packagePath = path.resolve('package.json');
+const packagePath = path.resolve("package.json");
 if (!packagePath) {
   throw new Error(`Could not find package.json: "${String(packagePath)}"`);
 }
 export const packageDirname = path.dirname(packagePath);
 
-logger.debug('init', { appDirname, packageDirname });
+logger.debug("init", { appDirname, packageDirname });
 
 export const packageConfig: Record<string, unknown> = JSON.parse(
-  readFileSync(packagePath, 'utf8'),
+  readFileSync(packagePath, "utf8"),
 ) as Record<string, unknown>;
 
 const buildedConfigPath = `${appDirname}/build/config/`;
@@ -39,7 +39,7 @@ export const config = new Config(configPath).loadSync({ packageConfig });
 
 export type AppOptions = Omit<
   AlpNodeAppOptions,
-  'appDirname' | 'config' | 'packageDirname'
+  "appDirname" | "config" | "packageDirname"
 >;
 
 export default class App extends AlpNodeApp {
@@ -53,11 +53,11 @@ export default class App extends AlpNodeApp {
   }
 }
 
-export { Config } from './config';
+export { Config } from "./config";
 
 export {
   default as router,
   createAlpRouterBuilder,
   type AlpRouteRef,
   type AlpRouter,
-} from './router';
+} from "./router";

package/src/language.ts

@@ -1,6 +1,6 @@
-import type { Context } from 'koa';
-import { defineLazyProperty } from 'object-properties';
-import type { AlpNodeApp } from './AlpNodeApp';
+import type { Context } from "koa";
+import { defineLazyProperty } from "object-properties";
+import type { AlpNodeApp } from "./AlpNodeApp";
 
 export interface AlpLanguageContext {
   readonly firstAcceptedLanguage: string;
@@ -8,20 +8,28 @@ export interface AlpLanguageContext {
 }
 export default function alpLanguage(app: AlpNodeApp): void {
   const config = app.context.config;
-  const availableLanguages: string[] = config.get('availableLanguages');
+  const availableLanguages: string[] = config.get("availableLanguages");
   if (!availableLanguages) {
     throw new Error('Missing config "availableLanguages"');
   }
 
-  defineLazyProperty(app.context, 'language', function (this: Context): string {
-    return this.acceptsLanguages(availableLanguages) || availableLanguages[0];
-  });
+  defineLazyProperty(
+    app.context,
+    "language",
+    function language(this: Context): string {
+      return (
+        this.acceptsLanguages(availableLanguages) ||
+        availableLanguages[0] ||
+        "en"
+      );
+    },
+  );
 
   defineLazyProperty(
     app.context,
-    'firstAcceptedLanguage',
-    function (this: Context): string {
-      return this.acceptsLanguages()[0] || availableLanguages[0];
+    "firstAcceptedLanguage",
+    function firstAcceptedLanguage(this: Context): string {
+      return this.acceptsLanguages()[0] || availableLanguages[0] || "en";
     },
   );
 }