@thisisagile/easy-service 17.0.0

package/src/resources/Requires.ts

@@ -0,0 +1,32 @@
+import { meta } from '@thisisagile/easy';
+import { Scope, UseCase } from '@thisisagile/easy';
+
+export class Requires {
+  readonly labCoat =
+    (): PropertyDecorator =>
+    (subject: unknown, property: string | symbol): void => {
+      meta(subject).property(property).set('labCoat', true);
+    };
+
+  readonly token =
+    (): PropertyDecorator =>
+    (subject: unknown, property: string | symbol): void => {
+      meta(subject).property(property).set('token', true);
+    };
+
+  readonly scope =
+    (scope: Scope): PropertyDecorator =>
+    (subject: unknown, property: string | symbol): void => {
+      meta(subject).property(property).set('token', true);
+      meta(subject).property(property).set('scope', scope);
+    };
+
+  readonly useCase =
+    (uc: UseCase): PropertyDecorator =>
+    (subject: unknown, property: string | symbol): void => {
+      meta(subject).property(property).set('token', true);
+      meta(subject).property(property).set('uc', uc);
+    };
+}
+
+export const requires = new Requires();

package/src/resources/Resource.ts

@@ -0,0 +1 @@
+export type Resource = any;

package/src/resources/Route.ts

@@ -0,0 +1,53 @@
+import { List, meta, Optional, tryTo, Uri, Scope, UseCase, Req } from '@thisisagile/easy';
+import { Resource } from './Resource';
+import { RequestHandler } from 'express';
+import { Verb } from '../http/Verb';
+
+export const route =
+  (uri: Uri): ClassDecorator =>
+  (subject: unknown): void => {
+    meta(subject).set('route', uri);
+  };
+
+export type Endpoint<T = unknown> = (re: Req) => Promise<T | List<T>>;
+export type RouteRequires = { token: boolean; labCoat: boolean; scope?: Scope; uc?: UseCase };
+export type Route = { verb: Verb; endpoint: Endpoint; requires: RouteRequires; middleware: RequestHandler[] };
+export type Routes = { route: Uri; middleware: RequestHandler[]; endpoints: List<Route> };
+
+const toRoute = (endpoint: Endpoint, requires: RouteRequires, verb?: Verb, middleware?: RequestHandler[]): Optional<Route> =>
+  tryTo(verb)
+    .is.defined()
+    .map(verb => ({ verb, endpoint, requires, middleware: middleware ?? [] }) as Route)
+    .orElse();
+
+class Router implements Routes {
+  constructor(readonly resource: Resource) {}
+
+  get route(): Uri {
+    return meta(this.resource).get('route');
+  }
+
+  get middleware(): RequestHandler[] {
+    return meta(this.resource).get<RequestHandler[]>('middleware') ?? [];
+  }
+
+  get endpoints(): List<Route> {
+    return meta(this.resource)
+      .properties('verb')
+      .mapDefined(v =>
+        toRoute(
+          this.resource[v.property],
+          {
+            labCoat: v.get<boolean>('labCoat') ?? false,
+            token: v.get<boolean>('token') ?? false,
+            scope: v.get<Scope>('scope'),
+            uc: v.get<UseCase>('uc'),
+          },
+          v.get<Verb>('verb'),
+          v.get<RequestHandler[]>('middleware')
+        )
+      );
+  }
+}
+
+export const routes = (resource: Resource): Routes => new Router(resource);

package/src/resources/Service.ts

@@ -0,0 +1,34 @@
+import { AppProvider, Handler } from './AppProvider';
+import { Constructor, Enum, List, toList, tryTo } from '@thisisagile/easy';
+import { Resource } from './Resource';
+
+export class Service extends Enum {
+  protected port = 8080;
+
+  constructor(
+    readonly name: string,
+    protected app: AppProvider,
+    protected resources: List<Resource> = toList()
+  ) {
+    super(name);
+  }
+
+  pre = (): Handler[] => [];
+  post = (): Handler[] => [];
+
+  with(...resources: Constructor<Resource>[]): this {
+    return tryTo(this).accept(t => t.resources.add(resources.map(r => new r()))).value;
+  }
+
+  atPort(port: number): this {
+    return tryTo(this).accept(t => (t.port = port)).value;
+  }
+
+  start(message = `Service ${this.name} listening on port ${this.port} with ${this.resources.length} resources.`): void {
+    tryTo(this)
+      .accept(t => t.pre().forEach(h => this.app.use(h)))
+      .accept(t => t.resources.forEach(r => this.app.route(this, r)))
+      .accept(t => t.post().forEach(h => this.app.use(h)))
+      .accept(t => t.app.listen(this.port, message));
+  }
+}

package/src/security/Jwt.ts

@@ -0,0 +1,32 @@
+import { Algorithm, sign, verify } from 'jsonwebtoken';
+import { ctx, Json, OneOrMore, Optional, tryTo, Validatable, Jwt as JwtBase } from '@thisisagile/easy';
+
+interface SignOptions {
+  audience?: Optional<OneOrMore<string>>;
+  issuer?: Optional<string>;
+}
+export class Jwt extends JwtBase implements Validatable {
+  static of = (a: { jwt: string }): Jwt => new Jwt(a.jwt);
+
+  get isValid(): boolean {
+    return (
+      tryTo(() => ctx.env.get('tokenPublicKey') ?? '')
+        .map(key => verify(this.value, key))
+        .map(() => true)
+        .orElse() ?? false
+    );
+  }
+
+  static sign = (token: Json, options?: SignOptions): Jwt =>
+    tryTo(() => ctx.env.get('tokenPrivateKey') ?? '')
+      .is.not.empty()
+      .map(key =>
+        sign(token, key, {
+          ...options,
+          expiresIn: ctx.env.get('tokenExpiresIn') ?? '1h',
+          keyid: ctx.env.get('tokenKeyid') ?? 'easy',
+          algorithm: ctx.env.get('tokenAlgorithm', 'RS256') as Algorithm,
+        })
+      )
+      .map(s => new Jwt(s)).value;
+}