updated implementation of db persist

lib/persist-resolver-materializer.ts

@@ -1,35 +1,31 @@
 import { Actor, ActorMessage, IMaterializer, IResolver } from 'tarant'
 import { IActor } from 'tarant/dist/actor-system/actor'
 import Waterline from 'waterline'
-import actorConfig from './actor-model.json'
 
-export default class PersistResolverMaterializer implements IMaterializer, IResolver {
-  public static create(config: any): Promise<PersistResolverMaterializer> {
+export default class PersistMaterializer implements IMaterializer, IResolver {
+  public static create(config: any, types: any): Promise<PersistMaterializer> {
     return new Promise((resolve, rejects) => {
-      const actorModel = Waterline.Collection.extend(actorConfig)
-      const waterline = new Waterline()
-      const dbConfig = {
-        adapters: {
-          adapt: config.adapter.type,
-        },
-        datastores: {
-          default: {
-            adapter: 'adapt',
-          },
+      const actorModel = Waterline.Collection.extend({
+        attributes: {
+          id: { type: 'string', required: true },
+          type: { type: 'string' },
         },
-      }
-      dbConfig.datastores.default = { ...dbConfig.datastores.default, ...config.adapter.settings }
+        datastore: 'default',
+        identity: 'actor',
+        primaryKey: 'id',
+        schema: false,
+      })
+      const waterline = new Waterline()
       waterline.registerModel(actorModel)
-      waterline.initialize(dbConfig, (err: any, ontology: any) => {
+      waterline.initialize(config, (err: any, ontology: any) => {
         if (err) {
           rejects(err)
         } else {
-          resolve(new PersistResolverMaterializer(ontology.collections.actor, config.actorTypes))
+          resolve(new PersistMaterializer(ontology.collections.actor, types))
         }
       })
     })
   }
-
   private actorModel: any
   private types: any
 
@@ -39,34 +35,35 @@ export default class PersistResolverMaterializer implements IMaterializer, IReso
   }
 
   public async onInitialize(actor: Actor): Promise<void> {
-    const record = await (actor as any).toJson()
-    await this.actorModel.findOrCreate({ id: record.id }, record)
+    await this.createOrUpdate(actor)
   }
-
   public onBeforeMessage(actor: Actor, message: ActorMessage): void {
     //
   }
-
   public async onAfterMessage(actor: Actor, message: ActorMessage): Promise<void> {
-    let record = await (actor as any).toJson()
-    const dbRecord = await this.actorModel.findOne({ id: record.id })
-    record = Object.keys(dbRecord).reduce((acc, key) => {
-      return { ...acc, [key]: record[key] || null }
-    }, {})
-    await this.actorModel.updateOne({ id: record.id }).set(record)
+    await this.createOrUpdate(actor)
   }
-
   public onError(actor: Actor, message: ActorMessage, error: any): void {
     //
   }
 
   public async resolveActorById(id: string): Promise<IActor> {
     const result = await this.actorModel.findOne({ id })
     if (!result) {
-      return Promise.reject('actor not found')
+      return Promise.reject('Actor not found')
     }
     const actor = new this.types[result.type](id)
     actor.updateFrom(result)
     return Promise.resolve(actor)
   }
+
+  private async createOrUpdate(actor: Actor) {
+    const record = await (actor as any).toJson()
+
+    if (await this.actorModel.findOne({ id: record.id })) {
+      await this.actorModel.updateOne({ id: record.id }).set(record)
+    } else {
+      await this.actorModel.create(record)
+    }
+  }
 }

package.json

@@ -35,30 +35,30 @@
     "preversion": "yarn test"
   },
   "devDependencies": {
-    "@types/faker": "4.1.4",
-    "@types/jest": "23.3.12",
-    "@types/node": "10.12.18",
-    "coveralls": "3.0.2",
+    "@types/faker": "4.1.8",
+    "@types/jest": "24.0.23",
+    "@types/node": "12.12.14",
+    "coveralls": "3.0.9",
     "faker": "4.1.0",
-    "jest": "23.6.0",
-    "prettier": "1.15.3",
-    "rollup": "1.1.0",
-    "rollup-plugin-commonjs": "9.2.0",
-    "rollup-plugin-json": "3.1.0",
+    "jest": "24.9.0",
+    "prettier": "1.19.1",
+    "rollup": "1.27.8",
+    "rollup-plugin-commonjs": "10.1.0",
+    "rollup-plugin-json": "4.0.0",
     "rollup-plugin-node-builtins": "2.1.2",
-    "rollup-plugin-node-resolve": "4.0.0",
-    "rollup-plugin-replace": "2.1.0",
-    "rollup-plugin-terser": "4.0.2",
-    "rollup-plugin-typescript2": "0.18.1",
-    "sails-disk": "1.0.1",
-    "ts-jest": "23.10.5",
-    "tslib": "1.9.3",
-    "tslint": "5.12.0",
-    "tslint-config-prettier": "1.17.0",
-    "typescript": "3.2.2"
+    "rollup-plugin-node-resolve": "5.2.0",
+    "rollup-plugin-replace": "2.2.0",
+    "rollup-plugin-terser": "5.1.2",
+    "rollup-plugin-typescript2": "0.25.3",
+    "sails-disk": "1.1.2",
+    "ts-jest": "24.2.0",
+    "tslib": "1.10.0",
+    "tslint": "5.20.1",
+    "tslint-config-prettier": "1.18.0",
+    "typescript": "3.7.3"
   },
   "dependencies": {
-    "tarant": "2.6.4",
+    "tarant": "2.7.2",
     "waterline": "0.13.6"
   },
   "jest": {

test/persist-resolver-materializer.spec.ts

@@ -5,13 +5,14 @@ import { ActorMessage } from 'tarant'
 
 class FakeActor {
   public readonly id: string
+  public some: string | undefined
   constructor(id: string) {
     this.id = id
   }
   public toJson() {
-    return { id: this.id, type: 'FakeActor' }
-    //
+    return { id: this.id, type: 'FakeActor', some: this.some }
   }
+
   public updateFrom() {
     //
   }
@@ -22,16 +23,18 @@ describe('tarant db', () => {
   let actorModel: any
 
   beforeEach(async () => {
-    const config = {
-      adapter: {
-        type: disk,
-        settings: {
+    var config = {
+      adapters: {
+        disk: disk,
+      },
+      datastores: {
+        default: {
+          adapter: 'disk',
           inMemoryOnly: true,
         },
       },
-      actorTypes: { FakeActor },
     }
-    persistor = await PersistResolverMaterializer.create(config)
+    persistor = await PersistResolverMaterializer.create(config, { FakeActor })
     actorModel = (persistor as any).actorModel
   })
 
@@ -61,14 +64,15 @@ describe('tarant db', () => {
   })
 
   describe('onAfterMessage', () => {
-    it('should not create if already exist setting undefined as null', async () => {
+    it('should not create and update if already exist setting undefined as null', async () => {
       const id = faker.random.uuid()
-      const actorMessage = jest.fn<ActorMessage>()()
+      const actorMessage = jest.fn<ActorMessage, []>()()
       const actorParam = new FakeActor(id) as any
+      actorParam.some = faker.random.uuid()
       await actorModel.create({ id, type: 'FakeActor', some: faker.random.uuid() })
       await persistor.onAfterMessage(actorParam, actorMessage)
       const actor = await actorModel.findOne({ id })
-      expect(actor).toEqual({ id, type: 'FakeActor', some: null })
+      expect(actor).toEqual({ id, type: 'FakeActor', some: actorParam.some })
     })
   })
 
@@ -87,7 +91,7 @@ describe('tarant db', () => {
         await persistor.resolveActorById(id)
         fail()
       } catch (error) {
-        expect(error).toEqual('actor not found')
+        expect(error).toEqual('Actor not found')
       }
     })
   })