@effect/platform-browser 4.0.0-beta.42 → 4.0.0-beta.43

package/dist/IndexedDbQueryBuilder.js

@@ -0,0 +1,862 @@
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import { BaseProto } from "effect/Inspectable";
+import * as Pipeable from "effect/Pipeable";
+import * as Schema from "effect/Schema";
+import * as SchemaIssue from "effect/SchemaIssue";
+import * as SchemaParser from "effect/SchemaParser";
+import * as Utils from "effect/Utils";
+const ErrorTypeId = "~@effect/platform-browser/IndexedDbQueryBuilder/IndexedDbQueryError";
+const CommonProto = {
+  [Symbol.iterator]() {
+    return new Utils.SingleShotGen(this);
+  },
+  ...Pipeable.Prototype,
+  ...BaseProto,
+  toJSON() {
+    return {
+      _id: "IndexedDbQueryBuilder"
+    };
+  }
+};
+/**
+ * @since 4.0.0
+ * @category errors
+ */
+export class IndexedDbQueryError extends /*#__PURE__*/Data.TaggedError("IndexedDbQueryError") {
+  /**
+   * @since 4.0.0
+   */
+  [ErrorTypeId] = ErrorTypeId;
+  message = this.reason;
+}
+const applyDelete = query => Effect.callback(resume => {
+  const database = query.delete.from.database;
+  const IDBKeyRange = query.delete.from.IDBKeyRange;
+  let transaction = query.delete.from.transaction;
+  transaction ??= database.transaction([query.delete.from.table.tableName], "readwrite");
+  const objectStore = transaction.objectStore(query.delete.from.table.tableName);
+  const predicate = query.predicate;
+  let keyRange = undefined;
+  if (query.only !== undefined) {
+    keyRange = IDBKeyRange.only(query.only);
+  } else if (query.lowerBound !== undefined && query.upperBound !== undefined) {
+    keyRange = IDBKeyRange.bound(query.lowerBound, query.upperBound, query.excludeLowerBound, query.excludeUpperBound);
+  } else if (query.lowerBound !== undefined) {
+    keyRange = IDBKeyRange.lowerBound(query.lowerBound, query.excludeLowerBound);
+  } else if (query.upperBound !== undefined) {
+    keyRange = IDBKeyRange.upperBound(query.upperBound, query.excludeUpperBound);
+  }
+  let request;
+  if (query.limitValue !== undefined || predicate) {
+    const cursorRequest = objectStore.openCursor();
+    let count = 0;
+    cursorRequest.onerror = () => {
+      resume(Effect.fail(new IndexedDbQueryError({
+        reason: "TransactionError",
+        cause: cursorRequest.error
+      })));
+    };
+    cursorRequest.onsuccess = () => {
+      const cursor = cursorRequest.result;
+      if (cursor === null) {
+        return resume(Effect.void);
+      }
+      if (predicate === undefined || predicate(cursor.value)) {
+        const deleteRequest = cursor.delete();
+        deleteRequest.onerror = () => {
+          resume(Effect.fail(new IndexedDbQueryError({
+            reason: "TransactionError",
+            cause: deleteRequest.error
+          })));
+        };
+        count += 1;
+      }
+      if (query.limitValue === undefined || count < query.limitValue) {
+        return cursor.continue();
+      }
+      resume(Effect.void);
+    };
+  } else if (keyRange !== undefined) {
+    request = objectStore.delete(keyRange);
+    request.onerror = event => {
+      resume(Effect.fail(new IndexedDbQueryError({
+        reason: "TransactionError",
+        cause: event
+      })));
+    };
+    request.onsuccess = () => {
+      resume(Effect.succeed(request.result));
+    };
+  } else {
+    resume(Effect.die(new Error("No key range provided for delete operation")));
+  }
+});
+const getReadonlyObjectStore = query => {
+  const database = query.from.database;
+  const IDBKeyRange = query.from.IDBKeyRange;
+  const transaction = query.from.transaction ?? database.transaction([query.from.table.tableName], "readonly");
+  const objectStore = transaction.objectStore(query.from.table.tableName);
+  let keyRange = undefined;
+  let store;
+  if (query.only !== undefined) {
+    keyRange = IDBKeyRange.only(query.only);
+  } else if (query.lowerBound !== undefined && query.upperBound !== undefined) {
+    keyRange = IDBKeyRange.bound(query.lowerBound, query.upperBound, query.excludeLowerBound, query.excludeUpperBound);
+  } else if (query.lowerBound !== undefined) {
+    keyRange = IDBKeyRange.lowerBound(query.lowerBound, query.excludeLowerBound);
+  } else if (query.upperBound !== undefined) {
+    keyRange = IDBKeyRange.upperBound(query.upperBound, query.excludeUpperBound);
+  }
+  if (query.index !== undefined) {
+    store = objectStore.index(query.index);
+  } else {
+    store = objectStore;
+  }
+  return {
+    store,
+    keyRange
+  };
+};
+const getSelect = /*#__PURE__*/Effect.fnUntraced(function* (query) {
+  const keyPath = query.from.table.keyPath;
+  const predicate = query.predicate;
+  const data = predicate || keyPath === undefined ? yield* Effect.callback(resume => {
+    const {
+      keyRange,
+      store
+    } = getReadonlyObjectStore(query);
+    const cursorRequest = store.openCursor(keyRange);
+    const results = [];
+    let count = 0;
+    cursorRequest.onerror = () => {
+      resume(Effect.fail(new IndexedDbQueryError({
+        reason: "TransactionError",
+        cause: cursorRequest.error
+      })));
+    };
+    cursorRequest.onsuccess = () => {
+      const cursor = cursorRequest.result;
+      if (cursor === null) {
+        return resume(Effect.succeed(results));
+      }
+      if (predicate === undefined || predicate(cursor.value)) {
+        results.push(keyPath === undefined ? {
+          ...cursor.value,
+          key: cursor.key
+        } : cursor.value);
+        count += 1;
+      }
+      if (query.limitValue === undefined || count < query.limitValue) {
+        return cursor.continue();
+      }
+      resume(Effect.succeed(results));
+    };
+  }) : yield* Effect.callback(resume => {
+    const {
+      keyRange,
+      store
+    } = getReadonlyObjectStore(query);
+    const request = store.getAll(keyRange, query.limitValue);
+    request.onerror = event => {
+      resume(Effect.fail(new IndexedDbQueryError({
+        reason: "TransactionError",
+        cause: event
+      })));
+    };
+    request.onsuccess = () => {
+      resume(Effect.succeed(request.result));
+    };
+  });
+  const tableSchema = query.from.table.arraySchema;
+  return yield* Schema.decodeUnknownEffect(tableSchema)(data).pipe(Effect.mapError(error => new IndexedDbQueryError({
+    reason: "DecodeError",
+    cause: error
+  })));
+});
+const getFirst = /*#__PURE__*/Effect.fnUntraced(function* (query) {
+  const keyPath = query.select.from.table.keyPath;
+  const data = yield* Effect.callback(resume => {
+    const {
+      keyRange,
+      store
+    } = getReadonlyObjectStore(query.select);
+    if (keyRange !== undefined) {
+      const request = store.get(keyRange);
+      request.onerror = event => {
+        resume(Effect.fail(new IndexedDbQueryError({
+          reason: "TransactionError",
+          cause: event
+        })));
+      };
+      request.onsuccess = () => {
+        resume(Effect.succeed(request.result));
+      };
+    } else {
+      const request = store.openCursor();
+      request.onerror = event => {
+        resume(Effect.fail(new IndexedDbQueryError({
+          reason: "TransactionError",
+          cause: event
+        })));
+      };
+      request.onsuccess = () => {
+        const value = request.result?.value;
+        const key = request.result?.key;
+        if (value === undefined) {
+          resume(Effect.fail(new IndexedDbQueryError({
+            reason: "NotFoundError",
+            cause: request.error
+          })));
+        } else {
+          resume(Effect.succeed(keyPath === undefined ? {
+            ...value,
+            key
+          } : value));
+        }
+      };
+    }
+  });
+  return yield* Schema.decodeUnknownEffect(query.select.from.table.readSchema)(data).pipe(Effect.mapError(error => new IndexedDbQueryError({
+    reason: "DecodeError",
+    cause: error
+  })));
+});
+const applyModify = /*#__PURE__*/Effect.fnUntraced(function* ({
+  query,
+  value
+}) {
+  const autoIncrement = query.from.table.autoIncrement;
+  const keyPath = query.from.table.keyPath;
+  const table = query.from.table;
+  const schema = autoIncrement && value[keyPath] === undefined ? table.autoincrementSchema : table.tableSchema;
+  const encodedValue = yield* SchemaParser.makeEffect(autoIncrement && value[keyPath] === undefined ? table.autoincrementSchema : table.tableSchema)(value).pipe(Effect.flatMap(Schema.encodeUnknownEffect(schema)), Effect.mapError(error => new IndexedDbQueryError({
+    reason: "EncodeError",
+    cause: error
+  })));
+  return yield* Effect.callback(resume => {
+    const database = query.from.database;
+    const transaction = query.from.transaction ?? database.transaction([query.from.table.tableName], "readwrite");
+    const objectStore = transaction.objectStore(query.from.table.tableName);
+    let request;
+    if (query.operation === "add") {
+      request = objectStore.add(encodedValue, keyPath === undefined ? value["key"] : undefined);
+    } else if (query.operation === "put") {
+      request = objectStore.put(encodedValue, keyPath === undefined ? value["key"] : undefined);
+    } else {
+      return resume(Effect.die(new Error("Invalid modify operation")));
+    }
+    request.onerror = event => {
+      resume(Effect.fail(new IndexedDbQueryError({
+        reason: "TransactionError",
+        cause: event
+      })));
+    };
+    request.onsuccess = () => {
+      resume(Effect.succeed(request.result));
+    };
+  });
+});
+const applyModifyAll = /*#__PURE__*/Effect.fnUntraced(function* ({
+  query,
+  values
+}) {
+  const autoIncrement = query.from.table.autoIncrement;
+  const keyPath = query.from.table.keyPath;
+  const schema = query.from.table.tableSchema;
+  const encodedValues = new Array(values.length);
+  const makeValue = SchemaParser.makeEffect(schema);
+  const encodeValue = SchemaParser.encodeUnknownEffect(schema);
+  const makeValueAutoincrement = SchemaParser.makeEffect(query.from.table.autoincrementSchema);
+  const encodeValueAutoincrement = SchemaParser.encodeUnknownEffect(query.from.table.autoincrementSchema);
+  for (let i = 0; i < values.length; i++) {
+    const value = values[i];
+    if (autoIncrement && value[keyPath] === undefined) {
+      encodedValues[i] = yield* encodeValueAutoincrement(yield* makeValueAutoincrement(value));
+    } else {
+      encodedValues[i] = yield* encodeValue(yield* makeValue(value));
+    }
+  }
+  return yield* Effect.callback(resume => {
+    const database = query.from.database;
+    const transaction = query.from.transaction;
+    const objectStore = (transaction ?? database.transaction([query.from.table.tableName], "readwrite")).objectStore(query.from.table.tableName);
+    const results = [];
+    if (query.operation === "add") {
+      for (let i = 0; i < encodedValues.length; i++) {
+        const request = objectStore.add(encodedValues[i], keyPath === undefined ? values[i]["key"] : undefined);
+        request.onerror = () => {
+          resume(Effect.fail(new IndexedDbQueryError({
+            reason: "TransactionError",
+            cause: request.error
+          })));
+        };
+        request.onsuccess = () => {
+          results.push(request.result);
+        };
+      }
+    } else if (query.operation === "put") {
+      for (let i = 0; i < encodedValues.length; i++) {
+        const request = objectStore.put(encodedValues[i], keyPath === undefined ? values[i]["key"] : undefined);
+        request.onerror = () => {
+          resume(Effect.fail(new IndexedDbQueryError({
+            reason: "TransactionError",
+            cause: request.error
+          })));
+        };
+        request.onsuccess = () => {
+          results.push(request.result);
+        };
+      }
+    } else {
+      return resume(Effect.die(new Error("Invalid modify all operation")));
+    }
+    objectStore.transaction.onerror = () => {
+      resume(Effect.fail(new IndexedDbQueryError({
+        reason: "TransactionError",
+        cause: objectStore.transaction.error
+      })));
+    };
+    objectStore.transaction.oncomplete = () => {
+      resume(Effect.succeed(results));
+    };
+  });
+}, /*#__PURE__*/Effect.catchIf(SchemaIssue.isIssue, issue => Effect.fail(new IndexedDbQueryError({
+  reason: "EncodeError",
+  cause: new Schema.SchemaError(issue)
+}))));
+const applyClear = options => Effect.callback(resume => {
+  const database = options.database;
+  const transaction = options.transaction ?? database.transaction([options.table], "readwrite");
+  const objectStore = transaction.objectStore(options.table);
+  const request = objectStore.clear();
+  request.onerror = event => {
+    resume(Effect.fail(new IndexedDbQueryError({
+      reason: "TransactionError",
+      cause: event
+    })));
+  };
+  request.onsuccess = () => {
+    resume(Effect.void);
+  };
+});
+const applyClearAll = options => Effect.callback(resume => {
+  const database = options.database;
+  const tables = database.objectStoreNames;
+  const transaction = options.transaction ?? database.transaction([...tables], "readwrite");
+  for (let t = 0; t < tables.length; t++) {
+    const objectStore = transaction.objectStore(tables[t]);
+    const request = objectStore.clear();
+    request.onerror = () => {
+      resume(Effect.fail(new IndexedDbQueryError({
+        reason: "TransactionError",
+        cause: request.error
+      })));
+    };
+  }
+  transaction.onerror = () => {
+    resume(Effect.fail(new IndexedDbQueryError({
+      reason: "TransactionError",
+      cause: transaction.error
+    })));
+  };
+  transaction.oncomplete = () => {
+    resume(Effect.void);
+  };
+});
+const getCount = query => Effect.callback(resume => {
+  const {
+    keyRange,
+    store
+  } = getReadonlyObjectStore(query);
+  const request = store.count(keyRange);
+  request.onerror = event => {
+    resume(Effect.fail(new IndexedDbQueryError({
+      reason: "TransactionError",
+      cause: event
+    })));
+  };
+  request.onsuccess = () => {
+    resume(Effect.succeed(request.result));
+  };
+});
+const FromProto = {
+  ...CommonProto,
+  select(index) {
+    return makeSelect({
+      from: this,
+      index
+    });
+  },
+  count(index) {
+    return makeCount({
+      from: this,
+      index
+    });
+  },
+  delete(index) {
+    return makeDeletePartial({
+      from: this,
+      index
+    });
+  },
+  insert(value) {
+    return makeModify({
+      from: this,
+      value,
+      operation: "add"
+    });
+  },
+  upsert(value) {
+    return makeModify({
+      from: this,
+      value,
+      operation: "put"
+    });
+  },
+  insertAll(values) {
+    return makeModifyAll({
+      from: this,
+      values,
+      operation: "add"
+    });
+  },
+  upsertAll(values) {
+    return makeModifyAll({
+      from: this,
+      values,
+      operation: "put"
+    });
+  },
+  get clear() {
+    const self = this;
+    return applyClear({
+      database: self.database,
+      transaction: self.transaction,
+      table: self.table.tableName
+    });
+  }
+};
+const makeFrom = options => {
+  const self = Object.create(FromProto);
+  self.table = options.table;
+  self.database = options.database;
+  self.IDBKeyRange = options.IDBKeyRange;
+  self.transaction = options.transaction;
+  self.reactivity = options.reactivity;
+  return self;
+};
+const DeletePartialProto = {
+  ...CommonProto,
+  limit(limit) {
+    return makeDelete({
+      delete: this,
+      limitValue: limit
+    });
+  },
+  equals(value) {
+    return makeDelete({
+      delete: this,
+      only: value
+    });
+  },
+  gte(value) {
+    return makeDelete({
+      delete: this,
+      lowerBound: value,
+      excludeLowerBound: false
+    });
+  },
+  lte(value) {
+    return makeDelete({
+      delete: this,
+      upperBound: value,
+      excludeUpperBound: false
+    });
+  },
+  gt(value) {
+    return makeDelete({
+      delete: this,
+      lowerBound: value,
+      excludeLowerBound: true
+    });
+  },
+  lt(value) {
+    return makeDelete({
+      delete: this,
+      upperBound: value,
+      excludeUpperBound: true
+    });
+  },
+  between(lowerBound, upperBound, queryOptions) {
+    return makeDelete({
+      delete: this,
+      lowerBound,
+      upperBound,
+      excludeLowerBound: queryOptions?.excludeLowerBound ?? false,
+      excludeUpperBound: queryOptions?.excludeUpperBound ?? false
+    });
+  }
+};
+const makeDeletePartial = options => {
+  const self = Object.create(DeletePartialProto);
+  self.from = options.from;
+  self.index = options.index;
+  return self;
+};
+const DeleteProto = {
+  ...CommonProto,
+  asEffect() {
+    return applyDelete(this);
+  },
+  limit(limit) {
+    return makeDelete({
+      delete: this.delete,
+      only: this.only,
+      lowerBound: this.lowerBound,
+      upperBound: this.upperBound,
+      excludeLowerBound: this.excludeLowerBound ?? false,
+      excludeUpperBound: this.excludeUpperBound ?? false,
+      limitValue: limit
+    });
+  },
+  equals(value) {
+    return makeDelete({
+      delete: this.delete,
+      only: value,
+      limitValue: this.limitValue
+    });
+  },
+  gte(value) {
+    return makeDelete({
+      delete: this.delete,
+      lowerBound: value,
+      excludeLowerBound: false,
+      limitValue: this.limitValue
+    });
+  },
+  lte(value) {
+    return makeDelete({
+      delete: this.delete,
+      upperBound: value,
+      excludeUpperBound: false,
+      limitValue: this.limitValue
+    });
+  },
+  gt(value) {
+    return makeDelete({
+      delete: this.delete,
+      lowerBound: value,
+      excludeLowerBound: true,
+      limitValue: this.limitValue
+    });
+  },
+  lt(value) {
+    return makeDelete({
+      delete: this.delete,
+      upperBound: value,
+      excludeUpperBound: true,
+      limitValue: this.limitValue
+    });
+  },
+  between(lowerBound, upperBound, queryOptions) {
+    return makeDelete({
+      delete: this.delete,
+      lowerBound,
+      upperBound,
+      excludeLowerBound: queryOptions?.excludeLowerBound ?? false,
+      excludeUpperBound: queryOptions?.excludeUpperBound ?? false,
+      limitValue: this.limitValue
+    });
+  },
+  filter(filter) {
+    const prev = this.predicate;
+    return makeDelete({
+      delete: this.delete,
+      predicate: prev ? item => prev(item) && filter(item) : filter
+    });
+  },
+  invalidate(keys) {
+    return this.delete.from.reactivity.mutation(keys, this.asEffect());
+  }
+};
+const makeDelete = options => {
+  const self = Object.create(DeleteProto);
+  self.delete = options.delete;
+  self.limitValue = options.limitValue;
+  self.only = options.only;
+  self.lowerBound = options.lowerBound;
+  self.upperBound = options.upperBound;
+  self.excludeLowerBound = options.excludeLowerBound;
+  self.excludeUpperBound = options.excludeUpperBound;
+  self.predicate = options.predicate;
+  return self;
+};
+const CountProto = {
+  ...CommonProto,
+  asEffect() {
+    return getCount(this);
+  },
+  equals(value) {
+    return makeCount({
+      from: this.from,
+      index: this.index,
+      only: value,
+      limitValue: this.limitValue
+    });
+  },
+  gte(value) {
+    return makeCount({
+      from: this.from,
+      index: this.index,
+      lowerBound: value,
+      excludeLowerBound: false,
+      limitValue: this.limitValue
+    });
+  },
+  lte(value) {
+    return makeCount({
+      from: this.from,
+      index: this.index,
+      upperBound: value,
+      excludeUpperBound: false,
+      limitValue: this.limitValue
+    });
+  },
+  gt(value) {
+    return makeCount({
+      from: this.from,
+      index: this.index,
+      lowerBound: value,
+      excludeLowerBound: true,
+      limitValue: this.limitValue
+    });
+  },
+  lt(value) {
+    return makeCount({
+      from: this.from,
+      index: this.index,
+      upperBound: value,
+      excludeUpperBound: true,
+      limitValue: this.limitValue
+    });
+  },
+  between(lowerBound, upperBound, queryOptions) {
+    return makeCount({
+      from: this.from,
+      index: this.index,
+      lowerBound,
+      upperBound,
+      excludeLowerBound: queryOptions?.excludeLowerBound ?? false,
+      excludeUpperBound: queryOptions?.excludeUpperBound ?? false,
+      limitValue: this.limitValue
+    });
+  }
+};
+const makeCount = options => {
+  const self = Object.create(CountProto);
+  self.from = options.from;
+  self.index = options.index;
+  self.only = options.only;
+  self.limitValue = options.limitValue;
+  self.lowerBound = options.lowerBound;
+  self.upperBound = options.upperBound;
+  self.excludeLowerBound = options.excludeLowerBound;
+  self.excludeUpperBound = options.excludeUpperBound;
+  return self;
+};
+const SelectProto = {
+  ...CommonProto,
+  limit(limit) {
+    return makeSelect({
+      ...this,
+      limitValue: limit
+    });
+  },
+  equals(value) {
+    return makeSelect({
+      ...this,
+      only: value
+    });
+  },
+  gte(value) {
+    return makeSelect({
+      ...this,
+      lowerBound: value,
+      excludeLowerBound: false
+    });
+  },
+  lte(value) {
+    return makeSelect({
+      ...this,
+      upperBound: value,
+      excludeUpperBound: false
+    });
+  },
+  gt(value) {
+    return makeSelect({
+      ...this,
+      lowerBound: value,
+      excludeLowerBound: true
+    });
+  },
+  lt(value) {
+    return makeSelect({
+      ...this,
+      upperBound: value,
+      excludeUpperBound: true
+    });
+  },
+  between(lowerBound, upperBound, queryOptions) {
+    return makeSelect({
+      ...this,
+      lowerBound,
+      upperBound,
+      excludeLowerBound: queryOptions?.excludeLowerBound ?? false,
+      excludeUpperBound: queryOptions?.excludeUpperBound ?? false
+    });
+  },
+  first() {
+    return makeFirst({
+      select: this
+    });
+  },
+  filter(filter) {
+    const prev = this.predicate;
+    return makeSelect({
+      ...this,
+      predicate: prev ? item => prev(item) && filter(item) : filter
+    });
+  },
+  asEffect() {
+    return getSelect(this);
+  },
+  reactive(keys) {
+    return this.from.reactivity.stream(keys, this.asEffect());
+  },
+  reactiveQueue(keys) {
+    return this.from.reactivity.query(keys, this.asEffect());
+  }
+};
+const makeSelect = options => {
+  const self = Object.create(SelectProto);
+  self.from = options.from;
+  self.index = options.index;
+  self.only = options.only;
+  self.limitValue = options.limitValue;
+  self.lowerBound = options.lowerBound;
+  self.upperBound = options.upperBound;
+  self.excludeLowerBound = options.excludeLowerBound;
+  self.excludeUpperBound = options.excludeUpperBound;
+  self.predicate = options.predicate;
+  return self;
+};
+const FirstProto = {
+  ...CommonProto,
+  asEffect() {
+    return getFirst(this);
+  }
+};
+const makeFirst = options => {
+  const self = Object.create(FirstProto);
+  self.select = options.select;
+  return self;
+};
+const ModifyProto = {
+  ...CommonProto,
+  asEffect() {
+    return applyModify({
+      query: this,
+      value: this.value
+    });
+  },
+  invalidate(keys) {
+    return this.from.reactivity.mutation(keys, this.asEffect());
+  }
+};
+const makeModify = options => {
+  const self = Object.create(ModifyProto);
+  self.from = options.from;
+  self.value = options.value;
+  self.operation = options.operation;
+  return self;
+};
+const ModifyAllProto = {
+  ...CommonProto,
+  asEffect() {
+    return applyModifyAll({
+      query: this,
+      values: this.values
+    });
+  },
+  invalidate(keys) {
+    return this.from.reactivity.mutation(keys, this.asEffect());
+  }
+};
+const makeModifyAll = options => {
+  const self = Object.create(ModifyAllProto);
+  self.from = options.from;
+  self.values = options.values;
+  self.operation = options.operation;
+  return self;
+};
+const QueryBuilderProto = {
+  ...CommonProto,
+  use(f) {
+    return Effect.tryPromise({
+      try: () => f(this.database),
+      catch: error => new IndexedDbQueryError({
+        reason: "UnknownError",
+        cause: error
+      })
+    });
+  },
+  from(table) {
+    return makeFrom({
+      database: this.database,
+      IDBKeyRange: this.IDBKeyRange,
+      table: this.tables.get(table),
+      transaction: this.IDBTransaction,
+      reactivity: this.reactivity
+    });
+  },
+  get clearAll() {
+    const self = this;
+    return applyClearAll({
+      database: self.database,
+      transaction: self.IDBTransaction
+    });
+  },
+  transaction: /*#__PURE__*/Effect.fnUntraced(function* (transactionTables, mode, callback, options) {
+    const transaction = this.database.transaction(transactionTables, mode, options);
+    return yield* callback({
+      from: table => makeFrom({
+        database: this.database,
+        IDBKeyRange: this.IDBKeyRange,
+        table: this.tables.get(table),
+        transaction,
+        reactivity: this.reactivity
+      })
+    });
+  })
+};
+/**
+ * @since 4.0.0
+ * @category constructors
+ */
+export const make = ({
+  IDBKeyRange,
+  database,
+  tables,
+  transaction,
+  reactivity
+}) => {
+  const self = Object.create(QueryBuilderProto);
+  self.tables = tables;
+  self.database = database;
+  self.reactivity = reactivity;
+  self.IDBKeyRange = IDBKeyRange;
+  self.IDBTransaction = transaction;
+  return self;
+};
+//# sourceMappingURL=IndexedDbQueryBuilder.js.map