anear-js-api 0.4.21 → 0.4.23

package/lib/models/JsonApiResource.js

@@ -1,9 +1,5 @@
 "use strict"
 
-const Persist = require('../utils/Persist')
-
-const Storage = new Persist()
-
 class JsonApiResource {
 
   constructor(json) {
@@ -25,10 +21,6 @@ class JsonApiResource {
     return null // override in subclass if desired
   }
 
-  async onLoad() {
-    return // called each time the event is loaded from Storage
-  }
-
   get attributes() {
     return this.data.attributes
   }
@@ -52,47 +44,6 @@ class JsonApiResource {
       return inc.type === data.type && inc.id === data.id
     })
   }
-
-  static async getFromStorage(modelId, ...args) {
-    const json = await this.getJsonFor(modelId)
-    if (!json) return null
-    const model = new this(json, ...args)
-    await model.onLoad()
-    return model
-  }
-
-  async persist() {
-    return await Storage.create(this)
-  }
-
-  async update() {
-    return await Storage.update(this)
-  }
-
-  async exists() {
-    return await Storage.exists(this)
-  }
-
-  async remove() {
-    return await Storage.remove(this)
-  }
-
-  static async close() {
-    await Storage.close()
-  }
-
-  static persistKey(id) {
-    return `${this.className()}:${id}`
-  }
-
-  get key() {
-    return this.constructor.persistKey(this.id)
-  }
-
-  static async getJsonFor(id) {
-    const key = this.persistKey(id)
-    return await Storage.fetch(key)
-  }
 }
 
 module.exports = JsonApiResource

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anear-js-api",
-  "version": "0.4.21",
+  "version": "0.4.23",
   "description": "Javascript Developer API for Anear Apps",
   "main": "lib/index.js",
   "scripts": {
@@ -18,9 +18,6 @@
   "homepage": "https://github.com/machvee/anear-js-api#readme",
   "dependencies": {
     "ably": "^2.7.0",
-    "archiver": "^6.0.1",
-    "async-mutex": "^0.3.2",
-    "async-redis": "^2.0.0",
     "clean-css": "^5.3.3",
     "cross-fetch": "^3.1.5",
     "pug": "^3.0.2",
@@ -31,8 +28,7 @@
   },
   "devDependencies": {
     "dotenv": "^16.0.3",
-    "fakeredis": "^2.0.0",
-    "jest": "^26.6.3",
+    "jest": "^29.7.0",
     "node-notifier": "^10.0.1"
   }
 }

package/lib/utils/Participants.js

@@ -1,181 +0,0 @@
-"use strict"
-
-const ActiveState = "active"
-const IdleState   = "idle"
-
-const MINUTES = (60 * 1000)
-const HOURS = (60 * MINUTES)
-const DefaultIdleMsecs = (30 * MINUTES)
-const DefaultPurgeMsecs = (2 * HOURS) // after Idle
-
-class Participants {
-
-  constructor(anearEvent, {idleMsecs = DefaultIdleMsecs, purgeMsecs = DefaultPurgeMsecs, ids = []} = {}) {
-    this.anearEvent = anearEvent
-    this.idleMsecs = idleMsecs
-    this.purgeMsecs = purgeMsecs
-    this._participants = {}
-    for (const id of ids) {
-      // app restart logic ...
-      // seeds from ids with empty objects awaiting full
-      // anearParticipant rehydration from redis
-      this._participants[id] = {}
-    }
-    this._host = null
-  }
-
-  toJSON() {
-    return {
-      ids: this.all.map(p => p.id),
-      idleMsecs: this.idleMsecs,
-      purgeMsecs: this.purgeMsecs
-    }
-  }
-
-  get ids() {
-    return Object.keys(this._participants)
-  }
-
-  indexedById() {
-    // returns an object that has AnearParticipant.id as key
-    return this._participants
-  }
-
-  getById(participantId) {
-    return this._participants[participantId]
-  }
-
-  exists({id}) {
-    const emptyObject = (obj) => {
-      return Object.keys(obj).length === 0 && Object.getPrototypeOf(obj) === Object.prototype
-    }
-
-    const participant = this.getById(id)
-
-    if (!participant) { return false } // id not found
-
-    return !emptyObject(participant)
-  }
-
-  get({id}) {
-    return this.getById(id)
-  }
-
-  get host() {
-    return this._host
-  }
-
-  set host(h) {
-    this._host = h
-  }
-
-  get all() {
-    return Object.values(this._participants).
-      sort((ca, cb) => ca.timestamp - cb.timestamp)
-  }
-
-  get active() {
-    return Object.values(this._participants).filter(c => c.state === ActiveState)
-  }
-
-  get idle() {
-    return Object.values(this._participants).filter(c => c.state === IdleState)
-  }
-
-  get count() {
-    return this.ids.length
-  }
-
-  get numActive() {
-    return this.active.length
-  }
-
-  get numIdle() {
-    return this.idle.length
-  }
-
-  isIdle(c, currentTimestamp) {
-    if (!this.idleMsecs) return false
-    return (currentTimestamp - c.timestamp) >= this.idleMsecs
-  }
-
-  isActive(c, currentTimestamp) {
-    if (!this.idleMsecs) return true
-    return (currentTimestamp - c.timestamp) < this.idleMsecs
-  }
-
-  isPurge(c, currentTimestamp) {
-    if (!this.purgeMsecs) return false
-    return (currentTimestamp - c.timestamp) >= this.purgeMsecs
-  }
-
-  updateState(currentTimestamp) {
-    const sweeper = participant => {
-      if (participant.state === ActiveState) {
-        if (this.isIdle(participant, currentTimestamp)) {
-          participant.state = IdleState
-        }
-      } else if (participant.state === IdleState) {
-        if (this.isPurge(participant, currentTimestamp)) {
-          this.purge(participant)
-        }
-      }
-    }
-
-    this.ids.forEach(
-      k => {
-        const c = this._participants[k]
-        sweeper(c)
-      }
-    )
-  }
-
-  add(anearParticipant, withTimestamp = this.currentTimestamp) {
-    if (anearParticipant.isHost() && this.anearEvent.hosted) {
-      // the host is not an eligible participant and isn't active nor idle
-      this.host = anearParticipant
-    } else {
-      this._participants[anearParticipant.id] = anearParticipant
-      this.markActive(anearParticipant, withTimestamp)
-    }
-    return anearParticipant
-  }
-
-  markActive(anearParticipant, withTimestamp = this.currentTimestamp) {
-    anearParticipant.timestamp = withTimestamp
-    anearParticipant.state = ActiveState
-  }
-
-  purge(participant) {
-    if (!participant) return
-
-    const {id} = participant
-
-    if (this.host && (id === this.host.id)) {
-      this.host = null
-    } else {
-      if (this._participants[id]) {
-        delete this._participants[id]
-      }
-    }
-  }
-
-  get currentTimestamp() {
-    return new Date().getTime()
-  }
-
-  load(anearParticipants) {
-    // used for tests only
-    anearParticipants.forEach(
-      p => {
-        if (p.isHost() && this.anearEvent.hosted) {
-          this.host = p
-        } else {
-          this._participants[p.id] = p
-        }
-      }
-    )
-  }
-}
-
-module.exports = Participants

package/lib/utils/Persist.js

@@ -1,52 +0,0 @@
-"use strict"
-
-const redis = require('async-redis')
-
-class Persist {
-
-  constructor(options={}) {
-    this.init(options)
-  }
-
-  init(options={}) {
-    this.client = redis.createClient() // TODO: createClient redis options passed via options.redis_config
-  }
-
-  async close() {
-    await this.client.quit()
-  }
-
-  async store(model) {
-    const jsonString = JSON.stringify(model.toJSON())
-    return await this.client.set(model.key, jsonString)
-  }
-
-  async fetch(key) {
-    const model = await this.client.get(key)
-    return JSON.parse(model)
-  }
-
-  async exists(model) {
-    const result = await this.client.exists(model.key)
-    return result == 1
-  }
-
-  async create(model) {
-    const alreadyPersisted = await this.exists(model)
-
-    if (alreadyPersisted) {
-      throw new Error(`model ${model.id} already exists`)
-    }
-    return await this.store(model)
-  }
-
-  async update(model) {
-    return await this.store(model)
-  }
-
-  async remove(model) {
-    return await this.client.del(model.key)
-  }
-}
-
-module.exports = Persist

package/tests/Participants.test.js

@@ -1,234 +0,0 @@
-"use strict"
-
-const Participants = require('../lib/utils/Participants')
-const { ParticipantsFixture: participantsJSON,
-        AnearParticipantFixture2: visitor2JSON,
-        AnearHostFixture: hostJSON } = require('./fixtures')
-const AnearParticipant = require('../lib/models/AnearParticipant')
-const AnearParticipantJSONBuilder = require('./utils/AnearParticipantJSONBuilder')
-
-const user1Id = "e053977c-dcb6-40e0-b7b8-e3dbd70ec8fd"
-const idleId = "f1056e6c-c393-4617-8a06-67ba9d2f4b8a"
-const activeId = user1Id
-const hours24 = (24 * 60 * 60 * 1000)
-const GeoLocation = {lat: 25.8348343, lng: -80.38438434}
-
-const MockHostedEvent = {hosted: true, anearParticipantClass: AnearParticipant}
-const MockNonHostedEvent = {hosted: false, anearParticipantClass: AnearParticipant}
-
-const newActiveParticipants = (timestamp, args = {}) => {
-  const copyParticipantsFixture = JSON.parse(JSON.stringify(participantsJSON))
-  const activeParticipants = Object.values(copyParticipantsFixture).filter(p => !p.isHost)
-
-  const participants = new Participants(MockHostedEvent, args)
-
-  activeParticipants.forEach(
-    (attrs, i) => {
-      const participant = new AnearParticipant(AnearParticipantJSONBuilder(attrs), MockHostedEvent)
-      participant.host = attrs.isHost
-      participants.add(participant, timestamp - (i*2000))
-    }
-  )
-  return participants
-}
-
-const newCurrentParticipants = (timestamp, anearEvent = MockHostedEvent) => {
-  const copyParticipantsFixture = JSON.parse(JSON.stringify(participantsJSON))
-  const currentParticipants= Object.values(copyParticipantsFixture).filter(p => !p.isHost)
-
-  const participants = new Participants(anearEvent)
-
-  const anearParticipants = currentParticipants.map(
-    (attrs, i) => {
-      const participant =  new AnearParticipant(AnearParticipantJSONBuilder(attrs), anearEvent)
-
-      let withTimestamp
-      if (attrs.state === 'active') {
-        withTimestamp = timestamp - (i*2000)
-      } else {
-        withTimestamp = timestamp - participants.idleMsecs
-      }
-
-      participant.state = attrs.state
-      participant.timestamp = withTimestamp
-      participant.host = attrs.isHost
-      return participant
-    }
-  )
-
-  participants.load(anearParticipants)
-
-  return participants
-}
-
-const now = new Date().getTime()
-
-test('constructor with JSON provided', () =>  {
-  const ids = ['123', '345', '456']
-  const args = {idleMsecs: 23400, purgeMsecs: 678900, ids}
-  const p = new Participants(MockHostedEvent, args)
-  expect(p).toBeDefined()
-  expect(p.idleMsecs).toBe(args.idleMsecs)
-  expect(p.purgeMsecs).toBe(args.purgeMsecs)
-  expect(p.ids).toStrictEqual(ids)
-})
-
-test('constructor with NO JSON provided has default idle and purge Msecs', () => {
-  const p = new Participants(MockHostedEvent)
-  expect(p).toBeDefined()
-  expect(p.idleMsecs).toBe(1800000)
-  expect(p.purgeMsecs).toBe(7200000)
-  expect(p.all).toHaveLength(0)
-})
-
-test('constructor with null idle and purge msecs avoids idle purge', () => {
-  const p = newActiveParticipants(now, {idleMsecs: null, purgeMsecs: null})
-  expect(p.idleMsecs).toBe(null)
-  expect(p.purgeMsecs).toBe(null)
-  expect(p.idle).toHaveLength(0)
-  expect(p.active).toHaveLength(10)
-
-  const c = p.getById(idleId)
-  expect(p.isIdle(c, now)).toBeFalsy()
-  c.timestamp = c.timestamp - hours24
-  expect(p.isPurge(c, now)).toBeFalsy()
-})
-
-test('getById', () =>  {
-  const p = newActiveParticipants(now)
-  expect(p.getById(user1Id)).toHaveProperty("name", "user1")
-})
-
-test('exists success', () =>  {
-  const p = newActiveParticipants(now)
-  expect(p.exists({id: user1Id})).toBeTruthy()
-})
-
-test('exists fail', () =>  {
-  const p = newActiveParticipants(now)
-  expect(p.exists({id: "abcd"})).toBeFalsy()
-})
-
-test('get success', () =>  {
-  const p = newActiveParticipants(now)
-  expect(p.get({id: user1Id})).toHaveProperty("name", "user1")
-})
-
-test('getParticipant fail', () =>  {
-  const p = newActiveParticipants(now)
-  expect(p.get({id: "abcd"})).toBeUndefined()
-})
-
-test('getParticipant success', () =>  {
-  const p = newActiveParticipants(now)
-  expect(p.get({id: user1Id}).name).toBe("user1")
-})
-
-test('add() participant user', async () => {
-  const p = newCurrentParticipants(now, MockNonHostedEvent)
-  const participant = new AnearParticipant(visitor2JSON, MockNonHostedEvent)
-  participant.geoLocation = GeoLocation
-
-  p.add(participant)
-  const part = p.get(participant)
-  expect(part.name).toBe("bbondfl93")
-  expect(part.avatarUrl).toBe("https://s3.amazonaws.com/anearassets/barbara_bond.png")
-  expect(part.userId).toBe("d280da7c-1baf-4607-a286-4b5faa03eaa7")
-
-  await AnearParticipant.close()
-})
-
-test('add() host user', async () => {
-  const p = newCurrentParticipants(now)
-  const host = new AnearParticipant(hostJSON, MockNonHostedEvent)
-  host.geoLocation = GeoLocation
-
-  p.add(host)
-  expect(p.get(host)).toBeUndefined()
-  expect(p.host.name).toBe('foxhole_host')
-  expect(p.host.avatarUrl).toBe("https://s3.amazonaws.com/anearassets/foxhole.png")
-
-  await AnearParticipant.close()
-})
-
-test('active', () => {
-  const p = newActiveParticipants(now)
-  expect(p.active).toHaveLength(10)
-})
-
-test('idle', () => {
-  const p = newCurrentParticipants(now)
-  expect(p.idle).toHaveLength(2)
-})
-
-test('toJSON', () => {
-  const p = newActiveParticipants(now)
-  const j = p.toJSON()
-  expect(j).toHaveProperty("ids")
-  expect(j).toHaveProperty("idleMsecs")
-  expect(j).toHaveProperty("purgeMsecs")
-  expect(j.ids.sort()).toEqual(p.ids.sort())
-  expect(j.ids.length).toBe(10)
-  expect(j.idleMsecs).toBe(1800000)
-  expect(j.purgeMsecs).toBe(7200000)
-})
-
-test('isIdle', () => {
-  const p = newCurrentParticipants(now)
-  const c = p.getById(idleId)
-  expect(p.isIdle(c, now)).toBeTruthy()
-})
-
-test('isActive', () => {
-  const p = newCurrentParticipants(now)
-  const c = p.getById(activeId)
-  expect(p.isActive(c, now)).toBeTruthy()
-})
-
-test('isPurge', () => {
-  const p = newCurrentParticipants(now)
-  const c = p.getById(idleId)
-  c.timestamp = c.timestamp - hours24
-  expect(p.isPurge(c, now)).toBeTruthy()
-})
-
-test('purgeParticipant participant user-type', () => {
-  const p = newCurrentParticipants(now)
-  const c = p.getById(idleId)
-  p.purge(c)
-  expect(p.exists(c)).toBeFalsy()
-})
-
-test('purge host user-type', () => {
-  const p = newActiveParticipants(now)
-  const c = p.host
-  p.purge(c)
-  expect(p.host).toStrictEqual(null)
-})
-
-test('updateState will leave state unchanged when timeout criteria not met', () => {
-  const p = newCurrentParticipants(now)
-  p.updateState(now)
-  expect(p.active).toHaveLength(8)
-  expect(p.idle).toHaveLength(2)
-  expect(p.numActive).toBe(8)
-  expect(p.numIdle).toBe(2)
-})
-
-test('updateState will mark active to idle when timeout reached', () => {
-  const current = now
-  const p = newCurrentParticipants(current)
-  expect(p.active).toHaveLength(8)
-  p.updateState(current + p.idleMsecs + 1000)
-  expect(Object.values(p.all).
-    filter(p => p.state === 'active')).toHaveLength(0)
-})
-
-test('updateState will purge idle participants', () => {
-  const current = now
-  const p = newCurrentParticipants(current)
-  const idlers = p.idle
-  expect(idlers).toHaveLength(2)
-  p.updateState(current + p.purgeMsecs + 1000)
-  idlers.forEach(c => expect(p.getById(c.id)).toBeUndefined())
-})

package/tests/Persist.test.js

@@ -1,102 +0,0 @@
-const Persist = require('../lib/utils/Persist')
-
-const p = new Persist()
-const key = "myModel"
-
-afterAll(
-  async () => {
-    await p.close()
-  }
-)
-
-const barb = "Barbie"
-const dave = "Dave"
-
-class TestModel {
-  constructor(keyArg, nameArg) {
-    this.id = 1
-    this.key = keyArg
-    this.name = nameArg
-  }
-
-  toJSON() {
-    return {name: this.name, age: 27, state: 'FL'}
-  }
-}
-
-const testModel = new TestModel(key, barb)
-const daveModel = new TestModel(key, dave)
-
-test('constructor', () =>  {
-  expect(p).not.toBe(null)
-})
-
-test('store a model', async () => {
-  try {
-    const result = await p.store(testModel)
-
-    expect(testModel.key).toBe(key)
-    expect(result).toBe('OK')
-  } catch(error) {
-    console.error(error)
-  }
-})
-
-test('fetch a model', async () => {
-  try {
-    const model = await p.fetch(key)
-    expect(model.name).toBe(barb)
-  } catch(error) {
-    console.error(error)
-  }
-})
-
-test('remove a model', async () => {
-  try {
-    const result = await p.remove(testModel)
-  } catch(error) {
-    console.error(error)
-  }
-})
-
-test('create a model only once, and exists only when it does', async () => {
-  try {
-    const result = await p.create(testModel)
-    expect(result).toBe('OK')
-
-    let isThere = await p.exists(testModel)
-    expect(isThere).toBe(true)
-
-    await expect(p.create(testModel))
-      .rejects
-      .toThrow('model 1 already exists');
-
-    await p.remove(testModel)
-
-    isThere = await p.exists(testModel)
-    expect(isThere).toBe(false)
-
-  } catch(error) {
-    console.error(error)
-  }
-})
-
-test('update a model', async () => {
-  try {
-    const result = await p.create(testModel)
-    expect(result).toBe('OK')
-
-    let model = await p.fetch(key)
-    expect(model.name).toBe(barb)
-
-    const ures = await p.update(daveModel)
-    expect(ures).toBe('OK')
-
-    model = await p.fetch(key)
-    expect(model.name).toBe(dave)
-
-    await p.remove(testModel)
-  } catch(error) {
-    console.error(error)
-  }
-})