@ohos-ports/redux-devtools-cli 5.0.0-beta.0

package/src/routes.ts

@@ -0,0 +1,144 @@
+import path from 'path';
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import express from 'express';
+import type { Router } from 'express';
+import morgan from 'morgan';
+import * as http from 'http';
+import bodyParser from 'body-parser';
+import cors from 'cors';
+import { AGServer } from 'socketcluster-server';
+import { ApolloServer } from '@apollo/server';
+import { expressMiddleware } from '@as-integrations/express5';
+import type { AddData, ReportBaseFields, Store } from './store.js';
+import { resolvers, schema } from './api/schema.js';
+
+const app = express.Router();
+
+const require = createRequire(import.meta.url);
+
+function serveUmdModule(name: string) {
+  app.use(
+    express.static(
+      path.dirname(require.resolve(name + '/package.json')) + '/umd',
+    ),
+  );
+}
+
+interface Context {
+  store?: Store;
+}
+
+function routes(
+  options: AGServer.AGServerOptions,
+  store: Store,
+  scServer: AGServer,
+): Router {
+  const limit = options.maxRequestBody;
+  const logHTTPRequests = options.logHTTPRequests;
+
+  if (logHTTPRequests) {
+    if (typeof logHTTPRequests === 'object')
+      app.use(
+        morgan(
+          'combined',
+          logHTTPRequests as morgan.Options<
+            http.IncomingMessage,
+            http.ServerResponse
+          >,
+        ),
+      );
+    else app.use(morgan('combined'));
+  }
+
+  const server = new ApolloServer<Context>({
+    typeDefs: schema,
+    resolvers,
+  });
+  server
+    .start()
+    .then(() => {
+      app.use(
+        '/graphql',
+        cors<cors.CorsRequest>(),
+        bodyParser.json(),
+        expressMiddleware(server, {
+          context: () => Promise.resolve({ store }),
+        }),
+      );
+    })
+    .catch((error) => {
+      console.error(error);
+    });
+
+  serveUmdModule('react');
+  serveUmdModule('react-dom');
+  serveUmdModule('@redux-devtools/app');
+
+  app.get('/port.js', function (req, res) {
+    res.send(`reduxDevToolsPort = ${options.port}`);
+  });
+  app.get('/{*splat}', function (req, res) {
+    res.sendFile(
+      path.join(
+        path.dirname(fileURLToPath(import.meta.url)),
+        '../app/index.html',
+      ),
+    );
+  });
+
+  app.use(cors({ methods: 'POST' }));
+  app.use(bodyParser.json({ limit: limit }));
+  app.use(bodyParser.urlencoded({ limit: limit, extended: false }));
+
+  app.post('/', function (req, res) {
+    if (!req.body) {
+      res.status(404).end();
+      return;
+    }
+    switch (req.body.op) {
+      case 'get':
+        store
+          .get(req.body.id as string)
+          .then(function (r) {
+            res.send(r || {});
+          })
+          .catch(function (error) {
+            console.error(error);
+            res.sendStatus(500);
+          });
+        break;
+      case 'list':
+        store
+          .list(req.body.query as string, req.body.fields as string[])
+          .then(function (r) {
+            res.send(r);
+          })
+          .catch(function (error) {
+            console.error(error);
+            res.sendStatus(500);
+          });
+        break;
+      default:
+        store
+          .add(req.body as AddData)
+          .then(function (r) {
+            res.send({
+              id: (r as ReportBaseFields).id,
+              error: (r as { error: string }).error,
+            });
+            void scServer.exchange.transmitPublish('report', {
+              type: 'add',
+              data: r,
+            });
+          })
+          .catch(function (error) {
+            console.error(error);
+            res.status(500).send({});
+          });
+    }
+  });
+  return app;
+}
+
+export default routes;

package/src/store.ts

@@ -0,0 +1,164 @@
+import { v4 as uuidV4 } from 'uuid';
+import { pick } from 'lodash-es';
+import { AGServer } from 'socketcluster-server';
+import { Knex } from 'knex';
+import connector from './db/connector.js';
+
+const reports = 'remotedev_reports';
+// var payloads = 'remotedev_payloads';
+let knex: Knex;
+
+const baseFields = ['id', 'title', 'added'];
+
+function error(msg: string): Promise<{ error: string }> {
+  return new Promise(function (resolve) {
+    return resolve({ error: msg });
+  });
+}
+
+type ReportType = 'STATE' | 'ACTION' | 'STATES' | 'ACTIONS';
+
+export interface Report {
+  id: string;
+  type: ReportType | null;
+  title: string | null;
+  description: string | null;
+  action: string | null;
+  payload: string;
+  preloadedState: string | null;
+  screenshot: string | null;
+  userAgent: string | null;
+  version: string | null;
+  userId: string | null;
+  user: string | null;
+  meta: string | null;
+  exception: string | null;
+  instanceId: string | null;
+  added: string | null;
+  appId?: string | null;
+}
+
+export interface ReportBaseFields {
+  id: string;
+  title: string | null;
+  added: string | null;
+}
+
+function list(query?: string, fields?: string[]): Promise<ReportBaseFields[]> {
+  const r = knex.select(fields || baseFields).from(reports);
+  if (query) return r.where(query);
+  return r;
+}
+
+function listAll(query?: string): Promise<Report[]> {
+  const r = knex.select().from(reports);
+  if (query) return r.where(query);
+  return r;
+}
+
+function get(id: string): Promise<Report | { error: string }> {
+  if (!id) return error('No id specified.');
+
+  return knex(reports).where('id', id).first();
+}
+
+export interface AddData {
+  type: ReportType | null;
+  title: string | null;
+  description: string | null;
+  action: string | null;
+  payload: string;
+  preloadedState: string | null;
+  screenshot: string | null;
+  version: string | null;
+  userAgent: string | null;
+  userId: string | null;
+  user: { id: string } | string | null;
+  instanceId: string | null;
+  meta: string | null;
+  exception?: Error;
+  appId?: string | null;
+}
+
+function add(data: AddData): Promise<ReportBaseFields | { error: string }> {
+  if (!data.type || !data.payload) {
+    return error("Required parameters aren't specified.");
+  }
+  if (data.type !== 'ACTIONS' && data.type !== 'STATE') {
+    return error('Type ' + data.type + ' is not supported yet.');
+  }
+
+  const reportId = uuidV4();
+  const report: Report = {
+    id: reportId,
+    type: data.type,
+    title:
+      data.title || (data.exception && data.exception.message) || data.action,
+    description: data.description,
+    action: data.action,
+    payload: data.payload,
+    preloadedState: data.preloadedState,
+    screenshot: data.screenshot,
+    version: data.version,
+    userAgent: data.userAgent,
+    user: data.user as string,
+    userId:
+      typeof data.user === 'object'
+        ? (data.user as { id: string }).id
+        : data.user,
+    instanceId: data.instanceId,
+    meta: data.meta,
+    exception: composeException(data.exception),
+    added: new Date().toISOString(),
+  };
+  if (data.appId) report.appId = data.appId; // TODO check if the id exists and we have access to link it
+  /*
+  var payload = {
+    id: uuid.v4(),
+    reportId: reportId,
+    state: data.payload
+  };
+  */
+
+  return knex
+    .insert(report)
+    .into(reports)
+    .then(function () {
+      return byBaseFields(report);
+    });
+}
+
+function byBaseFields(data: Report): ReportBaseFields {
+  return pick(data, baseFields) as ReportBaseFields;
+}
+
+export interface Store {
+  list: (query?: string, fields?: string[]) => Promise<ReportBaseFields[]>;
+  listAll: (query?: string) => Promise<Report[]>;
+  get: (id: string) => Promise<Report | { error: string }>;
+  add: (data: AddData) => Promise<ReportBaseFields | { error: string }>;
+}
+
+function createStore(options: AGServer.AGServerOptions): Store {
+  knex = connector(options);
+
+  return {
+    list: list,
+    listAll: listAll,
+    get: get,
+    add: add,
+  };
+}
+
+function composeException(exception: Error | undefined) {
+  let message = '';
+
+  if (exception) {
+    message = 'Exception thrown: ';
+    if (exception.message) message += exception.message;
+    if (exception.stack) message += '\n' + exception.stack;
+  }
+  return message;
+}
+
+export default createStore;