@hestia-earth/data-api 0.0.2-2 → 0.0.2-4

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

@@ -1,118 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

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

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

@@ -1,10 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

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

package/test/docker-compose.yml

@@ -1,40 +0,0 @@
-version: '3'
-
-services:
-  test:
-    env_file: '../.env.test'
-    image: hestia-data-api:test
-    build:
-      context: ../
-      dockerfile: test/Dockerfile
-    environment:
-      - PGHOST=hestia-data-api-test-db
-      - PGUSER=postgres
-      - PGDATABASE=postgres
-      - PGPASSWORD=password
-      - PGPORT=5432
-    volumes:
-      - ../src:/app/src
-      - ../coverage:/app/coverage
-      - ./:/app/test
-    depends_on:
-      db:
-        condition: service_healthy
-
-  db:
-    image: postgres:14
-    container_name: hestia-data-api-test-db
-    ports:
-      - 5432:5432
-    volumes:
-      - postgres:/data/postgres
-    environment:
-      - POSTGRES_PASSWORD=password
-    healthcheck:
-      test: ['CMD', 'pg_isready', '-q', '-d', 'postgres', '-U', 'postgres']
-      interval: 1s
-      timeout: 5s
-      retries: 5
-
-volumes:
-  postgres: