alp-node 6.2.0 → 8.0.0

package/src/params/ParamValidationResult.test.ts

@@ -0,0 +1,65 @@
+import { ParamValidationResult } from "./ParamValidationResult";
+
+// const createContextMock = (): Context &
+//   Record<
+//     'namedParam' | 'otherParam' | 'param' | 'paramGET' | 'paramGETorPOST',
+//     ReturnType<typeof jest.fn>
+//   > => {
+//   return {
+//     state: {} as ContextState,
+//     sanitizedState: {} as ContextSanitizedState,
+//     param: jest.fn(),
+//     namedParam: jest.fn(),
+//     otherParam: jest.fn(),
+//     paramGET: jest.fn(),
+//     paramGETorPOST: jest.fn(),
+//   } as unknown as Context &
+//     Record<
+//       'namedParam' | 'otherParam' | 'param' | 'paramGET' | 'paramGETorPOST',
+//       ReturnType<typeof jest.fn>
+//     >;
+// };
+
+test("on init is valid", () => {
+  const paramValidator = new ParamValidationResult();
+  expect(paramValidator.getErrors()).toBe(undefined);
+  expect(paramValidator.hasErrors()).toBe(false);
+  expect(paramValidator.isValid()).toBe(true);
+});
+
+test("has error", () => {
+  const paramValidator = new ParamValidationResult();
+  paramValidator._error("slug", "notEmpty", "");
+  expect(paramValidator.hasErrors()).toBe(true);
+  expect(paramValidator.isValid()).toBe(false);
+  expect(paramValidator.getErrors()).toEqual({
+    slug: { error: "notEmpty", value: "" },
+  });
+});
+
+// test('.string() empty', () => {
+//   const contextMock = createContextMock();
+//   contextMock.param.mockReturnValue('');
+
+//   const paramValidator = new ParamValidationResult(contextMock);
+
+//   paramValidator.string('slug').notEmpty();
+//   expect(contextMock.param).toHaveBeenNthCalledWith(1, 'slug');
+//   expect(paramValidator.hasErrors()).toBe(true);
+//   expect(paramValidator.isValid()).toBe(false);
+//   expect(paramValidator.getErrors()).toEqual({
+//     slug: { error: 'notEmpty', value: '' },
+//   });
+// });
+
+// test('.string() not empty', () => {
+//   const contextMock = createContextMock();
+//   contextMock.param.mockReturnValue('testValue');
+//   const paramValidator = new ParamValidationResult(contextMock);
+
+//   paramValidator.string('slug').notEmpty();
+//   expect(contextMock.param).toHaveBeenNthCalledWith(1, 'slug');
+//   expect(paramValidator.hasErrors()).toBe(false);
+//   expect(paramValidator.isValid()).toBe(true);
+//   expect(paramValidator.getErrors()).toBe(undefined);
+// });

package/src/params/ParamValidationResult.ts

@@ -0,0 +1,38 @@
+export type Errors = Record<string, any>;
+
+export class ParamValidationResult {
+  _errors?: Errors;
+
+  _error(name: string, key: string, value: unknown): void {
+    if (!this._errors) {
+      this._errors = {};
+    }
+
+    this._errors[name] = { error: key, value };
+  }
+
+  getErrors(): Errors | undefined {
+    return this._errors;
+  }
+
+  hasErrors(): boolean {
+    return this._errors !== undefined;
+  }
+
+  isValid(): boolean {
+    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));
+   } */
+}

package/src/params/ParamValueFromContext.ts

@@ -0,0 +1,42 @@
+import type { Context } from "../AlpNodeApp";
+import type { ParamValidationResult } from "./ParamValidationResult";
+import ParamValueStringValidator from "./ParamValueStringValidator";
+
+export class ParamValueFromContext {
+  readonly validationResult: ParamValidationResult;
+
+  readonly context: Context;
+
+  constructor(context: Context, validationResult: ParamValidationResult) {
+    this.validationResult = validationResult;
+    this.context = context;
+  }
+
+  namedParam(name: string): ParamValueStringValidator {
+    return new ParamValueStringValidator(
+      this.validationResult,
+      name,
+      this.context.namedRouteParam(name),
+    );
+  }
+
+  otherParam(position: number): ParamValueStringValidator {
+    return new ParamValueStringValidator(
+      this.validationResult,
+      String(position),
+      this.context.otherRouteParam(position),
+    );
+  }
+
+  queryParam(name: string): ParamValueStringValidator {
+    return new ParamValueStringValidator(
+      this.validationResult,
+      name,
+      this.context.queryParam(name),
+    );
+  }
+
+  // bodyParam: <T>(name: string): ParamValueValidator<string | undefined> {
+
+  // }
+}

package/src/params/ParamValueModelValidator.ts

@@ -0,0 +1,36 @@
+import ParamValueValidator from "./ParamValueValidator";
+
+export default class ParamValueModelValidator<
+  T,
+> extends ParamValueValidator<T> {
+  /*
+  required() {
+      if (this.value == null) {
+          this._error('required');
+      }
+      return this;
+  }
+  valid(fieldsRequired) {
+      if (this.value == null) {
+          return this;
+      }
+      if (S.isString(fieldsRequired)) {
+          fieldsRequired = fieldsRequired.split(' ');
+      }
+      S.forEach(this.value.constructor.Fields, (name, fModel) => {
+          let value = this.value[name];
+          if (fieldsRequired) {
+              if(S.array.has(fieldsRequired, name) && value == null) {
+                  this._error('required');
+              }
+          } else {
+              if (value == null && fModel[1] && fModel[1].required) {
+                  this._error('required');
+              }
+          }
+          //TODO ...
+      });
+      return this;
+  }
+   */
+}

package/src/params/ParamValueStringValidator.ts

@@ -0,0 +1,13 @@
+import ParamValueValidator from "./ParamValueValidator";
+
+export default class ParamValueStringValidator<
+  T extends string = string,
+> extends ParamValueValidator<T | null | undefined> {
+  notEmpty(): ParamValueValidator<T> {
+    if (this.value == null || this.value.trim() === "") {
+      this._error("notEmpty");
+    }
+
+    return this as ParamValueValidator<T>;
+  }
+}

package/src/params/ParamValueValidator.ts

@@ -0,0 +1,23 @@
+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) {
+    this.validationResult = validationResult;
+    this.name = name;
+    this.value = value;
+  }
+
+  isValid(): boolean {
+    return this.validationResult.isValid();
+  }
+
+  _error(key: string): void {
+    this.validationResult._error(this.name, key, this.value);
+  }
+}

package/src/params/index.ts

@@ -0,0 +1,70 @@
+import { defineLazyProperty } from "object-properties";
+import type { AlpNodeApp, Context } from "../AlpNodeApp";
+import ParamValid from "./ParamValid";
+import { ParamValidationResult } from "./ParamValidationResult";
+import { ParamValueFromContext } from "./ParamValueFromContext";
+
+export interface AlpParamsContext {
+  params: ParamValueFromContext;
+  validParams: ParamValueFromContext;
+  namedRouteParam: (name: string) => string | undefined;
+  otherRouteParam: (position: number) => string | undefined;
+  /** @deprecated use namedRouteParam */
+  namedParam: never;
+  /** @deprecated use otherRouteParam */
+  otherParam: never;
+  queryParam: (name: string) => string | undefined;
+  bodyParam: <T>(name: string) => T | undefined;
+}
+
+export interface AlpParamsRequest {
+  searchParams: URLSearchParams;
+}
+
+export default function alpParams(app: AlpNodeApp): void {
+  Object.assign(app.context, {
+    namedRouteParam(this: Context, name: string): string | undefined {
+      const namedParams = this.route.namedParams;
+      return namedParams?.get(name);
+    },
+
+    otherRouteParam(this: Context, position: number): string | undefined {
+      const otherParams = this.route.otherParams;
+      return otherParams?.[position - 1];
+    },
+
+    queryParam(this: Context, name: string): string | undefined {
+      const searchParams = this.request.searchParams;
+      return searchParams.get(name) ?? undefined;
+    },
+
+    bodyParam<T>(this: Context, name: string): T | undefined {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
+      return (this.body as any)[name];
+    },
+  });
+
+  defineLazyProperty(
+    app.request,
+    "searchParams",
+    function searchParams(this: Context["request"]): URLSearchParams {
+      return new URLSearchParams(this.search);
+    },
+  );
+
+  defineLazyProperty(
+    app.context,
+    "params",
+    function params(this: Context): ParamValueFromContext {
+      return new ParamValueFromContext(this, new ParamValidationResult());
+    },
+  );
+
+  defineLazyProperty(
+    app.context,
+    "validParams",
+    function validParams(this: Context): ParamValueFromContext {
+      return new ParamValueFromContext(this, new ParamValid(this));
+    },
+  );
+}

package/src/router.ts

@@ -0,0 +1,64 @@
+import type {
+  LocaleType,
+  RouteMatch,
+  Router,
+  RouterBuilder,
+} from "router-segments";
+import { createRouterBuilder } 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 const createAlpRouterBuilder = <
+  Locales extends LocaleType,
+>(): RouterBuilder<Locales, AlpRouteRef> =>
+  createRouterBuilder<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 {
+  return (app: AlpNodeApp) => {
+    app.router = router;
+
+    app.context.urlGenerator = function urlGenerator<
+      P extends Record<string, unknown> | undefined,
+    >(this: Context, routeKey: string, params?: P): string {
+      return router.toLocalizedPath(this.language as Locales, routeKey, params);
+    };
+
+    app.context.redirectTo = function redirectTo<
+      P extends Record<string, unknown> | undefined,
+    >(this: Context, to: string, params?: P): void {
+      this.redirect(
+        router.toLocalizedPath(this.language as Locales, to, params),
+      );
+    };
+
+    return async (ctx: Context): Promise<void> => {
+      // eslint-disable-next-line unicorn/no-array-method-this-argument
+      const routeMatch = router.find(ctx.request.path, ctx.language as Locales);
+
+      if (!routeMatch) {
+        ctx.status = 404;
+        throw new Error(`Route not found: ${ctx.request.path}`);
+      }
+
+      ctx.route = routeMatch;
+
+      await routeMatch.ref(ctx);
+    };
+  };
+}

package/src/translate/index.ts

@@ -0,0 +1,45 @@
+import { Logger } from "nightingale-logger";
+import type { AlpNodeApp, Context } from "../AlpNodeApp";
+import type { Translations } from "./load";
+import load from "./load";
+
+const logger = new Logger("alp:translate");
+
+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 {
+  dirname = dirname.replace(/\/*$/, "/");
+  return (app: AlpNodeApp) => {
+    const appTranslations = new Map<string, Translations>();
+
+    Object.assign(app.context, {
+      t(this: Context, id: string, args: Args): string {
+        const msg = appTranslations.get(this.language)?.[id];
+        if (!msg) {
+          logger.warn("invalid msg", { language: this.language, id });
+          return id;
+        }
+
+        return msg.format(args) as string;
+      },
+    });
+
+    const config = app.config;
+
+    config.get<string[]>("availableLanguages").forEach((language) => {
+      const translations = app.loadConfigSync(dirname + language);
+      appTranslations.set(language, load(translations, language));
+    });
+
+    return appTranslations;
+  };
+}

package/src/translate/load.ts

@@ -0,0 +1,31 @@
+import IntlMessageFormatDefault from "intl-messageformat";
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const IntlMessageFormat: typeof IntlMessageFormatDefault =
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  (IntlMessageFormatDefault as any).default || IntlMessageFormatDefault;
+
+export type Translations = Readonly<Record<string, IntlMessageFormatDefault>>;
+
+export default function load(
+  translations: Readonly<Record<string, unknown>>,
+  language: string,
+): Translations {
+  const result: Record<string, IntlMessageFormatDefault> = {};
+
+  (function loadMap(record: Record<string, unknown>, prefix: string) {
+    Object.entries(record).forEach(([key, value]) => {
+      if (typeof value === "object" && value !== null) {
+        loadMap(value as Record<string, unknown>, `${prefix}${key}.`);
+        return;
+      }
+
+      result[`${prefix}${key}`] = new IntlMessageFormat(
+        value as string,
+        language,
+      );
+    });
+  })(translations, "");
+
+  return result;
+}

package/src/types.ts

@@ -0,0 +1,67 @@
+type RawRecordConfig = Readonly<Record<string, unknown>>;
+
+export interface Config {
+  get: <T>(key: string) => T;
+}
+
+export type PackageConfig = Record<string, any>;
+
+export interface NodeConfig extends Config {
+  loadConfigSync: (name: string) => RawRecordConfig;
+  readonly packageConfig: PackageConfig;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface ContextState {}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+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) => RawRecordConfig;
+}
+
+export interface BrowserApplicationInCreation extends ApplicationInCreation {
+  appVersion: string;
+  existsConfig: (name: string) => Promise<boolean> | boolean;
+  loadConfig: (name: string) => Promise<RawRecordConfig>;
+  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) => RawRecordConfig;
+}
+
+export interface HtmlError extends Error {
+  status: number;
+  expose?: true;
+}

package/dist/AlpNodeApp-node18.mjs

@@ -1,94 +0,0 @@
-import path from 'node:path';
-import { deprecate } from 'node:util';
-import _listen from 'alp-listen';
-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 Koa from 'koa';
-import compress from 'koa-compress';
-import serve from 'koa-static';
-import { Logger } from 'nightingale-logger';
-
-const logger = new Logger('alp');
-class AlpNodeApp extends Koa {
-  /**
-   * @param {Object} [options]
-   * @param {string} [options.certPath] directory of the ssl certificates
-   * @param {string} [options.publicPath] directory of public files
-   */
-  constructor({
-    appDirname,
-    packageDirname,
-    config,
-    certPath,
-    publicPath
-  }) {
-    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.context.config = this.config;
-    params(this);
-    language(this);
-    translate('locales')(this);
-    this.use(compress());
-  }
-  existsConfigSync(name) {
-    return this.config.existsConfigSync(name);
-  }
-  loadConfigSync(name) {
-    return this.config.loadConfigSync(name);
-  }
-  createContext(req, res) {
-    const ctx = super.createContext(req, res);
-    ctx.sanitizedState = {};
-    return ctx;
-  }
-  servePublic() {
-    this.use(serve(this.publicPath)); // static files
-  }
-  catchErrors() {
-    this.use(errors);
-  }
-
-  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
-  listen() {
-    throw new Error('Use start instead');
-  }
-
-  /**
-   * Close server and emit close event
-   */
-  close() {
-    if (this._server) {
-      this._server.close();
-      this.emit('close');
-    }
-  }
-  async start(fn) {
-    await fn();
-    try {
-      const server = await _listen(this.config, this.callback(), this.certPath);
-      this._server = server;
-      logger.success('started');
-      if (process.send) process.send('ready');
-      return server;
-    } catch (error) {
-      logger.error('start fail', {
-        err: error
-      });
-      throw error;
-    }
-  }
-}
-
-export { AlpNodeApp };
-//# sourceMappingURL=AlpNodeApp-node18.mjs.map

package/dist/AlpNodeApp-node18.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"AlpNodeApp-node18.mjs","sources":["../src/AlpNodeApp.ts"],"sourcesContent":["import type { IncomingMessage, Server, ServerResponse } from 'node:http';\nimport path from 'node:path';\nimport { deprecate } from 'node:util';\nimport _listen from 'alp-listen';\nimport type { Config } from 'alp-node-config';\nimport _config from 'alp-node-config';\nimport errors from 'alp-node-errors';\nimport language from 'alp-node-language';\nimport params from 'alp-params';\nimport translate from 'alp-translate';\nimport type {\n  NodeApplication,\n  NodeConfig,\n  Context as AlpContext,\n  ContextState,\n  ContextSanitizedState,\n  ContextRequest,\n} from 'alp-types';\nimport Koa from 'koa';\nimport type { ParameterizedContext, DefaultState, BaseRequest } from 'koa';\nimport compress from 'koa-compress';\nimport serve from 'koa-static';\nimport { Logger } from 'nightingale-logger';\n\nconst logger = new Logger('alp');\n\nexport interface AlpNodeAppOptions {\n  appDirname: string;\n  packageDirname: string;\n  config: Config & NodeConfig;\n  certPath?: string;\n  publicPath?: string;\n}\n\ndeclare module 'koa' {\n  // eslint-disable-next-line @typescript-eslint/no-empty-interface, @typescript-eslint/no-shadow\n  interface DefaultState extends ContextState {}\n  // eslint-disable-next-line @typescript-eslint/no-empty-interface\n  interface DefaultContext extends AlpContext {}\n  // eslint-disable-next-line @typescript-eslint/no-empty-interface\n  interface BaseContext extends AlpContext {}\n  // eslint-disable-next-line @typescript-eslint/no-empty-interface, @typescript-eslint/no-shadow\n  interface BaseRequest extends ContextRequest {}\n}\n\nexport class AlpNodeApp extends Koa<ContextState> implements NodeApplication {\n  dirname: string;\n\n  certPath: string;\n\n  publicPath: string;\n\n  config: Config & NodeConfig;\n\n  declare request: BaseRequest & ContextRequest;\n\n  _server?: Server;\n\n  /**\n   * @param {Object} [options]\n   * @param {string} [options.certPath] directory of the ssl certificates\n   * @param {string} [options.publicPath] directory of public files\n   */\n  constructor({\n    appDirname,\n    packageDirname,\n    config,\n    certPath,\n    publicPath,\n  }: AlpNodeAppOptions) {\n    super();\n\n    this.dirname = path.normalize(appDirname);\n\n    Object.defineProperty(this, 'packageDirname', {\n      get: deprecate(() => packageDirname, 'packageDirname'),\n      configurable: false,\n      enumerable: false,\n    });\n\n    this.certPath = certPath || `${packageDirname}/config/cert`;\n    this.publicPath = publicPath || `${packageDirname}/public/`;\n\n    this.config = _config(this, config);\n    this.context.config = this.config;\n\n    params(this);\n    language(this);\n    translate('locales')(this);\n\n    this.use(compress());\n  }\n\n  existsConfigSync(name: string): ReturnType<Config['existsConfigSync']> {\n    return this.config.existsConfigSync(name);\n  }\n\n  loadConfigSync(name: string): ReturnType<Config['loadConfigSync']> {\n    return this.config.loadConfigSync(name);\n  }\n\n  override createContext<StateT = DefaultState>(\n    req: IncomingMessage,\n    res: ServerResponse,\n  ): ParameterizedContext<StateT> {\n    const ctx = super.createContext<StateT>(req, res);\n    ctx.sanitizedState = {} as ContextSanitizedState;\n    return ctx;\n  }\n\n  servePublic(): void {\n    this.use(serve(this.publicPath)); // static files\n  }\n\n  catchErrors(): void {\n    this.use(errors);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/class-methods-use-this\n  override listen(): never {\n    throw new Error('Use start instead');\n  }\n\n  /**\n   * Close server and emit close event\n   */\n  close(): void {\n    if (this._server) {\n      this._server.close();\n      this.emit('close');\n    }\n  }\n\n  async start(fn: () => Promise<void> | void): Promise<Server> {\n    await fn();\n    try {\n      const server = await _listen(this.config, this.callback(), this.certPath);\n      this._server = server;\n      logger.success('started');\n      if (process.send) process.send('ready');\n      return server;\n    } catch (error: unknown) {\n      logger.error('start fail', { err: error });\n      throw error;\n    }\n  }\n}\n\nexport type { Context } from 'koa';\n"],"names":["logger","Logger","AlpNodeApp","Koa","constructor","appDirname","packageDirname","config","certPath","publicPath","dirname","path","normalize","Object","defineProperty","get","deprecate","configurable","enumerable","_config","context","params","language","translate","use","compress","existsConfigSync","name","loadConfigSync","createContext","req","res","ctx","sanitizedState","servePublic","serve","catchErrors","errors","listen","Error","close","_server","emit","start","fn","server","_listen","callback","success","process","send","error","err"],"mappings":"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"}