@speckle/objectloader2 2.25.1 → 2.25.7

package/src/operations/downloaders/__snapshots__/memoryDownloader.spec.ts.snap

@@ -0,0 +1,12 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`MemoryDownloader > should add found item to results queue 1`] = `
+Map {
+  "id1" => {
+    "foo": "foo",
+  },
+  "id2" => {
+    "foo": "bar",
+  },
+}
+`;

package/src/operations/downloaders/memoryDownloader.spec.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { MemoryDownloader } from './memoryDownloader.js'
+import { Base, Item } from '../../types/types.js'
+import Queue from '../../helpers/queue.js'
+import BufferQueue from '../../helpers/bufferQueue.js'
+
+const makeBase = (foo: string): Base => ({ foo } as unknown as Base)
+
+describe('MemoryDownloader', () => {
+  let items: Map<string, Base>
+  let downloader: MemoryDownloader
+  let results: Queue<Item>
+
+  beforeEach(() => {
+    items = new Map([
+      ['id1', makeBase('foo')],
+      ['id2', makeBase('bar')]
+    ])
+    downloader = new MemoryDownloader('id1', items)
+    results = new BufferQueue<Item>()
+  })
+
+  it('should download the root item', async () => {
+    const item = await downloader.downloadSingle()
+    expect(item).toEqual({ baseId: 'id1', base: { foo: 'foo' } })
+  })
+
+  it('should throw if root item is missing', async () => {
+    const missingDownloader = new MemoryDownloader('missing', items)
+    await expect(missingDownloader.downloadSingle()).rejects.toThrow(
+      'Method not implemented.'
+    )
+  })
+
+  it('should add found item to results queue', () => {
+    downloader.initializePool({ results, total: 2 })
+    downloader.add('id2')
+    expect(items).toMatchSnapshot()
+  })
+
+  it('should throw if added item is missing', () => {
+    downloader.initializePool({ results, total: 2 })
+    expect(() => downloader.add('missing')).toThrow()
+  })
+
+  it('disposeAsync should resolve', async () => {
+    await expect(downloader.disposeAsync()).resolves.not.toThrow()
+  })
+})

package/src/operations/downloaders/memoryDownloader.ts

@@ -23,7 +23,7 @@ export class MemoryDownloader implements Downloader {
     if (root) {
       return Promise.resolve({ baseId: this.#rootId, base: root })
     }
-    throw new Error('Method not implemented.')
+    return Promise.reject(new Error('Method not implemented.'))
   }
   disposeAsync(): Promise<void> {
     return Promise.resolve()

package/src/operations/downloaders/serverDownloader.ts

@@ -53,7 +53,7 @@ export default class ServerDownloader implements Downloader {
       return [total]
     }
 
-    return [10000, 30000, 10000, 1000]
+    return [10000, 25000, 10000, 1000]
   }
 
   initializePool(params: {

package/src/operations/interfaces.ts

@@ -13,7 +13,6 @@ export interface Downloader extends Queue<string> {
 
 export interface Database {
   getAll(keys: string[]): Promise<(Item | undefined)[]>
-  getItem(params: { id: string }): Promise<Item | undefined>
   cacheSaveBatch(params: { batch: Item[] }): Promise<void>
   disposeAsync(): Promise<void>
 }

package/src/operations/objectLoader2.ts

@@ -41,7 +41,7 @@ export class ObjectLoader2 {
     this.#database = options.database
     this.#deferments = new DefermentManager({
       maxSizeInMb: 2_000, // 2 GBs
-      ttlms: 5_000, // 5 seconds
+      ttlms: 15_000, // 15 seconds
       logger: this.#logger
     })
     this.#cache = new CacheReader(this.#database, this.#deferments, cacheOptions)
@@ -55,13 +55,17 @@ export class ObjectLoader2 {
   }
 
   async disposeAsync(): Promise<void> {
-    await Promise.all([this.#downloader.disposeAsync(), this.#cache.disposeAsync()])
+    await Promise.all([
+      this.#downloader.disposeAsync(),
+      this.#cache.disposeAsync(),
+      this.#pump.disposeAsync()
+    ])
     this.#deferments.dispose()
   }
 
   async getRootObject(): Promise<Item | undefined> {
     if (!this.#root) {
-      this.#root = await this.#database.getItem({ id: this.#rootId })
+      this.#root = (await this.#database.getAll([this.#rootId]))[0]
       if (!this.#root) {
         this.#root = await this.#downloader.downloadSingle()
       }
@@ -90,7 +94,11 @@ export class ObjectLoader2 {
     yield rootItem.base
     if (!rootItem.base.__closure) return
 
-    const children = Object.keys(rootItem.base.__closure)
+    //sort the closures by their values descending
+    const sortedClosures = Object.entries(rootItem.base.__closure).sort(
+      (a, b) => b[1] - a[1]
+    )
+    const children = sortedClosures.map((x) => x[0])
     const total = children.length
     this.#downloader.initializePool({
       results: new AggregateQueue(this.#gathered, this.#pump),

package/src/operations/objectLoader2Factory.ts

@@ -5,6 +5,14 @@ import { MemoryDownloader } from './downloaders/memoryDownloader.js'
 import ServerDownloader from './downloaders/serverDownloader.js'
 import { ObjectLoader2 } from './objectLoader2.js'
 
+export interface ObjectLoader2FactoryOptions {
+  useMemoryCache?: boolean
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  keyRange?: { bound: Function; lowerBound: Function; upperBound: Function }
+  indexedDB?: IDBFactory
+  logger?: CustomLogger
+}
+
 export class ObjectLoader2Factory {
   static createFromObjects(objects: Base[]): ObjectLoader2 {
     const root = objects[0]
@@ -31,26 +39,40 @@ export class ObjectLoader2Factory {
     objectId: string
     token?: string
     headers?: Headers
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-    keyRange?: { bound: Function; lowerBound: Function; upperBound: Function }
-    indexedDB?: IDBFactory
-    logger?: CustomLogger
+    options?: ObjectLoader2FactoryOptions
   }): ObjectLoader2 {
-    const loader = new ObjectLoader2({
-      rootId: params.objectId,
-      downloader: new ServerDownloader({
-        serverUrl: params.serverUrl,
-        streamId: params.streamId,
-        objectId: params.objectId,
-        token: params.token,
-        headers: params.headers
-      }),
-      database: new IndexedDatabase({
-        logger: params.logger,
-        indexedDB: params.indexedDB,
-        keyRange: params.keyRange
+    let loader: ObjectLoader2
+    if (params.options?.useMemoryCache) {
+      loader = new ObjectLoader2({
+        rootId: params.objectId,
+        downloader: new ServerDownloader({
+          serverUrl: params.serverUrl,
+          streamId: params.streamId,
+          objectId: params.objectId,
+          token: params.token,
+          headers: params.headers
+        }),
+        database: new MemoryDatabase({
+          items: new Map<string, Base>()
+        })
       })
-    })
+    } else {
+      loader = new ObjectLoader2({
+        rootId: params.objectId,
+        downloader: new ServerDownloader({
+          serverUrl: params.serverUrl,
+          streamId: params.streamId,
+          objectId: params.objectId,
+          token: params.token,
+          headers: params.headers
+        }),
+        database: new IndexedDatabase({
+          logger: params.options?.logger,
+          indexedDB: params.options?.indexedDB,
+          keyRange: params.options?.keyRange
+        })
+      })
+    }
     return loader
   }
 }

package/src/test/e2e.spec.ts

@@ -14,8 +14,10 @@ describe('e2e', () => {
         serverUrl: 'https://app.speckle.systems',
         streamId: 'da9e320dad',
         objectId: '31d10c0cea569a1e26809658ed27e281',
-        indexedDB: new IDBFactory(),
-        keyRange: IDBKeyRange
+        options: {
+          indexedDB: new IDBFactory(),
+          keyRange: IDBKeyRange
+        }
       })
 
       const getObjectPromise = loader.getObject({