@bsv/wallet-toolbox 1.1.7 → 1.1.8

package/src/storage/methods/processAction.ts

@@ -8,7 +8,7 @@ import {
 import {
   asArray,
   asString,
-  entity,
+  EntityProvenTxReq,
   parseTxScriptOffsets,
   randomBytesBase64,
   sdk,
@@ -16,7 +16,11 @@ import {
   stampLog,
   stampLogFormat,
   StorageProvider,
-  table,
+  TableCommission,
+  TableOutput,
+  TableProvenTx,
+  TableProvenTxReq,
+  TableTransaction,
   TxScriptOffsets,
   validateStorageFeeModel,
   verifyId,
@@ -38,7 +42,7 @@ export async function processAction(
     sendWithResults: undefined
   }
 
-  let req: entity.ProvenTxReq | undefined
+  let req: EntityProvenTxReq | undefined
   const txidsOfReqsToShareWithWorld: string[] = [...args.sendWith]
 
   if (args.isNewTx) {
@@ -109,7 +113,7 @@ async function shareReqsWithWorld(
   // Filter original txids down to reqIds that are available and need sending
   const readyToSendReqs = r.details
     .filter(d => d.status === 'readyToSend')
-    .map(d => new entity.ProvenTxReq(d.req!))
+    .map(d => new EntityProvenTxReq(d.req!))
   const readyToSendReqIds = readyToSendReqs.map(r => r.id)
   const transactionIds = readyToSendReqs
     .map(r => r.notify.transactionIds || [])
@@ -213,15 +217,15 @@ interface ValidCommitNewTxToStorageArgs {
   tx: BsvTransaction
   txScriptOffsets: TxScriptOffsets
   transactionId: number
-  transaction: table.Transaction
-  inputOutputs: table.Output[]
-  outputOutputs: table.Output[]
-  commission: table.Commission | undefined
+  transaction: TableTransaction
+  inputOutputs: TableOutput[]
+  outputOutputs: TableOutput[]
+  commission: TableCommission | undefined
   beef: Beef
 
-  req: entity.ProvenTxReq
-  outputUpdates: { id: number; update: Partial<table.Output> }[]
-  transactionUpdate: Partial<table.Transaction>
+  req: EntityProvenTxReq
+  outputUpdates: { id: number; update: Partial<TableOutput> }[]
+  transactionUpdate: Partial<TableTransaction>
   postStatus?: ReqTxStatus
 }
 
@@ -292,7 +296,7 @@ async function validateCommitNewTxToStorageArgs(
       )
   }
 
-  const req = entity.ProvenTxReq.fromTxid(
+  const req = EntityProvenTxReq.fromTxid(
     params.txid,
     params.rawTx,
     transaction.inputBEEF
@@ -368,7 +372,7 @@ async function validateCommitNewTxToStorageArgs(
       throw new sdk.WERR_INVALID_OPERATION(
         `parsed transaction output locking script for vout ${vout} not equal to expected output script.`
       )
-    const update: Partial<table.Output> = {
+    const update: Partial<TableOutput> = {
       txid: vargs.txid,
       spendable: true, // spendability is gated by transaction status. Remains true until the output is spent.
       scriptLength: offset.length,
@@ -384,7 +388,7 @@ async function validateCommitNewTxToStorageArgs(
 }
 
 export interface CommitNewTxResults {
-  req: entity.ProvenTxReq
+  req: EntityProvenTxReq
   log?: string
 }
 
@@ -397,7 +401,7 @@ async function commitNewTxToStorage(
 
   log = stampLog(log, `start storage commitNewTxToStorage`)
 
-  let req: entity.ProvenTxReq | undefined
+  let req: EntityProvenTxReq | undefined
 
   await storage.transaction(async trx => {
     log = stampLog(
@@ -445,8 +449,8 @@ async function commitNewTxToStorage(
 
 export interface GetReqsAndBeefDetail {
   txid: string
-  req?: table.ProvenTxReq
-  proven?: table.ProvenTx
+  req?: TableProvenTxReq
+  proven?: TableProvenTx
   status: 'readyToSend' | 'alreadySent' | 'error' | 'unknown'
   error?: string
 }

package/src/storage/methods/purgeData.ts

@@ -1,6 +1,12 @@
 import { Beef } from '@bsv/sdk'
 import { Knex } from 'knex'
-import { table } from '../index.client'
+import {
+  TableCommission,
+  TableOutput,
+  TableOutputTagMap,
+  TableTransaction,
+  TableTxLabelMap
+} from '../index.client'
 import { sdk } from '../../index.client'
 import { StorageKnex } from '../StorageKnex'
 
@@ -148,25 +154,25 @@ export async function purgeData(
     let qs: PurgeQuery[] = []
 
     const spentTxsQ = storage
-      .toDb(trx)<table.Transaction>('transactions')
+      .toDb(trx)<TableTransaction>('transactions')
       .where('updated_at', '<', before)
       .where('status', 'completed')
       .whereRaw(
         `not exists(select outputId from outputs as o where o.transactionId = transactions.transactionId and o.spendable = 1)`
       )
-    const txs: table.Transaction[] = await spentTxsQ
+    const txs: TableTransaction[] = await spentTxsQ
     // Save any spent txid still needed to prove a utxo:
     const nptxs = txs.filter(t => !proofTxids[t.txid || ''])
     let spentTxIds = nptxs.map(tx => tx.transactionId)
 
     if (spentTxIds.length > 0) {
-      const update: Partial<table.Output> = {
+      const update: Partial<TableOutput> = {
         spentBy: null as unknown as undefined
       }
       qs.push({
         log: 'spent outputs no longer tracked by spentBy',
         q: storage
-          .toDb(trx)<table.Output>('outputs')
+          .toDb(trx)<TableOutput>('outputs')
           .update(
             storage.validatePartialForUpdate(update, undefined, ['spendable'])
           )
@@ -214,14 +220,14 @@ export async function purgeData(
         qs.push({
           log: `${reason} output_tags_map deleted`,
           q: storage
-            .toDb(trx)<table.OutputTagMap>('output_tags_map')
+            .toDb(trx)<TableOutputTagMap>('output_tags_map')
             .whereIn('outputId', outputIds)
             .delete()
         })
         qs.push({
           log: `${reason} outputs deleted`,
           q: storage
-            .toDb(trx)<table.Output>('outputs')
+            .toDb(trx)<TableOutput>('outputs')
             .whereIn('outputId', outputIds)
             .delete()
         })
@@ -230,7 +236,7 @@ export async function purgeData(
       qs.push({
         log: `${reason} tx_labels_map deleted`,
         q: storage
-          .toDb(trx)<table.TxLabelMap>('tx_labels_map')
+          .toDb(trx)<TableTxLabelMap>('tx_labels_map')
           .whereIn('transactionId', transactionIds)
           .delete()
       })
@@ -238,7 +244,7 @@ export async function purgeData(
       qs.push({
         log: `${reason} commissions deleted`,
         q: storage
-          .toDb(trx)<table.Commission>('commissions')
+          .toDb(trx)<TableCommission>('commissions')
           .whereIn('transactionId', transactionIds)
           .delete()
       })
@@ -247,7 +253,7 @@ export async function purgeData(
         qs.push({
           log: 'unspent outputs updated to spendable',
           q: storage
-            .toDb(trx)<table.Output>('outputs')
+            .toDb(trx)<TableOutput>('outputs')
             .update({ spendable: true, spentBy: null as unknown as undefined })
             .whereIn('spentBy', transactionIds)
         })
@@ -256,7 +262,7 @@ export async function purgeData(
       qs.push({
         log: `${reason} transactions deleted`,
         q: storage
-          .toDb(trx)<table.Transaction>('transactions')
+          .toDb(trx)<TableTransaction>('transactions')
           .whereIn('transactionId', transactionIds)
           .delete()
       })

package/src/storage/methods/reviewStatus.ts

@@ -1,6 +1,6 @@
 import { Beef } from '@bsv/sdk'
 import { Knex } from 'knex'
-import { table } from '../index.client'
+import { TableOutput, TableTransaction } from '../index.client'
 import { sdk } from '../../index.client'
 import { StorageKnex } from '../StorageKnex'
 
@@ -36,7 +36,7 @@ export async function reviewStatus(
         UPDATE transactions SET status = 'failed'
         WHERE exists(select 1 from proven_tx_reqs as r where transactions.txid = r.txid and r.status = 'invalid')
         */
-    q: k<table.Transaction>('transactions')
+    q: k<TableTransaction>('transactions')
       .update({ status: 'failed' })
       .whereNot({ status: 'failed' })
       .whereExists(function () {
@@ -52,7 +52,7 @@ export async function reviewStatus(
         UPDATE outputs SET spentBy = null, spendable = 1
         where exists(select 1 from transactions as t where outputs.spentBy = t.transactionId and t.status = 'failed')
         */
-    q: k<table.Output>('outputs')
+    q: k<TableOutput>('outputs')
       .update({ spentBy: null as unknown as undefined, spendable: true })
       .whereExists(function () {
         this.select(k.raw(1))
@@ -68,7 +68,7 @@ export async function reviewStatus(
         FROM proven_txs p
         WHERE transactions.txid = p.txid AND transactions.provenTxId IS NULL
         */
-    q: k<table.Transaction>('transactions')
+    q: k<TableTransaction>('transactions')
       .update({
         status: 'completed',
         provenTxId: k.raw(

package/src/storage/remoting/StorageClient.ts

@@ -17,7 +17,17 @@ import {
   RelinquishOutputArgs,
   WalletInterface
 } from '@bsv/sdk'
-import { sdk, table } from '../../index.client'
+import {
+  sdk,
+  TableCertificate,
+  TableCertificateX,
+  TableOutput,
+  TableOutputBasket,
+  TableProvenTxReq,
+  TableSettings,
+  TableSyncState,
+  TableUser
+} from '../../index.client'
 import { AuthFetch } from '@bsv/sdk'
 
 export class StorageClient implements sdk.WalletStorageProvider {
@@ -26,7 +36,7 @@ export class StorageClient implements sdk.WalletStorageProvider {
   private authClient: AuthFetch
 
   // Track ephemeral (in-memory) "settings" if you wish to align with isAvailable() checks
-  public settings?: table.Settings
+  public settings?: TableSettings
 
   constructor(wallet: WalletInterface, endpointUrl: string) {
     this.authClient = new AuthFetch(wallet)
@@ -91,7 +101,7 @@ export class StorageClient implements sdk.WalletStorageProvider {
     return !!this.settings
   }
 
-  getSettings(): table.Settings {
+  getSettings(): TableSettings {
     if (!this.settings) {
       throw new sdk.WERR_INVALID_OPERATION(
         'call makeAvailable at least once before getSettings'
@@ -100,9 +110,9 @@ export class StorageClient implements sdk.WalletStorageProvider {
     return this.settings
   }
 
-  async makeAvailable(): Promise<table.Settings> {
+  async makeAvailable(): Promise<TableSettings> {
     if (!this.settings) {
-      this.settings = await this.rpcCall<table.Settings>('makeAvailable', [])
+      this.settings = await this.rpcCall<TableSettings>('makeAvailable', [])
     }
     return this.settings
   }
@@ -178,8 +188,8 @@ export class StorageClient implements sdk.WalletStorageProvider {
 
   async findOrInsertUser(
     identityKey
-  ): Promise<{ user: table.User; isNew: boolean }> {
-    return this.rpcCall<{ user: table.User; isNew: boolean }>(
+  ): Promise<{ user: TableUser; isNew: boolean }> {
+    return this.rpcCall<{ user: TableUser; isNew: boolean }>(
       'findOrInsertUser',
       [identityKey]
     )
@@ -189,8 +199,8 @@ export class StorageClient implements sdk.WalletStorageProvider {
     auth: sdk.AuthId,
     storageIdentityKey: string,
     storageName: string
-  ): Promise<{ syncState: table.SyncState; isNew: boolean }> {
-    return this.rpcCall<{ syncState: table.SyncState; isNew: boolean }>(
+  ): Promise<{ syncState: TableSyncState; isNew: boolean }> {
+    return this.rpcCall<{ syncState: TableSyncState; isNew: boolean }>(
       'findOrInsertSyncStateAuth',
       [auth, storageIdentityKey, storageName]
     )
@@ -198,7 +208,7 @@ export class StorageClient implements sdk.WalletStorageProvider {
 
   async insertCertificateAuth(
     auth: sdk.AuthId,
-    certificate: table.CertificateX
+    certificate: TableCertificateX
   ): Promise<number> {
     return this.rpcCall<number>('insertCertificateAuth', [auth, certificate])
   }
@@ -230,8 +240,8 @@ export class StorageClient implements sdk.WalletStorageProvider {
   async findCertificatesAuth(
     auth: sdk.AuthId,
     args: sdk.FindCertificatesArgs
-  ): Promise<table.Certificate[]> {
-    return this.rpcCall<table.Certificate[]>('findCertificatesAuth', [
+  ): Promise<TableCertificate[]> {
+    return this.rpcCall<TableCertificate[]>('findCertificatesAuth', [
       auth,
       args
     ])
@@ -240,21 +250,21 @@ export class StorageClient implements sdk.WalletStorageProvider {
   async findOutputBasketsAuth(
     auth: sdk.AuthId,
     args: sdk.FindOutputBasketsArgs
-  ): Promise<table.OutputBasket[]> {
-    return this.rpcCall<table.OutputBasket[]>('findOutputBaskets', [auth, args])
+  ): Promise<TableOutputBasket[]> {
+    return this.rpcCall<TableOutputBasket[]>('findOutputBaskets', [auth, args])
   }
 
   async findOutputsAuth(
     auth: sdk.AuthId,
     args: sdk.FindOutputsArgs
-  ): Promise<table.Output[]> {
-    return this.rpcCall<table.Output[]>('findOutputsAuth', [auth, args])
+  ): Promise<TableOutput[]> {
+    return this.rpcCall<TableOutput[]>('findOutputsAuth', [auth, args])
   }
 
   findProvenTxReqs(
     args: sdk.FindProvenTxReqsArgs
-  ): Promise<table.ProvenTxReq[]> {
-    return this.rpcCall<table.ProvenTxReq[]>('findProvenTxReqs', [args])
+  ): Promise<TableProvenTxReq[]> {
+    return this.rpcCall<TableProvenTxReq[]>('findProvenTxReqs', [args])
   }
 
   async relinquishCertificate(

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

@@ -2,16 +2,15 @@
 import { MerklePath } from '@bsv/sdk'
 import {
   arraysEqual,
-  entity,
   sdk,
-  table,
+  TableCertificate,
   verifyId,
   verifyOneOrNone
 } from '../../../index.client'
-import { EntityBase } from '.'
+import { EntityBase, EntityStorage, SyncMap } from '.'
 
-export class Certificate extends EntityBase<table.Certificate> {
-  constructor(api?: table.Certificate) {
+export class EntityCertificate extends EntityBase<TableCertificate> {
+  constructor(api?: TableCertificate) {
     const now = new Date()
     super(
       api || {
@@ -118,13 +117,13 @@ export class Certificate extends EntityBase<table.Certificate> {
     this.api.certificateId = v
   }
   override get entityName(): string {
-    return 'entity.Certificate'
+    return 'certificate'
   }
   override get entityTable(): string {
     return 'certificates'
   }
 
-  override equals(ei: table.Certificate, syncMap?: entity.SyncMap): boolean {
+  override equals(ei: TableCertificate, syncMap?: SyncMap): boolean {
     if (
       this.type !== ei.type ||
       this.subject !== ei.subject ||
@@ -140,12 +139,12 @@ export class Certificate extends EntityBase<table.Certificate> {
   }
 
   static async mergeFind(
-    storage: entity.EntityStorage,
+    storage: EntityStorage,
     userId: number,
-    ei: table.Certificate,
-    syncMap: entity.SyncMap,
+    ei: TableCertificate,
+    syncMap: SyncMap,
     trx?: sdk.TrxToken
-  ): Promise<{ found: boolean; eo: entity.Certificate; eiId: number }> {
+  ): Promise<{ found: boolean; eo: EntityCertificate; eiId: number }> {
     const ef = verifyOneOrNone(
       await storage.findCertificates({
         partial: {
@@ -158,15 +157,15 @@ export class Certificate extends EntityBase<table.Certificate> {
     )
     return {
       found: !!ef,
-      eo: new entity.Certificate(ef || { ...ei }),
+      eo: new EntityCertificate(ef || { ...ei }),
       eiId: verifyId(ei.certificateId)
     }
   }
 
   override async mergeNew(
-    storage: entity.EntityStorage,
+    storage: EntityStorage,
     userId: number,
-    syncMap: entity.SyncMap,
+    syncMap: SyncMap,
     trx?: sdk.TrxToken
   ): Promise<void> {
     this.userId = userId
@@ -175,10 +174,10 @@ export class Certificate extends EntityBase<table.Certificate> {
   }
 
   override async mergeExisting(
-    storage: entity.EntityStorage,
+    storage: EntityStorage,
     since: Date | undefined,
-    ei: table.Certificate,
-    syncMap: entity.SyncMap,
+    ei: TableCertificate,
+    syncMap: SyncMap,
     trx?: sdk.TrxToken
   ): Promise<boolean> {
     let wasMerged = false

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

@@ -1,16 +1,15 @@
 import { MerklePath } from '@bsv/sdk'
 import {
   arraysEqual,
-  entity,
   sdk,
-  table,
+  TableCertificateField,
   verifyId,
   verifyOneOrNone
 } from '../../../index.client'
-import { EntityBase } from '.'
+import { EntityBase, EntityStorage, SyncMap } from '.'
 
-export class CertificateField extends EntityBase<table.CertificateField> {
-  constructor(api?: table.CertificateField) {
+export class EntityCertificateField extends EntityBase<TableCertificateField> {
+  constructor(api?: TableCertificateField) {
     const now = new Date()
     super(
       api || {
@@ -76,15 +75,15 @@ export class CertificateField extends EntityBase<table.CertificateField> {
     throw new sdk.WERR_INVALID_OPERATION('entity has no "id" value')
   }
   override get entityName(): string {
-    return 'CertificateField'
+    return 'certificateField'
   }
   override get entityTable(): string {
     return 'certificate_fields'
   }
 
   override equals(
-    ei: table.CertificateField,
-    syncMap?: entity.SyncMap | undefined
+    ei: TableCertificateField,
+    syncMap?: SyncMap | undefined
   ): boolean {
     if (
       this.certificateId !==
@@ -101,12 +100,12 @@ export class CertificateField extends EntityBase<table.CertificateField> {
   }
 
   static async mergeFind(
-    storage: entity.EntityStorage,
+    storage: EntityStorage,
     userId: number,
-    ei: table.CertificateField,
-    syncMap: entity.SyncMap,
+    ei: TableCertificateField,
+    syncMap: SyncMap,
     trx?: sdk.TrxToken
-  ): Promise<{ found: boolean; eo: entity.CertificateField; eiId: number }> {
+  ): Promise<{ found: boolean; eo: EntityCertificateField; eiId: number }> {
     const certificateId = syncMap.certificate.idMap[ei.certificateId]
     const ef = verifyOneOrNone(
       await storage.findCertificateFields({
@@ -116,15 +115,15 @@ export class CertificateField extends EntityBase<table.CertificateField> {
     )
     return {
       found: !!ef,
-      eo: new entity.CertificateField(ef || { ...ei }),
+      eo: new EntityCertificateField(ef || { ...ei }),
       eiId: -1
     }
   }
 
   override async mergeNew(
-    storage: entity.EntityStorage,
+    storage: EntityStorage,
     userId: number,
-    syncMap: entity.SyncMap,
+    syncMap: SyncMap,
     trx?: sdk.TrxToken
   ): Promise<void> {
     this.certificateId = syncMap.certificate.idMap[this.certificateId]
@@ -133,10 +132,10 @@ export class CertificateField extends EntityBase<table.CertificateField> {
   }
 
   override async mergeExisting(
-    storage: entity.EntityStorage,
+    storage: EntityStorage,
     since: Date | undefined,
-    ei: table.CertificateField,
-    syncMap: entity.SyncMap,
+    ei: TableCertificateField,
+    syncMap: SyncMap,
     trx?: sdk.TrxToken
   ): Promise<boolean> {
     let wasMerged = false

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

@@ -2,16 +2,15 @@
 import { MerklePath } from '@bsv/sdk'
 import {
   arraysEqual,
-  entity,
   sdk,
-  table,
+  TableCommission,
   verifyId,
   verifyOneOrNone
 } from '../../../index.client'
-import { EntityBase } from '.'
+import { EntityBase, EntityStorage, SyncMap } from '.'
 
-export class Commission extends EntityBase<table.Commission> {
-  constructor(api?: table.Commission) {
+export class EntityCommission extends EntityBase<TableCommission> {
+  constructor(api?: TableCommission) {
     const now = new Date()
     super(
       api || {
@@ -94,16 +93,13 @@ export class Commission extends EntityBase<table.Commission> {
     this.api.commissionId = v
   }
   override get entityName(): string {
-    return 'Commission'
+    return 'commission'
   }
   override get entityTable(): string {
     return 'commissions'
   }
 
-  override equals(
-    ei: table.Commission,
-    syncMap?: entity.SyncMap | undefined
-  ): boolean {
+  override equals(ei: TableCommission, syncMap?: SyncMap | undefined): boolean {
     if (
       this.isRedeemed !== ei.isRedeemed ||
       this.transactionId !==
@@ -120,27 +116,27 @@ export class Commission extends EntityBase<table.Commission> {
   }
 
   static async mergeFind(
-    storage: entity.EntityStorage,
+    storage: EntityStorage,
     userId: number,
-    ei: table.Commission,
-    syncMap: entity.SyncMap,
+    ei: TableCommission,
+    syncMap: SyncMap,
     trx?: sdk.TrxToken
-  ): Promise<{ found: boolean; eo: entity.Commission; eiId: number }> {
+  ): Promise<{ found: boolean; eo: EntityCommission; eiId: number }> {
     const transactionId = syncMap.transaction.idMap[ei.transactionId]
     const ef = verifyOneOrNone(
       await storage.findCommissions({ partial: { transactionId, userId }, trx })
     )
     return {
       found: !!ef,
-      eo: new entity.Commission(ef || { ...ei }),
+      eo: new EntityCommission(ef || { ...ei }),
       eiId: verifyId(ei.commissionId)
     }
   }
 
   override async mergeNew(
-    storage: entity.EntityStorage,
+    storage: EntityStorage,
     userId: number,
-    syncMap: entity.SyncMap,
+    syncMap: SyncMap,
     trx?: sdk.TrxToken
   ): Promise<void> {
     if (this.transactionId)
@@ -151,10 +147,10 @@ export class Commission extends EntityBase<table.Commission> {
   }
 
   override async mergeExisting(
-    storage: entity.EntityStorage,
+    storage: EntityStorage,
     since: Date | undefined,
-    ei: table.Commission,
-    syncMap: entity.SyncMap,
+    ei: TableCommission,
+    syncMap: SyncMap,
     trx?: sdk.TrxToken
   ): Promise<boolean> {
     let wasMerged = false

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

@@ -62,7 +62,7 @@ export abstract class EntityBase<T> {
 
   /**
    * Perform a 'merge' / 'convergent' equality migration of state
-   * from external `ei` to this existing local entity.
+   * from external `ei` to this existing local EntityUser
    *
    * @param ei
    * @param syncMap

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

@@ -1,6 +1,6 @@
-import { entity } from '../../index.client'
+import {} from '../../index.client'
 import { maxDate, sdk, verifyId } from '../../../index.client'
-import { EntityBase } from './EntityBase'
+import { EntityBase, EntityStorage, EntitySyncMap, SyncMap } from './EntityBase'
 
 /**
  * @param API one of the storage table interfaces.
@@ -15,14 +15,14 @@ export class MergeEntity<
   constructor(
     public stateArray: API[] | undefined,
     public find: (
-      storage: entity.EntityStorage,
+      storage: EntityStorage,
       userId: number,
       ei: API,
-      syncMap: entity.SyncMap,
+      syncMap: SyncMap,
       trx?: sdk.TrxToken
     ) => Promise<{ found: boolean; eo: DE; eiId: number }>,
     /** id map for primary id of API and DE object. */
-    public esm: entity.EntitySyncMap
+    public esm: EntitySyncMap
   ) {
     this.idMap = esm.idMap
   }
@@ -43,9 +43,9 @@ export class MergeEntity<
    */
   async merge(
     since: Date | undefined,
-    storage: entity.EntityStorage,
+    storage: EntityStorage,
     userId: number,
-    syncMap: entity.SyncMap,
+    syncMap: SyncMap,
     trx?: sdk.TrxToken
   ): Promise<{ inserts: number; updates: number }> {
     let inserts = 0,