alp-node 6.2.0 → 8.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alp-node",
-  "version": "6.2.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,46 +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",
-    "alp-listen": "7.1.1",
-    "alp-node-config": "9.1.1",
-    "alp-node-errors": "8.1.1",
-    "alp-node-language": "7.1.1",
-    "alp-params": "6.2.0",
-    "alp-translate": "8.1.1",
-    "alp-types": "3.1.1",
-    "koa": "^2.13.1",
-    "koa-compress": "^5.0.0",
+    "@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": "^3.0.1",
+    "koa-compress": "^5.1.1",
     "koa-static": "^5.0.0",
-    "nightingale-logger": "^15.0.0"
+    "minimist": "^1.2.8",
+    "nightingale-logger": "^15.0.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,28 +1,39 @@
-import type { IncomingMessage, Server, ServerResponse } from 'node:http';
-import path from 'node:path';
-import { deprecate } from 'node:util';
-import _listen from 'alp-listen';
-import type { Config } from 'alp-node-config';
-import _config from 'alp-node-config';
-import errors from 'alp-node-errors';
-import language from 'alp-node-language';
-import params from 'alp-params';
-import translate from 'alp-translate';
 import type {
-  NodeApplication,
-  NodeConfig,
+  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/index";
+import translate from "./translate/index";
+import type {
   Context as AlpContext,
-  ContextState,
   ContextSanitizedState,
-  ContextRequest,
-} from 'alp-types';
-import Koa from 'koa';
-import type { ParameterizedContext, DefaultState, BaseRequest } from 'koa';
-import compress from 'koa-compress';
-import serve from 'koa-static';
-import { Logger } from 'nightingale-logger';
+  ContextState,
+  NodeApplication,
+  NodeConfig,
+} from "./types";
 
-const logger = new Logger('alp');
+const logger = new Logger("alp");
 
 export interface AlpNodeAppOptions {
   appDirname: string;
@@ -32,15 +43,26 @@ 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 {}
-  // eslint-disable-next-line @typescript-eslint/no-empty-interface
-  interface DefaultContext extends AlpContext {}
-  // eslint-disable-next-line @typescript-eslint/no-empty-interface
-  interface BaseContext extends AlpContext {}
-  // eslint-disable-next-line @typescript-eslint/no-empty-interface, @typescript-eslint/no-shadow
-  interface BaseRequest extends ContextRequest {}
+
+  interface DefaultContext
+    extends AlpContext,
+      AlpParamsContext,
+      AlpRouterContext,
+      AlpLanguageContext,
+      TranslateContext {}
+
+  interface BaseContext extends AlpContext, TranslateBaseContext {
+    urlGenerator: UrlGenerator;
+    redirectTo: <P extends Record<string, unknown>>(
+      to: string,
+      params?: P,
+    ) => void;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface BaseRequest extends AlpParamsRequest {}
 }
 
 export class AlpNodeApp extends Koa<ContextState> implements NodeApplication {
@@ -52,10 +74,10 @@ export class AlpNodeApp extends Koa<ContextState> implements NodeApplication {
 
   config: Config & NodeConfig;
 
-  declare request: BaseRequest & ContextRequest;
-
   _server?: Server;
 
+  router?: Router<any, AlpRouteRef>;
+
   /**
    * @param {Object} [options]
    * @param {string} [options.certPath] directory of the ssl certificates
@@ -71,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);
   }
 
@@ -104,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;
   }
@@ -116,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");
   }
 
   /**
@@ -127,23 +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";

package/src/config.ts

@@ -0,0 +1,116 @@
+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));
+
+function _existsConfigSync(dirname: string, name: string): boolean {
+  return existsSync(`${dirname}${name}.json`);
+}
+
+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 {
+  argv?: string[];
+  packageConfig?: PackageConfig;
+  version?: string;
+}
+
+export class Config {
+  packageConfig?: PackageConfig;
+
+  private _record: Record<string, unknown>;
+
+  private readonly _dirname: string;
+
+  constructor(dirname: string, options?: ConfigOptions) {
+    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 { 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: string | undefined = (argv.socket ||
+      argv["socket-path"] ||
+      argv.socketPath) as string | undefined;
+    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((config, partialKey) => config[partialKey], argv);
+      if (value !== undefined) {
+        const last = splitted.pop()!;
+        const v =
+          splitted.length === 0
+            ? config
+            : // eslint-disable-next-line unicorn/no-array-reduce
+              splitted.reduce(
+                (config, partialKey) =>
+                  config[partialKey] as Record<string, unknown>,
+                config,
+              );
+        v[last] = value;
+      }
+    });
+
+    this._record = deepFreeze(config);
+    return this as unknown as Config & NodeConfig;
+  }
+
+  get<T>(key: string): Readonly<T> {
+    return this._record[key] as T;
+  }
+
+  existsConfigSync(name: string): boolean {
+    return _existsConfigSync(this._dirname, name);
+  }
+
+  loadConfigSync(name: string): Readonly<Record<string, unknown>> {
+    return _loadConfigSync(this._dirname, name);
+  }
+}

package/src/errors.ts

@@ -0,0 +1,70 @@
+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 errorHtmlRenderer = new ErrorHtmlRenderer({
+  appPath: `${process.cwd()}/`,
+});
+
+export default async function alpNodeErrors(
+  ctx: Context,
+  next: () => Promise<void> | void,
+): Promise<void> {
+  try {
+    await next();
+  } catch (error: unknown) {
+    // 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);
+
+    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";
+        if (
+          process.env.NODE_ENV !== "production" ||
+          (error as HtmlError).expose
+        ) {
+          ctx.body = { error: (error as Error).message };
+        } else {
+          ctx.body = { error: STATUS_CODES[ctx.status] };
+        }
+
+        break;
+
+      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;
+        } else {
+          throw error;
+        }
+
+        break;
+
+      case "text":
+      case false:
+      default:
+        ctx.type = "text/plain";
+        if (
+          process.env.NODE_ENV !== "production" ||
+          (error as HtmlError).expose
+        ) {
+          ctx.body = (error as Error).message;
+        } else {
+          throw error;
+        }
+
+        break;
+    }
+  }
+}

package/src/index.ts

@@ -1,27 +1,33 @@
-import { existsSync, readFileSync } from 'node:fs';
-import path from 'node:path';
-import { Config } from 'alp-node-config';
-import { Logger } from 'nightingale-logger';
-import type { AlpNodeAppOptions } from './AlpNodeApp';
-import { AlpNodeApp } from './AlpNodeApp';
-
-export type { Context } from './AlpNodeApp';
-export { Config } from 'alp-node-config';
-
-const logger = new Logger('alp');
-
-export const appDirname = path.resolve('build');
-
-const packagePath = path.resolve('package.json');
+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,
+  NodeApplication,
+  NodeConfig,
+  ContextState,
+  ContextSanitizedState,
+} from "./types";
+export type { Context } from "./AlpNodeApp";
+
+const logger = new Logger("alp");
+
+export const appDirname = path.resolve("build");
+
+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/`;
@@ -33,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 {
@@ -46,3 +52,12 @@ export default class App extends AlpNodeApp {
     });
   }
 }
+
+export { Config } from "./config";
+
+export {
+  default as router,
+  createAlpRouterBuilder,
+  type AlpRouteRef,
+  type AlpRouter,
+} from "./router";

package/src/language.ts

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

package/src/listen.ts

@@ -0,0 +1,68 @@
+import { chmodSync, readFileSync, unlinkSync } from "node:fs";
+import { createServer as createServerHttp } from "node:http";
+import type { IncomingMessage, Server, ServerResponse } from "node:http";
+import { createServer as createServerHttps } from "node:https";
+import { Logger } from "nightingale-logger";
+import type { Config } from "./config";
+
+const logger = new Logger("alp:listen");
+
+type RequestListener = (req: IncomingMessage, res: ServerResponse) => void;
+
+const createServer = (
+  callback: RequestListener,
+  socketPath?: string,
+  tls?: boolean,
+  dirname = "",
+  // eslint-disable-next-line @typescript-eslint/max-params
+): Server => {
+  const createHttpServer =
+    !socketPath && tls ? createServerHttps : createServerHttp;
+
+  if (!tls) {
+    return (createHttpServer as typeof createServerHttps)(callback);
+  }
+
+  const options = {
+    key: readFileSync(`${dirname}/server.key`),
+    cert: readFileSync(`${dirname}/server.crt`),
+  };
+
+  return (createHttpServer as typeof createServerHttps)(options, callback);
+};
+
+export default function alpListen(
+  config: Config,
+  callback: RequestListener,
+  dirname?: string,
+): Promise<Server> {
+  return new Promise((resolve) => {
+    const socketPath = config.get<string>("socketPath");
+    const port = config.get<number>("port");
+    const hostname = config.get<string>("hostname");
+    const tls = config.get<boolean>("tls");
+
+    logger.info("Creating server", socketPath ? { socketPath } : { port });
+    const server = createServer(callback, socketPath, tls, dirname);
+
+    if (socketPath) {
+      try {
+        unlinkSync(socketPath);
+      } catch {}
+
+      server.listen(socketPath, () => {
+        if (socketPath) {
+          chmodSync(socketPath, "777");
+        }
+
+        logger.info("Server listening", { socketPath });
+        resolve(server);
+      });
+    } else {
+      server.listen(port, hostname, () => {
+        logger.info("Server listening", { port });
+        resolve(server);
+      });
+    }
+  });
+}

package/src/params/ParamValid.ts

@@ -0,0 +1,15 @@
+import type { Context } from "../AlpNodeApp";
+import { ParamValidationResult } from "./ParamValidationResult";
+
+export default class ParamValid extends ParamValidationResult {
+  context: Context;
+
+  constructor(context: Context) {
+    super();
+    this.context = context;
+  }
+
+  override _error(): void {
+    this.context.throw(400, "Invalid params", { validator: this });
+  }
+}