node-server-engine 1.1.4 → 1.1.5

package/src/entities/WebError/WebError.ts

@@ -1,23 +1,23 @@
-import { WebErrorOptions } from './WebError.types';
-import { LogSeverity } from 'const';
-import { EngineError } from 'entities/EngineError';
-
-/**
- * Error class used when errors should be reported to the client
- */
-export class WebError extends EngineError {
-  /** Machine readable error code that will be sent to the client */
-  public errorCode: string;
-  /** HTTP status code associated with this error */
-  public statusCode: number;
-
-  /**
-   * Create a WebError, these errors are best suited for runtime errors
-   */
-  public constructor(config: WebErrorOptions) {
-    super({ ...config, severity: config.severity ?? LogSeverity.WARNING });
-
-    this.statusCode = config.statusCode ?? 400;
-    this.errorCode = config.errorCode;
-  }
-}
+import { WebErrorOptions } from './WebError.types';
+import { LogSeverity } from 'const';
+import { EngineError } from 'entities/EngineError';
+
+/**
+ * Error class used when errors should be reported to the client
+ */
+export class WebError extends EngineError {
+  /** Machine readable error code that will be sent to the client */
+  public errorCode: string;
+  /** HTTP status code associated with this error */
+  public statusCode: number;
+
+  /**
+   * Create a WebError, these errors are best suited for runtime errors
+   */
+  public constructor(config: WebErrorOptions) {
+    super({ ...config, severity: config.severity ?? LogSeverity.WARNING });
+
+    this.statusCode = config.statusCode ?? 400;
+    this.errorCode = config.errorCode;
+  }
+}

package/src/entities/WebError/WebError.types.ts

@@ -1,9 +1,9 @@
-import { EngineErrorOptions } from 'entities/EngineError';
-
-/** Options to create a Web Error */
-export interface WebErrorOptions extends EngineErrorOptions {
-  /** Machine readable error code that will be sent to the client */
-  errorCode: string;
-  /** HTTP status code associated with this error (default: 400) */
-  statusCode?: number;
-}
+import { EngineErrorOptions } from 'entities/EngineError';
+
+/** Options to create a Web Error */
+export interface WebErrorOptions extends EngineErrorOptions {
+  /** Machine readable error code that will be sent to the client */
+  errorCode: string;
+  /** HTTP status code associated with this error (default: 400) */
+  statusCode?: number;
+}

package/src/entities/WebError/index.ts

@@ -1,2 +1,2 @@
-export * from './WebError';
-export * from './WebError.types';
+export * from './WebError';
+export * from './WebError.types';

package/src/entities/index.ts

@@ -1,16 +1,16 @@
-export * from './EngineError';
-export * from './WebError';
-export * from './ValidationError';
-export * from './KeySet';
-export * from './Endpoint';
-export * from './MessageHandler';
-export * from './SocketClient';
-export * from './Server';
-export * from './Redis';
-export * from './Localizator';
-export * from './Storage';
-export * from './Sequelize';
-export * from './ElasticSearch';
-export * from './LifecycleController';
-export * from './PubSub';
-export * from './PushNotification';
+export * from './EngineError';
+export * from './WebError';
+export * from './ValidationError';
+export * from './KeySet';
+export * from './Endpoint';
+export * from './MessageHandler';
+export * from './SocketClient';
+export * from './Server';
+export * from './Redis';
+export * from './Localizator';
+export * from './Storage';
+export * from './Sequelize';
+export * from './ElasticSearch';
+export * from './LifecycleController';
+export * from './PubSub';
+export * from './PushNotification';

package/src/index.ts

@@ -1,4 +1,4 @@
-export * from './const';
-export * from './entities';
-export * from './utils';
-export * as middleware from './middleware';
+export * from './const';
+export * from './entities';
+export * from './utils';
+export * as middleware from './middleware';

package/src/metrics/debug.ts

@@ -1,10 +1,10 @@
-import { Gauge } from 'prom-client';
-import { instanceRegistry } from 'const';
-
-export const debugActivated = new Gauge({
-  name: 'debug_activated',
-  help: 'Debug is activated',
-  registers: [instanceRegistry]
-});
-
-debugActivated.set(process.env.DEBUG?.length ? 1 : 0);
+import { Gauge } from 'prom-client';
+import { instanceRegistry } from 'const';
+
+export const debugActivated = new Gauge({
+  name: 'debug_activated',
+  help: 'Debug is activated',
+  registers: [instanceRegistry]
+});
+
+debugActivated.set(process.env.DEBUG?.length ? 1 : 0);

package/src/metrics/index.ts

@@ -1,2 +1,2 @@
-export * from './request';
-export * from './debug';
+export * from './request';
+export * from './debug';

package/src/metrics/request.ts

@@ -1,17 +1,17 @@
-import { Counter, Histogram } from 'prom-client';
-import { instanceRegistry } from 'const';
-
-export const httpRequestCount = new Counter({
-  name: 'http_requests_total',
-  help: 'Total count of request received',
-  registers: [instanceRegistry],
-  labelNames: ['service', 'path', 'method', 'status']
-});
-
-export const httpRequestDuration = new Histogram({
-  name: 'http_requests_duration',
-  help: 'Duration of the request received',
-  registers: [instanceRegistry],
-  labelNames: ['service', 'path', 'method', 'status'],
-  buckets: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 0.5, 1, 2.5, 5, 10]
-});
+import { Counter, Histogram } from 'prom-client';
+import { instanceRegistry } from 'const';
+
+export const httpRequestCount = new Counter({
+  name: 'http_requests_total',
+  help: 'Total count of request received',
+  registers: [instanceRegistry],
+  labelNames: ['service', 'path', 'method', 'status']
+});
+
+export const httpRequestDuration = new Histogram({
+  name: 'http_requests_duration',
+  help: 'Duration of the request received',
+  registers: [instanceRegistry],
+  labelNames: ['service', 'path', 'method', 'status'],
+  buckets: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 0.5, 1, 2.5, 5, 10]
+});

package/src/middleware/authAdmin/authAdmin.test.ts

@@ -1,199 +1,199 @@
-import { factory, generateAccessToken, getBearer } from 'backend-test-tools';
-import { expect } from 'chai';
-import { Request, Response } from 'express';
-import { faker } from '@faker-js/faker';
-import { fake } from 'sinon';
-import { authAdmin } from './authAdmin';
-import {} from './authAdmin.types';
-
-describe('Middleware - Auth Admin', () => {
-  it('should authenticate with a JWT (auth-service)', async () => {
-    const email = faker.internet.email();
-    const permission = faker.lorem.word();
-    const request = {
-      headers: {
-        authorization: `Bearer ${generateAccessToken(
-          email,
-          {
-            audience: [process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE as string],
-            issuer: process.env.ADMIN_ACCESS_TOKEN_ISSUER
-          },
-          { per: permission }
-        )}`
-      }
-    } as unknown as Request;
-    const next = fake();
-
-    await authAdmin({ permission })(
-      request,
-      undefined as unknown as Response,
-      next
-    );
-
-    expect(next).to.have.been.calledOnceWithExactly();
-  });
-
-  it('should populate the admin object in the request (auth-service)', async () => {
-    const email = faker.internet.email();
-    const permission = faker.lorem.word();
-    const permissions = [permission, faker.lorem.word(), faker.lorem.word()];
-    const request = {
-      headers: {
-        authorization: `Bearer ${generateAccessToken(
-          email,
-          {
-            audience: [process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE as string],
-            issuer: process.env.ADMIN_ACCESS_TOKEN_ISSUER
-          },
-          { per: permissions }
-        )}`
-      }
-    } as unknown as Request;
-    const next = fake();
-
-    await authAdmin({ permission })(
-      request,
-      undefined as unknown as Response,
-      next
-    );
-
-    expect(request.admin?.email).to.equal(email);
-    expect(request.admin?.permissions).to.deep.members(permissions);
-  });
-
-  it('should throw an error if there is no token', async () => {
-    const request = { headers: {} } as unknown as Request;
-    const next = fake();
-
-    await expect(
-      authAdmin({ permission: faker.lorem.word() })(
-        request,
-        undefined as unknown as Response,
-        next
-      )
-    ).to.eventually.be.rejected;
-  });
-
-  it('should throw an error if the audience is not valid', async () => {
-    const user = factory.build('user');
-    const permission = faker.lorem.word();
-    const request = {
-      headers: {
-        authorization: getBearer(
-          user.id,
-          { audience: faker.internet.url() },
-          { per: permission }
-        )
-      }
-    } as unknown as Request;
-    const next = fake();
-
-    await expect(
-      authAdmin({ permission })(request, undefined as unknown as Response, next)
-    ).to.eventually.be.rejected;
-  });
-
-  it('should check user has permission', async () => {
-    const email = faker.internet.email();
-    const permissions = [faker.lorem.word(), faker.lorem.word()];
-    const request = {
-      headers: {
-        authorization: `Bearer ${generateAccessToken(
-          email,
-          {
-            audience: [process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE as string],
-            issuer: process.env.ADMIN_ACCESS_TOKEN_ISSUER
-          },
-          { per: permissions }
-        )}`
-      }
-    } as unknown as Request;
-    const next = fake();
-
-    await authAdmin({ permission: permissions[0] })(
-      request,
-      undefined as unknown as Response,
-      next
-    );
-
-    expect(request.admin?.email).to.equal(email);
-    expect(request.admin?.permissions).to.deep.members(permissions);
-  });
-
-  it('should all user has endpoint permission', async () => {
-    const email = faker.internet.email();
-    const permission = faker.lorem.word();
-    const request = {
-      headers: {
-        authorization: `Bearer ${generateAccessToken(
-          email,
-          {
-            audience: [process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE as string],
-            issuer: process.env.ADMIN_ACCESS_TOKEN_ISSUER
-          },
-          { per: permission }
-        )}`
-      }
-    } as unknown as Request;
-    const next = fake();
-
-    await authAdmin({ permission })(
-      request,
-      undefined as unknown as Response,
-      next
-    );
-
-    expect(request.admin?.email).to.equal(email);
-    expect(request.admin?.permissions).to.includes(permission);
-  });
-
-  it('should throw error if user does not have permission', async () => {
-    const email = faker.internet.email();
-    const permissions = [faker.lorem.word(), faker.lorem.word()];
-    const request = {
-      headers: {
-        authorization: `Bearer ${generateAccessToken(
-          email,
-          {
-            audience: [process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE as string],
-            issuer: process.env.ADMIN_ACCESS_TOKEN_ISSUER
-          },
-          { per: permissions }
-        )}`
-      }
-    } as unknown as Request;
-    const next = fake();
-
-    await expect(
-      authAdmin({ permission: faker.lorem.word() })(
-        request,
-        undefined as unknown as Response,
-        next
-      )
-    ).to.eventually.rejected;
-  });
-
-  it('should allow wildcard permissions', async () => {
-    const email = faker.internet.email();
-    const permission = faker.lorem.word();
-    const request = {
-      headers: {
-        authorization: `Bearer ${generateAccessToken(
-          email,
-          {
-            audience: [process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE as string],
-            issuer: process.env.ADMIN_ACCESS_TOKEN_ISSUER
-          },
-          { per: `${permission}:*` }
-        )}`
-      }
-    } as unknown as Request;
-    const next = fake();
-
-    await authAdmin({ permission: `${permission}:${faker.lorem.word()}` })(
-      request,
-      undefined as unknown as Response,
-      next
-    );
-  });
-});
+import { factory, generateAccessToken, getBearer } from 'backend-test-tools';
+import { expect } from 'chai';
+import { Request, Response } from 'express';
+import { faker } from '@faker-js/faker';
+import { fake } from 'sinon';
+import { authAdmin } from './authAdmin';
+import {} from './authAdmin.types';
+
+describe('Middleware - Auth Admin', () => {
+  it('should authenticate with a JWT (auth-service)', async () => {
+    const email = faker.internet.email();
+    const permission = faker.lorem.word();
+    const request = {
+      headers: {
+        authorization: `Bearer ${generateAccessToken(
+          email,
+          {
+            audience: [process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE as string],
+            issuer: process.env.ADMIN_ACCESS_TOKEN_ISSUER
+          },
+          { per: permission }
+        )}`
+      }
+    } as unknown as Request;
+    const next = fake();
+
+    await authAdmin({ permission })(
+      request,
+      undefined as unknown as Response,
+      next
+    );
+
+    expect(next).to.have.been.calledOnceWithExactly();
+  });
+
+  it('should populate the admin object in the request (auth-service)', async () => {
+    const email = faker.internet.email();
+    const permission = faker.lorem.word();
+    const permissions = [permission, faker.lorem.word(), faker.lorem.word()];
+    const request = {
+      headers: {
+        authorization: `Bearer ${generateAccessToken(
+          email,
+          {
+            audience: [process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE as string],
+            issuer: process.env.ADMIN_ACCESS_TOKEN_ISSUER
+          },
+          { per: permissions }
+        )}`
+      }
+    } as unknown as Request;
+    const next = fake();
+
+    await authAdmin({ permission })(
+      request,
+      undefined as unknown as Response,
+      next
+    );
+
+    expect(request.admin?.email).to.equal(email);
+    expect(request.admin?.permissions).to.deep.members(permissions);
+  });
+
+  it('should throw an error if there is no token', async () => {
+    const request = { headers: {} } as unknown as Request;
+    const next = fake();
+
+    await expect(
+      authAdmin({ permission: faker.lorem.word() })(
+        request,
+        undefined as unknown as Response,
+        next
+      )
+    ).to.eventually.be.rejected;
+  });
+
+  it('should throw an error if the audience is not valid', async () => {
+    const user = factory.build('user');
+    const permission = faker.lorem.word();
+    const request = {
+      headers: {
+        authorization: getBearer(
+          user.id,
+          { audience: faker.internet.url() },
+          { per: permission }
+        )
+      }
+    } as unknown as Request;
+    const next = fake();
+
+    await expect(
+      authAdmin({ permission })(request, undefined as unknown as Response, next)
+    ).to.eventually.be.rejected;
+  });
+
+  it('should check user has permission', async () => {
+    const email = faker.internet.email();
+    const permissions = [faker.lorem.word(), faker.lorem.word()];
+    const request = {
+      headers: {
+        authorization: `Bearer ${generateAccessToken(
+          email,
+          {
+            audience: [process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE as string],
+            issuer: process.env.ADMIN_ACCESS_TOKEN_ISSUER
+          },
+          { per: permissions }
+        )}`
+      }
+    } as unknown as Request;
+    const next = fake();
+
+    await authAdmin({ permission: permissions[0] })(
+      request,
+      undefined as unknown as Response,
+      next
+    );
+
+    expect(request.admin?.email).to.equal(email);
+    expect(request.admin?.permissions).to.deep.members(permissions);
+  });
+
+  it('should all user has endpoint permission', async () => {
+    const email = faker.internet.email();
+    const permission = faker.lorem.word();
+    const request = {
+      headers: {
+        authorization: `Bearer ${generateAccessToken(
+          email,
+          {
+            audience: [process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE as string],
+            issuer: process.env.ADMIN_ACCESS_TOKEN_ISSUER
+          },
+          { per: permission }
+        )}`
+      }
+    } as unknown as Request;
+    const next = fake();
+
+    await authAdmin({ permission })(
+      request,
+      undefined as unknown as Response,
+      next
+    );
+
+    expect(request.admin?.email).to.equal(email);
+    expect(request.admin?.permissions).to.includes(permission);
+  });
+
+  it('should throw error if user does not have permission', async () => {
+    const email = faker.internet.email();
+    const permissions = [faker.lorem.word(), faker.lorem.word()];
+    const request = {
+      headers: {
+        authorization: `Bearer ${generateAccessToken(
+          email,
+          {
+            audience: [process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE as string],
+            issuer: process.env.ADMIN_ACCESS_TOKEN_ISSUER
+          },
+          { per: permissions }
+        )}`
+      }
+    } as unknown as Request;
+    const next = fake();
+
+    await expect(
+      authAdmin({ permission: faker.lorem.word() })(
+        request,
+        undefined as unknown as Response,
+        next
+      )
+    ).to.eventually.rejected;
+  });
+
+  it('should allow wildcard permissions', async () => {
+    const email = faker.internet.email();
+    const permission = faker.lorem.word();
+    const request = {
+      headers: {
+        authorization: `Bearer ${generateAccessToken(
+          email,
+          {
+            audience: [process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE as string],
+            issuer: process.env.ADMIN_ACCESS_TOKEN_ISSUER
+          },
+          { per: `${permission}:*` }
+        )}`
+      }
+    } as unknown as Request;
+    const next = fake();
+
+    await authAdmin({ permission: `${permission}:${faker.lorem.word()}` })(
+      request,
+      undefined as unknown as Response,
+      next
+    );
+  });
+});