From 76f05fe2749808daf2c7bb226bee25719813f154 Mon Sep 17 00:00:00 2001
From: Y-k-Y <zzzzz.co.kr@gmail.com>
Date: Thu, 28 Apr 2022 02:21:10 +0900
Subject: [PATCH 1/9] fix: fix order of page categories with raw type

---
 src/backend/models/page.ts | 40 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 38 insertions(+), 2 deletions(-)

diff --git a/src/backend/models/page.ts b/src/backend/models/page.ts
index d90b1869..3983395a 100644
--- a/src/backend/models/page.ts
+++ b/src/backend/models/page.ts
@@ -84,9 +84,45 @@ class Page {
    * @returns {Promise<Page[]>}
    */
   public static async getAll(query: Record<string, unknown> = {}): Promise<Page[]> {
-    const docs = await pagesDb.find(query);
+    const result: PageData[] = [];
+    const obj = {};
+    let docs = await pagesDb.find(query);
 
-    return Promise.all(docs.map(doc => new Page(doc)));
+    docs = docs.sort((a, b) => {
+      if (a.body.time > b.body.time) {
+        return 1;
+      }
+
+      if (a.body.time < b.body.time) {
+        return -1;
+      }
+
+      return 0;
+    });
+    docs.forEach(doc => {
+      if(doc.parent === '0') {
+        // @ts-ignore
+        obj[doc._id] = [];
+        // @ts-ignore
+        obj[doc._id].push(doc);
+      } else {
+        // @ts-ignore
+        obj[doc._id] = [];
+        // @ts-ignore
+        obj[doc.parent].push(doc);
+      }
+    });
+    Object.entries(obj).forEach(([key, value]) => {
+      // @ts-ignore
+      if(!key || value.length <=0) {
+        return;
+      } else {
+        // @ts-ignore
+        result.push(...value);
+      }
+    });
+
+    return Promise.all(result.map(doc => new Page(doc)));
   }
 
   /**

From 7603f727f0ec53b55213e78eabbc042147d25618 Mon Sep 17 00:00:00 2001
From: Y-k-Y <zzzzz.co.kr@gmail.com>
Date: Thu, 28 Apr 2022 22:36:30 +0900
Subject: [PATCH 2/9] refactor: change method location and others

---
 src/backend/controllers/pages.ts  | 41 +++++++++++++++++++++++++++++++
 src/backend/models/page.ts        | 40 ++----------------------------
 src/backend/routes/pages.ts       |  3 ++-
 src/backend/views/pages/form.twig |  2 +-
 4 files changed, 46 insertions(+), 40 deletions(-)

diff --git a/src/backend/controllers/pages.ts b/src/backend/controllers/pages.ts
index 6a4bd075..59f8c33c 100644
--- a/src/backend/controllers/pages.ts
+++ b/src/backend/controllers/pages.ts
@@ -62,6 +62,47 @@ class Pages {
     return nullFilteredPages;
   }
 
+  /**
+   * Group given pages with descending order of creation time
+   *
+   * @param {pages[]} pages - pages to group
+   * @returns {Page[]}
+   */
+  public static group(pages: Page[]): Page[] {
+    const result: Page[] = [];
+    const obj:Record<string, Array<Page>> = {};
+
+    pages.sort((a, b) => {
+      if (a.body.time > b.body.time) {
+        return 1;
+      }
+
+      if (a.body.time < b.body.time) {
+        return -1;
+      }
+
+      return 0;
+    }).forEach(doc => {
+      if (doc._parent === '0' && typeof doc._id === 'string') {
+        obj[doc._id] = [];
+        obj[doc._id].push(doc);
+      } else if (doc._parent !== '0' && doc._parent && doc._id) {
+        obj[doc._id] = [];
+        obj[doc._parent].push(doc);
+      }
+    });
+
+    Object.entries(obj).forEach(([, value]) => {
+      if (value.length <=0) {
+        return;
+      } else {
+        result.push(...value);
+      }
+    });
+
+    return result;
+  }
+
   /**
    * Set all children elements to null
    *
diff --git a/src/backend/models/page.ts b/src/backend/models/page.ts
index 3983395a..d90b1869 100644
--- a/src/backend/models/page.ts
+++ b/src/backend/models/page.ts
@@ -84,45 +84,9 @@ class Page {
    * @returns {Promise<Page[]>}
    */
   public static async getAll(query: Record<string, unknown> = {}): Promise<Page[]> {
-    const result: PageData[] = [];
-    const obj = {};
-    let docs = await pagesDb.find(query);
+    const docs = await pagesDb.find(query);
 
-    docs = docs.sort((a, b) => {
-      if (a.body.time > b.body.time) {
-        return 1;
-      }
-
-      if (a.body.time < b.body.time) {
-        return -1;
-      }
-
-      return 0;
-    });
-    docs.forEach(doc => {
-      if(doc.parent === '0') {
-        // @ts-ignore
-        obj[doc._id] = [];
-        // @ts-ignore
-        obj[doc._id].push(doc);
-      } else {
-        // @ts-ignore
-        obj[doc._id] = [];
-        // @ts-ignore
-        obj[doc.parent].push(doc);
-      }
-    });
-    Object.entries(obj).forEach(([key, value]) => {
-      // @ts-ignore
-      if(!key || value.length <=0) {
-        return;
-      } else {
-        // @ts-ignore
-        result.push(...value);
-      }
-    });
-
-    return Promise.all(result.map(doc => new Page(doc)));
+    return Promise.all(docs.map(doc => new Page(doc)));
   }
 
   /**
diff --git a/src/backend/routes/pages.ts b/src/backend/routes/pages.ts
index 82c81078..174abb95 100644
--- a/src/backend/routes/pages.ts
+++ b/src/backend/routes/pages.ts
@@ -12,9 +12,10 @@ const router = express.Router();
 router.get('/page/new', verifyToken, allowEdit, async (req: Request, res: Response, next: NextFunction) => {
   try {
     const pagesAvailable = await Pages.getAll();
+    const groupedPagesAvailable = Pages.group(pagesAvailable);
 
     res.render('pages/form', {
-      pagesAvailable,
+      groupedPagesAvailable,
       page: null,
     });
   } catch (error) {
diff --git a/src/backend/views/pages/form.twig b/src/backend/views/pages/form.twig
index 2e3bc13e..cb56940a 100644
--- a/src/backend/views/pages/form.twig
+++ b/src/backend/views/pages/form.twig
@@ -22,7 +22,7 @@
         {% endif %}
           <select name="parent">
             <option value="0">Root</option>
-            {% for _page in pagesAvailable %}
+            {% for _page in groupedPagesAvailable %}
               {% if _page._id != currentPageId %}
                 <option value="{{ _page._id }}" {{ page is not empty and page._parent == _page._id ? 'selected' : ''}}>
                   {% if _page._parent != "0" %}

From 5a1be35d719bf2b34999d2dfdd3856e4c70b1e51 Mon Sep 17 00:00:00 2001
From: Y-k-Y <zzzzz.co.kr@gmail.com>
Date: Fri, 29 Apr 2022 10:02:00 +0900
Subject: [PATCH 3/9] refactor: fix method names and variables also split
 methods to be clear their role

---
 src/backend/controllers/pages.ts | 59 +++++++++++++++++++++++---------
 src/backend/routes/pages.ts      |  3 +-
 2 files changed, 44 insertions(+), 18 deletions(-)

diff --git a/src/backend/controllers/pages.ts b/src/backend/controllers/pages.ts
index 59f8c33c..da597668 100644
--- a/src/backend/controllers/pages.ts
+++ b/src/backend/controllers/pages.ts
@@ -63,16 +63,13 @@ class Pages {
   }
 
   /**
-   * Group given pages with descending order of creation time
+   * Sort given pages with descending order of creation time
    *
-   * @param {pages[]} pages - pages to group
-   * @returns {Page[]}
+   * @param {pages[]} pages - pages to sort
+   * @returns {page[]}
    */
-  public static group(pages: Page[]): Page[] {
-    const result: Page[] = [];
-    const obj:Record<string, Array<Page>> = {};
-
-    pages.sort((a, b) => {
+  public static sortByTimeDesc(pages: Page[]): Page[] {
+    return pages.sort((a, b) => {
       if (a.body.time > b.body.time) {
         return 1;
       }
@@ -82,18 +79,36 @@ class Pages {
       }
 
       return 0;
-    }).forEach(doc => {
-      if (doc._parent === '0' && typeof doc._id === 'string') {
-        obj[doc._id] = [];
-        obj[doc._id].push(doc);
-      } else if (doc._parent !== '0' && doc._parent && doc._id) {
-        obj[doc._id] = [];
-        obj[doc._parent].push(doc);
+    });
+  }
+
+
+  /**
+   * Group given pages by their parents
+   *
+   * @param {pages[]} pages - pages to group
+   * @returns {Page[]}
+   */
+  public static groupByParent(pages: Page[]): Page[] {
+    const result: Page[] = [];
+    const pagesGroupedByParent:Record<string, Array<Page>> = {};
+
+    pages.forEach(page => {
+      pagesGroupedByParent[String(page._id)] = [];
+
+      if (this.isRootPage(page)) {
+        pagesGroupedByParent[String(page._id)].push(page);
+      } else {
+        pagesGroupedByParent[String(page._parent)].push(page);
       }
     });
 
-    Object.entries(obj).forEach(([, value]) => {
-      if (value.length <=0) {
+    /**
+     * It converts grouped object to array
+     * Also removes redundant keys when there is no children
+     */
+    Object.entries(pagesGroupedByParent).forEach(([, value]) => {
+      if (value.length <= 0) {
         return;
       } else {
         result.push(...value);
@@ -244,6 +259,16 @@ class Pages {
       throw new Error('Please, fill page Header');
     }
   }
+
+  /**
+   * Check if the given page is root
+   *
+   * @param {page} page - page to check
+   * @returns {boolean}
+   */
+  private static isRootPage(page:Page):boolean {
+    return page._parent === '0';
+  }
 }
 
 export default Pages;
diff --git a/src/backend/routes/pages.ts b/src/backend/routes/pages.ts
index 174abb95..1efcc4f6 100644
--- a/src/backend/routes/pages.ts
+++ b/src/backend/routes/pages.ts
@@ -12,7 +12,8 @@ const router = express.Router();
 router.get('/page/new', verifyToken, allowEdit, async (req: Request, res: Response, next: NextFunction) => {
   try {
     const pagesAvailable = await Pages.getAll();
-    const groupedPagesAvailable = Pages.group(pagesAvailable);
+    const sortedPagesAvailable = Pages.sortByTimeDesc(pagesAvailable);
+    const groupedPagesAvailable = Pages.groupByParent(sortedPagesAvailable);
 
     res.render('pages/form', {
       groupedPagesAvailable,

From 8a7242d36470f5629a6aeae5153ea33c17f1b629 Mon Sep 17 00:00:00 2001
From: Y-k-Y <zzzzz.co.kr@gmail.com>
Date: Fri, 29 Apr 2022 10:05:23 +0900
Subject: [PATCH 4/9] fix: fix variable name

---
 src/backend/routes/pages.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/backend/routes/pages.ts b/src/backend/routes/pages.ts
index 1efcc4f6..41869e5b 100644
--- a/src/backend/routes/pages.ts
+++ b/src/backend/routes/pages.ts
@@ -12,11 +12,11 @@ const router = express.Router();
 router.get('/page/new', verifyToken, allowEdit, async (req: Request, res: Response, next: NextFunction) => {
   try {
     const pagesAvailable = await Pages.getAll();
-    const sortedPagesAvailable = Pages.sortByTimeDesc(pagesAvailable);
-    const groupedPagesAvailable = Pages.groupByParent(sortedPagesAvailable);
+    const pagesAvailableSorted = Pages.sortByTimeDesc(pagesAvailable);
+    const pagesAvailableGrouped = Pages.groupByParent(pagesAvailableSorted);
 
     res.render('pages/form', {
-      groupedPagesAvailable,
+      pagesAvailableGrouped,
       page: null,
     });
   } catch (error) {

From 45d9e501d25089228af15ccdbefca892eefef406 Mon Sep 17 00:00:00 2001
From: Y-k-Y <zzzzz.co.kr@gmail.com>
Date: Sun, 1 May 2022 01:15:16 +0900
Subject: [PATCH 5/9] fix: change the method to group of pages

---
 src/backend/controllers/pages.ts      | 136 ++++++++++++++++----------
 src/backend/controllers/pagesOrder.ts |  18 ++++
 src/backend/models/pageOrder.ts       |  22 +++++
 src/backend/routes/pages.ts           |   7 +-
 src/backend/views/pages/form.twig     |   2 +-
 src/test/models/pageOrder.ts          |  27 +++++
 6 files changed, 155 insertions(+), 57 deletions(-)

diff --git a/src/backend/controllers/pages.ts b/src/backend/controllers/pages.ts
index da597668..ed5478c9 100644
--- a/src/backend/controllers/pages.ts
+++ b/src/backend/controllers/pages.ts
@@ -1,5 +1,7 @@
 import Page, { PageData } from '../models/page';
 import Alias from '../models/alias';
+import PagesOrder from './pagesOrder';
+import PageOrder from '../models/pageOrder';
 
 type PageDataFields = keyof PageData;
 
@@ -63,59 +65,99 @@ class Pages {
   }
 
   /**
-   * Sort given pages with descending order of creation time
+   * Group all pages by their parents
+   * If the pageId is passed, it excludes passed page from result pages
    *
-   * @param {pages[]} pages - pages to sort
-   * @returns {page[]}
-   */
-  public static sortByTimeDesc(pages: Page[]): Page[] {
-    return pages.sort((a, b) => {
-      if (a.body.time > b.body.time) {
-        return 1;
-      }
-
-      if (a.body.time < b.body.time) {
-        return -1;
-      }
-
-      return 0;
-    });
-  }
-
-
-  /**
-   * Group given pages by their parents
-   *
-   * @param {pages[]} pages - pages to group
+   * @param {string} pageId - pageId to exclude from result pages
    * @returns {Page[]}
    */
-  public static groupByParent(pages: Page[]): Page[] {
+  public static async groupByParent(pageId = ''): Promise<Page[]> {
     const result: Page[] = [];
-    const pagesGroupedByParent:Record<string, Array<Page>> = {};
+    const orderGroupedByParent: Record<string, string[]> = {};
+    const rootPageOrder = await PagesOrder.getRootPageOrder();
+    const childPageOrder = await PagesOrder.getChildPageOrder();
+    const orphanPageOrder: PageOrder[] = [];
 
-    pages.forEach(page => {
-      pagesGroupedByParent[String(page._id)] = [];
+    /**
+     * If there is no root nad child page order, then it returns empty array
+     */
+    if (!rootPageOrder || (!rootPageOrder && childPageOrder.length <= 0)) {
+      return [];
+    }
 
-      if (this.isRootPage(page)) {
-        pagesGroupedByParent[String(page._id)].push(page);
-      } else {
-        pagesGroupedByParent[String(page._parent)].push(page);
-      }
-    });
+    const pages = (await this.getAll()).reduce((map, _page) => {
+      map.set(_page._id, _page);
+
+      return map;
+    }, new Map);
+    const rootPagesId = rootPageOrder.order;
 
     /**
-     * It converts grouped object to array
-     * Also removes redundant keys when there is no children
+     * It groups root pages and 1 level pages by its parent
      */
-    Object.entries(pagesGroupedByParent).forEach(([, value]) => {
-      if (value.length <= 0) {
-        return;
+    rootPagesId.reduce((prev, curr, idx) => {
+      const childPages = childPageOrder.filter((child, _idx) => {
+        if (child.page === curr) {
+          childPageOrder.splice(_idx, 1);
+
+          return child;
+        }
+      });
+      const hasChildPage = childPages.length > 0;
+
+      if (hasChildPage) {
+        prev[curr] = [];
+        prev[curr].push(curr);
+        prev[curr].push(...childPages[0].order);
       } else {
-        result.push(...value);
+        prev[curr] = [];
+        prev[curr].push(curr);
       }
-    });
 
-    return result;
+      if (idx === rootPagesId.length - 1 && childPageOrder.length > 0) {
+        orphanPageOrder.push(...childPageOrder);
+      }
+
+      return prev;
+    }, orderGroupedByParent);
+
+    /**
+     * It groups remained ungrouped pages by its parent
+     */
+    while (orphanPageOrder.length > 0) {
+      orphanPageOrder.forEach((orphanOrder, idx) => {
+        Object.entries(orderGroupedByParent).forEach(([key, value]) => {
+          if (orphanOrder.page && orphanOrder.order && value.includes(orphanOrder.page)) {
+            orderGroupedByParent[key].splice(value.indexOf(orphanOrder.page) + 1, 0, ...orphanOrder.order);
+            orphanPageOrder.splice(idx, 1);
+          }
+        });
+      });
+    }
+
+    /**
+     * It converts grouped pages(object) to array
+     */
+    Object.values(orderGroupedByParent).flatMap(arr => [ ...arr ])
+      .forEach(arr => {
+        result.push(pages.get(arr));
+      });
+
+    /**
+     * If the pageId passed, it excludes itself from result pages
+     * Otherwise just returns result itself
+     */
+    if (pageId) {
+      return this.removeChildren(result, pageId).reduce((prev, curr) => {
+        if (curr instanceof Page) {
+          prev.push(curr);
+        }
+
+        return prev;
+      }, Array<Page>());
+    } else {
+      return result;
+    }
   }
 
   /**
@@ -125,7 +167,7 @@ class Pages {
    * @param {string} parent - id of parent page
    * @returns {Array<?Page>}
    */
-  public static removeChildren(pagesAvailable: Array<Page|null>, parent: string | undefined): Array<Page | null> {
+  public static removeChildren(pagesAvailable: Array<Page | null>, parent: string | undefined): Array<Page | null> {
     pagesAvailable.forEach(async (item, index) => {
       if (item === null || item._parent !== parent) {
         return;
@@ -259,16 +301,6 @@ class Pages {
       throw new Error('Please, fill page Header');
     }
   }
-
-  /**
-   * Check if the given page is root
-   *
-   * @param {page} page - page to check
-   * @returns {boolean}
-   */
-  private static isRootPage(page:Page):boolean {
-    return page._parent === '0';
-  }
 }
 
 export default Pages;
diff --git a/src/backend/controllers/pagesOrder.ts b/src/backend/controllers/pagesOrder.ts
index f084af30..846c9ac3 100644
--- a/src/backend/controllers/pagesOrder.ts
+++ b/src/backend/controllers/pagesOrder.ts
@@ -33,6 +33,24 @@ class PagesOrder {
     return PageOrder.getAll();
   }
 
+  /**
+   * Returns only root page's order
+   *
+   * @returns {Promise<PageOrder[]>}
+   */
+  public static async getRootPageOrder(): Promise<PageOrder> {
+    return PageOrder.getRootPageOrder();
+  }
+
+  /**
+   * Returns only child page's order
+   *
+   * @returns {Promise<PageOrder[]>}
+   */
+  public static async getChildPageOrder(): Promise<PageOrder[]> {
+    return PageOrder.getChildPageOrder();
+  }
+
   /**
    * Pushes the child page to the parent's order list
    *
diff --git a/src/backend/models/pageOrder.ts b/src/backend/models/pageOrder.ts
index 761fc6a8..bf1df32e 100644
--- a/src/backend/models/pageOrder.ts
+++ b/src/backend/models/pageOrder.ts
@@ -75,6 +75,28 @@ class PageOrder {
     return Promise.all(docs.map(doc => new PageOrder(doc)));
   }
 
+  /**
+   * Returns only root page's order
+   *
+   * @returns {Promise<PageOrder[]>}
+   */
+  public static async getRootPageOrder(): Promise<PageOrder> {
+    const docs = await this.getAll();
+
+    return docs.filter(doc => doc.page === '0')[0];
+  }
+
+  /**
+   * Returns only child page's order
+   *
+   * @returns {Promise<PageOrder[]>}
+   */
+  public static async getChildPageOrder(): Promise<PageOrder[]> {
+    const docs = await this.getAll();
+
+    return docs.filter(doc => doc.page !== '0');
+  }
+
   /**
    * constructor data setter
    *
diff --git a/src/backend/routes/pages.ts b/src/backend/routes/pages.ts
index 41869e5b..fe70f371 100644
--- a/src/backend/routes/pages.ts
+++ b/src/backend/routes/pages.ts
@@ -11,9 +11,7 @@ const router = express.Router();
  */
 router.get('/page/new', verifyToken, allowEdit, async (req: Request, res: Response, next: NextFunction) => {
   try {
-    const pagesAvailable = await Pages.getAll();
-    const pagesAvailableSorted = Pages.sortByTimeDesc(pagesAvailable);
-    const pagesAvailableGrouped = Pages.groupByParent(pagesAvailableSorted);
+    const pagesAvailableGrouped = await Pages.groupByParent();
 
     res.render('pages/form', {
       pagesAvailableGrouped,
@@ -34,6 +32,7 @@ router.get('/page/edit/:id', verifyToken, allowEdit, async (req: Request, res: R
   try {
     const page = await Pages.get(pageId);
     const pagesAvailable = await Pages.getAllExceptChildren(pageId);
+    const pagesAvailableGrouped = await Pages.groupByParent(pageId);
 
     if (!page._parent) {
       throw new Error('Parent not found');
@@ -44,7 +43,7 @@ router.get('/page/edit/:id', verifyToken, allowEdit, async (req: Request, res: R
     res.render('pages/form', {
       page,
       parentsChildrenOrdered,
-      pagesAvailable,
+      pagesAvailableGrouped,
     });
   } catch (error) {
     res.status(404);
diff --git a/src/backend/views/pages/form.twig b/src/backend/views/pages/form.twig
index cb56940a..91503e28 100644
--- a/src/backend/views/pages/form.twig
+++ b/src/backend/views/pages/form.twig
@@ -22,7 +22,7 @@
         {% endif %}
           <select name="parent">
             <option value="0">Root</option>
-            {% for _page in groupedPagesAvailable %}
+            {% for _page in pagesAvailableGrouped %}
               {% if _page._id != currentPageId %}
                 <option value="{{ _page._id }}" {{ page is not empty and page._parent == _page._id ? 'selected' : ''}}>
                   {% if _page._parent != "0" %}
diff --git a/src/test/models/pageOrder.ts b/src/test/models/pageOrder.ts
index 569af526..7a3bbe39 100644
--- a/src/test/models/pageOrder.ts
+++ b/src/test/models/pageOrder.ts
@@ -146,4 +146,31 @@ describe('PageOrder model', () => {
 
     await pageOrder.destroy();
   });
+
+  it('Testing get parents and children order methods', async () => {
+    const parentTestData = {
+      page: '0',
+      order: ['1', '2', '3', '4', '5'],
+    };
+    const childTestData = {
+      page: 'child',
+      order: ['a', 'b', 'c', 'd', 'e'],
+    };
+
+    const parentOrder = new PageOrder(parentTestData);
+    const childOrder = new PageOrder(childTestData);
+    const insertedParentOrder = await parentOrder.save();
+    const insertedChildOrder = await childOrder.save();
+    const fetchedParentOrder = await PageOrder.getRootPageOrder();
+    const fetchedChildOrder = await PageOrder.getChildPageOrder();
+
+    expect(fetchedParentOrder.page).to.deep.equals(parentTestData.page);
+    expect(fetchedParentOrder.order).to.deep.equal(parentTestData.order);
+    expect(fetchedChildOrder).to.be.an('array').that.is.length(1);
+    expect(fetchedChildOrder[0].page).to.deep.equals(childTestData.page);
+    expect(fetchedChildOrder[0].order).to.deep.equals(childTestData.order);
+
+    await insertedParentOrder.destroy();
+    await insertedChildOrder.destroy();
+  });
 });

From db0614c61440a7d773b73caefc5114e50805047c Mon Sep 17 00:00:00 2001
From: Y-k-Y <zzzzz.co.kr@gmail.com>
Date: Wed, 11 May 2022 22:40:32 +0900
Subject: [PATCH 6/9] refactor: replace filter metethod to querying database

---
 src/backend/models/pageOrder.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/backend/models/pageOrder.ts b/src/backend/models/pageOrder.ts
index bf1df32e..84c18b53 100644
--- a/src/backend/models/pageOrder.ts
+++ b/src/backend/models/pageOrder.ts
@@ -81,9 +81,9 @@ class PageOrder {
    * @returns {Promise<PageOrder[]>}
    */
   public static async getRootPageOrder(): Promise<PageOrder> {
-    const docs = await this.getAll();
+    const docs = await db.findOne({ 'page': '0' });
 
-    return docs.filter(doc => doc.page === '0')[0];
+    return new PageOrder(docs);
   }
 
   /**
@@ -92,9 +92,9 @@ class PageOrder {
    * @returns {Promise<PageOrder[]>}
    */
   public static async getChildPageOrder(): Promise<PageOrder[]> {
-    const docs = await this.getAll();
+    const docs = await this.getAll({ 'page': { $ne: '0' } });
 
-    return docs.filter(doc => doc.page !== '0');
+    return Promise.all(docs.map(doc => new PageOrder(doc)));
   }
 
   /**

From f4e7264a8254de690cc5f8203522f3eb356b5417 Mon Sep 17 00:00:00 2001
From: Y-k-Y <zzzzz.co.kr@gmail.com>
Date: Thu, 12 May 2022 23:39:53 +0900
Subject: [PATCH 7/9] refactor: fix typo, rename variable, add comments,
 improve code quality

---
 src/backend/controllers/pages.ts | 41 ++++++++++++++++++++------------
 1 file changed, 26 insertions(+), 15 deletions(-)

diff --git a/src/backend/controllers/pages.ts b/src/backend/controllers/pages.ts
index ed5478c9..f1f88c34 100644
--- a/src/backend/controllers/pages.ts
+++ b/src/backend/controllers/pages.ts
@@ -79,7 +79,7 @@ class Pages {
     const orphanPageOrder: PageOrder[] = [];
 
     /**
-     * If there is no root nad child page order, then it returns empty array
+     * If there is no root and child page order, then it returns an empty array
      */
     if (!rootPageOrder || (!rootPageOrder && childPageOrder.length <= 0)) {
       return [];
@@ -90,31 +90,38 @@ class Pages {
 
       return map;
     }, new Map);
-    const rootPagesId = rootPageOrder.order;
+    const idsOfRootPages = rootPageOrder.order;
 
     /**
      * It groups root pages and 1 level pages by its parent
      */
-    rootPagesId.reduce((prev, curr, idx) => {
-      const childPages = childPageOrder.filter((child, _idx) => {
-        if (child.page === curr) {
-          childPageOrder.splice(_idx, 1);
+    idsOfRootPages.reduce((prev, curr, idx) => {
+      const childPages:PageOrder[] = [];
 
-          return child;
+      childPageOrder.forEach((pageOrder, _idx) => {
+        if (pageOrder.page === curr) {
+          childPages.push(pageOrder);
+          childPageOrder.splice(_idx, 1);
         }
       });
+
       const hasChildPage = childPages.length > 0;
 
+      prev[curr] = [];
+      prev[curr].push(curr);
+
+      /**
+       * It attaches 1 level page id to its parent page id
+       */
       if (hasChildPage) {
-        prev[curr] = [];
-        prev[curr].push(curr);
         prev[curr].push(...childPages[0].order);
-      } else {
-        prev[curr] = [];
-        prev[curr].push(curr);
       }
 
-      if (idx === rootPagesId.length - 1 && childPageOrder.length > 0) {
+      /**
+       * If non-attached childPages which is not 1 level page still remains,
+       * It is stored as an orphan page so that it can be processed in the next statements
+       */
+      if (idx === idsOfRootPages.length - 1 && childPageOrder.length > 0) {
         orphanPageOrder.push(...childPageOrder);
       }
 
@@ -126,9 +133,13 @@ class Pages {
      */
     while (orphanPageOrder.length > 0) {
       orphanPageOrder.forEach((orphanOrder, idx) => {
-        Object.entries(orderGroupedByParent).forEach(([key, value]) => {
+        // It loops each of grouped orders formatted as [root page id(1): corresponding child pages id(2)]
+        Object.entries(orderGroupedByParent).forEach(([parentPageId, value]) => {
+          // If (2) contains orphanOrder's parent id(page)
           if (orphanOrder.page && orphanOrder.order && value.includes(orphanOrder.page)) {
-            orderGroupedByParent[key].splice(value.indexOf(orphanOrder.page) + 1, 0, ...orphanOrder.order);
+            // Append orphanOrder's id(order) into its parent id
+            orderGroupedByParent[parentPageId].splice(value.indexOf(orphanOrder.page) + 1, 0, ...orphanOrder.order);
+            // Finally, remove orphanOrder from orphanPageOrder
             orphanPageOrder.splice(idx, 1);
           }
         });

From 73f10cc81169c69c871a7cf94cfb8cf4cc5e1479 Mon Sep 17 00:00:00 2001
From: Y-k-Y <zzzzz.co.kr@gmail.com>
Date: Wed, 22 Jun 2022 02:40:17 +0900
Subject: [PATCH 8/9] fix: add exit infinite loop

---
 src/backend/controllers/pages.ts | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/backend/controllers/pages.ts b/src/backend/controllers/pages.ts
index f1f88c34..1a17db40 100644
--- a/src/backend/controllers/pages.ts
+++ b/src/backend/controllers/pages.ts
@@ -128,10 +128,16 @@ class Pages {
       return prev;
     }, orderGroupedByParent);
 
+    let count = 0;
+
     /**
      * It groups remained ungrouped pages by its parent
      */
     while (orphanPageOrder.length > 0) {
+      if (count >= 1000) {
+        break;
+      }
+
       orphanPageOrder.forEach((orphanOrder, idx) => {
         // It loops each of grouped orders formatted as [root page id(1): corresponding child pages id(2)]
         Object.entries(orderGroupedByParent).forEach(([parentPageId, value]) => {
@@ -144,6 +150,8 @@ class Pages {
           }
         });
       });
+
+      count += 1;
     }
 
     /**

From b445414098c9b4d41e7d0e1b53aa0f8255a3a150 Mon Sep 17 00:00:00 2001
From: Y-k-Y <zzzzz.co.kr@gmail.com>
Date: Wed, 22 Jun 2022 22:57:06 +0900
Subject: [PATCH 9/9] fix: replace exiting loop to throwing exception

---
 src/backend/controllers/pages.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/backend/controllers/pages.ts b/src/backend/controllers/pages.ts
index 1a17db40..fa92c2be 100644
--- a/src/backend/controllers/pages.ts
+++ b/src/backend/controllers/pages.ts
@@ -2,6 +2,7 @@ import Page, { PageData } from '../models/page';
 import Alias from '../models/alias';
 import PagesOrder from './pagesOrder';
 import PageOrder from '../models/pageOrder';
+import HttpException from "../exceptions/httpException";
 
 type PageDataFields = keyof PageData;
 
@@ -135,7 +136,7 @@ class Pages {
      */
     while (orphanPageOrder.length > 0) {
       if (count >= 1000) {
-        break;
+        throw new HttpException(500, `Page cannot be processed`);
       }
 
       orphanPageOrder.forEach((orphanOrder, idx) => {