@fireproof/core 0.0.1

package/test/db-index.test.js

@@ -0,0 +1,214 @@
+import { describe, it, beforeEach } from 'mocha'
+import assert from 'node:assert'
+import Blockstore from '../src/blockstore.js'
+import Fireproof from '../src/fireproof.js'
+import Index from '../src/db-index.js'
+console.x = function () {}
+
+describe('Index query', () => {
+  let database, index
+  beforeEach(async () => {
+    database = new Fireproof(new Blockstore(), []) // todo: these need a cloud name aka w3name, add this after we have cloud storage of blocks
+    const docs = [
+      { _id: 'a1s3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c', name: 'alice', age: 40 },
+      { _id: 'b2s3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c', name: 'bob', age: 40 },
+      { _id: 'c3s3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c', name: 'carol', age: 43 },
+      { _id: 'd4s3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c', name: 'dave', age: 48 },
+      { _id: 'e4s3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c', name: 'emily', age: 4 },
+      { _id: 'f4s3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c', name: 'frank', age: 7 }
+    ]
+    for (const doc of docs) {
+      const id = doc._id
+      const response = await database.put(doc)
+      assert(response)
+      assert(response.id, 'should have id')
+      assert.equal(response.id, id)
+    }
+    index = new Index(database, function (doc, map) {
+      map(doc.age, doc.name)
+    })
+  })
+  it('query index range', async () => {
+    const result = await index.query({ range: [41, 44] })
+    assert(result, 'did return result')
+    assert(result.rows)
+    assert.equal(result.rows.length, 1, 'one row matched')
+    assert.equal(result.rows[0].key, 43)
+    assert(result.rows[0].value === 'carol', 'correct value')
+  })
+  it.skip('query exact key', async () => {
+    const result = await index.query({ key: 43 })
+    assert(result, 'did return result')
+    assert(result.rows)
+    assert.equal(result.rows.length, 1, 'one row matched')
+    assert.equal(result.rows[0].key, 43)
+    assert(result.rows[0].value === 'carol', 'correct value')
+  })
+  it('query twice', async () => {
+    let result = await index.query({ range: [41, 44] })
+    assert(result, 'did return result')
+    assert(result.rows)
+    assert.equal(result.rows.length, 1, 'one row matched')
+    result = await index.query({ range: [41, 44] })
+    assert(result.rows[0].key === 43, 'correct key')
+    assert(result.rows[0].value === 'carol', 'correct value')
+  })
+  it('query two rows oops', async () => {
+    const result = await index.query({ range: [39, 41] })
+    assert(result, 'did return result')
+    assert(result.rows)
+    assert.equal(result.rows[0].key, 40, 'correct key') // TODO fix this is currently collating as strings - use gson?
+    assert.equal(result.rows.length, 2, '2 row matched')
+    assert(result.rows[0].value === 'alice', 'correct value')
+  })
+  it('query two rows easy', async () => {
+    const result = await index.query({ range: [40, 41] })
+    assert(result, 'did return result')
+    assert(result.rows)
+    assert.equal(result.rows.length, 2, '2 row matched')
+    assert(result.rows[0].key === 40, 'correct key')
+    assert(result.rows[0].value === 'alice', 'correct value')
+  })
+  it('update index', async () => {
+    const bresult = await index.query({ range: [2, 90] })
+    assert(bresult, 'did return bresult')
+    // console.x('bresult.rows', bresult.rows)
+    assert.equal(bresult.rows.length, 6, 'all row matched')
+
+    const oldHead = database.clock
+
+    const notYet = await database.get('xxxx-3c3a-4b5e-9c1c-8c5c0c5c0c5c').catch((e) => e)
+    assert.equal(notYet.message, 'Not found', 'not yet there')
+    console.x('initial Xander 53', notYet)
+    const response = await database.put({ _id: 'xxxx-3c3a-4b5e-9c1c-8c5c0c5c0c5c', name: 'Xander', age: 53 })
+    assert(response)
+    assert(response.id, 'should have id')
+
+    const gotX = await database.get(response.id)
+    assert(gotX)
+    assert(gotX.name === 'Xander', 'got Xander')
+    console.x('got X')
+
+    const snap = database.snapshot(oldHead)
+
+    const aliceOld = await snap.get('a1s3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c')// .catch((e) => e)
+    console.x('aliceOld', aliceOld)
+    assert.equal(aliceOld.name, 'alice', 'alice old')
+
+    const noX = await snap.get(response.id).catch((e) => e)
+    assert.equal(noX.message, 'Not found', 'not yet there')
+
+    const allresult = await index.query({ range: [2, 90] })
+    assert.equal(allresult.rows.length, 7, 'all row matched')
+
+    const result = await index.query({ range: [51, 54] })
+    assert(result, 'did return result')
+    assert(result.rows)
+    assert.equal(result.rows.length, 1, '1 row matched')
+    assert(result.rows[0].key === 53, 'correct key')
+  })
+  it('update index with document update to different key', async () => {
+    await index.query({ range: [51, 54] })
+
+    console.x('--- make Xander 53')
+    const DOCID = 'xxxx-3c3a-4b5e-9c1c-8c5c0c5c0c5c'
+    const r1 = await database.put({ _id: DOCID, name: 'Xander', age: 53 })
+    assert(r1.id, 'should have id')
+
+    const result = await index.query({ range: [51, 54] })
+    assert(result, 'did return result')
+    assert(result.rows)
+    console.x('result.rows', result.rows)
+    assert.equal(result.rows.length, 1, '1 row matched')
+    assert(result.rows[0].key === 53, 'correct key')
+
+    const snap = database.snapshot(database.clock)
+
+    console.x('--- make Xander 63')
+    const response = await database.put({ _id: DOCID, name: 'Xander', age: 63 })
+    assert(response)
+    assert(response.id, 'should have id')
+
+    const oldXander = await snap.get(r1.id)
+    assert.equal(oldXander.age, 53, 'old xander')
+    // console.x('--- test snapshot', snap.clock)
+
+    const newZander = await database.get(r1.id)
+    assert.equal(newZander.age, 63, 'new xander')
+
+    // console.x('--- test liveshot', database.clock)
+
+    const result2 = await index.query({ range: [61, 64] })
+    assert(result2, 'did return result')
+    assert(result2.rows)
+    assert.equal(result2.rows.length, 1, '1 row matched')
+    assert(result2.rows[0].key === 63, 'correct key')
+
+    const resultempty = await index.query({ range: [51, 54] })
+    assert(resultempty, 'did return resultempty')
+    assert(resultempty.rows)
+    console.x('resultempty.rows', resultempty.rows)
+    assert(resultempty.rows.length === 0, 'old Xander should be gone')
+
+    const allresult = await index.query({ range: [2, 90] })
+    console.x('allresult.rows', allresult.rows)
+    // todo
+    assert.equal(allresult.rows.length, 7, 'all row matched')
+  })
+  it('update index with document deletion', async () => {
+    await index.query({ range: [51, 54] })
+
+    console.x('--- make Xander 53')
+    const DOCID = 'xxxx-3c3a-4b5e-9c1c-8c5c0c5c0c5c'
+    const r1 = await database.put({ _id: DOCID, name: 'Xander', age: 53 })
+    assert(r1.id, 'should have id')
+
+    const result = await index.query({ range: [51, 54] })
+    assert(result, 'did return result')
+    assert(result.rows)
+    console.x('result.rows', result.rows)
+    assert.equal(result.rows.length, 1, '1 row matched')
+    assert(result.rows[0].key === 53, 'correct key')
+
+    const snap = database.snapshot(database.clock)
+
+    console.x('--- delete Xander 53')
+    const response = await database.del(DOCID)
+    assert(response)
+    assert(response.id, 'should have id')
+
+    const oldXander = await snap.get(r1.id)
+    assert.equal(oldXander.age, 53, 'old xander')
+    // console.x('--- test snapshot', snap.clock)
+
+    const newZander = await database.get(r1.id).catch((e) => e)
+    assert.equal(newZander.message, 'Not found', 'new xander')
+    // console.x('--- test liveshot', database.clock)
+
+    const allresult = await index.query({ range: [2, 90] })
+    console.x('allresult.rows', allresult.rows)
+    // todo
+    assert.equal(allresult.rows.length, 6, 'all row matched')
+
+    const result2 = await index.query({ range: [51, 54] })
+    assert(result2, 'did return result')
+    assert(result2.rows)
+    assert.equal(result2.rows.length, 0, '0 row matched')
+  })
+})
+
+describe('Index query with bad index definition', () => {
+  let database, index
+  beforeEach(async () => {
+    database = new Fireproof(new Blockstore(), []) // todo: these need a cloud name aka w3name, add this after we have cloud storage of blocks
+    await database.put({ _id: 'a1s3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c', name: 'alice', age: 40 })
+    index = new Index(database, function (doc, map) {
+      map(doc.oops.missingField, doc.name)
+    })
+  })
+  it('query index range', async () => {
+    await index.query({ range: [41, 44] }).catch((e) => {
+      assert(/missingField/.test(e.message))
+    })
+  })
+})

package/test/fireproof.test.js

@@ -0,0 +1,287 @@
+import { describe, it, beforeEach } from 'mocha'
+import assert from 'node:assert'
+import Blockstore from '../src/blockstore.js'
+import Fireproof from '../src/fireproof.js'
+
+let database, resp0
+
+// const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+
+describe('Fireproof', () => {
+  beforeEach(async () => {
+    database = new Fireproof(new Blockstore(), []) // todo: these need a cloud name aka w3name, add this after we have cloud storage of blocks
+    resp0 = await database.put({
+      _id: '1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c',
+      name: 'alice',
+      age: 42
+    })
+  })
+
+  it('put and get document', async () => {
+    assert(resp0.id, 'should have id')
+    assert.equal(resp0.id, '1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c')
+
+    const avalue = await database.get('1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c')
+    assert.equal(avalue.name, 'alice')
+    assert.equal(avalue.age, 42)
+    assert.equal(avalue._id, '1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c')
+  })
+  it('has a factory for making new instances with default settings', async () => {
+    // TODO if you pass it an email it asks the local keyring, and if no key, does the email validation thing
+    const db = await Fireproof.storage({ email: 'jchris@gmail.com' })
+    assert(db instanceof Fireproof)
+  })
+  it('an empty database has no documents', async () => {
+    const db = Fireproof.storage()
+    assert(db instanceof Fireproof)
+    const e = await db.get('8c5c0c5c0c5c').catch((err) => err)
+    assert.equal(e.message, 'Not found')
+    const changes = await db.changesSince()
+    assert.equal(changes.rows.length, 0)
+  })
+  it('update existing document', async () => {
+    // const alice = await database.get('1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c')
+    // assert.equal(alice.name, 'alice')
+
+    const dogKey = 'aster-3c3a-4b5e-9c1c-8c5c0c5c0c5c'
+    const value = {
+      _id: dogKey,
+      name: 'aster',
+      age: 2
+    }
+    const response = await database.put(value)
+    assert(response.id, 'should have id')
+    assert.equal(response.id, dogKey)
+    assert.equal(value._id, dogKey)
+    const oldClock = database.clock
+
+    const avalue = await database.get(dogKey)
+    assert.equal(avalue.name, value.name)
+    assert.equal(avalue.age, value.age)
+    assert.equal(avalue._id, dogKey)
+
+    avalue.age = 3
+    const response2 = await database.put(avalue)
+    assert(response2.id, 'should have id')
+    assert.equal(response2.id, dogKey)
+
+    const bvalue = await database.get(dogKey)
+    assert.equal(bvalue.name, value.name)
+    assert.equal(bvalue.age, 3)
+    assert.equal(bvalue._id, dogKey)
+
+    const snapshot = database.snapshot(oldClock)
+    const snapdoc = await snapshot.get(dogKey)
+    // console.log('snapdoc', snapdoc)
+    // assert(snapdoc.id, 'should have id')
+    assert.equal(snapdoc._id, dogKey)
+    assert.equal(snapdoc.age, 2)
+  })
+  it("update document with validation function that doesn't allow it", async () => {
+    const validationDatabase = new Fireproof(new Blockstore(), [], {
+      validateChange: (newDoc, oldDoc, authCtx) => {
+        if (newDoc.name === 'bob') {
+          throw new Error('no bobs allowed')
+        }
+      }
+    })
+    const validResp = await validationDatabase.put({
+      _id: '111-alice',
+      name: 'alice',
+      age: 42
+    })
+    const getResp = await validationDatabase.get(validResp.id)
+    assert.equal(getResp.name, 'alice')
+
+    let e = await validationDatabase
+      .put({
+        _id: '222-bob',
+        name: 'bob',
+        age: 11
+      })
+      .catch((e) => e)
+    assert.equal(e.message, 'no bobs allowed')
+
+    e = await validationDatabase.get('222-bob').catch((e) => e)
+    assert.equal(e.message, 'Not found')
+  })
+
+  it('get missing document', async () => {
+    const e = await database.get('missing').catch((e) => e)
+    assert.equal(e.message, 'Not found')
+  })
+  it('delete a document', async () => {
+    const id = '1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c'
+    const found = await database.get(id)
+    assert.equal(found._id, id)
+    const deleted = await database.del(id)
+    assert.equal(deleted.id, id)
+    const e = await database
+      .get(id)
+      .then((doc) => assert.equal('should be deleted', JSON.stringify(doc)))
+      .catch((e) => {
+        if (e.message !== 'Not found') {
+          throw e
+        }
+        return e
+      })
+    assert.equal(e.message, 'Not found')
+  })
+
+  it("delete a document with validation function that doesn't allow it", async () => {
+    const validationDatabase = new Fireproof(new Blockstore(), [], {
+      validateChange: (newDoc, oldDoc, authCtx) => {
+        if (oldDoc.name === 'bob') {
+          throw new Error('no changing bob')
+        }
+      }
+    })
+    const validResp = await validationDatabase.put({
+      _id: '222-bob',
+      name: 'bob',
+      age: 11
+    })
+    const getResp = await validationDatabase.get(validResp.id)
+    assert.equal(getResp.name, 'bob')
+
+    const e = await validationDatabase
+      .put({
+        _id: '222-bob',
+        name: 'bob',
+        age: 12
+      })
+      .catch((e) => e)
+    assert.equal(e.message, 'no changing bob')
+
+    let prevBob = await validationDatabase.get('222-bob')
+    assert.equal(prevBob.name, 'bob')
+    assert.equal(prevBob.age, 11)
+
+    const e2 = await validationDatabase.del('222-bob').catch((e) => e)
+    assert.equal(e2.message, 'no changing bob')
+
+    prevBob = await validationDatabase.get('222-bob')
+    assert.equal(prevBob.name, 'bob')
+    assert.equal(prevBob.age, 11)
+  })
+
+  it('provides docs since', async () => {
+    const result = await database.changesSince()
+    assert.equal(result.rows.length, 1)
+    assert.equal(result.rows[0].key, '1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c')
+
+    const result2 = await database.changesSince(result.clock)
+    assert.equal(result2.rows.length, 0)
+
+    const bKey = 'befbef-3c3a-4b5e-9c1c-bbbbbb'
+    const bvalue = {
+      _id: bKey,
+      name: 'bob',
+      age: 44
+    }
+    const response = await database.put(bvalue)
+    assert(response.id, 'should have id')
+    assert.equal(response.id, bKey)
+
+    const res3 = await database.changesSince(result2.clock)
+    assert.equal(res3.rows.length, 1)
+
+    const res4 = await database.changesSince(res3.clock)
+    assert.equal(res4.rows.length, 0)
+    assert.equal(res4.clock[0], res3.clock[0])
+    assert.equal(res4.clock.length, res3.clock.length)
+
+    const cKey = 'cefecef-3c3a-4b5e-9c1c-bbbbbb'
+    const value = {
+      _id: cKey,
+      name: 'carol',
+      age: 44
+    }
+    const response2 = await database.put(value)
+    assert(response2.id, 'should have id')
+    assert.equal(response2.id, cKey)
+
+    const res5 = await database.changesSince(res4.clock)
+
+    // await database.visClock()
+
+    assert.equal(res5.rows.length, 1)
+
+    const res6 = await database.changesSince(result2.clock)
+    assert.equal(res6.rows.length, 2)
+
+    const resultAll = await database.changesSince()
+    assert.equal(resultAll.rows.length, 3)
+    assert.equal(resultAll.rows[0].key, '1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c')
+
+    const res7 = await database.changesSince(resultAll.clock)
+    assert.equal(res7.rows.length, 0)
+
+    const valueCupdate = {
+      _id: cKey,
+      name: 'carol update',
+      age: 45
+    }
+    const responseUpdate = await database.put(valueCupdate)
+    assert(responseUpdate.id)
+
+    const res8 = await database.changesSince(resultAll.clock)
+    assert.equal(res8.rows.length, 1)
+
+    const res9 = await database.changesSince(res8.clock)
+    assert.equal(res9.rows.length, 0)
+  })
+
+  it.skip('docs since repeated changes', async () => {
+    assert.equal((await database.changesSince()).rows.length, 1)
+    let resp, doc, changes
+    for (let index = 0; index < 200; index++) {
+      const id = '' + (300 - index).toString()
+      resp = await database.put({ index, _id: id }).catch(e => {
+        assert.equal(e.message, 'put failed on  _id: ' + id)
+      })
+      assert(resp.id)
+      doc = await database.get(resp.id).catch(e => {
+        console.trace('failed', e)
+        assert.equal(e.message, 'get failed on _id: ' + id)
+      })
+      assert.equal(doc.index, index)
+      changes = await database.changesSince().catch(e => {
+        assert.equal(e.message, 'changesSince failed on  _id: ' + id)
+      })
+      assert.equal(changes.rows.length, index + 2)
+    }
+  }).timeout(20000)
+  it('concurrent transactions', async () => {
+    assert.equal((await database.changesSince()).rows.length, 1)
+    const promises = []
+    let putYes = 0
+    for (let index = 0; index < 20; index++) {
+      const id = 'a' + (300 - index).toString()
+      promises.push(database.put({ index, _id: id }).catch(e => {
+        assert.equal(e.message, 'put failed on  _id: ' + id)
+      }).then(r => {
+        if (r.id) {
+          putYes++
+          return database.get(r.id).catch(e => {
+            // assert.equal(e.message, 'get failed on _id: ' + r.id)
+          }).then(d => {
+            // assert.equal(d.index, index)
+            return r.id
+          })
+        }
+      }))
+      promises.push(database.changesSince().catch(e => {
+        assert.equal(e.message, 'changesSince failed')
+      }).then(c => {
+        assert(c.rows.length > 0)
+        return c.rows.length
+      }))
+    }
+    const got = await Promise.all(promises)
+    assert.equal(got.length, putYes * 2)
+    // console.log('putYes', putYes)
+    // await sleep(1000)
+    assert.equal((await database.changesSince()).rows.length, 2)
+  }).timeout(20000)
+})

package/test/helpers.js

@@ -0,0 +1,45 @@
+import crypto from 'node:crypto'
+// import assert from 'node:assert'
+import * as Link from 'multiformats/link'
+import * as raw from 'multiformats/codecs/raw'
+import { sha256 } from 'multiformats/hashes/sha2'
+import { MemoryBlockstore } from '../src/block.js'
+
+// console.x = console.log
+// console.log = function (...args) {
+//   // window.mutedLog = window.mutedLog || []
+//   // window.mutedLog.push(args)
+// }
+
+/** @param {number} size */
+export async function randomCID (size) {
+  const hash = await sha256.digest(await randomBytes(size))
+  return Link.create(raw.code, hash)
+}
+
+/** @param {number} size */
+export async function randomBytes (size) {
+  const bytes = new Uint8Array(size)
+  while (size) {
+    const chunk = new Uint8Array(Math.min(size, 65_536))
+    crypto.getRandomValues(chunk)
+    size -= bytes.length
+    bytes.set(chunk, size)
+  }
+  return bytes
+}
+
+export class Blockstore extends MemoryBlockstore {
+
+}
+
+let seq = 0
+export function seqEventData (tag = '') {
+  return {
+    type: 'put',
+    value: `event${seq++}${tag}`
+  }
+}
+export function setSeq (n) {
+  seq = n
+}

package/test/listener.test.js

@@ -0,0 +1,102 @@
+import { describe, it, beforeEach } from 'mocha'
+import assert from 'node:assert'
+import Blockstore from '../src/blockstore.js'
+import Fireproof from '../src/fireproof.js'
+import Listener from '../src/listener.js'
+
+let database, listener, star
+
+describe('Listener', () => {
+  beforeEach(async () => {
+    database = new Fireproof(new Blockstore(), []) // todo: these need a cloud name aka w3name, add this after we have cloud storage of blocks
+    const docs = [ // dave is first today
+      { _id: 'd4s3b32a-3c3a', name: 'dave', age: 48 },
+      { _id: 'a1s3b32a-3c3a', name: 'alice', age: 40 },
+      { _id: 'b2s3b32a-3c3a', name: 'bob', age: 40 },
+      { _id: 'c3s3b32a-3c3a', name: 'carol', age: 43 },
+      { _id: 'e4s3b32a-3c3a', name: 'emily', age: 4 },
+      { _id: 'f4s3b32a-3c3a', name: 'frank', age: 7 }
+    ]
+    for (const doc of docs) {
+      const id = doc._id
+      const response = await database.put(doc)
+      assert(response)
+      assert(response.id, 'should have id')
+      assert.equal(response.id, id)
+    }
+    listener = new Listener(database, function (doc, emit) {
+      if (doc.name) { emit('person') }
+    })
+    star = new Listener(database)
+  })
+  it('all listeners get the reset event', (done) => {
+    let count = 0
+    const check = () => {
+      console.log('increment check count')
+      count++
+      if (count === 3) done()
+    }
+    const startClock = database.clock
+    database.put({ _id: 'k645-87tk', name: 'karl' }).then((ok) => {
+      listener.on('person', check)
+      listener.on('not-found', check)
+      star.on('*', check)
+      database.put({ _id: 'k645-87tk', name: 'karl2' }).then((ok) => {
+        assert(ok.id)
+        assert.notEqual(database.clock, startClock)
+        database.setClock(startClock)
+      }).catch(done)
+    })
+  })
+
+  it('can listen to all events', (done) => {
+    star.on('*', (key) => {
+      assert.equal(key, 'i645-87ti')
+      done()
+    })
+    database.put({ _id: 'i645-87ti', name: 'isaac' }).then((ok) => {
+      assert(ok.id)
+    }).catch(done)
+  })
+  it('shares only new events by default', (done) => {
+    listener.on('person', (key) => {
+      assert.equal(key, 'g645-87tg')
+      done()
+    })
+    database.put({ _id: 'g645-87tg', name: 'gwen' }).then((ok) => {
+      assert(ok.id)
+    }).catch(done)
+  }).timeout(200)
+  it('shares all events if asked', async () => {
+    let people = 0
+    listener.on('person', (key) => {
+      people++
+    }, null)
+    // this has to take longer than the database save operation
+    // it's safe to make this number longer if it start failing
+    await sleep(50)
+    assert.equal(people, 6)
+  }).timeout(200)
+  it('shares events since db.clock', (done) => {
+    const clock = database.clock
+    const afterEvent = () => {
+      database.put({ _id: 'j645-87tj', name: 'jimmy' })
+    }
+    let people = 0
+    database.put({ _id: 'h645-87th', name: 'harold' }).then(newPerson => {
+      assert(newPerson.id)
+      listener.on('person', (key) => {
+        people++
+        if (people === 1) {
+          assert.equal(key, 'h645-87th')
+        } else {
+          assert.equal(key, 'j645-87tj')
+          done()
+        }
+        if (people === 1) afterEvent()
+      }, clock)
+    })
+  }).timeout(200)
+})
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))