transactionDataset readability refactor

main
jaxoncreed 2 years ago
parent cf38dcb5f9
commit 5a9cd3660f
  1. 2
      packages/ldo/src/LdoDatasetFactory.ts
  2. 23
      packages/ldo/src/LdoTransactionalDataset.ts
  3. 28
      packages/subscribable-dataset/src/SubscribableDataset.ts
  4. 31
      packages/subscribable-dataset/src/SubscribableDatasetFactory.ts
  5. 43
      packages/subscribable-dataset/src/TransactionDataset.ts
  6. 27
      packages/subscribable-dataset/src/TransactionDatasetFactory.ts
  7. 27
      packages/subscribable-dataset/src/WrapperSubscribableDatasetFactory.ts
  8. 46
      packages/subscribable-dataset/src/createSubscribableDataset.ts
  9. 10
      packages/subscribable-dataset/src/createSubscribableDatasetFromSerializedInput.ts
  10. 30
      packages/subscribable-dataset/src/createWrapperSubscribableDataset.ts
  11. 14
      packages/subscribable-dataset/src/index.ts
  12. 47
      packages/subscribable-dataset/src/types.ts
  13. 11
      packages/subscribable-dataset/test/SubscribableDataset.test.ts
  14. 27
      packages/subscribable-dataset/test/TransactionalDataset.test.ts
  15. 0
      packages/subscribable-dataset/test/createSubscribableDatasetFromSerializedInput.test.ts
  16. 14
      packages/subscribable-dataset/test/index.test.ts

@ -34,7 +34,7 @@ export class LdoDatasetFactory implements DatasetFactory<Quad, Quad> {
*/
dataset(quads?: Dataset<Quad, Quad> | Quad[]): LdoDataset {
return new LdoDataset(
this.datasetFactory,
this,
quads
? Array.isArray(quads)
? this.datasetFactory.dataset(quads)

@ -0,0 +1,23 @@
import type { TransactionalDataset } from "@ldo/subscribable-dataset";
import { LdoDataset } from "../dist/LdoDataset";
import type { Quad } from "@rdfjs/types";
import type { DatasetChanges } from "@ldo/rdf-utils";
export class LdoTransactionalDataset
extends LdoDataset
implements TransactionalDataset<Quad>
{
constructor() {
}
rollback(): void {
throw new Error("Method not implemented.");
}
commit(): void {
throw new Error("Method not implemented.");
}
getChanges(): DatasetChanges<Quad> {
throw new Error("Method not implemented.");
}
}

@ -17,31 +17,34 @@ import type {
} from "@rdfjs/types";
import type {
nodeEventListener,
SubscribableDataset,
TransactionalDataset,
ISubscribableDataset,
ITransactionDataset,
ITransactionDatasetFactory,
} from "./types";
import { ProxyTransactionalDataset } from "./ProxyTransactionalDataset";
/**
* A wrapper for a dataset that allows subscriptions to be made on nodes to
* be triggered whenever a quad containing that added or removed.
*/
export class WrapperSubscribableDataset<
InAndOutQuad extends BaseQuad = BaseQuad,
> implements SubscribableDataset<InAndOutQuad>
export class SubscribableDataset<InAndOutQuad extends BaseQuad = BaseQuad>
implements ISubscribableDataset<InAndOutQuad>
{
/**
* The underlying dataset factory
*/
private datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>;
protected datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>;
/**
* The underlying dataset
*/
private dataset: Dataset<InAndOutQuad, InAndOutQuad>;
protected dataset: Dataset<InAndOutQuad, InAndOutQuad>;
/**
* The underlying event emitter
*/
private eventEmitter: EventEmitter;
protected eventEmitter: EventEmitter;
/**
* The underlying dataset factory for creating transaction datasets
*/
protected transactionDatasetFactory: ITransactionDatasetFactory<InAndOutQuad>;
/**
* Helps find all the events for a given listener
*/
@ -54,9 +57,11 @@ export class WrapperSubscribableDataset<
*/
constructor(
datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>,
transactionDatasetFactory: ITransactionDatasetFactory<InAndOutQuad>,
initialDataset?: Dataset<InAndOutQuad, InAndOutQuad>,
) {
this.datasetFactory = datasetFactory;
this.transactionDatasetFactory = transactionDatasetFactory;
this.dataset = initialDataset || this.datasetFactory.dataset();
this.eventEmitter = new EventEmitter();
}
@ -249,6 +254,7 @@ export class WrapperSubscribableDataset<
* Note: Since a DatasetCore is an unordered set, the order of the quads within the returned sequence is arbitrary.
*/
public toArray(): InAndOutQuad[] {
console.log("Calling toArray");
return this.dataset.toArray();
}
@ -609,7 +615,7 @@ export class WrapperSubscribableDataset<
/**
* Returns a transactional dataset that will update this dataset when its transaction is committed.
*/
public startTransaction(): TransactionalDataset<InAndOutQuad> {
return new ProxyTransactionalDataset(this, this.datasetFactory);
public startTransaction(): ITransactionDataset<InAndOutQuad> {
return this.transactionDatasetFactory.transactionDataset(this);
}
}

@ -0,0 +1,31 @@
import type { DatasetFactory, BaseQuad, Dataset } from "@rdfjs/types";
import type { ITransactionDatasetFactory } from "./types";
import { SubscribableDataset } from "./SubscribableDataset";
/**
* A DatasetFactory that returns a SubscribableDataset given a generic DatasetFactory.
*/
export class SubscribableDatasetFactory<
InAndOutQuad extends BaseQuad = BaseQuad,
> implements DatasetFactory<InAndOutQuad, InAndOutQuad>
{
private datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>;
private transactionDatasetFactory: ITransactionDatasetFactory<InAndOutQuad>;
constructor(
datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>,
transactionDatasetFactory: ITransactionDatasetFactory<InAndOutQuad>,
) {
this.datasetFactory = datasetFactory;
this.transactionDatasetFactory = transactionDatasetFactory;
}
dataset(
quads?: Dataset<InAndOutQuad, InAndOutQuad> | InAndOutQuad[],
): SubscribableDataset<InAndOutQuad> {
return new SubscribableDataset(
this.datasetFactory,
this.transactionDatasetFactory,
quads ? this.datasetFactory.dataset(quads) : undefined,
);
}
}

@ -1,27 +1,26 @@
import type { Dataset, BaseQuad, Term, DatasetFactory } from "@rdfjs/types";
import type { DatasetChanges } from "@ldo/rdf-utils";
import type { BulkEditableDataset, TransactionalDataset } from "./types";
import { ExtendedDataset } from "@ldo/dataset";
import type {
ISubscribableDataset,
ITransactionDataset,
ITransactionDatasetFactory,
} from "./types";
import { mergeDatasetChanges } from "./mergeDatasetChanges";
import { SubscribableDataset } from "./SubscribableDataset";
/**
* Proxy Transactional Dataset is a transactional dataset that does not duplicate
* the parent dataset, it will dynamically determine the correct return value for
* methods in real time when the method is called.
*/
export class ProxyTransactionalDataset<InAndOutQuad extends BaseQuad = BaseQuad>
extends ExtendedDataset<InAndOutQuad>
implements TransactionalDataset<InAndOutQuad>
export class TransactionDataset<InAndOutQuad extends BaseQuad = BaseQuad>
extends SubscribableDataset<InAndOutQuad>
implements ITransactionDataset<InAndOutQuad>
{
/**
* The parent dataset that will be updated upon commit
*/
private parentDataset: Dataset<InAndOutQuad, InAndOutQuad>;
/**
* A factory for creating new datasets to be added to the update method
*/
private datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>;
public readonly parentDataset: ISubscribableDataset<InAndOutQuad>;
/**
* The changes made that are ready to commit
@ -42,12 +41,12 @@ export class ProxyTransactionalDataset<InAndOutQuad extends BaseQuad = BaseQuad>
* @param parentDataset The dataset that will be updated upon commit
*/
constructor(
parentDataset: Dataset<InAndOutQuad, InAndOutQuad>,
parentDataset: ISubscribableDataset<InAndOutQuad>,
datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>,
transactionDatasetFactory: ITransactionDatasetFactory<InAndOutQuad>,
) {
super(datasetFactory.dataset(), datasetFactory);
super(datasetFactory, transactionDatasetFactory, datasetFactory.dataset());
this.parentDataset = parentDataset;
this.datasetFactory = datasetFactory;
this.datasetChanges = {};
}
@ -179,6 +178,7 @@ export class ProxyTransactionalDataset<InAndOutQuad extends BaseQuad = BaseQuad>
* Returns an iterator
*/
public [Symbol.iterator](): Iterator<InAndOutQuad> {
console.log("Getting Iterator");
const addedIterator = (this.datasetChanges.added || [])[Symbol.iterator]();
let addedNext = addedIterator.next();
const parentIterator = this.parentDataset[Symbol.iterator]();
@ -253,9 +253,7 @@ export class ProxyTransactionalDataset<InAndOutQuad extends BaseQuad = BaseQuad>
private updateParentDataset(datasetChanges: DatasetChanges<InAndOutQuad>) {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
if ((this.parentDataset as any).bulk) {
(this.parentDataset as BulkEditableDataset<InAndOutQuad>).bulk(
datasetChanges,
);
this.parentDataset.bulk(datasetChanges);
} else {
if (datasetChanges.added) {
this.parentDataset.addAll(datasetChanges.added);
@ -296,17 +294,6 @@ export class ProxyTransactionalDataset<InAndOutQuad extends BaseQuad = BaseQuad>
this.committedDatasetChanges = undefined;
}
/**
* Starts a new transaction with this transactional dataset as the parent
* @returns
*/
public startTransaction(): TransactionalDataset<InAndOutQuad> {
// This is caused by the typings being incorrect for the intersect method
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
return new ProxyTransactionalDataset(this, this.datasetFactory);
}
public getChanges(): DatasetChanges<InAndOutQuad> {
return this.datasetChanges;
}

@ -0,0 +1,27 @@
import type { BaseQuad, DatasetFactory } from "@rdfjs/types";
import type { ISubscribableDataset, ITransactionDatasetFactory } from "./types";
import { TransactionDataset } from "./TransactionDataset";
export class TransactionDatasetFactory<InAndOutQuad extends BaseQuad>
implements ITransactionDatasetFactory<InAndOutQuad>
{
private datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>;
private transactionDatasetFactory: ITransactionDatasetFactory<InAndOutQuad>;
constructor(
datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>,
transactionDatasetFactory?: ITransactionDatasetFactory<InAndOutQuad>,
) {
this.datasetFactory = datasetFactory;
this.transactionDatasetFactory = transactionDatasetFactory || this;
}
transactionDataset(
parentDataset: ISubscribableDataset<InAndOutQuad>,
): TransactionDataset<InAndOutQuad> {
return new TransactionDataset<InAndOutQuad>(
parentDataset,
this.datasetFactory,
this.transactionDatasetFactory,
);
}
}

@ -1,27 +0,0 @@
import type { DatasetFactory, BaseQuad, Dataset } from "@rdfjs/types";
import { WrapperSubscribableDataset } from "./WrapperSubscribableDataset";
/**
* A DatasetFactory that returns a WrapperSubscribableDataset given a generic DatasetFactory.
*/
export class WrapperSubscribableDatasetFactory<
InAndOutQuad extends BaseQuad = BaseQuad,
> implements DatasetFactory<InAndOutQuad, InAndOutQuad>
{
private datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>;
constructor(datasetFactory: DatasetFactory<InAndOutQuad, InAndOutQuad>) {
this.datasetFactory = datasetFactory;
}
dataset(
quads?: Dataset<InAndOutQuad, InAndOutQuad> | InAndOutQuad[],
): WrapperSubscribableDataset<InAndOutQuad> {
// Typings are wrong
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
return new WrapperSubscribableDataset(
this.datasetFactory,
quads ? this.datasetFactory.dataset(quads) : undefined,
);
}
}

@ -0,0 +1,46 @@
import type { Dataset, DatasetFactory, Quad } from "@rdfjs/types";
import { createDataset } from "@ldo/dataset";
import { SubscribableDatasetFactory } from "./SubscribableDatasetFactory";
import type {
ISubscribableDataset,
ISubscribableDatasetFactory,
ITransactionDatasetFactory,
} from "./types";
import { TransactionDatasetFactory } from "./TransactionDatasetFactory";
const datasetFactory: DatasetFactory<Quad> = {
dataset: (quads?: Dataset<Quad> | Quad[]): Dataset<Quad> => {
return createDataset(quads);
},
};
/**
* Creates a factory that generates TransactionDatasets
* @returns TransactionDatasetFactory
*/
export function createTransactionDatasetFactory(): ITransactionDatasetFactory<Quad> {
return new TransactionDatasetFactory(datasetFactory);
}
/**
* Creates a dataset factory that generates a SubscribableDataset
* @returns DatasetFactory for SubscribableDataset
*/
export function createSubscribableDatasetFactory(): ISubscribableDatasetFactory<Quad> {
return new SubscribableDatasetFactory(
datasetFactory,
createTransactionDatasetFactory(),
);
}
/**
* Creates a SubscribableDataset
* @param quads: A dataset or array of Quads to initialize the dataset.
* @returns Dataset
*/
export function createSubscribableDataset(
quads?: Dataset<Quad> | Quad[],
): ISubscribableDataset<Quad> {
const subscribableDatasetFactory = createSubscribableDatasetFactory();
return subscribableDatasetFactory.dataset(quads);
}

@ -1,8 +1,8 @@
import type { Quad } from "@rdfjs/types";
import type { ParserOptions } from "@ldo/rdf-utils";
import { createDatasetFromSerializedInput } from "@ldo/dataset";
import { createWrapperSubscribableDatasetFactory } from "./createWrapperSubscribableDataset";
import type { WrapperSubscribableDataset } from "./WrapperSubscribableDataset";
import { createSubscribableDatasetFactory } from "./createSubscribableDataset";
import type { ISubscribableDataset } from "./types";
/**
* Creates a SubscribableDataset with a string input that could be JSON-LD, Turtle, N-Triples, TriG, RDF*, or N3.
@ -18,9 +18,9 @@ import type { WrapperSubscribableDataset } from "./WrapperSubscribableDataset";
export async function createWrapperSubscribableDatasetFromSerializedInput(
data: string,
options?: ParserOptions,
): Promise<WrapperSubscribableDataset<Quad>> {
const datasetFactory = createWrapperSubscribableDatasetFactory();
return createDatasetFromSerializedInput<WrapperSubscribableDataset<Quad>>(
): Promise<ISubscribableDataset<Quad>> {
const datasetFactory = createSubscribableDatasetFactory();
return createDatasetFromSerializedInput<ISubscribableDataset<Quad>>(
datasetFactory,
data,
options,

@ -1,30 +0,0 @@
import type { Dataset, DatasetFactory, Quad } from "@rdfjs/types";
import type { WrapperSubscribableDataset } from "./WrapperSubscribableDataset";
import { createDataset } from "@ldo/dataset";
import { WrapperSubscribableDatasetFactory } from "./WrapperSubscribableDatasetFactory";
/**
* Creates a dataset factory that generates a SubscribableDataset
* @returns DatasetFactory for SubscribableDataset
*/
export function createWrapperSubscribableDatasetFactory(): WrapperSubscribableDatasetFactory<Quad> {
const datasetFactory: DatasetFactory<Quad> = {
dataset: (quads?: Dataset<Quad> | Quad[]): Dataset<Quad> => {
return createDataset(quads);
},
};
return new WrapperSubscribableDatasetFactory(datasetFactory);
}
/**
* Creates a SubscribableDataset
* @param quads: A dataset or array of Quads to initialize the dataset.
* @returns Dataset
*/
export function createWrapperSubscribableDataset(
quads?: Dataset<Quad> | Quad[],
): WrapperSubscribableDataset<Quad> {
const wrapperSubscribableDatasetFactory =
createWrapperSubscribableDatasetFactory();
return wrapperSubscribableDatasetFactory.dataset(quads);
}

@ -1,10 +1,8 @@
export {
createWrapperSubscribableDataset as createSubscribableDataset,
createWrapperSubscribableDatasetFactory as createSubscribableDatasetFactory,
} from "./createWrapperSubscribableDataset";
export { createWrapperSubscribableDatasetFromSerializedInput as serializedToSubscribableDataset } from "./createWrapperSubscribableDatasetFromSerializedInput";
export * from "./ProxyTransactionalDataset";
export * from "./WrapperSubscribableDataset";
export * from "./WrapperSubscribableDatasetFactory";
export * from "./createSubscribableDataset";
export { createWrapperSubscribableDatasetFromSerializedInput as serializedToSubscribableDataset } from "./createSubscribableDatasetFromSerializedInput";
export * from "./TransactionDataset";
export * from "./TransactionDatasetFactory";
export * from "./SubscribableDataset";
export * from "./SubscribableDatasetFactory";
export * from "./types";
export * from "./mergeDatasetChanges";

@ -1,5 +1,5 @@
import type { DatasetChanges, QuadMatch } from "@ldo/rdf-utils";
import type { Dataset, BaseQuad } from "@rdfjs/types";
import type { Dataset, BaseQuad, DatasetFactory } from "@rdfjs/types";
/**
* An event listeners for nodes
@ -11,28 +11,29 @@ export type nodeEventListener<InAndOutQuad extends BaseQuad = BaseQuad> = (
/**
* Adds the bulk method for add and remove
*/
export interface BulkEditableDataset<InAndOutQuad extends BaseQuad = BaseQuad>
export interface IBulkEditableDataset<InAndOutQuad extends BaseQuad = BaseQuad>
extends Dataset<InAndOutQuad, InAndOutQuad> {
bulk(changes: DatasetChanges<InAndOutQuad>): this;
}
/**
* A dataset that allows you to modify the dataset and
* Factory for creating SubscribableDatasets
*/
export interface TransactionalDataset<InAndOutQuad extends BaseQuad = BaseQuad>
extends BulkEditableDataset<InAndOutQuad> {
rollback(): void;
commit(): void;
getChanges(): DatasetChanges<InAndOutQuad>;
}
export type ISubscribableDatasetFactory<
InAndOutQuad extends BaseQuad = BaseQuad,
> = DatasetFactory<
InAndOutQuad,
InAndOutQuad,
ISubscribableDataset<InAndOutQuad>
>;
/**
* Dataset that allows developers to subscribe to a sepecific term and be alerted
* if a quad is added or removed containing that term. It's methods follow the
* EventEmitter interface except take in namedNodes as keys.
*/
export interface SubscribableDataset<InAndOutQuad extends BaseQuad = BaseQuad>
extends BulkEditableDataset<InAndOutQuad> {
export interface ISubscribableDataset<InAndOutQuad extends BaseQuad = BaseQuad>
extends IBulkEditableDataset<InAndOutQuad> {
/**
* Alias for emitter.on(eventName, listener).
* @param eventName
@ -140,5 +141,27 @@ export interface SubscribableDataset<InAndOutQuad extends BaseQuad = BaseQuad>
/**
* Returns a transactional dataset that will update this dataset when its transaction is committed.
*/
startTransaction(): TransactionalDataset<InAndOutQuad>;
startTransaction(): ITransactionDataset<InAndOutQuad>;
}
/**
* Creates a TransactionDataset
*/
export interface ITransactionDatasetFactory<
InAndOutQuad extends BaseQuad = BaseQuad,
> {
transactionDataset(
parent: ISubscribableDataset<InAndOutQuad>,
): ITransactionDataset<InAndOutQuad>;
}
/**
* A dataset that allows you to modify the dataset and
*/
export interface ITransactionDataset<InAndOutQuad extends BaseQuad = BaseQuad>
extends ISubscribableDataset<InAndOutQuad> {
readonly parentDataset: ISubscribableDataset<InAndOutQuad>;
rollback(): void;
commit(): void;
getChanges(): DatasetChanges<InAndOutQuad>;
}

@ -1,5 +1,5 @@
import type { SubscribableDataset } from "../src";
import { ProxyTransactionalDataset, createSubscribableDataset } from "../src";
import type { ISubscribableDataset } from "../src";
import { TransactionDataset, createSubscribableDataset } from "../src";
import { createDataset } from "@ldo/dataset";
import {
namedNode,
@ -11,14 +11,14 @@ import {
import type { Quad, BlankNode } from "@rdfjs/types";
import testDataset from "@ldo/dataset/test/dataset.testHelper";
describe("WrapperSubscribableDataset", () => {
describe("SubscribableDataset", () => {
// Regular dataset tests
testDataset({
dataset: createSubscribableDataset,
});
// Subscribable Dataset tests
let subscribableDatastet: SubscribableDataset<Quad>;
let subscribableDatastet: ISubscribableDataset<Quad>;
const tomTypeQuad = quad(
namedNode("http://example.org/cartoons#Tom"),
namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"),
@ -449,8 +449,7 @@ describe("WrapperSubscribableDataset", () => {
it("Returns a transaction", () => {
expect(
subscribableDatastet.startTransaction() instanceof
ProxyTransactionalDataset,
subscribableDatastet.startTransaction() instanceof TransactionDataset,
).toBe(true);
});
});

@ -5,14 +5,18 @@ import type {
Quad,
DatasetCore,
} from "@rdfjs/types";
import type { BulkEditableDataset } from "../src";
import type { ISubscribableDataset } from "../src";
import { ExtendedDatasetFactory } from "@ldo/dataset";
import { ProxyTransactionalDataset } from "../src";
import {
TransactionDataset,
createSubscribableDataset,
createTransactionDatasetFactory,
} from "../src";
import datasetCoreFactory from "@rdfjs/dataset";
describe("ProxyTransactionalDataset", () => {
let parentDataset: Dataset<Quad>;
let transactionalDataset: ProxyTransactionalDataset<Quad>;
describe("TransactionDataset", () => {
let parentDataset: ISubscribableDataset<Quad>;
let transactionalDataset: TransactionDataset<Quad>;
const tomTypeQuad = quad(
namedNode("http://example.org/cartoons#Tom"),
namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"),
@ -41,12 +45,13 @@ describe("ProxyTransactionalDataset", () => {
const extendedDatasetFactory = new ExtendedDatasetFactory(datasetFactory);
const initializeWithExtendedDatasetParent = (quads?: Quad[]) => {
parentDataset = extendedDatasetFactory.dataset(
parentDataset = createSubscribableDataset(
quads || [tomTypeQuad, tomNameQuad],
);
transactionalDataset = new ProxyTransactionalDataset(
transactionalDataset = new TransactionDataset(
parentDataset,
extendedDatasetFactory,
createTransactionDatasetFactory(),
);
};
@ -301,14 +306,15 @@ describe("ProxyTransactionalDataset", () => {
// Disable for tests
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
const mockParent: BulkEditableDataset<Quad> = {
const mockParent: ISubscribableDataset<Quad> = {
bulk: jest.fn(),
has: (curQuad) => parentDataset.has(curQuad),
[Symbol.iterator]: () => parentDataset[Symbol.iterator](),
};
transactionalDataset = new ProxyTransactionalDataset<Quad>(
transactionalDataset = new TransactionDataset<Quad>(
mockParent,
extendedDatasetFactory,
createTransactionDatasetFactory(),
);
transactionalDataset.add(lickyNameQuad);
@ -319,8 +325,7 @@ describe("ProxyTransactionalDataset", () => {
it("Returns a transactional dataset", () => {
expect(
transactionalDataset.startTransaction() instanceof
ProxyTransactionalDataset,
transactionalDataset.startTransaction() instanceof TransactionDataset,
).toBe(true);
});

@ -2,17 +2,19 @@ import {
createSubscribableDataset,
createSubscribableDatasetFactory,
serializedToSubscribableDataset,
ProxyTransactionalDataset,
WrapperSubscribableDataset,
WrapperSubscribableDatasetFactory,
SubscribableDataset,
SubscribableDatasetFactory,
TransactionDataset,
TransactionDatasetFactory,
} from "../src";
describe("Exports", () => {
it("Has all exports", () => {
expect(createSubscribableDataset);
expect(ProxyTransactionalDataset);
expect(WrapperSubscribableDataset);
expect(WrapperSubscribableDatasetFactory);
expect(SubscribableDataset);
expect(TransactionDataset);
expect(SubscribableDatasetFactory);
expect(TransactionDatasetFactory);
expect(serializedToSubscribableDataset);
expect(createSubscribableDatasetFactory);
});

Loading…
Cancel
Save