@bsv/wallet-toolbox 1.7.18 → 2.0.0-beta.0

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

@@ -1,121 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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 }
-  }
-}