alp-node 6.2.0 → 7.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.namedParam(name),
+    );
+  }
+
+  otherParam(position: number): ParamValueStringValidator {
+    return new ParamValueStringValidator(
+      this.validationResult,
+      String(position),
+      this.context.otherParam(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,66 @@
+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;
+  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 {
+  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 (this: Context['request']): URLSearchParams {
+      return new URLSearchParams(this.search);
+    },
+  );
+
+  defineLazyProperty(
+    app.context,
+    'params',
+    function (this: Context): ParamValueFromContext {
+      return new ParamValueFromContext(this, new ParamValidationResult());
+    },
+  );
+
+  defineLazyProperty(
+    app.context,
+    'validParams',
+    function (this: Context): ParamValueFromContext {
+      return new ParamValueFromContext(this, new ParamValid(this));
+    },
+  );
+}

package/src/router.ts

@@ -0,0 +1,64 @@
+import type {
+  Router,
+  LocaleType,
+  RouterBuilder,
+  RouteMatch,
+} 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 <
+      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 <
+      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)!.get(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,30 @@
+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 = ReadonlyMap<string, IntlMessageFormatDefault>;
+
+export default function load(
+  translations: ReadonlyMap<string, unknown>,
+  language: string,
+): Translations {
+  const result = new Map();
+
+  (function loadMap(map, prefix) {
+    map.forEach((value: any, 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;
+}

package/src/types.ts

@@ -0,0 +1,67 @@
+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;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface ContextState {}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+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;
+}