persistent data storage is added

Author: mehmetsefabalik

package-lock.json

@@ -26,6 +26,9 @@
     "@nestjs/serve-static": "^1.0.1",
     "@nestjs/websockets": "^6.9.0",
     "@puzzle-js/sentry-ui": "0.0.5",
+    "@types/couchbase": "^2.4.1",
+    "couchbase": "^2.6.9",
+    "ottoman": "^1.0.6",
     "reflect-metadata": "^0.1.12",
     "rimraf": "^2.6.2",
     "rxjs": "^6.3.3",

package.json

@@ -3,7 +3,8 @@ import { GatewayModule } from './gateway/gateway.module';
 import { PageModule } from './page/page.module';
 import { FragmentModule } from './fragment/fragment.module';
 import { ServeStaticModule } from '@nestjs/serve-static';
-import { join, dirname } from 'path';
+import { dirname } from 'path';
+import { CouchbaseModule } from './couchbase/couchbase.module';
 
 const sentryUi = dirname(require.resolve('@puzzle-js/sentry-ui'));
 
@@ -15,6 +16,7 @@ const sentryUi = dirname(require.resolve('@puzzle-js/sentry-ui'));
     GatewayModule,
     PageModule,
     FragmentModule,
+    CouchbaseModule,
   ],
 })
 export class AppModule { }

src/app.module.ts

@@ -0,0 +1,9 @@
+import { Module, Global } from '@nestjs/common';
+import { CouchbaseService } from './couchbase.service';
+
+@Global()
+@Module({
+  providers: [CouchbaseService],
+  exports: [CouchbaseService],
+})
+export class CouchbaseModule {}

src/couchbase/couchbase.module.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { CouchbaseService } from './couchbase.service';
+
+describe('CouchbaseService', () => {
+  let service: CouchbaseService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [CouchbaseService],
+    }).compile();
+
+    service = module.get<CouchbaseService>(CouchbaseService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

src/couchbase/couchbase.service.spec.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { Cluster } from 'couchbase';
+
+@Injectable()
+export class CouchbaseService {
+  cluster: any;
+  bucket: any;
+  constructor() {
+    this.cluster = new Cluster(process.env.COUCHBASE_URL);
+    this.cluster.authenticate(process.env.COUCHBASE_USERNAME, process.env.COUCHBASE_PASSWORD);
+    this.bucket = this.cluster.openBucket(process.env.COUCHBASE_BUCKET);
+  }
+
+  getBucket() {
+    return this.bucket;
+  }
+}

src/couchbase/couchbase.service.ts

@@ -12,38 +12,38 @@ export class GatewayGateway implements OnGatewayInit, OnGatewayConnection, OnGat
   @WebSocketServer() server: Server;
 
   @SubscribeMessage('panel.gateways.get')
-  getForPanel() {
-    const gateways = this.gatewayService.get();
+  async getForPanel() {
+    const gateways = await this.gatewayService.get();
     return { event: 'panel.gateways', data: gateways };
   }
 
   @SubscribeMessage('panel.gateways.delete')
-  deleteForPanel(@MessageBody() name: string) {
-    const deletionSuccessful = this.gatewayService.delete(name);
+  async deleteForPanel(@MessageBody() name: string) {
+    const deletionSuccessful = await this.gatewayService.delete(name);
     if (!deletionSuccessful) return;
-    const gateways = this.gatewayService.get();
+    const gateways = await this.gatewayService.get();
     this.server.emit('panel.gateways', gateways);
     this.server.emit('gateway.delete', name);
   }
 
   @SubscribeMessage('panel.gateways.add')
-  addForPanel(@MessageBody() gateway: Gateway) {
-    this.gatewayService.add(gateway);
-    this.server.emit('panel.gateways', this.gatewayService.get());
+  async addForPanel(@MessageBody() gateway: Gateway) {
+    await this.gatewayService.add(gateway);
+    this.server.emit('panel.gateways', await this.gatewayService.get());
     this.server.emit('gateway.add', gateway);
   }
 
   @SubscribeMessage('panel.gateways.update')
-  updateForPanel(@MessageBody() gateway: Gateway) {
-    const updateSuccessful = this.gatewayService.update(gateway);
+  async updateForPanel(@MessageBody() gateway: Gateway) {
+    const updateSuccessful = await this.gatewayService.update(gateway);
     if (!updateSuccessful) return;
-    this.server.emit('panel.gateways', this.gatewayService.get());
+    this.server.emit('panel.gateways', await this.gatewayService.get());
     this.server.emit('gateway.update', gateway);
   }
 
   @SubscribeMessage('gateways.get')
-  get() {
-    const gateways = this.gatewayService.get();
+  async get() {
+    const gateways = await this.gatewayService.get();
     return { event: 'gateways', data: gateways };
   }
 

src/gateway/gateway.gateway.ts

@@ -1,30 +1,51 @@
 import { Injectable } from '@nestjs/common';
 import { Gateway } from './gateway.interface';
+import { CouchbaseService } from '../couchbase/couchbase.service';
+import { ViewQuery } from 'couchbase';
 
 @Injectable()
 export class GatewayService {
-  private gateways: Gateway[] = [];
+  constructor(private readonly couchbaseService: CouchbaseService) { }
 
   add(gateway: Gateway) {
-    this.gateways.push(gateway);
+    return new Promise((resolve, reject) => {
+      this.couchbaseService.getBucket().insert(`gateway_${gateway.name}`, {...gateway, type: 'gateway'}, (err, data) => {
+        if (err) return reject(null);
+        resolve(data);
+      });
+    });
   }
 
   delete(name: string) {
-    const gatewayToDelete = this.gateways.find(fr => fr.name === name);
-    if (!gatewayToDelete) return false;
-    const newgateways = this.gateways.filter(fr => fr.name === name);
-    this.gateways = [...newgateways];
-    return true;
+    return new Promise((resolve, reject) => {
+      this.couchbaseService.getBucket().remove(`gateway_${name}`, (err, data) => {
+        if (err) return reject(null);
+        resolve(data);
+      });
+    });
   }
 
   update(gateway: Gateway) {
-    const gatewayToUpdate = this.gateways.find(gw => gw.name === gateway.name);
-    if (!gatewayToUpdate) return false;
-    const newGateways = this.gateways.filter(gw => gw.name !== gatewayToUpdate.name);
-    this.gateways = [...newGateways, gateway];
+    return new Promise((resolve, reject) => {
+      this.couchbaseService.getBucket().upsert(`gateway_${gateway.name}`, {...gateway, type: 'gateway'}, (err, data) => {
+        if (err) return reject(null);
+        resolve(data);
+      });
+    });
   }
 
   get() {
-    return this.gateways;
+    return new Promise((resolve, reject) => {
+      const query = ViewQuery
+        .from('gateway', 'getAll')
+        .stale(ViewQuery.Update.BEFORE);
+      this.couchbaseService.getBucket().query(query, (err, data) => {
+        console.log("err", err);
+        console.log("data", data)
+        if (err) return reject(null);
+        const gateways = data.map((g) => g.value);
+        resolve(gateways);
+      });
+    });
   }
 }

src/gateway/gateway.service.ts

@@ -12,38 +12,38 @@ export class PageGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
   @WebSocketServer() server: Server;
 
   @SubscribeMessage('panel.pages.get')
-  getForPanel() {
-    const pages = this.pageService.get();
+  async getForPanel() {
+    const pages = await this.pageService.get();
     return { event: 'panel.pages', data: pages };
   }
 
   @SubscribeMessage('panel.pages.delete')
-  deleteForPanel(@MessageBody() name: string) {
-    const deletionSuccessful = this.pageService.delete(name);
+  async deleteForPanel(@MessageBody() name: string) {
+    const deletionSuccessful = await this.pageService.delete(name);
     if (!deletionSuccessful) return;
-    const pages = this.pageService.get();
+    const pages = await this.pageService.get();
     this.server.emit('panel.pages', pages);
     this.server.emit('page.delete', name);
   }
 
   @SubscribeMessage('panel.pages.add')
-  addForPanel(@MessageBody() page: Page) {
-    this.pageService.add(page);
-    this.server.emit('panel.pages', this.pageService.get());
+  async addForPanel(@MessageBody() page: Page) {
+    await this.pageService.add(page);
+    this.server.emit('panel.pages', await this.pageService.get());
     this.server.emit('page.add', page);
   }
 
   @SubscribeMessage('panel.pages.update')
-  updateForPanel(@MessageBody() page: Page) {
-    const updateSuccessful = this.pageService.update(page);
+  async updateForPanel(@MessageBody() page: Page) {
+    const updateSuccessful = await this.pageService.update(page);
     if (!updateSuccessful) return;
-    this.server.emit('panel.pages', this.pageService.get());
+    this.server.emit('panel.pages', await this.pageService.get());
     this.server.emit('page.update', page);
   }
 
   @SubscribeMessage('pages.get')
-  get() {
-    const pages = this.pageService.get();
+  async get() {
+    const pages = await this.pageService.get();
     return { event: 'pages', data: pages };
   }
 

src/page/page.gateway.ts

@@ -1,31 +1,48 @@
 import { Injectable } from '@nestjs/common';
+import { CouchbaseService } from '../couchbase/couchbase.service';
 import { Page } from './page.interface';
-
+import {ViewQuery} from 'couchbase';
 @Injectable()
 export class PageService {
-  private pages: Page[] = [];
+  constructor(private readonly couchbaseService: CouchbaseService) { }
 
   add(page: Page) {
-    this.pages.push(page);
+    return new Promise((resolve, reject) => {
+      this.couchbaseService.getBucket().insert(`page_${page.name}`, {...page, type: 'page'}, (err, data) => {
+        if (err) return reject(null);
+        resolve(data);
+      });
+    });
   }
 
   delete(name: string) {
-    const pageToDelete = this.pages.find(pg => pg.name === name);
-    if (!pageToDelete) return false;
-    const newpages = this.pages.filter(pg => pg.name === name);
-    this.pages = [...newpages];
-    return true;
+    return new Promise((resolve, reject) => {
+      this.couchbaseService.getBucket().remove(`page_${name}`, (err, data) => {
+        if (err) return reject(null);
+        resolve(data);
+      });
+    });
   }
 
   update(page: Page) {
-    const pageToUpdate = this.pages.find(pg => pg.name === page.name);
-    if (!pageToUpdate) return false;
-    const newpages = this.pages.filter(pg => pg.name !== pageToUpdate.name);
-    this.pages = [...newpages, page ];
-    return true;
+    return new Promise((resolve, reject) => {
+      this.couchbaseService.getBucket().upsert(`page_${page.name}`, { ...page, type: 'page' }, (err, data) => {
+        if (err) return reject(null);
+        resolve(data);
+      });
+    });
   }
 
   get() {
-    return this.pages;
+    return new Promise((resolve, reject) => {
+      const query = ViewQuery
+        .from('page', 'getAll')
+        .stale(ViewQuery.Update.BEFORE);
+      this.couchbaseService.getBucket().query(query, (err, data) => {
+        if (err) return reject(null);
+        const pages = data.map((d) => d.value);
+        resolve(pages);
+      });
+    });
   }
 }