feat: support a few domains (500)

ilc/common/wrapWithCache.js

@@ -6,13 +6,14 @@ errors.WrapWithCacheError = extendError('WrapWithCacheError');
 const wrapWithCache = (localStorage, logger, createHash = hashFn) => (fn, cacheParams = {}) => {
  const {
  cacheForSeconds = 60,
+ name = '', // "hash" of returned value is based only on arguments, so with the help "name" we can add prefix to hash
  } = cacheParams;
 
  const cacheResolutionPromise = {};
 
  return (...args) => {
  const now = Math.floor(Date.now() / 1000);
- const hash = args.length > 0 ? createHash(JSON.stringify(args)) : '__null__';
+ const hash = `${name ? name + '__' : ''}${args.length > 0 ? createHash(JSON.stringify(args)) : '__null__'}`;
 
  if (localStorage.getItem(hash) === null || JSON.parse(localStorage.getItem(hash)).cachedAt < now - cacheForSeconds) {
  if (cacheResolutionPromise[hash] !== undefined) {

ilc/server/app.js

@@ -43,7 +43,8 @@ module.exports = (registryService, pluginManager) => {
  app.register(require('./ping'));
 
  app.get('/_ilc/api/v1/registry/template/:templateName', async (req, res) => {
- const data = await registryService.getTemplate(req.params.templateName);
+ const currentDomain = req.hostname;
+ const data = await registryService.getTemplate(req.params.templateName, currentDomain);
  res.status(200).send(data.data.content);
  });
 

ilc/server/errorHandler/ErrorHandler.js

@@ -51,7 +51,8 @@ module.exports = class ErrorHandler {
  errorId
  });
 
- let data = await this.#registryService.getTemplate('500');
+ const currentDomain = req.hostname;
+ let data = await this.#registryService.getTemplate('500', currentDomain);
  data = data.data.content.replace('%ERRORID%', `Error ID: ${errorId}`);
 
  nres.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');

ilc/server/registry/Registry.js

@@ -13,6 +13,7 @@ module.exports = class Registry {
  #cacheHeated = {
  config: false,
  template: false,
+ routerDomains: false,
  };
 
  /**
@@ -30,6 +31,7 @@ module.exports = class Registry {
 
  const getConfigMemo = wrapFetchWithCache(this.#getConfig, {
  cacheForSeconds: 5,
+ name: 'registry_getConfig',
  });
 
  this.getConfig = async (options) => {
@@ -38,13 +40,28 @@ module.exports = class Registry {
  return res;
  };
 
- this.getTemplate = wrapFetchWithCache(this.#getTemplate, {
+ this.getRouterDomains = wrapFetchWithCache(this.#getRouterDomains, {
  cacheForSeconds: 30,
+ name: 'registry_routerDomains',
  });
+
+ const getTemplateMemo = wrapFetchWithCache(this.#getTemplate, {
+ cacheForSeconds: 30,
+ });
+
+ this.getTemplate = async (templateName, forDomain) => {
+ if (templateName === '500' && forDomain) {
+ const routerDomains = await this.getRouterDomains();
+ const redefined500 = routerDomains.data.find(item => item.domainName === forDomain)?.template500;
+ templateName = redefined500 || templateName;
+ }
+
+ return await getTemplateMemo(templateName);
+ };
  }
 
  async preheat() {
- if (this.#cacheHeated.template && this.#cacheHeated.config) {
+ if (this.#cacheHeated.template && this.#cacheHeated.config && this.#cacheHeated.routerDomains) {
  return;
  }
 
@@ -53,6 +70,7 @@ module.exports = class Registry {
  await Promise.all([
  this.getConfig(),
  this.getTemplate('500'),
+ this.getRouterDomains(),
  ]);
 
  this.#logger.info('Registry preheated successfully!');
@@ -102,6 +120,27 @@ module.exports = class Registry {
  return res.data;
  };
 
+ #getRouterDomains = async () => {
+ this.#logger.debug('Calling get routerDomains registry endpoint...');
+
+ const url = urljoin(this.#address, 'api/v1/router_domains');
+ let res;
+ try {
+ res = await axios.get(url, { responseType: 'json' });
+ } catch (e) {
+ throw new errors.RegistryError({
+ message: `Error while requesting routerDomains from registry`,
+ cause: e,
+ data: {
+ requestedUrl: url
+ }
+ });
+ }
+
+ this.#cacheHeated.routerDomains = true;
+ return res.data;
+ };
+
  #filterConfig = (config, filter) => {
  if (!filter || !Object.keys(filter).length) {
  return config;

registry/client/src/routerDomains/Edit.js

@@ -6,6 +6,8 @@ import {
  TextInput,
  required,
  TextField,
+ ReferenceInput,
+ SelectInput,
 } from 'react-admin'; // eslint-disable-line import/no-unresolved
 
 const Title = ({ record }) => {
@@ -19,7 +21,12 @@ const InputForm = ({ mode = 'edit', ...props }) => {
  ? <TextField source="id" />
  : null}
 
- <TextInput source="domainName" fullWidth validate={required()} />
+ <TextInput source="domainName" fullWidth validate={required()} />
+ <ReferenceInput reference="template"
+ source="template500"
+ label="Template of 500 error">
+ <SelectInput resettable optionText="name" helperText="Default template name is '500'" />
+ </ReferenceInput>
  </SimpleForm>
  );
 };

registry/client/src/routerDomains/List.js

@@ -51,6 +51,7 @@ const PostList = props => {
  <Datagrid rowClick="edit" optimized>
  <TextField source="id" sortable={false} />
  <TextField source="domainName" sortable={false} />
+ <TextField source="template500" sortable={false} emptyText="-" />
  <ListActionsToolbar>
  <EditButton />
  </ListActionsToolbar>

registry/server/app.ts

@@ -40,7 +40,7 @@ export default (withAuth: boolean = true) => {
  app.use('/api/v1/auth_entities', authMw, routes.authEntities);
  app.use('/api/v1/versioning', authMw, routes.versioning);
  app.use('/api/v1/settings', routes.settings(authMw));
- app.use('/api/v1/router_domains', authMw, routes.routerDomains);
+ app.use('/api/v1/router_domains', routes.routerDomains(authMw));
 
  app.use(errorHandler);
 

registry/server/migrations/20210405164831_router_domains.ts

@@ -5,6 +5,7 @@ export async function up(knex: Knex): Promise<any> {
  return knex.schema.createTable('router_domains', table => {
  table.increments('id');
  table.string('domainName', 255).notNullable();
+ table.string('template500', 50).nullable().references('templates.name')
  });
 }
 

registry/server/routerDomains/interfaces/index.ts

@@ -1,18 +1,24 @@
 import Joi from 'joi';
+import { templateNameSchema } from '../../templates/interfaces';
 
 export default interface RouterDomains {
  id: number,
  domainName: string,
+ template500?: string,
 };
 
 export const routerDomainIdSchema = Joi.string().trim().required();
 
-const routerDomainNameSchema = Joi.string().trim().min(1);
+const commonRouterDomainsSchema = {
+ domainName: Joi.string().trim().min(1),
+ template500: templateNameSchema.allow(null),
+};
 
 export const partialRouterDomainsSchema = Joi.object({
- domainName: routerDomainNameSchema,
+ ...commonRouterDomainsSchema,
 });
 
 export const routerDomainsSchema = Joi.object({
- domainName: routerDomainNameSchema.required(),
+ ...commonRouterDomainsSchema,
+ domainName: commonRouterDomainsSchema.domainName.required(),
 });

registry/server/routerDomains/routes/index.ts

@@ -1,17 +1,19 @@
-import express from 'express';
+import express, { RequestHandler } from 'express';
 
 import getRouterDomains from './getRouterDomains';
 import getAllRouterDomains from './getAllRouterDomains';
 import updateRouterDomains from './updateRouterDomains';
 import createRouterDomains from './createRouterDomains';
 import deleteRouterDomains from './deleteRouterDomains';
 
-const routerDomainsRouter = express.Router();
+export default (authMw: RequestHandler) => {
+ const routerDomainsRouter = express.Router();
 
-routerDomainsRouter.get('/', ...getAllRouterDomains);
-routerDomainsRouter.post('/', ...createRouterDomains);
-routerDomainsRouter.get('/:id', ...getRouterDomains);
-routerDomainsRouter.put('/:id', ...updateRouterDomains);
-routerDomainsRouter.delete('/:id', ...deleteRouterDomains);
+ routerDomainsRouter.get('/', ...getAllRouterDomains);
+ routerDomainsRouter.post('/', authMw, ...createRouterDomains);
+ routerDomainsRouter.get('/:id', authMw, ...getRouterDomains);
+ routerDomainsRouter.put('/:id', authMw, ...updateRouterDomains);
+ routerDomainsRouter.delete('/:id', authMw, ...deleteRouterDomains);
 
-export default routerDomainsRouter;
+ return routerDomainsRouter;
+};

registry/tests/routerDomains.spec.ts

@@ -29,6 +29,17 @@ describe(`Tests ${example.url}`, () => {
  .expect(422, '"domainName" must be a string');
  });
 
+ it('should not create record with non-existed template500', async () => {
+ const response = await request.post(example.url)
+ .send({
+ ...example.correct,
+ template500: 'nonExistedTemplate',
+ })
+ .expect(500);
+
+ expect(response.text).to.include('Internal server error occurred.');
+ });
+
  it('should successfully create record', async () => {
  let routerDomainsId;
 
@@ -56,6 +67,46 @@ describe(`Tests ${example.url}`, () => {
  }
  });
 
+ it('should successfully create record with template for 500', async () => {
+ const templateName = 'testTemplate500';
+ let routerDomainsId;
+
+ const exampleWithTemplate500 = {
+ ...example.correct,
+ template500: templateName,
+ };
+
+ try {
+ await request.post('/api/v1/template/')
+ .send({
+ name: templateName,
+ content: 'ncTestTemplateContent'
+ });
+
+ const responseCreation = await request.post(example.url)
+ .send(exampleWithTemplate500)
+ .expect(200)
+
+ routerDomainsId = responseCreation.body.id;
+
+ expect(responseCreation.body).deep.equal({
+ id: routerDomainsId,
+ ...exampleWithTemplate500,
+ });
+
+ const responseFetching = await request.get(example.url + routerDomainsId)
+ .expect(200);
+
+ expect(responseFetching.body).deep.equal({
+ id: routerDomainsId,
+ ...exampleWithTemplate500,
+ });
+ } finally {
+ routerDomainsId && await request.delete(example.url + routerDomainsId);
+ await request.delete('/api/v1/template/' + templateName);
+ }
+ });
+
  describe('Authentication / Authorization', () => {
  it('should deny access w/o authentication', async () => {
  await requestWithAuth.post(example.url)
@@ -159,9 +210,6 @@ describe(`Tests ${example.url}`, () => {
 
  describe('Authentication / Authorization', () => {
  it('should deny access w/o authentication', async () => {
- await requestWithAuth.get(example.url)
- .expect(401);
-
  await requestWithAuth.get(example.url + 123)
  .expect(401);
  });

registry/tests/templates.spec.ts

@@ -292,6 +292,38 @@ describe(`Tests ${example.url}`, () => {
  expect(response.body).deep.equal({});
  });
 
+ it('should successfully delete record if doesn\'t have any reference from foreign (routerDomains -> template500) to current primary key', async () => {
+ let routerDomainsId;
+
+ try {
+ await request.post(example.url).send(example.correct).expect(200);
+
+ const responseRouterDomains = await request.post('/api/v1/router_domains/')
+ .send({
+ domainName: 'domainNameCorrect',
+ template500: example.correct.name,
+ })
+ .expect(200)
+
+ routerDomainsId = responseRouterDomains.body.id;
+
+ const response = await request.delete(example.url + example.correct.name)
+ .expect(500);
+ expect(response.text).to.include('Internal server error occurred.');
+
+ await request.delete('/api/v1/router_domains/' + routerDomainsId);
+
+ await request.delete(example.url + example.correct.name)
+ .expect(204, '');
+
+ await request.get(example.url + example.correct.name)
+ .expect(404, 'Not found');
+ } finally {
+ routerDomainsId && await request.delete('/api/v1/router_domains/' + routerDomainsId);
+ await request.delete(example.url + example.correct.name)
+ }
+ });
+
  it('should successfully delete record', async () => {
  await request.post(example.url).send(example.correct).expect(200);