@hestia-earth/data-api 0.0.2-1

package/src/settings/services/get.spec.ts

@@ -0,0 +1,62 @@
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+chai.use(chaiAsPromised);
+const { expect } = chai;
+
+import * as sinon from 'sinon';
+import 'mocha';
+
+import { fixtures, initDb } from '../../../test/utils';
+
+import { get, isEnabled } from './get';
+import * as specs from './get';
+import { SettingKey } from '../model';
+
+let stubs: sinon.SinonStub[] = [];
+
+describe('settings > services', () => {
+  beforeEach(() => {
+    stubs = [];
+  });
+
+  afterEach(() => {
+    stubs.forEach((stub) => stub.restore());
+  });
+
+  describe('get', () => {
+    beforeEach(async () => {
+      await initDb();
+    });
+
+    describe('get', () => {
+      describe('setting not found', () => {
+        it('should throw an error', () => {
+          return expect(get('random_key' as any)).to.be.rejected;
+        });
+      });
+
+      describe('setting found', () => {
+        it('should return the setting', async () => {
+          const {
+            rows: [setting]
+          } = await get(SettingKey.maintenanceEnabled);
+          expect(setting).to.deep.equal(fixtures.settings[0]);
+        });
+      });
+    });
+
+    describe('isEnabled', () => {
+      const active = true;
+
+      describe('setting exists', () => {
+        beforeEach(() => {
+          stubs.push(sinon.stub(specs, 'get').resolves({ rows: [{ setting: 'key', active }] } as any));
+        });
+
+        it('should return the setting value', async () => {
+          expect(await isEnabled('key' as any)).to.equal(active);
+        });
+      });
+    });
+  });
+});

package/src/settings/services/get.ts

@@ -0,0 +1,18 @@
+import { SettingKey, getSetting, getAllSettings } from '../model/';
+
+const loadAllSettings = async () => {
+  const { rows } = await getAllSettings();
+  const value = rows.reduce((prev, setting) => ({ ...prev, [setting.setting]: setting.active }), {});
+  return value;
+};
+
+export const getAll = () => loadAllSettings();
+
+export const get = (key: SettingKey) => getSetting(key);
+
+export const isEnabled = async (key: SettingKey) => {
+  const {
+    rows: [setting]
+  } = await get(key);
+  return setting?.active;
+};

package/src/settings/services/update.spec.ts

@@ -0,0 +1,118 @@
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import 'mocha';
+
+import * as slack from '../../slack';
+import { postMessage } from './update';
+import * as model from '../model';
+import * as servicesGet from './get';
+
+let stubs: sinon.SinonStub[] = [];
+
+describe('settings > services', () => {
+  beforeEach(() => {
+    stubs = [];
+  });
+
+  afterEach(() => {
+    stubs.forEach((stub) => stub.restore());
+  });
+
+  describe('update', () => {
+    describe('postMessage', () => {
+      const slackThreadTs = 'thread';
+      let updateStub: sinon.SinonStub;
+      let sendMessageStub: sinon.SinonStub;
+      let replyMessageStub: sinon.SinonStub;
+
+      beforeEach(() => {
+        stubs.push((updateStub = sinon.stub(model, 'setSetting').resolves()));
+        stubs.push((sendMessageStub = sinon.stub(slack, 'sendMessage').resolves(slackThreadTs)));
+        stubs.push((replyMessageStub = sinon.stub(slack, 'replyMessage').resolves(slackThreadTs)));
+      });
+
+      describe('turning setting on', () => {
+        const key = model.SettingKey.maintenanceEnabled;
+        const value = true;
+
+        beforeEach(() => {
+          stubs.push(
+            sinon.stub(servicesGet, 'get').resolves({
+              rows: [{ setting: key, active: value, metadata: {} }]
+            } as any)
+          );
+        });
+
+        it('should send the message', async () => {
+          await postMessage(key, value);
+          expect(sendMessageStub.called).to.equal(true);
+        });
+
+        it('should not reply to the message', async () => {
+          await postMessage(key, value);
+          expect(replyMessageStub.called).to.equal(false);
+        });
+
+        it('should set the thread', async () => {
+          await postMessage(key, value);
+          expect(updateStub.calledWith({ key, value, metadata: { slackThreadTs } })).to.equal(true);
+        });
+      });
+
+      describe('turning setting off', () => {
+        const key = model.SettingKey.maintenanceEnabled;
+        const value = false;
+
+        describe('existing thread', () => {
+          beforeEach(() => {
+            stubs.push(
+              sinon.stub(servicesGet, 'get').resolves({
+                rows: [{ setting: key, active: value, metadata: { slackThreadTs } }]
+              } as any)
+            );
+          });
+
+          it('should not send the message', async () => {
+            await postMessage(key, value);
+            expect(sendMessageStub.called).to.equal(false);
+          });
+
+          it('should reply the message', async () => {
+            await postMessage(key, value);
+            expect(replyMessageStub.called).to.equal(true);
+          });
+
+          it('should remove the thread', async () => {
+            await postMessage(key, value);
+            expect(updateStub.calledWith({ key, value, metadata: { slackThreadTs: null } })).to.equal(true);
+          });
+        });
+
+        describe('non-existing thread', () => {
+          beforeEach(() => {
+            stubs.push(
+              sinon.stub(servicesGet, 'get').resolves({
+                rows: [{ setting: key, active: value, metadata: {} }]
+              } as any)
+            );
+          });
+
+          it('should not send the message', async () => {
+            await postMessage(key, value);
+            expect(sendMessageStub.called).to.equal(false);
+          });
+
+          it('should not reply to the message', async () => {
+            await postMessage(key, value);
+            expect(replyMessageStub.called).to.equal(false);
+          });
+
+          it('should remove the thread', async () => {
+            await postMessage(key, value);
+            expect(updateStub.calledWith({ key, value, metadata: { slackThreadTs: null } })).to.equal(true);
+          });
+        });
+      });
+    });
+  });
+});

package/src/settings/services/update.ts

@@ -0,0 +1,47 @@
+import { apiUrl, webappUrl } from '../../config';
+import { sendMessage, replyMessage } from '../../slack';
+import { get } from './get';
+import { SettingKey, setSetting } from '../model/';
+
+type settingData = { [key in SettingKey]?: any };
+
+const slackChannel = 'product-team';
+
+const messageByKey: {
+  [key in SettingKey]?: (value: any) => string;
+} = {
+  [SettingKey.maintenanceEnabled]: (value: boolean) =>
+    value ? 'Data API is under maintenance, please do not use the data explorer' : 'Maintenance ended'
+};
+
+export const postMessage = async (key: SettingKey, value: boolean) => {
+  const { rows } = await get(key);
+  const setting = rows?.[0];
+  const message = messageByKey[key](value);
+  const fullMessage = `
+${messageByKey[key](value)}
+
+*API*: ${apiUrl}
+*Website*: ${webappUrl}
+  `.trim();
+  const existingThread = setting ? setting.metadata?.slackThreadTs : null;
+  const ts = value
+    ? // setting is turned on, create new thread
+    await sendMessage({ channel: slackChannel, text: fullMessage })
+    : existingThread
+      ? // setting is turned off and thread exists, reply to it
+      await replyMessage(existingThread, { channel: slackChannel, text: message })
+      : // setting is turned off and no thread exists, ignore
+      null;
+
+  return setSetting({ key, value, metadata: { slackThreadTs: value ? ts : null } });
+};
+
+export const updateSingle = async (key: SettingKey, value: any) => {
+  await setSetting({ key, value });
+  Object.keys(messageByKey).includes(key) && (await postMessage(key, value));
+};
+
+export const updateAll = (value: settingData) => {
+  return Promise.all(Object.entries(value).map(([key, v]) => updateSingle(key as SettingKey, v)));
+};

package/src/slack.spec.ts

@@ -0,0 +1,42 @@
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import 'mocha';
+import * as slackApi from '@slack/web-api/dist/WebClient';
+import { sendMessage, replyMessage } from './slack';
+
+let stubs: sinon.SinonStub[] = [];
+const postMessageStub: sinon.SinonStub = sinon.stub().returns({ ts: 'ts' });
+
+const SlackWebClientStub = sinon.createStubInstance(slackApi.WebClient);
+(SlackWebClientStub as any).chat = { postMessage: postMessageStub };
+
+describe('slack', () => {
+  beforeEach(() => {
+    stubs = [];
+    stubs.push(sinon.stub(slackApi, 'WebClient').returns(SlackWebClientStub));
+  });
+
+  afterEach(() => {
+    stubs.forEach((stub) => stub.restore());
+    postMessageStub.resetHistory();
+  });
+
+  describe('sendMessage', () => {
+    it('should send a message to a channel', async () => {
+      await sendMessage({});
+      expect(postMessageStub.args).to.deep.equal([[{ channel: process.env.SLACK_CHANNEL, link_names: true }]]);
+    });
+  });
+
+  describe('replyMessage', () => {
+    describe('with thread', () => {
+      it('should send a message to a thread', async () => {
+        await replyMessage('thread_ts', {});
+
+        expect(postMessageStub.args).to.deep.equal([
+          [{ channel: process.env.SLACK_CHANNEL, thread_ts: 'thread_ts', link_names: true }]
+        ]);
+      });
+    });
+  });
+});

package/src/slack.ts

@@ -0,0 +1,17 @@
+import { WebClient, ChatPostMessageArguments } from '@slack/web-api';
+
+import { slackConfig } from './config';
+
+const channel = slackConfig.channel;
+
+export const sendMessage = async (args: Partial<ChatPostMessageArguments>) =>
+  (
+    await new WebClient(slackConfig.token).chat.postMessage({
+      channel: args.channel || channel,
+      link_names: true,
+      ...args
+    })
+  ).ts;
+
+export const replyMessage = async (thread_ts: string, args: Omit<ChatPostMessageArguments, 'thread_ts'>) =>
+  thread_ts ? await sendMessage({ thread_ts, ...args }) : null;

package/src/swagger/routes.ts

@@ -0,0 +1,57 @@
+import { Router } from 'express';
+import { serve, setup } from 'swagger-ui-express';
+import swaggerJSDoc from 'swagger-jsdoc';
+
+import { apiUrl } from '../config';
+import pkg from '../../package.json';
+
+const options = {
+  swaggerDefinition: {
+    openapi: '3.0.1',
+    info: {
+      title: pkg.name,
+      version: pkg.version,
+      description: 'Hestia Data API documentation.',
+      license: {
+        name: 'GPL-3.0-or-later',
+        url: 'https://choosealicense.com/licenses/gpl-3.0/'
+      }
+    },
+    components: {
+      securitySchemes: {
+        AccessToken: {
+          type: 'apiKey',
+          in: 'header',
+          name: 'x-access-token'
+        }
+      }
+    },
+    servers: [
+      {
+        url: apiUrl
+      }
+    ]
+  },
+  apis: ['src/*.ts', 'src/**/*.ts']
+};
+
+const swaggerSpec = swaggerJSDoc(options);
+const swaggerOptions = {
+  customCss: `
+.swagger-ui .topbar {
+  display: none;
+}
+  `,
+  customSiteTitle: 'Hestia Data API Explorer',
+  url: '/swagger.json'
+};
+
+export default () => {
+  const router = Router();
+
+  router.use('/', serve);
+  router.get('/', setup(swaggerSpec, swaggerOptions));
+  router.get('/swagger.json', (req, res) => res.json(swaggerSpec));
+
+  return router;
+};

package/src/types/async-express-errors/index.d.ts

@@ -0,0 +1 @@
+declare module 'express-async-errors';

package/src/types/express/index.d.ts

@@ -0,0 +1,10 @@
+import { IFilter } from '../../aggregated-nodes/model';
+
+declare global {
+  namespace Express {
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface
+    interface Request {
+      filter: IFilter;
+    }
+  }
+}

package/src/utils/endpoint-wrapper.spec.ts

@@ -0,0 +1,80 @@
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import 'mocha';
+
+import { endpointWrapper } from './endpoint-wrapper';
+
+class Response {
+  status(_status: number) {
+    return this;
+  }
+
+  json() {}
+}
+
+let stubs: sinon.SinonStub[] = [];
+
+describe('utils > endpoint-wrapper', () => {
+  beforeEach(() => {
+    stubs = [];
+  });
+
+  afterEach(() => {
+    stubs.forEach((stub) => stub.restore());
+  });
+
+  describe('endpointWrapper', () => {
+    const response = new Response();
+    let fakeFunction: Function;
+    let jsonStub: sinon.SinonStub;
+    let nextStub: sinon.SinonStub;
+
+    beforeEach(() => {
+      stubs.push((jsonStub = sinon.stub(response, 'json')));
+      nextStub = sinon.stub();
+    });
+
+    describe('function fail', () => {
+      const err = new Error('error');
+
+      beforeEach(() => {
+        fakeFunction = () => {
+          throw err;
+        };
+      });
+
+      it('should reject', async () => {
+        const result = endpointWrapper(fakeFunction);
+        await result(null, response as any, nextStub);
+        expect(jsonStub.called).to.equal(false);
+        expect(nextStub.calledWith(err)).to.equal(true);
+      });
+    });
+
+    describe('function success', () => {
+      beforeEach(() => {
+        fakeFunction = () => 'success';
+      });
+
+      it('should resolve', async () => {
+        const result = endpointWrapper(fakeFunction);
+        await result(null, response as any, nextStub);
+        expect(jsonStub.calledWith('success')).to.equal(true);
+        expect(nextStub.called).to.equal(false);
+      });
+    });
+
+    describe('without a function', () => {
+      beforeEach(() => {
+        fakeFunction = undefined;
+      });
+
+      it('should resolve', async () => {
+        const result = endpointWrapper(fakeFunction);
+        await result(null, response as any, nextStub);
+        expect(jsonStub.calledWith({})).to.equal(true);
+        expect(nextStub.called).to.equal(false);
+      });
+    });
+  });
+});

package/src/utils/endpoint-wrapper.ts

@@ -0,0 +1,16 @@
+import { Request, Response, NextFunction } from 'express';
+
+// Until express v5 promises must be coerced to void
+// See https://github.com/davidbanham/express-async-errors/issues/36#issuecomment-944954003
+export const endpointWrapper =
+  (originalFunction: Function = () => ({})) =>
+    (req: Request, res: Response, next: NextFunction) =>
+      void (async function () {
+        try {
+          const output = await Promise.resolve(originalFunction(req, res, next));
+          return res.status(200).json(output);
+        }
+        catch (err) {
+          return next(err);
+        }
+      })();

package/src/utils/middleware.spec.ts

@@ -0,0 +1,154 @@
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import 'mocha';
+
+import { Errors } from '../errors';
+import { requireQueryParams, parseArrayQueryParams, parseBooleanQueryParams } from './middleware';
+import * as errors from '../errors';
+
+let stubs: sinon.SinonStub[] = [];
+
+describe('utils', () => {
+  beforeEach(() => {
+    stubs = [];
+  });
+
+  afterEach(() => {
+    stubs.forEach((stub) => stub.restore());
+  });
+
+  describe('middleware', () => {
+    let nextStub: sinon.SinonStub;
+    let throwErrorStub: sinon.SinonStub;
+
+    beforeEach(() => {
+      nextStub = sinon.stub();
+      stubs.push((throwErrorStub = sinon.stub(errors, 'throwError')));
+    });
+
+    describe('requireQueryParams', () => {
+      const req: any = { query: {} };
+
+      describe('with missing params', () => {
+        beforeEach(() => {
+          req.query.a = 1;
+          req.query.b = {};
+          req.query.c = '';
+        });
+
+        it('should throw an error', () => {
+          requireQueryParams('a', 'b', 'c')(req, null, nextStub);
+          expect(throwErrorStub.calledWith(Errors.MissingQueryParam, { params: ['b', 'c'] })).to.equal(true);
+        });
+
+        it('should NOT call next', () => {
+          requireQueryParams('a', 'b', 'c')(req, null, nextStub);
+          expect(nextStub.called).to.equal(false);
+        });
+      });
+
+      describe('with all params', () => {
+        beforeEach(() => {
+          req.query.a = 1;
+          req.query.b = { value: true };
+          req.query.c = 'test';
+        });
+
+        it('should NOT throw an error', () => {
+          requireQueryParams('a', 'b', 'c')(req, null, nextStub);
+          expect(throwErrorStub.called).to.equal(false);
+        });
+
+        it('should call next', () => {
+          requireQueryParams('a', 'b', 'c')(req, null, nextStub);
+          expect(nextStub.called).to.equal(true);
+        });
+      });
+    });
+
+    describe('parseArrayQueryParams', () => {
+      const req: any = { query: {} };
+
+      describe('specified param is a string', () => {
+        beforeEach(() => {
+          req.query.stringParam = 'param1,param2';
+        });
+
+        it('should split the search params', () => {
+          parseArrayQueryParams('stringParam')(req, null, nextStub);
+          expect(req.query.stringParam).to.deep.equal(['param1', 'param2']);
+        });
+
+        it('should call next', () => {
+          parseArrayQueryParams()(req, null, nextStub);
+          expect(nextStub.called).to.equal(true);
+        });
+      });
+
+      describe('specified param is an array', () => {
+        beforeEach(() => {
+          req.query.arrayParam = ['param1', 'param2'];
+        });
+
+        it('should keep the search params', () => {
+          parseArrayQueryParams('arrayParam')(req, null, nextStub);
+          expect(req.query.arrayParam).to.deep.equal(['param1', 'param2']);
+        });
+
+        it('should call next', () => {
+          parseArrayQueryParams()(req, null, nextStub);
+          expect(nextStub.called).to.equal(true);
+        });
+      });
+    });
+
+    describe('parseBooleanQueryParams', () => {
+      let req: any;
+
+      describe('param as "true"', () => {
+        beforeEach(() => {
+          req = {
+            query: {
+              booleanParam: 'true'
+            }
+          };
+        });
+
+        it('should return true', () => {
+          parseBooleanQueryParams('booleanParam')(req, null, nextStub);
+          expect(req.query.booleanParam).to.equal(true);
+        });
+      });
+
+      describe('param as "false"', () => {
+        beforeEach(() => {
+          req = {
+            query: {
+              booleanParam: 'false'
+            }
+          };
+        });
+
+        it('should return false', () => {
+          parseBooleanQueryParams('booleanParam')(req, null, nextStub);
+          expect(req.query.booleanParam).to.equal(false);
+        });
+      });
+
+      describe('with empty query string', () => {
+        beforeEach(() => {
+          req = {
+            query: {
+              booleanParam: ''
+            }
+          };
+        });
+
+        it('should return false', () => {
+          parseBooleanQueryParams('booleanParam')(req, null, nextStub);
+          expect(req.query.booleanParam).to.equal(false);
+        });
+      });
+    });
+  });
+});

package/src/utils/middleware.ts

@@ -0,0 +1,33 @@
+import { Request, Response, NextFunction } from 'express';
+
+import { Errors, throwError } from '../errors';
+
+const undefinedObject = <T>(value: T) => typeof value === 'object' && !Object.keys(value).length;
+
+const undefinedString = <T>(value: T) => typeof value === 'string' && !value;
+
+const isUndefined = <T>(value: T) =>
+  value === null || typeof value === 'undefined' || undefinedObject(value) || undefinedString(value);
+
+export const requireQueryParams =
+  (...params: string[]) =>
+    ({ query }: Request, _r: Response, next: NextFunction) => {
+      const missingParams = params.filter((param) => isUndefined(query[param]));
+      return missingParams.length === 0 ? next() : throwError(Errors.MissingQueryParam, { params: missingParams });
+    };
+
+export const parseArrayQueryParams =
+  (...fields: string[]) =>
+    ({ query }: Request, _r: Response, next: NextFunction) => {
+      fields.forEach((field) => {
+        query[field] = typeof query[field] === 'string' ? (query[field] as string).split(',') : query[field];
+      });
+      next();
+    };
+
+export const parseBooleanQueryParams =
+  (...fields: string[]) =>
+    (req: Request, _res: Response, next: NextFunction) => {
+      fields.forEach((field) => ((req.query as any)[field] = req.query[field] === 'true'));
+      next();
+    };

package/test/Dockerfile

@@ -0,0 +1,13 @@
+FROM node:18-slim
+
+WORKDIR /app
+
+COPY package.json .
+COPY package-lock.json .
+
+RUN npm ci
+
+# copy source from context
+ADD . .
+
+CMD npm test