alp-node 6.2.0 → 7.0.0

package/dist/definitions/params/ParamValidationResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParamValidationResult.d.ts","sourceRoot":"","sources":["../../../src/params/ParamValidationResult.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAEzC,qBAAa,qBAAqB;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAQvD,SAAS,IAAI,MAAM,GAAG,SAAS;IAI/B,SAAS,IAAI,OAAO;IAIpB,OAAO,IAAI,OAAO;CAgBnB"}

package/dist/definitions/params/ParamValidationResult.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ParamValidationResult.test.d.ts.map

package/dist/definitions/params/ParamValidationResult.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParamValidationResult.test.d.ts","sourceRoot":"","sources":["../../../src/params/ParamValidationResult.test.ts"],"names":[],"mappings":""}

package/dist/definitions/params/ParamValueFromContext.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="koa" />
+import type { Context } from '../AlpNodeApp';
+import type { ParamValidationResult } from './ParamValidationResult';
+import ParamValueStringValidator from './ParamValueStringValidator';
+export declare class ParamValueFromContext {
+    readonly validationResult: ParamValidationResult;
+    readonly context: Context;
+    constructor(context: Context, validationResult: ParamValidationResult);
+    namedParam(name: string): ParamValueStringValidator;
+    otherParam(position: number): ParamValueStringValidator;
+    queryParam(name: string): ParamValueStringValidator;
+}
+//# sourceMappingURL=ParamValueFromContext.d.ts.map

package/dist/definitions/params/ParamValueFromContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParamValueFromContext.d.ts","sourceRoot":"","sources":["../../../src/params/ParamValueFromContext.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,yBAAyB,MAAM,6BAA6B,CAAC;AAEpE,qBAAa,qBAAqB;IAChC,QAAQ,CAAC,gBAAgB,EAAE,qBAAqB,CAAC;IAEjD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;gBAEd,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,qBAAqB;IAKrE,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,yBAAyB;IAQnD,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,yBAAyB;IAQvD,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,yBAAyB;CAWpD"}

package/dist/definitions/params/ParamValueModelValidator.d.ts

@@ -0,0 +1,4 @@
+import ParamValueValidator from './ParamValueValidator';
+export default class ParamValueModelValidator<T> extends ParamValueValidator<T> {
+}
+//# sourceMappingURL=ParamValueModelValidator.d.ts.map

package/dist/definitions/params/ParamValueModelValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParamValueModelValidator.d.ts","sourceRoot":"","sources":["../../../src/params/ParamValueModelValidator.ts"],"names":[],"mappings":"AAAA,OAAO,mBAAmB,MAAM,uBAAuB,CAAC;AAExD,MAAM,CAAC,OAAO,OAAO,wBAAwB,CAC3C,CAAC,CACD,SAAQ,mBAAmB,CAAC,CAAC,CAAC;CA+B/B"}

package/dist/definitions/params/ParamValueStringValidator.d.ts

@@ -0,0 +1,5 @@
+import ParamValueValidator from './ParamValueValidator';
+export default class ParamValueStringValidator<T extends string = string> extends ParamValueValidator<T | null | undefined> {
+    notEmpty(): ParamValueValidator<T>;
+}
+//# sourceMappingURL=ParamValueStringValidator.d.ts.map

package/dist/definitions/params/ParamValueStringValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParamValueStringValidator.d.ts","sourceRoot":"","sources":["../../../src/params/ParamValueStringValidator.ts"],"names":[],"mappings":"AAAA,OAAO,mBAAmB,MAAM,uBAAuB,CAAC;AAExD,MAAM,CAAC,OAAO,OAAO,yBAAyB,CAC5C,CAAC,SAAS,MAAM,GAAG,MAAM,CACzB,SAAQ,mBAAmB,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;IACjD,QAAQ,IAAI,mBAAmB,CAAC,CAAC,CAAC;CAOnC"}

package/dist/definitions/params/ParamValueValidator.d.ts

@@ -0,0 +1,10 @@
+import type { ParamValidationResult } from './ParamValidationResult';
+export default class ParamValueValidator<T> {
+    readonly validationResult: ParamValidationResult;
+    readonly name: string;
+    readonly value: T;
+    constructor(validationResult: ParamValidationResult, name: string, value: T);
+    isValid(): boolean;
+    _error(key: string): void;
+}
+//# sourceMappingURL=ParamValueValidator.d.ts.map

package/dist/definitions/params/ParamValueValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParamValueValidator.d.ts","sourceRoot":"","sources":["../../../src/params/ParamValueValidator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAErE,MAAM,CAAC,OAAO,OAAO,mBAAmB,CAAC,CAAC;IACxC,QAAQ,CAAC,gBAAgB,EAAE,qBAAqB,CAAC;IAEjD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;gBAEN,gBAAgB,EAAE,qBAAqB,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAM3E,OAAO,IAAI,OAAO;IAIlB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;CAG1B"}

package/dist/definitions/params/index.d.ts

@@ -0,0 +1,15 @@
+import type { AlpNodeApp } from '../AlpNodeApp';
+import { ParamValueFromContext } from './ParamValueFromContext';
+export interface AlpParamsContext {
+    params: ParamValueFromContext;
+    validParams: ParamValueFromContext;
+    namedParam: (name: string) => string | undefined;
+    otherParam: (position: number) => string | undefined;
+    queryParam: (name: string) => string | undefined;
+    bodyParam: <T>(name: string) => T | undefined;
+}
+export interface AlpParamsRequest {
+    searchParams: URLSearchParams;
+}
+export default function alpParams(app: AlpNodeApp): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/definitions/params/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/params/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAW,MAAM,eAAe,CAAC;AAGzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,qBAAqB,CAAC;IAC9B,WAAW,EAAE,qBAAqB,CAAC;IACnC,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IACjD,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IACrD,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IACjD,SAAS,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,KAAK,CAAC,GAAG,SAAS,CAAC;CAC/C;AAED,MAAM,WAAW,gBAAgB;IAC/B,YAAY,EAAE,eAAe,CAAC;CAC/B;AAED,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI,CA8CvD"}

package/dist/definitions/router.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="koa" />
+import type { Router, LocaleType, RouterBuilder, RouteMatch } from 'router-segments';
+import type { AlpNodeApp, Context } from './AlpNodeApp';
+export type AlpRouter<Locales extends LocaleType> = Router<Locales, AlpRouteRef>;
+export type AlpRouteRef = (ctx: Context) => Promise<void> | void;
+type ReturnType = (app: AlpNodeApp) => AlpRouteRef;
+export interface RouterContext {
+    route: RouteMatch<any, AlpRouteRef>;
+}
+export declare const createAlpRouterBuilder: <Locales extends string>() => RouterBuilder<Locales, AlpRouteRef>;
+export type UrlGenerator = <P extends Record<string, unknown> | undefined>(routeKey: string, params?: P) => string;
+export default function alpRouter<Locales extends string>(router: Router<Locales, AlpRouteRef>): ReturnType;
+export {};
+//# sourceMappingURL=router.d.ts.map

package/dist/definitions/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/router.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EACV,MAAM,EACN,UAAU,EACV,aAAa,EACb,UAAU,EACX,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAExD,MAAM,MAAM,SAAS,CAAC,OAAO,SAAS,UAAU,IAAI,MAAM,CACxD,OAAO,EACP,WAAW,CACZ,CAAC;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AACjE,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,UAAU,KAAK,WAAW,CAAC;AAEnD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,UAAU,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;CACrC;AACD,eAAO,MAAM,sBAAsB,mEAGU,CAAC;AAE9C,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EACvE,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,CAAC,KACP,MAAM,CAAC;AAEZ,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,OAAO,SAAS,MAAM,EACtD,MAAM,EAAE,MAAM,CAAC,OAAO,EAAE,WAAW,CAAC,GACnC,UAAU,CAgCZ"}

package/dist/definitions/translate/index.d.ts

@@ -0,0 +1,11 @@
+import type { AlpNodeApp } from '../AlpNodeApp';
+type Args = Record<string, any>;
+export interface TranslateBaseContext {
+    t: (id: string, args: Args) => string;
+}
+export interface TranslateContext {
+    readonly language: string;
+}
+export default function alpTranslate(dirname: string): (app: AlpNodeApp) => void;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/definitions/translate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/translate/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAW,MAAM,eAAe,CAAC;AAMzD,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAEhC,MAAM,WAAW,oBAAoB;IACnC,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,KAAK,MAAM,CAAC;CACvC;AACD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,OAAO,EAAE,MAAM,GACd,CAAC,GAAG,EAAE,UAAU,KAAK,IAAI,CA0B3B"}

package/dist/definitions/translate/load.d.ts

@@ -0,0 +1,4 @@
+import IntlMessageFormatDefault from 'intl-messageformat';
+export type Translations = ReadonlyMap<string, IntlMessageFormatDefault>;
+export default function load(translations: ReadonlyMap<string, unknown>, language: string): Translations;
+//# sourceMappingURL=load.d.ts.map

package/dist/definitions/translate/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../../src/translate/load.ts"],"names":[],"mappings":"AAAA,OAAO,wBAAwB,MAAM,oBAAoB,CAAC;AAO1D,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;AAEzE,MAAM,CAAC,OAAO,UAAU,IAAI,CAC1B,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1C,QAAQ,EAAE,MAAM,GACf,YAAY,CAiBd"}

package/dist/definitions/types.d.ts

@@ -0,0 +1,53 @@
+type RawConfig = ReadonlyMap<string, any>;
+export interface Config {
+    get: <T>(key: string) => T;
+}
+export type PackageConfig = Record<string, any>;
+export interface NodeConfig extends Config {
+    loadConfigSync: (name: string) => RawConfig;
+    readonly packageConfig: PackageConfig;
+}
+export interface ContextState {
+}
+export interface ContextSanitizedState {
+}
+export interface BaseContext {
+    config: Config;
+}
+export interface Context extends BaseContext {
+    state: ContextState;
+    sanitizedState: ContextSanitizedState;
+    status: number;
+    response: any;
+    redirect: (url: string) => Promise<void>;
+    [key: string]: any;
+}
+export interface ApplicationInCreation {
+    config?: Config;
+    context: BaseContext;
+}
+export interface Application extends ApplicationInCreation {
+    config: Config;
+}
+export interface NodeApplicationInCreation extends ApplicationInCreation {
+    loadConfigSync: (name: string) => RawConfig;
+}
+export interface BrowserApplicationInCreation extends ApplicationInCreation {
+    appVersion: string;
+    existsConfig: (name: string) => Promise<boolean> | boolean;
+    loadConfig: (name: string) => Promise<RawConfig>;
+    createContext: () => Context;
+}
+export interface NodeApplication extends Application, NodeApplicationInCreation {
+    config: NodeConfig;
+    dirname: string;
+    on: (event: 'close', callback: () => void) => void;
+    existsConfigSync: (name: string) => boolean;
+    loadConfigSync: (name: string) => RawConfig;
+}
+export interface HtmlError extends Error {
+    status: number;
+    expose?: true;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/definitions/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,KAAK,SAAS,GAAG,WAAW,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAE1C,MAAM,WAAW,MAAM;IACrB,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC,CAAC;CAC5B;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAEhD,MAAM,WAAW,UAAW,SAAQ,MAAM;IACxC,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,CAAC;IAC5C,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;CACvC;AAGD,MAAM,WAAW,YAAY;CAAG;AAGhC,MAAM,WAAW,qBAAqB;CAAG;AAEzC,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,OAAQ,SAAQ,WAAW;IAC1C,KAAK,EAAE,YAAY,CAAC;IACpB,cAAc,EAAE,qBAAqB,CAAC;IACtC,MAAM,EAAE,MAAM,CAAC;IAEf,QAAQ,EAAE,GAAG,CAAC;IACd,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,WAAW,WAAY,SAAQ,qBAAqB;IACxD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,yBAA0B,SAAQ,qBAAqB;IACtE,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,CAAC;CAC7C;AAED,MAAM,WAAW,4BAA6B,SAAQ,qBAAqB;IACzE,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IAC3D,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IACjD,aAAa,EAAE,MAAM,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,eACf,SAAQ,WAAW,EACjB,yBAAyB;IAC3B,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IACnD,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAC5C,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,CAAC;CAC7C;AAED,MAAM,WAAW,SAAU,SAAQ,KAAK;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,IAAI,CAAC;CACf"}

package/dist/index-node18.mjs

@@ -1,17 +1,381 @@
-import { readFileSync, existsSync } from 'node:fs';
+import { existsSync, readFileSync, unlinkSync, chmodSync } from 'node:fs';
 import path from 'node:path';
-import _config, { Config } from 'alp-node-config';
-export { Config } from 'alp-node-config';
 import { Logger } from 'nightingale-logger';
 import { deprecate } from 'node:util';
-import _listen from 'alp-listen';
-import errors from 'alp-node-errors';
-import language from 'alp-node-language';
-import params from 'alp-params';
-import translate from 'alp-translate';
 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 { 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 errorHtmlRenderer = new ErrorHtmlRenderer({
+  appPath: `${process.cwd()}/`
+});
+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);
+    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
+          };
+        } 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);
+        } else if (error.expose) {
+          ctx.body = error.message;
+        } else {
+          throw error;
+        }
+        break;
+      case 'text':
+      default:
+        ctx.type = 'text/plain';
+        if (process.env.NODE_ENV !== 'production' || error.expose) {
+          ctx.body = error.message;
+        } else {
+          throw error;
+        }
+        break;
+    }
+  }
+}
+
+function alpLanguage(app) {
+  const config = app.context.config;
+  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];
+  });
+}
+
+const logger$3 = new Logger('alp:listen');
+const createServer = (callback, socketPath, tls, dirname = ''
+// eslint-disable-next-line @typescript-eslint/max-params
+) => {
+  const createHttpServer = !socketPath && tls ? createServer$1 : createServer$2;
+  if (!tls) {
+    return createHttpServer(callback);
+  }
+  const options = {
+    key: readFileSync(`${dirname}/server.key`),
+    cert: readFileSync(`${dirname}/server.crt`)
+  };
+  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
+    });
+    const server = createServer(callback, socketPath, tls, dirname);
+    if (socketPath) {
+      try {
+        unlinkSync(socketPath);
+      } catch {}
+      server.listen(socketPath, () => {
+        if (socketPath) {
+          chmodSync(socketPath, '777');
+        }
+        logger$3.info('Server listening', {
+          socketPath
+        });
+        resolve(server);
+      });
+    } else {
+      server.listen(port, hostname, () => {
+        logger$3.info('Server listening', {
+          port
+        });
+        resolve(server);
+      });
+    }
+  });
+}
+
+class ParamValidationResult {
+  _error(name, key, value) {
+    if (!this._errors) {
+      this._errors = {};
+    }
+    this._errors[name] = {
+      error: key,
+      value
+    };
+  }
+  getErrors() {
+    return this._errors;
+  }
+  hasErrors() {
+    return this._errors !== undefined;
+  }
+  isValid() {
+    return this._errors === undefined;
+  }
+
+  // string(name: string): ParamValueStringValidator {
+  //   return new ParamValueStringValidator(this, name, this.context.param(name));
+  // }
+  /* int(name, position) {
+   return new ParamValueIntValidator(this, name, this.context.param(name, position));
+   }
+   model(modelName, name) {
+   name = name || S.string.lcFirst(modelName);
+   console.log('paramvalidator model', modelName, M[modelName]);
+   let data = this.context.getOrPostParam(name);
+   return new ParamValueModelValidator(this, name, !data ? null : new M[modelName](data));
+   } */
+}
+
+class ParamValid extends ParamValidationResult {
+  constructor(context) {
+    super();
+    this.context = context;
+  }
+  _error() {
+    this.context.throw(400, 'Invalid params', {
+      validator: this
+    });
+  }
+}
+
+class ParamValueValidator {
+  constructor(validationResult, name, value) {
+    this.validationResult = validationResult;
+    this.name = name;
+    this.value = value;
+  }
+  isValid() {
+    return this.validationResult.isValid();
+  }
+  _error(key) {
+    this.validationResult._error(this.name, key, this.value);
+  }
+}
+
+class ParamValueStringValidator extends ParamValueValidator {
+  notEmpty() {
+    if (this.value == null || this.value.trim() === '') {
+      this._error('notEmpty');
+    }
+    return this;
+  }
+}
+
+class ParamValueFromContext {
+  constructor(context, validationResult) {
+    this.validationResult = validationResult;
+    this.context = context;
+  }
+  namedParam(name) {
+    return new ParamValueStringValidator(this.validationResult, name, this.context.namedParam(name));
+  }
+  otherParam(position) {
+    return new ParamValueStringValidator(this.validationResult, String(position), this.context.otherParam(position));
+  }
+  queryParam(name) {
+    return new ParamValueStringValidator(this.validationResult, name, this.context.queryParam(name));
+  }
+
+  // bodyParam: <T>(name: string): ParamValueValidator<string | undefined> {
+
+  // }
+}
+
+function alpParams(app) {
+  Object.assign(app.context, {
+    namedRouteParam(name) {
+      const namedParams = this.route.namedParams;
+      return namedParams?.get(name);
+    },
+    otherRouteParam(position) {
+      const otherParams = this.route.otherParams;
+      return otherParams?.[position - 1];
+    },
+    queryParam(name) {
+      const searchParams = this.request.searchParams;
+      return searchParams.get(name) ?? undefined;
+    },
+    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));
+  });
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+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
+        loadMap(value, `${prefix}${key}.`);
+        return;
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      result.set(`${prefix}${key}`, new IntlMessageFormat(value, language));
+    });
+  })(translations, '');
+  return result;
+}
+
+const logger$2 = new Logger('alp:translate');
+function alpTranslate(dirname) {
+  dirname = dirname.replace(/\/*$/, '/');
+  return app => {
+    const appTranslations = new Map();
+    Object.assign(app.context, {
+      t(id, args) {
+        const msg = appTranslations.get(this.language).get(id);
+        if (!msg) {
+          logger$2.warn('invalid msg', {
+            language: this.language,
+            id
+          });
+          return id;
+        }
+        return msg.format(args);
+      }
+    });
+    const config = app.config;
+    config.get('availableLanguages').forEach(language => {
+      const translations = app.loadConfigSync(dirname + language);
+      appTranslations.set(language, load(translations, language));
+    });
+    return appTranslations;
+  };
+}
 
 const logger$1 = new Logger('alp');
 class AlpNodeApp extends Koa {
@@ -36,11 +400,11 @@ class AlpNodeApp extends Koa {
     });
     this.certPath = certPath || `${packageDirname}/config/cert`;
     this.publicPath = publicPath || `${packageDirname}/public/`;
-    this.config = _config(this, config);
+    this.config = getConfig(this, config);
     this.context.config = this.config;
-    params(this);
-    language(this);
-    translate('locales')(this);
+    alpParams(this);
+    alpLanguage(this);
+    alpTranslate('locales')(this);
     this.use(compress());
   }
   existsConfigSync(name) {
@@ -58,7 +422,7 @@ class AlpNodeApp extends Koa {
     this.use(serve(this.publicPath)); // static files
   }
   catchErrors() {
-    this.use(errors);
+    this.use(alpNodeErrors);
   }
 
   // eslint-disable-next-line @typescript-eslint/class-methods-use-this
@@ -78,7 +442,7 @@ class AlpNodeApp extends Koa {
   async start(fn) {
     await fn();
     try {
-      const server = await _listen(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');
@@ -92,6 +456,29 @@ class AlpNodeApp extends Koa {
   }
 }
 
+const createAlpRouterBuilder = () => createRouterBuilder();
+function alpRouter(router) {
+  return app => {
+    app.router = router;
+    app.context.urlGenerator = function (routeKey, params) {
+      return router.toLocalizedPath(this.language, routeKey, params);
+    };
+    app.context.redirectTo = function (to, params) {
+      this.redirect(router.toLocalizedPath(this.language, to, params));
+    };
+    return async ctx => {
+      // eslint-disable-next-line unicorn/no-array-method-this-argument
+      const routeMatch = router.find(ctx.request.path, ctx.language);
+      if (!routeMatch) {
+        ctx.status = 404;
+        throw new Error(`Route not found: ${ctx.request.path}`);
+      }
+      ctx.route = routeMatch;
+      await routeMatch.ref(ctx);
+    };
+  };
+}
+
 const logger = new Logger('alp');
 const appDirname = path.resolve('build');
 const packagePath = path.resolve('package.json');
@@ -120,5 +507,5 @@ class App extends AlpNodeApp {
   }
 }
 
-export { appDirname, config, App as default, packageConfig, packageDirname };
+export { Config, appDirname, config, createAlpRouterBuilder, App as default, packageConfig, packageDirname, alpRouter as router };
 //# sourceMappingURL=index-node18.mjs.map