@bopen-io/wallet-toolbox 1.7.18

package/src/storage/schema/entities/EntityTxLabel.ts

@@ -0,0 +1,121 @@
+import { TrxToken } from '../../../sdk/WalletStorage.interfaces'
+import { verifyId, verifyOneOrNone } from '../../../utility/utilityHelpers'
+import { EntityBase, EntityStorage, SyncMap } from './EntityBase'
+import { TableTxLabel } from '../tables/TableTxLabel'
+
+export class EntityTxLabel extends EntityBase<TableTxLabel> {
+  constructor(api?: TableTxLabel) {
+    const now = new Date()
+    super(
+      api || {
+        txLabelId: 0,
+        created_at: now,
+        updated_at: now,
+        label: '',
+        userId: 0,
+        isDeleted: false
+      }
+    )
+  }
+
+  override updateApi(): void {
+    /* nothing needed yet... */
+  }
+
+  get txLabelId() {
+    return this.api.txLabelId
+  }
+  set txLabelId(v: number) {
+    this.api.txLabelId = v
+  }
+  get created_at() {
+    return this.api.created_at
+  }
+  set created_at(v: Date) {
+    this.api.created_at = v
+  }
+  get updated_at() {
+    return this.api.updated_at
+  }
+  set updated_at(v: Date) {
+    this.api.updated_at = v
+  }
+  get label() {
+    return this.api.label
+  }
+  set label(v: string) {
+    this.api.label = v
+  }
+  get userId() {
+    return this.api.userId
+  }
+  set userId(v: number) {
+    this.api.userId = v
+  }
+  get isDeleted() {
+    return this.api.isDeleted
+  }
+  set isDeleted(v: boolean) {
+    this.api.isDeleted = v
+  }
+
+  override get id(): number {
+    return this.api.txLabelId
+  }
+  override set id(v: number) {
+    this.api.txLabelId = v
+  }
+  override get entityName(): string {
+    return 'txLabel'
+  }
+  override get entityTable(): string {
+    return 'tx_labels'
+  }
+
+  override equals(ei: TableTxLabel, syncMap?: SyncMap): boolean {
+    const eo = this.toApi()
+    if (eo.label != ei.label || eo.isDeleted != ei.isDeleted) return false
+    if (!syncMap) {
+      if (eo.userId !== ei.userId) return false
+    }
+    return true
+  }
+
+  static async mergeFind(
+    storage: EntityStorage,
+    userId: number,
+    ei: TableTxLabel,
+    syncMap: SyncMap,
+    trx?: TrxToken
+  ): Promise<{ found: boolean; eo: EntityTxLabel; eiId: number }> {
+    const ef = verifyOneOrNone(await storage.findTxLabels({ partial: { label: ei.label, userId }, trx }))
+    return {
+      found: !!ef,
+      eo: new EntityTxLabel(ef || { ...ei }),
+      eiId: verifyId(ei.txLabelId)
+    }
+  }
+
+  override async mergeNew(storage: EntityStorage, userId: number, syncMap: SyncMap, trx?: TrxToken): Promise<void> {
+    this.userId = userId
+    this.txLabelId = 0
+    this.txLabelId = await storage.insertTxLabel(this.toApi(), trx)
+  }
+
+  override async mergeExisting(
+    storage: EntityStorage,
+    since: Date | undefined,
+    ei: TableTxLabel,
+    syncMap: SyncMap,
+    trx?: TrxToken
+  ): Promise<boolean> {
+    let wasMerged = false
+    if (ei.updated_at > this.updated_at) {
+      this.isDeleted = ei.isDeleted
+      this.updated_at = new Date(Math.max(ei.updated_at.getTime(), this.updated_at.getTime()))
+      await storage.updateTxLabel(this.id, this.toApi(), trx)
+      wasMerged = true
+    }
+    return wasMerged
+  }
+}

package/src/storage/schema/entities/EntityTxLabelMap.ts

@@ -0,0 +1,123 @@
+import { TrxToken } from '../../../sdk/WalletStorage.interfaces'
+import { verifyId, verifyOneOrNone } from '../../../utility/utilityHelpers'
+import { EntityBase, EntityStorage, SyncMap } from './EntityBase'
+import { TableTxLabelMap } from '../tables/TableTxLabelMap'
+import { WERR_INVALID_OPERATION } from '../../../sdk/WERR_errors'
+
+export class EntityTxLabelMap extends EntityBase<TableTxLabelMap> {
+  constructor(api?: TableTxLabelMap) {
+    const now = new Date()
+    super(
+      api || {
+        created_at: now,
+        updated_at: now,
+        transactionId: 0,
+        txLabelId: 0,
+        isDeleted: false
+      }
+    )
+  }
+
+  override updateApi(): void {
+    /* nothing needed yet... */
+  }
+
+  get txLabelId() {
+    return this.api.txLabelId
+  }
+  set txLabelId(v: number) {
+    this.api.txLabelId = v
+  }
+  get transactionId() {
+    return this.api.transactionId
+  }
+  set transactionId(v: number) {
+    this.api.transactionId = v
+  }
+  get created_at() {
+    return this.api.created_at
+  }
+  set created_at(v: Date) {
+    this.api.created_at = v
+  }
+  get updated_at() {
+    return this.api.updated_at
+  }
+  set updated_at(v: Date) {
+    this.api.updated_at = v
+  }
+  get isDeleted() {
+    return this.api.isDeleted
+  }
+  set isDeleted(v: boolean) {
+    this.api.isDeleted = v
+  }
+
+  override get id(): number {
+    throw new WERR_INVALID_OPERATION('entity has no "id" value')
+  } // entity does not have its own id.
+  override get entityName(): string {
+    return 'txLabelMap'
+  }
+  override get entityTable(): string {
+    return 'tx_labels_map'
+  }
+
+  override equals(ei: TableTxLabelMap, syncMap?: SyncMap | undefined): boolean {
+    const eo = this.toApi()
+
+    if (
+      eo.transactionId !== (syncMap ? syncMap.transaction.idMap[verifyId(ei.transactionId)] : ei.transactionId) ||
+      eo.txLabelId !== (syncMap ? syncMap.txLabel.idMap[verifyId(ei.txLabelId)] : ei.txLabelId) ||
+      eo.isDeleted !== ei.isDeleted
+    )
+      return false
+
+    return true
+  }
+
+  static async mergeFind(
+    storage: EntityStorage,
+    userId: number,
+    ei: TableTxLabelMap,
+    syncMap: SyncMap,
+    trx?: TrxToken
+  ): Promise<{ found: boolean; eo: EntityTxLabelMap; eiId: number }> {
+    const transactionId = syncMap.transaction.idMap[ei.transactionId]
+    const txLabelId = syncMap.txLabel.idMap[ei.txLabelId]
+    const ef = verifyOneOrNone(
+      await storage.findTxLabelMaps({
+        partial: { transactionId, txLabelId },
+        trx
+      })
+    )
+    return {
+      found: !!ef,
+      eo: new EntityTxLabelMap(ef || { ...ei }),
+      eiId: -1
+    }
+  }
+
+  override async mergeNew(storage: EntityStorage, userId: number, syncMap: SyncMap, trx?: TrxToken): Promise<void> {
+    this.transactionId = syncMap.transaction.idMap[this.transactionId]
+    this.txLabelId = syncMap.txLabel.idMap[this.txLabelId]
+    await storage.insertTxLabelMap(this.toApi(), trx)
+  }
+
+  override async mergeExisting(
+    storage: EntityStorage,
+    since: Date | undefined,
+    ei: TableTxLabelMap,
+    syncMap: SyncMap,
+    trx?: TrxToken
+  ): Promise<boolean> {
+    let wasMerged = false
+    if (ei.updated_at > this.updated_at) {
+      this.isDeleted = ei.isDeleted
+      this.updated_at = new Date(Math.max(ei.updated_at.getTime(), this.updated_at.getTime()))
+      await storage.updateTxLabelMap(this.transactionId, this.txLabelId, this.toApi(), trx)
+      wasMerged = true
+    }
+    return wasMerged
+  }
+}

package/src/storage/schema/entities/EntityUser.ts

@@ -0,0 +1,112 @@
+import { TrxToken } from '../../../sdk/WalletStorage.interfaces'
+import { verifyId, verifyOneOrNone } from '../../../utility/utilityHelpers'
+import { EntityBase, EntityStorage, SyncMap } from './EntityBase'
+import { TableUser } from '../tables/TableUser'
+import { WERR_INTERNAL } from '../../../sdk/WERR_errors'
+
+export class EntityUser extends EntityBase<TableUser> {
+  constructor(api?: TableUser) {
+    const now = new Date()
+    super(
+      api || {
+        userId: 0,
+        created_at: now,
+        updated_at: now,
+        identityKey: '',
+        activeStorage: ''
+      }
+    )
+  }
+
+  override updateApi(): void {
+    /* nothing needed yet... */
+  }
+
+  get userId() {
+    return this.api.userId
+  }
+  set userId(v: number) {
+    this.api.userId = v
+  }
+  get created_at() {
+    return this.api.created_at
+  }
+  set created_at(v: Date) {
+    this.api.created_at = v
+  }
+  get updated_at() {
+    return this.api.updated_at
+  }
+  set updated_at(v: Date) {
+    this.api.updated_at = v
+  }
+  get identityKey() {
+    return this.api.identityKey
+  }
+  set identityKey(v: string) {
+    this.api.identityKey = v
+  }
+  get activeStorage() {
+    return this.api.activeStorage
+  }
+  set activeStorage(v: string) {
+    this.api.activeStorage = v
+  }
+
+  override get id(): number {
+    return this.api.userId
+  }
+  override set id(v: number) {
+    this.api.userId = v
+  }
+  override get entityName(): string {
+    return 'user'
+  }
+  override get entityTable(): string {
+    return 'users'
+  }
+
+  override equals(ei: TableUser, syncMap?: SyncMap | undefined): boolean {
+    const eo = this.toApi()
+    if (eo.identityKey != ei.identityKey || eo.activeStorage != ei.activeStorage) return false
+    if (!syncMap) {
+      /** */
+    }
+    return true
+  }
+  static async mergeFind(
+    storage: EntityStorage,
+    userId: number,
+    ei: TableUser,
+    trx?: TrxToken
+  ): Promise<{ found: boolean; eo: EntityUser; eiId: number }> {
+    const ef = verifyOneOrNone(await storage.findUsers({ partial: { identityKey: ei.identityKey }, trx }))
+    if (ef && ef.userId != userId) throw new WERR_INTERNAL('logic error, userIds don not match.')
+    return {
+      found: !!ef,
+      eo: new EntityUser(ef || { ...ei }),
+      eiId: verifyId(ei.userId)
+    }
+  }
+  override async mergeNew(storage: EntityStorage, userId: number, syncMap: SyncMap, trx?: TrxToken): Promise<void> {
+    throw new WERR_INTERNAL('a sync chunk merge must never create a new user')
+  }
+  override async mergeExisting(
+    storage: EntityStorage,
+    since: Date | undefined,
+    ei: TableUser,
+    syncMap?: SyncMap,
+    trx?: TrxToken
+  ): Promise<boolean> {
+    let wasMerged = false
+    // The condition on activeStorage here is critical as a new user record may have just been created
+    // in a backup store to which a backup is being pushed.
+    if (ei.updated_at > this.updated_at || (this.activeStorage === undefined && ei.activeStorage !== undefined)) {
+      this.activeStorage = ei.activeStorage
+      this.updated_at = new Date(Math.max(ei.updated_at.getTime(), this.updated_at.getTime()))
+      await storage.updateUser(this.id, this.toApi(), trx)
+      wasMerged = true
+    }
+    return wasMerged
+  }
+}

package/src/storage/schema/entities/MergeEntity.ts

@@ -0,0 +1,73 @@
+import { TrxToken } from '../../../sdk/WalletStorage.interfaces'
+import { maxDate, verifyId } from '../../../utility/utilityHelpers'
+import { EntityBase, EntityStorage, EntitySyncMap, SyncMap } from './EntityBase'
+import { WERR_INTERNAL } from '../../../sdk/WERR_errors'
+import { EntityTimeStamp } from '../../../sdk/types'
+
+/**
+ * @param API one of the storage table interfaces.
+ * @param DE the corresponding entity class
+ */
+export class MergeEntity<API extends EntityTimeStamp, DE extends EntityBase<API>> {
+  idMap: Record<number, number>
+
+  constructor(
+    public stateArray: API[] | undefined,
+    public find: (
+      storage: EntityStorage,
+      userId: number,
+      ei: API,
+      syncMap: SyncMap,
+      trx?: TrxToken
+    ) => Promise<{ found: boolean; eo: DE; eiId: number }>,
+    /** id map for primary id of API and DE object. */
+    public esm: EntitySyncMap
+  ) {
+    this.idMap = esm.idMap
+  }
+
+  updateSyncMap(map: Record<number, number>, inId: number, outId: number) {
+    const i = verifyId(inId)
+    const o = verifyId(outId)
+    if (map[i] === undefined) {
+      map[i] = o
+    } else if (map[i] !== o) throw new WERR_INTERNAL(`updateSyncMap map[${inId}] can't override ${map[i]} with ${o}`)
+  }
+
+  /**
+   * @param since date of current sync chunk
+   */
+  async merge(
+    since: Date | undefined,
+    storage: EntityStorage,
+    userId: number,
+    syncMap: SyncMap,
+    trx?: TrxToken
+  ): Promise<{ inserts: number; updates: number }> {
+    let inserts = 0,
+      updates = 0
+    if (!this.stateArray) return { inserts, updates }
+    for (const ei of this.stateArray) {
+      this.esm.maxUpdated_at = maxDate(this.esm.maxUpdated_at, ei.updated_at)
+      /**
+       * TODO:
+       * Switch to using syncMap. If the ei id is in the map its an existing merge, else its a new merge.
+       */
+      try {
+        const { found, eo, eiId } = await this.find(storage, userId, ei, syncMap, trx)
+        if (found) {
+          if (await eo.mergeExisting(storage, since, ei, syncMap, trx)) {
+            updates++
+          }
+        } else {
+          await eo.mergeNew(storage, userId, syncMap, trx)
+          inserts++
+        }
+        if (eiId > -1) this.updateSyncMap(this.idMap, eiId, eo.id)
+      } catch (eu: unknown) {
+        throw eu
+      }
+    }
+    return { inserts, updates }
+  }
+}