Typescript rewrite (#147)

* Updated highlight.js

* Update .codexdocsrc.sample

remove undefined page for a fresh new install

* backend rewritten in TS

* test -> TS, .added dockerignore, bug fixed

* Removed compiled js files, eslint codex/ts added

* fixed jsdocs warning, leaving editor confirmation

* use path.resolve for DB paths

* db drives updated + fixed User model

* redundant cleared + style fixed

* explicit type fixing

* fixing testing code

* added body block type

* compiled JS files -> dist, fixed compiling errors

* fixed compiling error, re-organized ts source code

* updated Dockerfile

* fixed link to parent page

* up nodejs version

* fix package name

* fix deps

Co-authored-by: nvc8996 <nvc.8996@gmail.com>
Co-authored-by: Taly <vitalik7tv@yandex.ru>

src/test/models/page.ts

@@ -0,0 +1,394 @@
+import { expect } from 'chai';
+import fs from 'fs';
+import path from 'path';
+import config from 'config';
+import Page from '../../backend/models/page';
+import translateString from '../../backend/utils/translation';
+import database from '../../backend/utils/database';
+
+const pages = database['pages'];
+
+describe('Page model', () => {
+  const transformToUri = (text: string): string => {
+    return translateString(text
+      .replace(/ /g, ' ')
+      .replace(/[^a-zA-Z0-9А-Яа-яЁё ]/g, ' ')
+      .replace(/  +/g, ' ')
+      .trim()
+      .toLowerCase()
+      .split(' ')
+      .join('-'));
+  };
+
+  after(() => {
+    const pathToDB = path.resolve(__dirname, '../../../', config.get('database'), './pages.db');
+
+    if (fs.existsSync(pathToDB)) {
+      fs.unlinkSync(pathToDB);
+    }
+  });
+
+  it('Working with empty model', async () => {
+    let page = new Page();
+
+    expect(page.data).to.be.a('object');
+
+    let {data} = page;
+
+    expect(data._id).to.be.undefined;
+    expect(data.title).to.be.empty;
+    expect(data.uri).to.be.empty;
+    expect(data.body).to.be.undefined;
+    expect(data.parent).to.be.equal('0');
+
+    page = new Page();
+
+    data = page.data;
+
+    expect(data._id).to.be.undefined;
+    expect(data.title).to.be.empty;
+    expect(data.uri).to.be.empty;
+    expect(data.body).to.be.undefined;
+    expect(data.parent).to.be.equal('0');
+
+    const initialData = {
+      _id: 'page_id',
+      body: {
+        blocks: [
+          {
+            type: 'header',
+            data: {
+              text: 'Page header'
+            }
+          }
+        ]
+      }
+    };
+
+    page = new Page(initialData);
+
+    const json = page.toJSON();
+
+    data = page.data;
+
+    expect(data._id).to.equal(initialData._id);
+    expect(data.title).to.equal(initialData.body.blocks[0].data.text);
+    expect(data.uri).to.be.empty;
+    expect(data.body).to.deep.equal(initialData.body);
+    expect(data.parent).to.be.equal('0');
+
+    expect(json._id).to.equal(initialData._id);
+    expect(json.title).to.equal(initialData.body.blocks[0].data.text);
+    expect(json.title).to.equal(initialData.body.blocks[0].data.text);
+    expect(json.body).to.deep.equal(initialData.body);
+    expect(json.parent).to.be.equal('0');
+
+    const update = {
+      _id: '12345',
+      body: {
+        blocks: [
+          {
+            type: 'header',
+            data: {
+              text: 'Updated page header'
+            }
+          }
+        ]
+      }
+    };
+
+    page.data = update;
+
+    data = page.data;
+
+    expect(data._id).to.equal(initialData._id);
+    expect(data.title).to.equal(update.body.blocks[0].data.text);
+    expect(data.uri).to.be.empty;
+    expect(data.body).to.equal(update.body);
+    expect(data.parent).to.be.equal('0');
+  });
+
+  it('Saving, updating and deleting model in the database', async () => {
+    const initialData = {
+      body: {
+        blocks: [
+          {
+            type: 'header',
+            data: {
+              text: 'New page header'
+            }
+          }
+        ]
+      }
+    };
+    const page = new Page(initialData);
+
+    const savedPage = await page.save();
+
+    expect(savedPage._id).not.be.undefined;
+    expect(savedPage.title).to.equal(initialData.body.blocks[0].data.text);
+    expect(savedPage.uri).to.equal(transformToUri(initialData.body.blocks[0].data.text));
+    expect(savedPage.body).to.equal(initialData.body);
+    expect(page._id).not.be.undefined;
+
+    const insertedPage = await pages.findOne({_id: page._id});
+
+    expect(insertedPage._id).to.equal(page._id);
+    expect(insertedPage.title).to.equal(page.title);
+    expect(insertedPage.uri).to.equal(page.uri);
+    expect(insertedPage.body).to.deep.equal(page.body);
+
+    const updateData = {
+      body: {
+        blocks: [
+          {
+            type: 'header',
+            data: {
+              text: 'Updated page header'
+            }
+          }
+        ]
+      },
+      uri: 'updated-uri'
+    };
+
+    page.data = updateData;
+    await page.save();
+
+    expect(page._id).to.equal(insertedPage._id);
+
+    const updatedPage = await pages.findOne({_id: page._id});
+
+    expect(updatedPage._id).to.equal(savedPage._id);
+    expect(updatedPage.title).to.equal(updateData.body.blocks[0].data.text);
+    expect(updatedPage.uri).to.equal(updateData.uri);
+    expect(updatedPage.body).to.deep.equal(updateData.body);
+
+    await page.destroy();
+
+    expect(page._id).to.be.undefined;
+
+    const removedPage = await pages.findOne({_id: updatedPage._id});
+
+    expect(removedPage).to.be.null;
+  });
+
+  it('Handle multiple page creation with the same uri', async () => {
+    const initialData = {
+      body: {
+        blocks: [
+          {
+            type: 'header',
+            data: {
+              text: 'New page header'
+            }
+          }
+        ]
+      }
+    };
+    const firstPage = new Page(initialData);
+    let firstSavedPage = await firstPage.save();
+    const secondPage = new Page(initialData);
+    const secondSavedPage = await secondPage.save();
+
+    expect(secondSavedPage.uri).to.equal(transformToUri(initialData.body.blocks[0].data.text) + '-1');
+
+    const newUri = 'new-uri';
+
+    firstPage.data = {...firstPage.data, uri: newUri};
+    firstSavedPage = await firstPage.save();
+
+    expect(firstSavedPage.uri).to.equal(newUri);
+
+    const thirdPage = new Page(initialData);
+    const thirdSavedPage = await thirdPage.save();
+
+    expect(thirdSavedPage.uri).to.equal(transformToUri(initialData.body.blocks[0].data.text));
+  });
+
+  it('Static get method', async () => {
+    const initialData = {
+      body: {
+        blocks: [
+          {
+            type: 'header',
+            data: {
+              text: 'Test Page header'
+            }
+          }
+        ]
+      }
+    };
+    const page = new Page(initialData);
+
+    const savedPage = await page.save();
+
+    if (savedPage._id == undefined) {
+      await page.destroy();
+
+      return;
+    }
+
+    const foundPage = await Page.get(savedPage._id);
+
+    const {data} = foundPage;
+
+    expect(data._id).to.equal(savedPage._id);
+    expect(data.title).to.equal(initialData.body.blocks[0].data.text);
+    expect(data.uri).to.equal(transformToUri(initialData.body.blocks[0].data.text));
+    expect(data.body).to.deep.equal(initialData.body);
+
+    await page.destroy();
+  });
+
+  it('Static getAll method', async () => {
+    const pagesToSave = [
+      new Page({
+        body: {
+          blocks: [
+            {
+              type: 'header',
+              data: {
+                text: 'Page 1 header'
+              }
+            }
+          ]
+        }
+      }),
+      new Page({
+        body: {
+          blocks: [
+            {
+              type: 'header',
+              data: {
+                text: 'Page 2 header'
+              }
+            }
+          ]
+        }
+      })
+    ];
+
+    const savedPages = await Promise.all(pagesToSave.map(page => page.save()));
+
+    const foundPages = await Page.getAll({_id: {$in: savedPages.map(page => page._id)}});
+
+    expect(foundPages.length).to.equal(2);
+    foundPages.forEach((page, i) => {
+      expect(page.title).to.equal(pagesToSave[i].body.blocks[0].data.text);
+      expect(page.uri).to.equal(transformToUri(pagesToSave[i].body.blocks[0].data.text));
+      expect(page.body).to.deep.equal(pagesToSave[i].body);
+    });
+  });
+
+  it('Parent pages', async () => {
+    const parent = new Page(
+      {
+        body: {
+          blocks: [
+            {
+              type: 'header',
+              data: {
+                text: 'Parent page header'
+              }
+            }
+          ]
+        }
+      }
+    );
+    const {_id: parentId} = await parent.save();
+
+    const child = new Page(
+      {
+        body: {
+          blocks: [
+            {
+              type: 'header',
+              data: {
+                text: 'Child page header'
+              }
+            }
+          ]
+        },
+        parent: parentId,
+      }
+    );
+
+    const {_id: childId} = await child.save();
+
+    const testedParent = await child.getParent();
+
+    expect(testedParent).to.be.not.null;
+    if (testedParent) {
+      expect(testedParent._id).to.equal(parentId);
+      expect(testedParent.title).to.equal(parent.body.blocks[0].data.text);
+      expect(testedParent.uri).to.equal(transformToUri(parent.body.blocks[0].data.text));
+      expect(testedParent.body).to.deep.equal(parent.body);
+    }
+
+    const children = await parent.children;
+
+    expect(children.length).to.equal(1);
+
+    const temp: Page|undefined = children.pop();
+    const testedChild: Page = !temp ? new Page({}) : temp;
+
+    expect(testedChild._id).to.equal(childId);
+    expect(testedChild.title).to.equal(child.body.blocks[0].data.text);
+    expect(testedChild.uri).to.equal(transformToUri(child.body.blocks[0].data.text));
+    expect(testedChild.body).to.deep.equal(child.body);
+    expect(testedChild._parent).to.equal(child._parent);
+    expect(testedChild._parent).to.equal(parent._id);
+
+    parent.destroy();
+    child.destroy();
+  });
+
+  it('Extracting title from page body', async () => {
+    const pageData = {
+      body: {
+        blocks: [
+          {
+            type: 'header',
+            data: {
+              text: 'Page header'
+            }
+          }
+        ]
+      }
+    };
+
+    const page = new Page(pageData);
+
+    expect(page.title).to.equal(pageData.body.blocks[0].data.text);
+  });
+
+  it('test deletion', async () => {
+    const pageIndexes = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
+    const orders = {
+      '0' : ['1', '2', '3'],
+      '1' : ['4', '5'],
+      '5' : ['6', '7', '8'],
+      '3' : ['9'],
+    } as { [key: string]: string[] };
+
+    function deleteRecursively(startFrom: string): void {
+      const order: string[] = orders[startFrom];
+
+      if (!order) {
+        const found = pageIndexes.indexOf(startFrom);
+
+        pageIndexes.splice(found, 1);
+
+        return;
+      }
+
+      order.forEach(id => {
+        deleteRecursively(id);
+      });
+
+      const found = pageIndexes.indexOf(startFrom);
+      pageIndexes.splice(found, 1);
+    }
+  });
+});