From 28e0acf4d46116deecfc4b50fcf85ae6dc97aefc Mon Sep 17 00:00:00 2001
From: Pawel Psztyc <jarrodek@gmail.com>
Date: Thu, 29 Aug 2019 17:00:42 -0700
Subject: [PATCH] chore: started building parting API

---
 demo/demo-base.js                             |  15 +-
 demo/demo-server/api.js                       |  41 +-
 .../demo-server/api/amf-service/amf-parser.js |  67 +++
 .../api/amf-service/amf-service.js            | 423 ++++++++++++++++++
 .../demo-server/api/amf-service/api-search.js | 164 +++++++
 demo/demo-server/api/api-parser.js            | 156 +++++++
 demo/demo-server/app.js                       |   3 +-
 demo/helpers/upload-api-screen.js             |  10 -
 demo/standalone/app.js                        |   3 +-
 package-lock.json                             |  10 +
 package.json                                  |   2 +
 11 files changed, 873 insertions(+), 21 deletions(-)
 create mode 100644 demo/demo-server/api/amf-service/amf-parser.js
 create mode 100644 demo/demo-server/api/amf-service/amf-service.js
 create mode 100644 demo/demo-server/api/amf-service/api-search.js
 create mode 100644 demo/demo-server/api/api-parser.js

diff --git a/demo/demo-base.js b/demo/demo-base.js
index c33ca1571..8f551b025 100644
--- a/demo/demo-base.js
+++ b/demo/demo-base.js
@@ -15,7 +15,7 @@ export class DemoBase {
     ]);
 
     this._selectApi = this._selectApi.bind(this);
-    this._processApiFile = this._processApiFile.bind(this);
+    this._processApiFileUpload = this._processApiFileUpload.bind(this);
   }
 
   get loading() {
@@ -156,13 +156,24 @@ export class DemoBase {
         body: value
       });
       const data = await response.json();
-      console.log(data);
+      if (response.status === 200) {
+        this.model = JSON.parse(data.data.api);
+      } else if (response.status === 300) {
+        this._requestSelectApi(data.data);
+      } else {
+        this.notifyError(data.message);
+      }
     } catch (e) {
       this.notifyError(e.message);
     }
     this.loading = false;
   }
 
+  _requestSelectApi(data) {
+    const { key, candidates } = data;
+    console.log(key, candidates);
+  }
+
   firstRendered() {}
 
   menuSelectorTemplate() {
diff --git a/demo/demo-server/api.js b/demo/demo-server/api.js
index 5458a0868..7a148a123 100644
--- a/demo/demo-server/api.js
+++ b/demo/demo-server/api.js
@@ -1,17 +1,44 @@
+import { ApiParser } from './api/api-parser.js';
+const parser = new ApiParser();
+
+function wrapError(cause) {
+  return {
+    error: true,
+    code: 500,
+    message: cause.message,
+    detail: 'The server misbehave. That is all we know.'
+  };
+}
 
 async function apiRequest(ctx) {
-  if (ctx.request.url === '/api/parse/api') {
-    ctx.body = 'PARSING SERVICE';
-  } else {
-    ctx.response.status = 404;
-    ctx.body = 'unknown';
+  let body;
+  try {
+    if (ctx.request.url === '/api/parse/api') {
+      body = await parser.parseFile(ctx.req);
+    } else if (ctx.request.url.indexOf('/api/parse/candidate') === 0) {
+      body = await parser.parseCandidate(ctx.req);
+    } else if (ctx.request.url.indexOf('/api/parse/result/') === 0) {
+      const id = ctx.request.url.substr(18);
+      body = await parser.checkStatus(id);
+    } else {
+      ctx.response.status = 404;
+      body = 'unknown';
+    }
+  } catch (e) {
+    body = wrapError(e);
+  }
+  /* eslint-disable require-atomic-updates */
+  if (body.code) {
+    ctx.status = body.code;
   }
+  // console.log('response', body);
+  ctx.body = body;
 }
 
 export async function demoApi(ctx, next) {
-  if (ctx.request.url.indexOf('/api') === 0) {
+  if (ctx.request.url.indexOf('/api/') === 0) {
     await apiRequest(ctx);
   } else {
-    await next();
+    return next();
   }
 }
diff --git a/demo/demo-server/api/amf-service/amf-parser.js b/demo/demo-server/api/amf-service/amf-parser.js
new file mode 100644
index 000000000..86393fb4c
--- /dev/null
+++ b/demo/demo-server/api/amf-service/amf-parser.js
@@ -0,0 +1,67 @@
+const amf = require('amf-client-js');
+// import amf from 'amf-client-js';
+amf.plugins.document.WebApi.register();
+amf.plugins.document.Vocabularies.register();
+amf.plugins.features.AMFValidation.register();
+let initied = false;
+
+async function validateDoc(type, doc) {
+  let validateProfile;
+  switch (type) {
+    case 'RAML 1.0': validateProfile = amf.ProfileNames.RAML; break;
+    case 'RAML 0.8': validateProfile = amf.ProfileNames.RAML08; break;
+    case 'OAS 1.0':
+    case 'OAS 2.0':
+    case 'OAS 3.0':
+      validateProfile = amf.ProfileNames.OAS;
+      break;
+  }
+  const result = await amf.AMF.validate(doc, validateProfile);
+  process.send({ validation: result.toString() });
+}
+/**
+ * AMF parser to be called in a child process.
+ *
+ * AMF can in extreme cases takes forever to parse API data if, for example,
+ * RAML type us defined as a number of union types. It may sometimes cause
+ * the process to crash. To protect the renderer proces this is run as forked
+ * process.
+ *
+ * @param {Object} data
+ */
+async function processData(data) {
+  const sourceFile = data.source;
+  const type = data.from.type;
+  const contentType = data.from.contentType;
+  const validate = data.validate;
+  if (!initied) {
+    await amf.Core.init();
+  }
+  /* eslint-disable-next-line require-atomic-updates */
+  initied = true;
+  const file = `file://${sourceFile}`;
+  const parser = amf.Core.parser(type, contentType);
+  let doc = await parser.parseFileAsync(file);
+  if (validate) {
+    await validateDoc(type, doc);
+  }
+
+  const resolver = amf.Core.resolver(type);
+  doc = resolver.resolve(doc, 'editing');
+  const generator = amf.Core.generator('AMF Graph', 'application/ld+json');
+  const opts = amf.render.RenderOptions().withSourceMaps.withCompactUris;
+  return await generator.generateString(doc, opts);
+}
+
+process.on('message', async (data) => {
+  try {
+    const api = await processData(data);
+    process.send({
+      api
+    });
+  } catch (cause) {
+    let m = `AMF parser: Unable to parse API ${data.source}.\n`;
+    m += cause.s$1 || cause.message;
+    process.send({ error: m });
+  }
+});
diff --git a/demo/demo-server/api/amf-service/amf-service.js b/demo/demo-server/api/amf-service/amf-service.js
new file mode 100644
index 000000000..b4f3471e9
--- /dev/null
+++ b/demo/demo-server/api/amf-service/amf-service.js
@@ -0,0 +1,423 @@
+import tmp from 'tmp';
+import { Duplex } from 'stream';
+import unzipper from 'unzipper';
+import path from 'path';
+import { fork } from 'child_process';
+import fs from 'fs-extra';
+import { ApiSearch } from './api-search.js';
+
+/**
+ * A class that handles parsing a file to AMF format.
+ *
+ * It unpacks zip files, searches for main entry point to the API and parses
+ * the data to AMF json-ld format.
+ *
+ * The process can be split into 3 parts:
+ *
+ * - prepare - unzips file to temporaty location, sets paths
+ * - resolve - in case when deterministic method of finding API main file
+ * fails, the application should aks a user to choose the main file.
+ * - parse - parsing API data and returning AMF model.
+ *
+ * Example use:
+ *
+ * ```javascript
+ * const service = new AmfService(filePathOrBuffer);
+ * service.prepare()
+ * .then(() => service.resolve())
+ * .then((candidates) => {
+ *  // If "candidates" is set then the application
+ *  // should ask the user to select main file
+ *  if (candidates) {
+ *    return askUser(candidates);
+ *  } else {
+ *    return service.parse();
+ *  }
+ * })
+ * .then((mainFile) => service.parse(mainFile))
+ * .then((model) => console.log(model))
+ * .catch((cause) => console.error(cause));
+ * ```
+ */
+export class AmfService {
+  /**
+   * The same as with constructror but resets the sate.
+   * @param {Buffer|String} source Location of the API file on the disk or
+   * buffer of a file. If the source is a file and it's not a zip file then
+   * it must be the API file.
+   * @param {?Object} opts Process options:
+   * - zip {Boolean} - if true it treats the source as a zip data. Files are
+   * unzzipped to a temporary location before processing.
+   * - validate {Boolean} - if true it validates the API when parsing.
+   * Validation is made in the `parse` phase and results (as string) are stored
+   * in `validationResult` property of the service.
+   */
+  setSource(source, opts) {
+    if (!opts) {
+      opts = {};
+    }
+    this.source = source;
+    this.isZip = opts.zip;
+    this.validate = opts.validate;
+    // created at run time.
+    /**
+     * Temp folder data object.
+     * @type {Object}
+     */
+    this.tmpobj = undefined;
+    /**
+     * A directory path where files are stored.
+     * @type {String}
+     */
+    this._workingDir = undefined;
+    /**
+     * API main file (entry point) in the working directory.
+     * If this is set it means the files has been resolved.
+     * @type {String}
+     */
+    this._mainFile = undefined;
+    /**
+     * True when tmp object represents a file and not a directory
+     * @type {Boolean}
+     */
+    this._tmpIsFile = false;
+  }
+  /**
+   * Returns current working directory.
+   * @return {String}
+   */
+  get workingDir() {
+    return this._workingDir;
+  }
+
+  set workingDir(value) {
+    this._workingDir = value;
+  }
+
+  /**
+   * Cleans up if the operation is canceled.
+   * This must be called if `prepare()` was called or otherwise some temporary
+   * files will be kept on the disk.
+   * @return {Promise}
+   */
+  async cancel() {
+    await this._cleanTempFiles();
+    this.tmpobj = undefined;
+    this._workingDir = undefined;
+    this._mainFile = undefined;
+  }
+
+  async cleanup() {
+    this._cancelMonitorParser();
+    this._cancelParseProcTimeout();
+    const proc = this._parserProc;
+    if (!proc) {
+      return await this.cancel();
+    }
+    return new Promise((resolve) => {
+      this._killParser();
+      proc.on('exit', () => {
+        this.cancel().then(() => resolve());
+      });
+    });
+  }
+  /**
+   * Prepares the file to be processed.
+   * @return {Promise}
+   */
+  async prepare() {
+    if (this.isZip) {
+      return await this._prepareZip();
+    }
+    if (this.source instanceof Buffer) {
+      return await this._prepareBuffer();
+    }
+    const stat = await fs.stat(this.source);
+    if (stat.isDirectory()) {
+      this._workingDir = this.source;
+    } else {
+      this._workingDir = path.dirname(this.source);
+      this._mainFile = path.basename(this.source);
+    }
+  }
+
+  async _prepareZip() {
+    try {
+      await this._unzipSource();
+    } catch (cause) {
+      await this._cleanTempFiles();
+      throw cause;
+    }
+  }
+
+  async _prepareBuffer() {
+    const location = await this._tmpBuffer(this.source);
+    this._workingDir = path.dirname(location);
+    this._mainFile = path.basename(location);
+  }
+  /**
+   * Resolves the API structure and tries to find main API file.
+   *
+   * @return {Promise<Array<String>>} If promise resolves to an array it means
+   * that API type could not be determined automatically.
+   */
+  async resolve() {
+    if (this._tmpIsFile) {
+      return;
+    }
+    if (!this._workingDir) {
+      await this._cleanTempFiles();
+      throw new Error(`prepare() function not called`);
+    }
+    if (this._mainFile) {
+      return;
+    }
+    const search = new ApiSearch(this._workingDir);
+    try {
+      const result = await search.findApiFile();
+      if (!result) {
+        throw new Error('Unable to find API files in the source location');
+      }
+      if (result instanceof Array) {
+        return result;
+      }
+      this._mainFile = result;
+    } catch (cause) {
+      await this._cleanTempFiles();
+      throw cause;
+    }
+  }
+  /**
+   * Parses API data using AMF parser.
+   * @param {?String} mainFile Main API file to use.
+   * @return {Promise<Object>} A promise resolved to AMF model.
+   */
+  async parse(mainFile) {
+    if (!this._workingDir) {
+      await this._cleanTempFiles();
+      throw new Error(`prepare() function not called`);
+    }
+    if (mainFile && typeof mainFile === 'string') {
+      this._mainFile = mainFile;
+    }
+    if (!this._mainFile) {
+      await this._cleanTempFiles();
+      throw new Error(`resolve() function not called`);
+    }
+    const search = new ApiSearch(this._workingDir);
+    const apiLocation = path.join(this._workingDir, this._mainFile);
+
+    try {
+      const type = await search._readApiType(apiLocation);
+      const model = await this._runParser(apiLocation, type);
+      await this._cleanTempFiles();
+      return model;
+    } catch (cause) {
+      await this._cleanTempFiles();
+      throw cause;
+    }
+  }
+  /**
+   * Unzpis the source to a tem folder.
+   * @return {Promise}
+   */
+  async _unzipSource() {
+    let buffer;
+    if (this.source instanceof Buffer) {
+      buffer = this.source;
+    } else {
+      buffer = await fs.readFile(this.source);
+    }
+    const location = await this._unzip(buffer);
+    this._workingDir = location;
+    await this._removeZipMainFolder(location);
+  }
+
+  async _tmpBuffer(buffer) {
+    this.tmpobj = tmp.fileSync();
+    this._tmpIsFile = true;
+    const fd = this.tmpobj.fd;
+    await fs.write(fd, buffer);
+    await fs.close(fd);
+    return this.tmpobj.name;
+  }
+  /**
+   * Unzips API folder and returns path to the folder in tmp location.
+   * @param {ArrayBuffer} buffer Zip data
+   * @return {Promise}
+   */
+  _unzip(buffer) {
+    this.tmpobj = tmp.dirSync();
+    return new Promise((resolve, reject) => {
+      const stream = new Duplex();
+      stream.push(buffer);
+      stream.push(null);
+      const extractor = unzipper.Extract({
+        path: this.tmpobj.name
+      });
+      extractor.on('close', () => {
+        resolve(this.tmpobj.name);
+      });
+      extractor.on('error', (err) => {
+        reject(err);
+      });
+      stream.pipe(extractor);
+    });
+  }
+  /**
+   * The zip may have source files enclosed in a folder.
+   * This will look for a folder in the root path and will copy sources from it.
+   *
+   * @param {String} destination A place where the zip sources has been
+   * extracted.
+   * @return {Promise}
+   */
+  async _removeZipMainFolder(destination) {
+    let files = await fs.readdir(destination);
+    files = files.filter((item) => item !== '__MACOSX');
+    if (files.length > 1) {
+      return;
+    }
+    const dirPath = path.join(destination, files[0]);
+    const stats = await fs.stat(dirPath);
+    if (stats.isDirectory()) {
+      await fs.copy(dirPath, destination);
+    }
+  }
+  /**
+   * Removes created temporary directory.
+   * @return {Promise}
+   */
+  async _cleanTempFiles() {
+    if (!this.tmpobj) {
+      return;
+    }
+    if (this._tmpIsFile) {
+      this.tmpobj.removeCallback();
+      this.tmpobj = undefined;
+      return;
+    }
+    await fs.emptyDir(this.tmpobj.name);
+    this.tmpobj.removeCallback();
+    this.tmpobj = undefined;
+  }
+
+  _createParserProcess() {
+    if (this._parserProc) {
+      if (this._parserProc.connected) {
+        return this._parserProc;
+      } else {
+        this._killParser();
+      }
+    }
+    const options = {
+      execArgv: []
+    };
+    this._parserProc = fork(`${__dirname}/amf-parser.js`, options);
+    this._parserProc.on('exit', () => {
+      this._cancelParseProcTimeout();
+      this._cancelMonitorParser();
+      this._parserProc = undefined;
+    });
+    return this._parserProc;
+  }
+
+  _setParserProcTimeout(cb, time = 180000) {
+    this._parserProcCb = cb;
+    this._parserProceTimeout = setTimeout(() => {
+      this._parserProceTimeout = undefined;
+      this._killParser();
+      const fn = this._parserProcCb;
+      this._parserProcCb = undefined;
+      fn();
+    }, time);
+  }
+
+  _cancelParseProcTimeout() {
+    if (this._parserProceTimeout) {
+      clearTimeout(this._parserProceTimeout);
+      this._parserProceTimeout = undefined;
+      this._parserProcCb = undefined;
+    }
+  }
+
+  _killParser() {
+    this._cancelParseProcTimeout();
+    this._cancelMonitorParser();
+    if (this._parserProc) {
+      this._parserProc.disconnect();
+      this._parserProc.removeAllListeners('message');
+      this._parserProc.removeAllListeners('error');
+      this._parserProc.removeAllListeners('exit');
+      this._parserProc.kill();
+      this._parserProc = undefined;
+    }
+  }
+
+  _monitorParserProc() {
+    this._parserMinitorTimeout = setTimeout(() => {
+      this._parserMinitorTimeout = undefined;
+      this._killParser();
+    }, 60000);
+  }
+
+  _cancelMonitorParser() {
+    if (this._parserMinitorTimeout) {
+      clearTimeout(this._parserMinitorTimeout);
+    }
+  }
+  /**
+   * Runs the parser.
+   *
+   * @param {String} apiLocation API file location
+   * @param {Object} type API type info object.
+   * @return {Promise}
+   */
+  _runParser(apiLocation, type) {
+    this._cancelMonitorParser();
+    return new Promise((resolve, reject) => {
+      const callbacks = {
+        onmessage: (result) => {
+          if (result.validation) {
+            console.log(result.validation);
+            return;
+          }
+          this._cancelParseProcTimeout();
+          this._parserProc.removeAllListeners('message', callbacks.onmessage);
+          this._parserProc.removeAllListeners('error', callbacks.onerror);
+          this._parserProcCb = undefined;
+          this._monitorParserProc();
+          this._killParser();
+          if (result.error) {
+            reject(new Error(result.error));
+          } else {
+            resolve(result.api);
+          }
+        },
+        onerror: (err) => {
+          this._cancelParseProcTimeout();
+          this._parserProc.removeAllListeners('message', callbacks.onmessage);
+          this._parserProc.removeAllListeners('error', callbacks.onerror);
+          this._parserProcCb = undefined;
+          this._monitorParserProc();
+          reject(new Error(err.message || 'Unknown error'));
+        }
+      };
+
+      const proc = this._createParserProcess();
+      this._setParserProcTimeout(() => {
+        reject(new Error('API parsing timeout'));
+        this._parserProc.removeAllListeners('message', callbacks.onmessage);
+        this._parserProc.removeAllListeners('error', callbacks.onerror);
+        this._monitorParserProc();
+      });
+      proc.on('message', callbacks.onmessage);
+      proc.on('error', callbacks.onerror);
+      proc.send({
+        source: apiLocation,
+        from: type,
+        validate: this.validate
+      });
+    });
+  }
+}
diff --git a/demo/demo-server/api/amf-service/api-search.js b/demo/demo-server/api/amf-service/api-search.js
new file mode 100644
index 000000000..3d70efc3a
--- /dev/null
+++ b/demo/demo-server/api/amf-service/api-search.js
@@ -0,0 +1,164 @@
+import fs from 'fs-extra';
+import path from 'path';
+/**
+ * Searches for API main file in given location
+ */
+export class ApiSearch {
+  /**
+   * @param {String} dir API directory location
+   */
+  constructor(dir) {
+    this._workingDir = dir;
+  }
+  /**
+   * Finds main API name.
+   *
+   * If one of the files is one of the popular names for the API spec files
+   * then it always returns this file.
+   *
+   * If it finds single candidate it returns it as a main file.
+   *
+   * If it finds more than a single file it means that the user has to decide
+   * which one is the main file.
+   *
+   * If it returns undefined than the process failed and API main file cannot
+   * be determined.
+   *
+   * @return {Promise<Array<String>|String|undefined>}
+   */
+  async findApiFile() {
+    const items = await fs.readdir(this._workingDir);
+    const popularNames = ['api.raml', 'api.yaml', 'api.json'];
+    const exts = ['.raml', '.yaml', '.json'];
+    const ignore = ['__macosx', 'exchange.json', '.ds_store'];
+    const files = [];
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      const lower = items[i].toLowerCase();
+      if (ignore.indexOf(lower) !== -1) {
+        continue;
+      }
+      if (popularNames.indexOf(lower) !== -1) {
+        return item;
+      }
+      const ext = path.extname(lower);
+      if (exts.indexOf(ext) !== -1) {
+        files.push(item);
+      }
+    }
+    if (files.length === 1) {
+      return files[0];
+    }
+    if (files.length) {
+      return this._decideMainFile(files);
+    }
+  }
+
+  /**
+   * Decides which file to use as API main file.
+   * @param {Array<String>} files A file or list of files.
+   * @return {Promise<String>}
+   */
+  async _decideMainFile(files) {
+    const root = this._workingDir;
+    const fullPathFiles = files.map((item) => {
+      return {
+        absolute: path.join(root, item),
+        relative: item
+      };
+    });
+    const list = await this._findWebApiFile(fullPathFiles);
+    if (!list) {
+      return files;
+    }
+    return list;
+  }
+  /**
+   * Reads all files and looks for 'RAML 0.8' or 'RAML 1.0' header which
+   * is a WebApi.
+   * @param {Array<String>} files List of candidates
+   * @param {?Array<Object>} results List od results
+   * @return {Promise<String>}
+   */
+  async _findWebApiFile(files, results) {
+    if (!results) {
+      results = [];
+    }
+    const f = files.shift();
+    if (!f) {
+      if (!results.length) {
+        results = undefined;
+      }
+      if (results && results.length === 1) {
+        results = results[0];
+      }
+      return results;
+    }
+    try {
+      const type = await this._readApiType(f.absolute);
+      if (type && type.type) {
+        /* eslint-disable-next-line require-atomic-updates */
+        results[results.length] = f.relative;
+      }
+      return await this._findWebApiFile(files, results);
+    } catch (e) {
+      console.warn('Unable to find file type', e);
+    }
+  }
+  /**
+   * Reads API type from the API main file.
+   * @param {String} file File location
+   * @return {Promise}
+   */
+  async _readApiType(file) {
+    const size = 100;
+    // todo (pawel): This works 100% for RAML files as they have to have a
+    // type and version in the file header. However JSON OAS can have version
+    // definition anythere in the JSON object. It works for lot of APIs
+    // but it may be broken for some APIs.
+    // It should read and parse JSON files and look for the version value.
+    // Leaving it here for performance reasons.
+    const fd = await fs.open(file, 'r');
+    const result = await fs.read(fd, Buffer.alloc(size), 0, size, 0);
+    await fs.close(fd);
+    const data = result.buffer.toString().trim();
+    if (data[0] === '{') {
+      // OAS 1/2
+      const match = data.match(/"swagger"(?:\s*)?:(?:\s*)"(.*)"/im);
+      if (!match) {
+        throw new Error('Expected OAS but could not find version header.');
+      }
+      const v = match[1].trim();
+      return {
+        type: `OAS ${v}`,
+        contentType: 'application/json'
+      };
+    }
+    const oasMatch = data.match(/openapi(?:\s*)?:(?:\s*)"?(\d\.\d*)"?/im);
+    if (oasMatch) {
+      const v = oasMatch[1].trim();
+      return {
+        type: `OAS ${v}`,
+        contentType: 'application/yaml'
+      };
+    }
+    const header = data.split('\n')[0].substr(2).trim();
+    if (!header || header.indexOf('RAML ') !== 0) {
+      throw new Error('The API file header is unknown');
+    }
+    if (header === 'RAML 1.0' || header === 'RAML 0.8') {
+      return {
+        type: header,
+        contentType: 'application/raml'
+      };
+    }
+    if (header.indexOf('RAML 1.0 Overlay') === 0 ||
+      header.indexOf('RAML 1.0 Extension') === 0) {
+      return {
+        type: 'RAML 1.0',
+        contentType: 'application/raml'
+      };
+    }
+    throw new Error('Unsupported API file');
+  }
+}
diff --git a/demo/demo-server/api/api-parser.js b/demo/demo-server/api/api-parser.js
new file mode 100644
index 000000000..e754031eb
--- /dev/null
+++ b/demo/demo-server/api/api-parser.js
@@ -0,0 +1,156 @@
+import { AmfService } from './amf-service/amf-service.js';
+import NodeCache from 'node-cache';
+import uuidv4 from 'uuid/v4.js';
+
+export class ApiParser {
+  async parseFile(request) {
+    const buff = await this.readIncommingMessage(request);
+    const data = await this.processBuffer(buff);
+    return data;
+  }
+
+  get store() {
+    if (!this._store) {
+      this._store = new NodeCache({
+        stdTTL: 300,
+        checkperiod: 120,
+        useClones: false
+      });
+
+      this._store.on('expired', this._cacheExpired.bind(this));
+    }
+    return this._store;
+  }
+
+  get service() {
+    if (!this._amfService) {
+      this._amfService = new AmfService();
+    }
+    return this._amfService;
+  }
+
+  /**
+   * Parses API data to AMF model.
+   * @param {Buffer} buffer Buffer created from API file.
+   * @param {Object} opts Processing options:
+   * - zip {Boolean} If true the buffer represents zipped file.
+   * @return {Promise<Object>} Promise resolved to the AMF json-ld model
+   */
+  async processBuffer(buffer, opts) {
+    if (this._bufferIsZip(buffer)) {
+      if (!opts) {
+        opts = {};
+      }
+      opts.zip = true;
+    }
+    const service = this.service;
+    service.setSource(buffer, opts);
+
+    await service.prepare();
+    const candidates = await service.resolve();
+    if (candidates) {
+      const key = uuidv4();
+      const { workingDir, tmpobj } = service;
+      this.store.set(key, [workingDir, tmpobj]);
+      return {
+        code: 300, // Multiple Choices
+        data: {
+          candidates,
+          key
+        }
+      };
+    } else {
+      // TODO (pawel): The API should return 201 and the key to use
+      // the retreive the data later. The API processing should be async.
+      const api = await service.parse();
+      return {
+        code: 200, // OK, should be 202 accepted
+        data: {
+          api
+        }
+      };
+    }
+  }
+
+  /**
+   * Tests if the buffer has ZIP file header.
+   * @param {Buffer} buffer File buffer
+   * @return {Boolean} true if the buffer is compressed zip.
+   */
+  _bufferIsZip(buffer) {
+    return buffer[0] === 0x50 && buffer[1] === 0x4b;
+  }
+
+  async readIncommingMessage(request) {
+    return new Promise((resolve) => {
+      let message;
+      request.on('data', (chunk) => {
+        if (message) {
+          message = Buffer.concat(message, chunk);
+        } else {
+          message = chunk;
+        }
+      });
+
+      request.on('end', () => {
+        resolve(message);
+      });
+    });
+  }
+
+  checkStatus(id) {
+    console.log(id);
+  }
+
+  async parseCandidate(request) {
+    const buff = await this.readIncommingMessage(request);
+    let message = buff.toString();
+    try {
+      message = JSON.parse(message);
+    } catch (e) {
+      return {
+        error: true,
+        code: 400,
+        message: 'Unable to process the message',
+        detail: e.message
+      };
+    }
+    const { key, file } = message;
+    if (!key) {
+      return {
+        error: true,
+        code: 400,
+        message: 'The "key" property is missing',
+        detail: 'Provide "key" property which you have got from parse API request.'
+      };
+    }
+    const value = this.store.get(key);
+    if (!value) {
+      return {
+        error: true,
+        code: 410, // Gone
+        message: 'The API files are no longer available.',
+        detail: 'The cache for the API files expired and no longer available. Try all over.'
+      };
+    }
+    this.store.del(key);
+    const service = this.service;
+    const [workingDir, tmpobj] = value;
+    service.workingDir = workingDir;
+    service.tmpobj = tmpobj;
+    const api = await service.parse(file);
+    return {
+      code: 200, // OK, should be 202 accepted
+      data: {
+        api
+      }
+    };
+  }
+
+  async _cacheExpired(key, value) {
+    const [workingDir, tmpobj] = value;
+    this.service.workingDir = workingDir;
+    this.service.tmpobj = tmpobj;
+    await this.service._cleanTempFiles();
+  }
+}
diff --git a/demo/demo-server/app.js b/demo/demo-server/app.js
index 2d994dc7a..cf911431b 100644
--- a/demo/demo-server/app.js
+++ b/demo/demo-server/app.js
@@ -3,7 +3,7 @@ import { createConfig, startServer } from 'es-dev-server';
 import { demoApi } from './api.js';
 
 const config = createConfig({
-  // port: 8082,
+  port: 8001,
   watch: true,
   nodeResolve: true,
   appIndex: 'demo/index.html',
@@ -14,4 +14,5 @@ const config = createConfig({
     demoApi
   ]
 });
+config.openBrowser = true;
 startServer(config);
diff --git a/demo/helpers/upload-api-screen.js b/demo/helpers/upload-api-screen.js
index 2c4d87097..623a348cb 100644
--- a/demo/helpers/upload-api-screen.js
+++ b/demo/helpers/upload-api-screen.js
@@ -52,12 +52,6 @@ class UploadApiScreen extends LitElement {
       font-size: 1.2rem;
     }
 
-    .intro {
-      margin: 40px 0;
-      font-size: 1.5rem;
-      color: #616161;
-    }
-
     code {
       background-color: #FFF8E1;
     }
@@ -171,10 +165,6 @@ class UploadApiScreen extends LitElement {
   render() {
     return html`
       <h1>Upload own API</h1>
-      <p class="intro">
-        <b>Before you begin</b>
-        run <code>npm run start:devserver</code> in the console to run API parsing server.
-      </p>
       <section role="main">
         <p class="drop-welcome">Drop your API file here</p>
         <p class="accept-info">
diff --git a/demo/standalone/app.js b/demo/standalone/app.js
index 68ca121dc..bed857c94 100644
--- a/demo/standalone/app.js
+++ b/demo/standalone/app.js
@@ -12,7 +12,8 @@ class ApicApplication extends DemoBase {
       ['google-drive-api', 'Google Drive API'],
       ['httpbin', 'HTTPbin API'],
       ['exchange-experience-api', 'Exchange Experience API'],
-      ['data-type-fragment', 'RAML data type fragment']
+      ['data-type-fragment', 'RAML data type fragment'],
+      ['demo-api', 'Demo API']
     ];
     // this.hasUploader = true;
   }
diff --git a/package-lock.json b/package-lock.json
index 64f23d651..b797764e3 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9438,6 +9438,16 @@
         "lower-case": "^1.1.1"
       }
     },
+    "node-cache": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/node-cache/-/node-cache-4.2.1.tgz",
+      "integrity": "sha512-BOb67bWg2dTyax5kdef5WfU3X8xu4wPg+zHzkvls0Q/QpYycIFRLEEIdAx9Wma43DxG6Qzn4illdZoYseKWa4A==",
+      "dev": true,
+      "requires": {
+        "clone": "2.x",
+        "lodash": "^4.17.15"
+      }
+    },
     "node-environment-flags": {
       "version": "1.0.5",
       "resolved": "https://registry.npmjs.org/node-environment-flags/-/node-environment-flags-1.0.5.tgz",
diff --git a/package.json b/package.json
index aea8b7ddd..4d27cd1f9 100644
--- a/package.json
+++ b/package.json
@@ -79,9 +79,11 @@
     "karma": "^4.2.0",
     "lint-staged": "^9.2.5",
     "multer": "^1.4.2",
+    "node-cache": "^4.2.1",
     "sinon": "^7.4.1",
     "tmp": "0.1.0",
     "unzipper": "^0.10.4",
+    "uuid": "^3.3.3",
     "web-animations-js": "^2.3.2"
   },
   "scripts": {