slate/server.js

import * as Middleware from '~/common/middleware';
import * as Strings from '~/common/strings';
import * as Utilities from '~/node_common/utilities';
import * as Constants from '~/node_common/constants';

import { createPow, ffs } from '@textile/powergate-client';

// NOTE(jim):
// https://github.com/textileio/js-powergate-client
const PowerGate = createPow({ host: Constants.POWERGATE_HOST });

import FS from 'fs-extra';
import WebSocketServer from 'ws';
import express from 'express';
import formidable from 'formidable';
import next from 'next';
import bodyParser from 'body-parser';
import compression from 'compression';
import { v4 as uuid } from 'uuid';

// TODO(jim): Support multiple desktop applications.
let client = null;
let state = null;

const production = process.env.NODE_ENV === 'production';
const port = process.env.PORT || 1337;
const wsPort = process.env.WS_PORT || 2448;
const app = next({ dev: !production, quiet: false });
const nextRequestHandler = app.getRequestHandler();

const setIntervalViewerUpdatesUnsafe = async () => {
  if (client) {
    try {
      console.log('[ prototype ] polling: new viewer state.');
      state = await Utilities.emitState({
        state,
        client,
        PG: PowerGate,
      });

      console.log('[ prototype ] polling: new library state.');
      state = await Utilities.refreshLibrary({
        state,
        PG: PowerGate,
        FFS: ffs,
      });
    } catch (e) {
      console.log(e);
    }
  }

  setTimeout(setIntervalViewerUpdatesUnsafe, Constants.POLLING_RATE);
};

app.prepare().then(async () => {
  console.log('[ prototype ] initializing ');

  state = {
    production,
    port,
    wsPort,
    token: null,
    library: null,
    status: null,
    messageList: null,
    peersList: null,
    addrsList: null,
    info: null,
    local: null,
  };

  if (!production) {
    try {
      // TODO(jim): Remove later.
      // We wipe all of the local data each time you run the application.
      await Utilities.resetFileSystem();

      const updates = await Utilities.refresh({ PG: PowerGate });
      state = await Utilities.updateStateData(state, updates);
      console.log('[ prototype ] updated without token');

      // NOTE(jim): This is a configuration folder with all of the client tokens.
      // TODO(jim): Unnecessary if we use a local and remote postgres.
      if (!FS.existsSync(`./.data`)) {
        FS.mkdirSync(`./.data`, { recursive: true });
      }

      // NOTE(jim): This will create a token for authentication with powergate.
      // TODO(jim): Roll this up into Postgres instead.
      if (!FS.existsSync('./.data/powergate-token')) {
        const FFS = await PowerGate.ffs.create();
        state.token = FFS.token ? FFS.token : null;

        // NOTE(jim): Write a new token file.
        if (state.token) {
          FS.writeFileSync('./.data/powergate-token', state.token);
        }
      } else {
        state.token = FS.readFileSync('./.data/powergate-token', 'utf8');
      }

      if (state.token) {
        console.log('[ prototype ] powergate token:', state.token);
        PowerGate.setToken(state.token);
      }

      const tokenUpdates = await Utilities.refreshWithToken({
        PG: PowerGate,
      });
      state = await Utilities.updateStateData(state, tokenUpdates);
      console.log('[ prototype ] updated with token');

      // NOTE(jim): Local library retrieval or creation
      // TODO(jim): Needs to support nested folders in the future.
      // TODO(jim): May consider a move to buckets.
      if (!FS.existsSync('./.data/library.json')) {
        const librarySchema = {
          library: [
            {
              ...Utilities.createFolder({ id: Constants.FILE_STORAGE_URL }),
              file: 'Files',
              name: 'Files',
            },
          ],
        };

        FS.writeFileSync('./.data/library.json', JSON.stringify(librarySchema));
        state.library = librarySchema.library;
      } else {
        const parsedLibrary = FS.readFileSync('./.data/library.json', 'utf8');
        state.library = JSON.parse(parsedLibrary).library;
      }

      // NOTE(jim): Local settings retrieval or creation
      // TODO(jim): Move this to postgres later.
      if (!FS.existsSync('./.data/local-settings.json')) {
        const localSettingsSchema = {
          local: { photo: null, name: `node-${uuid()}`, settings_deals_auto_approve: false },
        };

        FS.writeFileSync('./.data/local-settings.json', JSON.stringify(localSettingsSchema));
        state.local = localSettingsSchema.local;
      } else {
        const parsedLocal = FS.readFileSync('./data/local-settings.json', 'utf8');
        state.local = JSON.parse(parsedLocal).local;
      }
    } catch (e) {
      console.log(e);
      console.log('[ prototype ] "/" -- WILL REDIRECT TO /SYSTEM ');
      console.log('[ prototype ]        SLATE WILL NOT RUN LOCALLY UNTIL YOU HAVE ');
      console.log('[ prototype ]        PROPERLY CONFIGURED POWERGATE AND ');
      console.log('[ prototype ]        CONNECTED TO THE FILECOIN NETWORK (DEVNET/TESTNET) ');
    }
  }

  const server = express();
  const WSS = new WebSocketServer.Server({ port: wsPort });

  WSS.on('connection', (s) => {
    // TODO(jim): Suppport more than one client.
    client = s;

    s.on('close', function () {
      s.send(JSON.stringify({ action: null, data: 'closed' }));
    });

    s.send(JSON.stringify({ action: null, data: 'connected' }));
  });

  if (production) {
    server.use(compression());
  }

  server.use(Middleware.CORS);
  server.use('/public', express.static('public'));
  server.use(bodyParser.json());
  server.use(
    bodyParser.urlencoded({
      extended: false,
    })
  );

  server.post('/_/viewer', async (req, res) => {
    let data = state;

    if (!production) {
      const updates = await Utilities.refresh({ PG: PowerGate });
      const updatesWithToken = await Utilities.refreshWithToken({
        PG: PowerGate,
      });
      data = await Utilities.updateStateData(data, {
        ...updates,
        ...updatesWithToken,
      });
    }

    return res.status(200).send({ success: true, data });
  });

  server.post('/_/deals/storage', async (req, res) => {
    if (Strings.isEmpty(req.body.src)) {
      return res.status(500).send({ success: false });
    }

    const localPath = `.${req.body.src}`;
    const buffer = FS.readFileSync(localPath);
    const { cid } = await PowerGate.ffs.addToHot(buffer);
    const { jobId } = await PowerGate.ffs.pushConfig(cid);

    // TODO(jim): Refactor this so we repeat this less often.
    let write = false;
    for (let i = 0; i < state.library.length; i++) {
      for (let j = 0; j < state.library[i].children.length; j++) {
        if (localPath === state.library[i].children[j].id) {
          state.library[i].children[j].job_id = jobId;
          state.library[i].children[j].cid = cid;
          state.library[i].children[j].storage_status = 1;
          write = true;
        }
      }
    }

    // NOTE(jim): Writes the updated deal state.
    if (write) {
      FS.writeFileSync('./.data/library.json', JSON.stringify({ library: state.library }));
    }

    state = await Utilities.emitState({ state, client, PG: PowerGate });
    return res.status(200).send({ success: true, cid, jobId });
  });

  server.post('/_/storage/:file', async (req, res) => {
    const form = formidable({
      multiples: true,
      uploadDir: Constants.FILE_STORAGE_URL,
    });

    form.parse(req, async (error, fields, files) => {
      if (error) {
        return res.status(500).send({ error });
      } else {
        // TODO(jim): Need to support other file types.
        if (!files.image) {
          console.error('[ prototype ] File type unspported', files);
          return res.status(500).send({ error: 'File type unsupported', files });
        }

        const newPath = form.uploadDir + req.params.file;
        FS.rename(files.image.path, newPath, function (err) {});

        const localFile = Utilities.createFile({
          id: newPath,
          data: files.image,
        });

        // TODO(jim): Messy, refactor.
        let pushed = false;
        for (let i = 0; i < state.library.length; i++) {
          if (!pushed) {
            state.library[i].children.push(localFile);
            pushed = true;
            break;
          }
        }

        // NOTE(jim): Writes the added file.
        if (pushed) {
          FS.writeFileSync('./.data/library.json', JSON.stringify({ library: state.library }));
        }

        state = await Utilities.emitState({
          state,
          client,
          PG: PowerGate,
        });

        return res.status(200).send({ success: true, file: localFile });
      }
    });
  });

  server.post('/_/upload/avatar', async (req, res) => {
    const form = formidable({
      multiples: true,
      uploadDir: Constants.AVATAR_STORAGE_URL,
    });

    form.parse(req, async (error, fields, files) => {
      if (error) {
        return res.status(500).send({ error });
      } else {
        const newName = `avatar-${uuid()}.png`;
        const newPath = form.uploadDir + newName;
        FS.rename(files.image.path, newPath, function (err) {});

        // NOTE(jim): updates avatar photo.
        state.local.photo = `/static/system/${newName}`;
        FS.writeFileSync('./.data/local-settings.json', JSON.stringify({ local: { ...state.local } }));

        state = await Utilities.emitState({
          state,
          client,
          PG: PowerGate,
        });

        return res.status(200).send({ success: true });
      }
    });
  });

  server.post('/_/settings', async (req, res) => {
    let data;
    try {
      data = await PowerGate.ffs.setDefaultConfig(req.body.config);
    } catch (e) {
      return res.status(500).send({ error: e.message });
    }

    state = await Utilities.emitState({ state, client, PG: PowerGate });
    return res.status(200).send({ success: true, data });
  });

  server.post('/_/local-settings', async (req, res) => {
    state.local = { ...state.local, ...req.body.local };

    FS.writeFileSync('./.data/local-settings.json', JSON.stringify({ local: { ...state.local } }));
    state = await Utilities.emitState({ state, client, PG: PowerGate });
    return res.status(200).send({ success: true });
  });

  server.post('/_/wallet/create', async (req, res) => {
    let data;
    try {
      data = await PowerGate.ffs.newAddr(req.body.name, req.body.type, req.body.makeDefault);
    } catch (e) {
      return res.status(500).send({ error: e.message });
    }

    state = await Utilities.emitState({ state, client, PG: PowerGate });
    return res.status(200).send({ success: true, data });
  });

  server.post('/_/wallet/send', async (req, res) => {
    let data;
    try {
      data = await PowerGate.ffs.sendFil(req.body.source, req.body.target, req.body.amount);
    } catch (e) {
      return res.status(500).send({ error: e.message });
    }

    state = await Utilities.emitState({ state, client, PG: PowerGate });
    return res.status(200).send({ success: true, data: { ...data, ...req.body } });
  });

  server.get('/', async (req, res) => {
    if (!state.token) {
      return res.redirect('/system');
    }

    return app.render(req, res, '/', {
      production,
      wsPort,
    });
  });

  server.get('*', async (req, res) => {
    return nextRequestHandler(req, res, req.url);
  });

  server.listen(port, async (err) => {
    if (err) {
      throw err;
    }

    console.log(`[ prototype ] client: http://localhost:${port}`);
    console.log(`[ prototype ] constants:`, Constants);

    if (!production) {
      await setIntervalViewerUpdatesUnsafe();
    }
  });
});