@itwin/core-backend 5.1.0-dev.34 → 5.1.0-dev.37

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (25) hide show
  1. package/lib/cjs/ChangesetECAdaptor.d.ts +67 -8
  2. package/lib/cjs/ChangesetECAdaptor.d.ts.map +1 -1
  3. package/lib/cjs/ChangesetECAdaptor.js +248 -33
  4. package/lib/cjs/ChangesetECAdaptor.js.map +1 -1
  5. package/lib/cjs/IModelDb.d.ts.map +1 -1
  6. package/lib/cjs/IModelDb.js +1 -0
  7. package/lib/cjs/IModelDb.js.map +1 -1
  8. package/lib/cjs/core-backend.d.ts.map +1 -1
  9. package/lib/cjs/core-backend.js +20 -0
  10. package/lib/cjs/core-backend.js.map +1 -1
  11. package/lib/esm/ChangesetECAdaptor.d.ts +67 -8
  12. package/lib/esm/ChangesetECAdaptor.d.ts.map +1 -1
  13. package/lib/esm/ChangesetECAdaptor.js +248 -33
  14. package/lib/esm/ChangesetECAdaptor.js.map +1 -1
  15. package/lib/esm/IModelDb.d.ts.map +1 -1
  16. package/lib/esm/IModelDb.js +1 -0
  17. package/lib/esm/IModelDb.js.map +1 -1
  18. package/lib/esm/core-backend.d.ts.map +1 -1
  19. package/lib/esm/core-backend.js +20 -0
  20. package/lib/esm/core-backend.js.map +1 -1
  21. package/lib/esm/test/imodel/IModel.test.js +27 -0
  22. package/lib/esm/test/imodel/IModel.test.js.map +1 -1
  23. package/lib/esm/test/standalone/ChangesetReader.test.js +294 -136
  24. package/lib/esm/test/standalone/ChangesetReader.test.js.map +1 -1
  25. package/package.json +13 -13
package/lib/esm/test/standalone/ChangesetReader.test.js CHANGED
@@ -60,7 +60,7 @@ import { Arc3d, IModelJson, Point3d } from "@itwin/core-geometry";
60
60
  import { assert, expect } from "chai";
61
61
  import * as path from "node:path";
62
62
  import { DrawingCategory } from "../../Category";
63
- import { ChangesetECAdaptor as ECChangesetAdaptor, PartialECChangeUnifier } from "../../ChangesetECAdaptor";
63
+ import { ChangesetECAdaptor as ECChangesetAdaptor, ECChangeUnifierCache, PartialECChangeUnifier } from "../../ChangesetECAdaptor";
64
64
  import { HubMock } from "../../internal/HubMock";
65
65
  import { SnapshotDb } from "../../IModelDb";
66
66
  import { SqliteChangesetReader } from "../../SqliteChangesetReader";
@@ -292,32 +292,24 @@ describe("Changeset Reader API", async () => {
292
292
  };
293
293
  rwIModel.saveChanges("user 1: data");
294
294
  if (true || "test local changes") {
295
- const env_1 = { stack: [], error: void 0, hasError: false };
296
- try {
297
- const reader = SqliteChangesetReader.openLocalChanges({ db: rwIModel, disableSchemaCheck: true });
298
- const adaptor = __addDisposableResource(env_1, new ECChangesetAdaptor(reader), false);
299
- const cci = new PartialECChangeUnifier();
300
- while (adaptor.step()) {
301
- cci.appendFrom(adaptor);
302
- }
303
- const changes = Array.from(cci.instances);
295
+ const testChanges = (changes) => {
304
296
  assert.equal(changes.length, 3);
305
- assert.equal(changes[0].ECInstanceId, "0x20000000004");
306
- assert.equal(changes[0].$meta?.classFullName, "TestDomain:Test2dElement");
307
- assert.equal(changes[0].$meta?.op, "Inserted");
297
+ assert.equal(changes[0].ECInstanceId, "0x20000000001");
298
+ assert.equal(changes[0].$meta?.classFullName, "BisCore:DrawingModel");
299
+ assert.equal(changes[0].$meta?.op, "Updated");
308
300
  assert.equal(changes[0].$meta?.stage, "New");
301
+ assert.isNotNull(changes[0].LastMod);
302
+ assert.isNotNull(changes[0].GeometryGuid);
309
303
  assert.equal(changes[1].ECInstanceId, "0x20000000001");
310
304
  assert.equal(changes[1].$meta?.classFullName, "BisCore:DrawingModel");
311
305
  assert.equal(changes[1].$meta?.op, "Updated");
312
- assert.equal(changes[1].$meta?.stage, "New");
313
- assert.isNotNull(changes[1].LastMod);
314
- assert.isNotNull(changes[1].GeometryGuid);
315
- assert.equal(changes[2].ECInstanceId, "0x20000000001");
316
- assert.equal(changes[2].$meta?.classFullName, "BisCore:DrawingModel");
317
- assert.equal(changes[2].$meta?.op, "Updated");
318
- assert.equal(changes[2].$meta?.stage, "Old");
319
- assert.isNull(changes[2].LastMod);
320
- assert.isNull(changes[2].GeometryGuid);
306
+ assert.equal(changes[1].$meta?.stage, "Old");
307
+ assert.isNull(changes[1].LastMod);
308
+ assert.isNull(changes[1].GeometryGuid);
309
+ assert.equal(changes[2].ECInstanceId, "0x20000000004");
310
+ assert.equal(changes[2].$meta?.classFullName, "TestDomain:Test2dElement");
311
+ assert.equal(changes[2].$meta?.op, "Inserted");
312
+ assert.equal(changes[2].$meta?.stage, "New");
321
313
  const el = changes.filter((x) => x.ECInstanceId === "0x20000000004")[0];
322
314
  assert.equal(el.Rotation, 0);
323
315
  // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -357,15 +349,45 @@ describe("Changeset Reader API", async () => {
357
349
  1,
358
350
  ],
359
351
  stage: "New",
360
- fallbackClassId: undefined,
361
352
  });
353
+ };
354
+ if (true || "test with InMemoryInstanceCache") {
355
+ const env_1 = { stack: [], error: void 0, hasError: false };
356
+ try {
357
+ const reader = __addDisposableResource(env_1, SqliteChangesetReader.openLocalChanges({ db: rwIModel, disableSchemaCheck: true }), false);
358
+ const adaptor = __addDisposableResource(env_1, new ECChangesetAdaptor(reader), false);
359
+ const pcu = __addDisposableResource(env_1, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createInMemoryCache()), false);
360
+ while (adaptor.step()) {
361
+ pcu.appendFrom(adaptor);
362
+ }
363
+ testChanges(Array.from(pcu.instances));
364
+ }
365
+ catch (e_1) {
366
+ env_1.error = e_1;
367
+ env_1.hasError = true;
368
+ }
369
+ finally {
370
+ __disposeResources(env_1);
371
+ }
362
372
  }
363
- catch (e_1) {
364
- env_1.error = e_1;
365
- env_1.hasError = true;
366
- }
367
- finally {
368
- __disposeResources(env_1);
373
+ if (true || "test with SqliteBackedInstanceCache") {
374
+ const env_2 = { stack: [], error: void 0, hasError: false };
375
+ try {
376
+ const reader = __addDisposableResource(env_2, SqliteChangesetReader.openLocalChanges({ db: rwIModel, disableSchemaCheck: true }), false);
377
+ const adaptor = __addDisposableResource(env_2, new ECChangesetAdaptor(reader), false);
378
+ const pcu = __addDisposableResource(env_2, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createSqliteBackedCache(rwIModel)), false);
379
+ while (adaptor.step()) {
380
+ pcu.appendFrom(adaptor);
381
+ }
382
+ testChanges(Array.from(pcu.instances));
383
+ }
384
+ catch (e_2) {
385
+ env_2.error = e_2;
386
+ env_2.hasError = true;
387
+ }
388
+ finally {
389
+ __disposeResources(env_2);
390
+ }
369
391
  }
370
392
  }
371
393
  const targetDir = path.join(KnownTestLocations.outputDir, rwIModelId, "changesets");
@@ -373,86 +395,144 @@ describe("Changeset Reader API", async () => {
373
395
  await updatedElements();
374
396
  const changesets = await HubMock.downloadChangesets({ iModelId: rwIModelId, targetDir });
375
397
  if (true || "updated element") {
376
- const reader = SqliteChangesetReader.openFile({ fileName: changesets[3].pathname, db: rwIModel, disableSchemaCheck: true });
377
- const adaptor = new ECChangesetAdaptor(reader);
378
- const cci = new PartialECChangeUnifier();
379
- while (adaptor.step()) {
380
- cci.appendFrom(adaptor);
398
+ const testChanges = (changes) => {
399
+ assert.equal(changes.length, 4);
400
+ const classId = getClassIdByName(rwIModel, "Test2dElement");
401
+ // new value
402
+ assert.equal(changes[2].ECInstanceId, "0x20000000004");
403
+ assert.equal(changes[2].ECClassId, classId);
404
+ assert.equal(changes[2].s, "updated property");
405
+ assert.equal(changes[2].$meta?.classFullName, "TestDomain:Test2dElement");
406
+ assert.equal(changes[2].$meta?.op, "Updated");
407
+ assert.equal(changes[2].$meta?.stage, "New");
408
+ // old value
409
+ assert.equal(changes[3].ECInstanceId, "0x20000000004");
410
+ assert.equal(changes[3].ECClassId, classId);
411
+ assert.equal(changes[3].s, "xxxxxxxxx");
412
+ assert.equal(changes[3].$meta?.classFullName, "TestDomain:Test2dElement");
413
+ assert.equal(changes[3].$meta?.op, "Updated");
414
+ assert.equal(changes[3].$meta?.stage, "Old");
415
+ };
416
+ if (true || "test with InMemoryInstanceCache") {
417
+ const env_3 = { stack: [], error: void 0, hasError: false };
418
+ try {
419
+ const reader = __addDisposableResource(env_3, SqliteChangesetReader.openFile({ fileName: changesets[3].pathname, db: rwIModel, disableSchemaCheck: true }), false);
420
+ const adaptor = __addDisposableResource(env_3, new ECChangesetAdaptor(reader), false);
421
+ const pcu = __addDisposableResource(env_3, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createInMemoryCache()), false);
422
+ while (adaptor.step()) {
423
+ pcu.appendFrom(adaptor);
424
+ }
425
+ testChanges(Array.from(pcu.instances));
426
+ }
427
+ catch (e_3) {
428
+ env_3.error = e_3;
429
+ env_3.hasError = true;
430
+ }
431
+ finally {
432
+ __disposeResources(env_3);
433
+ }
434
+ }
435
+ if (true || "test with SqliteBackedInstanceCache") {
436
+ const env_4 = { stack: [], error: void 0, hasError: false };
437
+ try {
438
+ const reader = __addDisposableResource(env_4, SqliteChangesetReader.openFile({ fileName: changesets[3].pathname, db: rwIModel, disableSchemaCheck: true }), false);
439
+ const adaptor = __addDisposableResource(env_4, new ECChangesetAdaptor(reader), false);
440
+ const pcu = __addDisposableResource(env_4, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createSqliteBackedCache(rwIModel)), false);
441
+ while (adaptor.step()) {
442
+ pcu.appendFrom(adaptor);
443
+ }
444
+ testChanges(Array.from(pcu.instances));
445
+ }
446
+ catch (e_4) {
447
+ env_4.error = e_4;
448
+ env_4.hasError = true;
449
+ }
450
+ finally {
451
+ __disposeResources(env_4);
452
+ }
381
453
  }
382
- const changes = Array.from(cci.instances);
383
- assert.equal(changes.length, 4);
384
- const classId = getClassIdByName(rwIModel, "Test2dElement");
385
- // new value
386
- assert.equal(changes[0].ECInstanceId, "0x20000000004");
387
- assert.equal(changes[0].ECClassId, classId);
388
- assert.equal(changes[0].s, "updated property");
389
- assert.equal(changes[0].$meta?.classFullName, "TestDomain:Test2dElement");
390
- assert.equal(changes[0].$meta?.op, "Updated");
391
- assert.equal(changes[0].$meta?.stage, "New");
392
- // old value
393
- assert.equal(changes[1].ECInstanceId, "0x20000000004");
394
- assert.equal(changes[1].ECClassId, classId);
395
- assert.equal(changes[1].s, "xxxxxxxxx");
396
- assert.equal(changes[1].$meta?.classFullName, "TestDomain:Test2dElement");
397
- assert.equal(changes[1].$meta?.op, "Updated");
398
- assert.equal(changes[1].$meta?.stage, "Old");
399
454
  }
400
455
  if (true || "updated element when no classId") {
401
456
  const otherDb = SnapshotDb.openFile(IModelTestUtils.resolveAssetFile("test.bim"));
402
- const reader = SqliteChangesetReader.openFile({ fileName: changesets[3].pathname, db: otherDb, disableSchemaCheck: true });
403
- const adaptor = new ECChangesetAdaptor(reader);
404
- const cci = new PartialECChangeUnifier();
405
- while (adaptor.step()) {
406
- cci.appendFrom(adaptor);
457
+ const testChanges = (changes) => {
458
+ assert.equal(changes.length, 4);
459
+ // new value
460
+ assert.equal(changes[2].ECInstanceId, "0x20000000004");
461
+ assert.isUndefined(changes[2].ECClassId);
462
+ assert.isDefined(changes[2].$meta?.fallbackClassId);
463
+ assert.equal(changes[2].$meta?.fallbackClassId, "0x3d");
464
+ assert.isUndefined(changes[2].s);
465
+ assert.equal(changes[2].$meta?.classFullName, "BisCore:GeometricElement2d");
466
+ assert.equal(changes[2].$meta?.op, "Updated");
467
+ assert.equal(changes[2].$meta?.stage, "New");
468
+ // old value
469
+ assert.equal(changes[3].ECInstanceId, "0x20000000004");
470
+ assert.isUndefined(changes[3].ECClassId);
471
+ assert.isDefined(changes[3].$meta?.fallbackClassId);
472
+ assert.equal(changes[3].$meta?.fallbackClassId, "0x3d");
473
+ assert.isUndefined(changes[3].s);
474
+ assert.equal(changes[3].$meta?.classFullName, "BisCore:GeometricElement2d");
475
+ assert.equal(changes[3].$meta?.op, "Updated");
476
+ assert.equal(changes[3].$meta?.stage, "Old");
477
+ };
478
+ if (true || "test with InMemoryInstanceCache") {
479
+ const env_5 = { stack: [], error: void 0, hasError: false };
480
+ try {
481
+ const reader = __addDisposableResource(env_5, SqliteChangesetReader.openFile({ fileName: changesets[3].pathname, db: otherDb, disableSchemaCheck: true }), false);
482
+ const adaptor = __addDisposableResource(env_5, new ECChangesetAdaptor(reader), false);
483
+ const pcu = __addDisposableResource(env_5, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createInMemoryCache()), false);
484
+ while (adaptor.step()) {
485
+ pcu.appendFrom(adaptor);
486
+ }
487
+ testChanges(Array.from(pcu.instances));
488
+ }
489
+ catch (e_5) {
490
+ env_5.error = e_5;
491
+ env_5.hasError = true;
492
+ }
493
+ finally {
494
+ __disposeResources(env_5);
495
+ }
496
+ }
497
+ if (true || "test with SqliteBackedInstanceCache") {
498
+ const env_6 = { stack: [], error: void 0, hasError: false };
499
+ try {
500
+ const reader = __addDisposableResource(env_6, SqliteChangesetReader.openFile({ fileName: changesets[3].pathname, db: otherDb, disableSchemaCheck: true }), false);
501
+ const adaptor = __addDisposableResource(env_6, new ECChangesetAdaptor(reader), false);
502
+ const pcu = __addDisposableResource(env_6, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createSqliteBackedCache(rwIModel)), false);
503
+ while (adaptor.step()) {
504
+ pcu.appendFrom(adaptor);
505
+ }
506
+ testChanges(Array.from(pcu.instances));
507
+ }
508
+ catch (e_6) {
509
+ env_6.error = e_6;
510
+ env_6.hasError = true;
511
+ }
512
+ finally {
513
+ __disposeResources(env_6);
514
+ }
407
515
  }
408
- const changes = Array.from(cci.instances);
409
- assert.equal(changes.length, 4);
410
- // new value
411
- assert.equal(changes[0].ECInstanceId, "0x20000000004");
412
- assert.isUndefined(changes[0].ECClassId);
413
- assert.isDefined(changes[0].$meta?.fallbackClassId);
414
- assert.equal(changes[0].$meta?.fallbackClassId, "0x3d");
415
- assert.isUndefined(changes[0].s);
416
- assert.equal(changes[0].$meta?.classFullName, "BisCore:GeometricElement2d");
417
- assert.equal(changes[0].$meta?.op, "Updated");
418
- assert.equal(changes[0].$meta?.stage, "New");
419
- // old value
420
- assert.equal(changes[1].ECInstanceId, "0x20000000004");
421
- assert.isUndefined(changes[1].ECClassId);
422
- assert.isDefined(changes[1].$meta?.fallbackClassId);
423
- assert.equal(changes[1].$meta?.fallbackClassId, "0x3d");
424
- assert.isUndefined(changes[1].s);
425
- assert.equal(changes[1].$meta?.classFullName, "BisCore:GeometricElement2d");
426
- assert.equal(changes[1].$meta?.op, "Updated");
427
- assert.equal(changes[1].$meta?.stage, "Old");
428
516
  }
429
517
  if (true || "test changeset file") {
430
- const env_2 = { stack: [], error: void 0, hasError: false };
431
- try {
432
- const reader = SqliteChangesetReader.openFile({ fileName: changesets[2].pathname, db: rwIModel, disableSchemaCheck: true });
433
- const adaptor = __addDisposableResource(env_2, new ECChangesetAdaptor(reader), false);
434
- const cci = new PartialECChangeUnifier();
435
- while (adaptor.step()) {
436
- cci.appendFrom(adaptor);
437
- }
438
- const changes = Array.from(cci.instances);
518
+ const testChanges = (changes) => {
439
519
  assert.equal(changes.length, 3);
440
- assert.equal(changes[0].ECInstanceId, "0x20000000004");
441
- assert.equal(changes[0].$meta?.classFullName, "TestDomain:Test2dElement");
442
- assert.equal(changes[0].$meta?.op, "Inserted");
520
+ assert.equal(changes[0].ECInstanceId, "0x20000000001");
521
+ assert.equal(changes[0].$meta?.classFullName, "BisCore:DrawingModel");
522
+ assert.equal(changes[0].$meta?.op, "Updated");
443
523
  assert.equal(changes[0].$meta?.stage, "New");
524
+ assert.isNotNull(changes[0].LastMod);
525
+ assert.isNotNull(changes[0].GeometryGuid);
444
526
  assert.equal(changes[1].ECInstanceId, "0x20000000001");
445
527
  assert.equal(changes[1].$meta?.classFullName, "BisCore:DrawingModel");
446
528
  assert.equal(changes[1].$meta?.op, "Updated");
447
- assert.equal(changes[1].$meta?.stage, "New");
448
- assert.isNotNull(changes[1].LastMod);
449
- assert.isNotNull(changes[1].GeometryGuid);
450
- assert.equal(changes[2].ECInstanceId, "0x20000000001");
451
- assert.equal(changes[2].$meta?.classFullName, "BisCore:DrawingModel");
452
- assert.equal(changes[2].$meta?.op, "Updated");
453
- assert.equal(changes[2].$meta?.stage, "Old");
454
- assert.isNull(changes[2].LastMod);
455
- assert.isNull(changes[2].GeometryGuid);
529
+ assert.equal(changes[1].$meta?.stage, "Old");
530
+ assert.isNull(changes[1].LastMod);
531
+ assert.isNull(changes[1].GeometryGuid);
532
+ assert.equal(changes[2].ECInstanceId, "0x20000000004");
533
+ assert.equal(changes[2].$meta?.classFullName, "TestDomain:Test2dElement");
534
+ assert.equal(changes[2].$meta?.op, "Inserted");
535
+ assert.equal(changes[2].$meta?.stage, "New");
456
536
  const el = changes.filter((x) => x.ECInstanceId === "0x20000000004")[0];
457
537
  assert.equal(el.Rotation, 0);
458
538
  // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -492,50 +572,95 @@ describe("Changeset Reader API", async () => {
492
572
  1,
493
573
  ],
494
574
  stage: "New",
495
- fallbackClassId: undefined,
496
575
  });
576
+ };
577
+ if (true || "test with InMemoryInstanceCache") {
578
+ const env_7 = { stack: [], error: void 0, hasError: false };
579
+ try {
580
+ const reader = __addDisposableResource(env_7, SqliteChangesetReader.openFile({ fileName: changesets[2].pathname, db: rwIModel, disableSchemaCheck: true }), false);
581
+ const adaptor = __addDisposableResource(env_7, new ECChangesetAdaptor(reader), false);
582
+ const pcu = __addDisposableResource(env_7, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createInMemoryCache()), false);
583
+ while (adaptor.step()) {
584
+ pcu.appendFrom(adaptor);
585
+ }
586
+ testChanges(Array.from(pcu.instances));
587
+ }
588
+ catch (e_7) {
589
+ env_7.error = e_7;
590
+ env_7.hasError = true;
591
+ }
592
+ finally {
593
+ __disposeResources(env_7);
594
+ }
497
595
  }
498
- catch (e_2) {
499
- env_2.error = e_2;
500
- env_2.hasError = true;
501
- }
502
- finally {
503
- __disposeResources(env_2);
596
+ if (true || "test with SqliteBackedInstanceCache") {
597
+ const env_8 = { stack: [], error: void 0, hasError: false };
598
+ try {
599
+ const reader = __addDisposableResource(env_8, SqliteChangesetReader.openFile({ fileName: changesets[2].pathname, db: rwIModel, disableSchemaCheck: true }), false);
600
+ const adaptor = __addDisposableResource(env_8, new ECChangesetAdaptor(reader), false);
601
+ const pcu = __addDisposableResource(env_8, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createSqliteBackedCache(rwIModel)), false);
602
+ while (adaptor.step()) {
603
+ pcu.appendFrom(adaptor);
604
+ }
605
+ testChanges(Array.from(pcu.instances));
606
+ }
607
+ catch (e_8) {
608
+ env_8.error = e_8;
609
+ env_8.hasError = true;
610
+ }
611
+ finally {
612
+ __disposeResources(env_8);
613
+ }
504
614
  }
505
615
  }
506
616
  if (true || "test ChangesetAdaptor.acceptClass()") {
507
- const env_3 = { stack: [], error: void 0, hasError: false };
508
- try {
509
- const reader = SqliteChangesetReader.openFile({ fileName: changesets[2].pathname, db: rwIModel, disableSchemaCheck: true });
510
- const adaptor = __addDisposableResource(env_3, new ECChangesetAdaptor(reader), false);
511
- adaptor.acceptClass("TestDomain.Test2dElement");
512
- const cci = new PartialECChangeUnifier();
513
- while (adaptor.step()) {
514
- cci.appendFrom(adaptor);
515
- }
516
- const changes = Array.from(cci.instances);
617
+ const testChanges = (changes) => {
517
618
  assert.equal(changes.length, 1);
518
619
  assert.equal(changes[0].$meta?.classFullName, "TestDomain:Test2dElement");
620
+ };
621
+ if (true || "test with InMemoryInstanceCache") {
622
+ const env_9 = { stack: [], error: void 0, hasError: false };
623
+ try {
624
+ const reader = __addDisposableResource(env_9, SqliteChangesetReader.openFile({ fileName: changesets[2].pathname, db: rwIModel, disableSchemaCheck: true }), false);
625
+ const adaptor = __addDisposableResource(env_9, new ECChangesetAdaptor(reader), false);
626
+ adaptor.acceptClass("TestDomain.Test2dElement");
627
+ const pcu = __addDisposableResource(env_9, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createInMemoryCache()), false);
628
+ while (adaptor.step()) {
629
+ pcu.appendFrom(adaptor);
630
+ }
631
+ testChanges(Array.from(pcu.instances));
632
+ }
633
+ catch (e_9) {
634
+ env_9.error = e_9;
635
+ env_9.hasError = true;
636
+ }
637
+ finally {
638
+ __disposeResources(env_9);
639
+ }
519
640
  }
520
- catch (e_3) {
521
- env_3.error = e_3;
522
- env_3.hasError = true;
523
- }
524
- finally {
525
- __disposeResources(env_3);
641
+ if (true || "test with SqliteBackedInstanceCache") {
642
+ const env_10 = { stack: [], error: void 0, hasError: false };
643
+ try {
644
+ const reader = __addDisposableResource(env_10, SqliteChangesetReader.openFile({ fileName: changesets[2].pathname, db: rwIModel, disableSchemaCheck: true }), false);
645
+ const adaptor = __addDisposableResource(env_10, new ECChangesetAdaptor(reader), false);
646
+ adaptor.acceptClass("TestDomain.Test2dElement");
647
+ const pcu = __addDisposableResource(env_10, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createSqliteBackedCache(rwIModel)), false);
648
+ while (adaptor.step()) {
649
+ pcu.appendFrom(adaptor);
650
+ }
651
+ testChanges(Array.from(pcu.instances));
652
+ }
653
+ catch (e_10) {
654
+ env_10.error = e_10;
655
+ env_10.hasError = true;
656
+ }
657
+ finally {
658
+ __disposeResources(env_10);
659
+ }
526
660
  }
527
661
  }
528
662
  if (true || "test ChangesetAdaptor.adaptor()") {
529
- const env_4 = { stack: [], error: void 0, hasError: false };
530
- try {
531
- const reader = SqliteChangesetReader.openFile({ fileName: changesets[2].pathname, db: rwIModel, disableSchemaCheck: true });
532
- const adaptor = __addDisposableResource(env_4, new ECChangesetAdaptor(reader), false);
533
- adaptor.acceptOp("Updated");
534
- const cci = new PartialECChangeUnifier();
535
- while (adaptor.step()) {
536
- cci.appendFrom(adaptor);
537
- }
538
- const changes = Array.from(cci.instances);
663
+ const testChanges = (changes) => {
539
664
  assert.equal(changes.length, 2);
540
665
  assert.equal(changes[0].ECInstanceId, "0x20000000001");
541
666
  assert.equal(changes[0].$meta?.classFullName, "BisCore:DrawingModel");
@@ -545,13 +670,46 @@ describe("Changeset Reader API", async () => {
545
670
  assert.equal(changes[1].$meta?.classFullName, "BisCore:DrawingModel");
546
671
  assert.equal(changes[1].$meta?.op, "Updated");
547
672
  assert.equal(changes[1].$meta?.stage, "Old");
673
+ };
674
+ if (true || "test with InMemoryInstanceCache") {
675
+ const env_11 = { stack: [], error: void 0, hasError: false };
676
+ try {
677
+ const reader = __addDisposableResource(env_11, SqliteChangesetReader.openFile({ fileName: changesets[2].pathname, db: rwIModel, disableSchemaCheck: true }), false);
678
+ const adaptor = __addDisposableResource(env_11, new ECChangesetAdaptor(reader), false);
679
+ adaptor.acceptOp("Updated");
680
+ const pcu = __addDisposableResource(env_11, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createInMemoryCache()), false);
681
+ while (adaptor.step()) {
682
+ pcu.appendFrom(adaptor);
683
+ }
684
+ testChanges(Array.from(pcu.instances));
685
+ }
686
+ catch (e_11) {
687
+ env_11.error = e_11;
688
+ env_11.hasError = true;
689
+ }
690
+ finally {
691
+ __disposeResources(env_11);
692
+ }
548
693
  }
549
- catch (e_4) {
550
- env_4.error = e_4;
551
- env_4.hasError = true;
552
- }
553
- finally {
554
- __disposeResources(env_4);
694
+ if (true || "test with SqliteBackedInstanceCache") {
695
+ const env_12 = { stack: [], error: void 0, hasError: false };
696
+ try {
697
+ const reader = __addDisposableResource(env_12, SqliteChangesetReader.openFile({ fileName: changesets[2].pathname, db: rwIModel, disableSchemaCheck: true }), false);
698
+ const adaptor = __addDisposableResource(env_12, new ECChangesetAdaptor(reader), false);
699
+ adaptor.acceptOp("Updated");
700
+ const pcu = __addDisposableResource(env_12, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createSqliteBackedCache(rwIModel)), false);
701
+ while (adaptor.step()) {
702
+ pcu.appendFrom(adaptor);
703
+ }
704
+ testChanges(Array.from(pcu.instances));
705
+ }
706
+ catch (e_12) {
707
+ env_12.error = e_12;
708
+ env_12.hasError = true;
709
+ }
710
+ finally {
711
+ __disposeResources(env_12);
712
+ }
555
713
  }
556
714
  }
557
715
  rwIModel.close();