@effect/platform-browser 4.0.0-beta.7 → 4.0.0-beta.70

package/dist/IndexedDbQueryBuilder.js

@@ -0,0 +1,927 @@
+import * as Cause from "effect/Cause";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Effectable from "effect/Effectable";
+import * as Fiber from "effect/Fiber";
+import { BaseProto } from "effect/Inspectable";
+import * as Option from "effect/Option";
+import * as Pipeable from "effect/Pipeable";
+import * as References from "effect/References";
+import * as Schema from "effect/Schema";
+import * as SchemaIssue from "effect/SchemaIssue";
+import * as SchemaParser from "effect/SchemaParser";
+import * as Stream from "effect/Stream";
+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"
+    };
+  }
+};
+/**
+ * Tagged error for IndexedDB query operations, carrying a query error reason and the original cause.
+ *
+ * @category errors
+ * @since 4.0.0
+ */
+export class IndexedDbQueryError extends /*#__PURE__*/Data.TaggedError("IndexedDbQueryError") {
+  /**
+   * Marks this value as an IndexedDB query builder error for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [ErrorTypeId] = ErrorTypeId;
+  message = this.reason;
+}
+/**
+ * Service tag for the active `IDBTransaction` used to share a transaction across IndexedDB query effects.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export class IndexedDbTransaction extends /*#__PURE__*/Context.Service()("@effect/platform-browser/IndexedDbQueryBuilder/IndexedDbTransaction") {}
+const applyDelete = query => Effect.callback(resume => {
+  const database = query.delete.from.database;
+  const IDBKeyRange = query.delete.from.IDBKeyRange;
+  const transaction = getOrCreateTransaction(database.current, [query.delete.from.table.tableName], "readwrite", {
+    durability: query.delete.from.table.durability
+  });
+  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 = getOrCreateTransaction(database.current, [query.from.table.tableName], "readonly", {
+    durability: query.from.table.durability
+  });
+  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 applySelect = /*#__PURE__*/Effect.fnUntraced(function* (query) {
+  const keyPath = query.from.table.keyPath;
+  const predicate = query.predicate;
+  const data = predicate || keyPath === undefined || query.offsetValue !== undefined ? yield* Effect.callback(resume => {
+    const {
+      keyRange,
+      store
+    } = getReadonlyObjectStore(query);
+    const cursorRequest = store.openCursor(keyRange, query.reverseValue ? "prev" : "next");
+    const results = [];
+    let count = 0;
+    let offsetApplied = false;
+    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 (query.offsetValue && !offsetApplied) {
+        offsetApplied = true;
+        return cursor.advance(query.offsetValue);
+      }
+      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 = () => {
+      if (query.reverseValue) {
+        request.result.reverse();
+      }
+      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 applyFirst = /*#__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 Cause.NoSuchElementError(`No such element in table ${query.select.from.table.tableName}`)));
+        } 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* schema.makeEffect(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 = getOrCreateTransaction(database.current, [query.from.table.tableName], "readwrite", {
+      durability: query.from.table.durability
+    });
+    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 => {
+    if (encodedValues.length === 0) {
+      return resume(Effect.succeed([]));
+    }
+    const database = query.from.database;
+    const transaction = getOrCreateTransaction(database.current, [query.from.table.tableName], "readwrite", {
+      durability: query.from.table.durability
+    });
+    const objectStore = transaction.objectStore(query.from.table.tableName);
+    const results = new Array(encodedValues.length);
+    let remaining = encodedValues.length;
+    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[i] = request.result;
+          remaining -= 1;
+          if (remaining === 0) {
+            resume(Effect.succeed(results));
+          }
+        };
+      }
+    } 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[i] = request.result;
+          remaining -= 1;
+          if (remaining === 0) {
+            resume(Effect.succeed(results));
+          }
+        };
+      }
+    } 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
+      })));
+    };
+  });
+}, /*#__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 = getOrCreateTransaction(database, [options.table.tableName], "readwrite", {
+    durability: options.table.durability
+  });
+  const objectStore = transaction.objectStore(options.table.tableName);
+  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 = getOrCreateTransaction(database, [...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) {
+    let select = this.selectCache.get(index);
+    if (select === undefined) {
+      select = makeSelect({
+        from: this,
+        index
+      });
+      this.selectCache.set(index, select);
+    }
+    return select;
+  },
+  count(index) {
+    let count = this.countCache.get(index);
+    if (count === undefined) {
+      count = makeCount({
+        from: this,
+        index
+      });
+      this.countCache.set(index, count);
+    }
+    return count;
+  },
+  delete(index) {
+    let cached = this.deleteCache.get(index);
+    if (cached === undefined) {
+      cached = makeDeletePartial({
+        from: this,
+        index
+      });
+      this.deleteCache.set(index, cached);
+    }
+    return cached;
+  },
+  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.current,
+      table: self.table
+    });
+  }
+};
+const makeFrom = options => {
+  const self = Object.create(FromProto);
+  self.table = options.table;
+  self.database = options.database;
+  self.IDBKeyRange = options.IDBKeyRange;
+  self.reactivity = options.reactivity;
+  self.selectCache = new Map();
+  self.countCache = new Map();
+  self.deleteCache = new Map();
+  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,
+  ... /*#__PURE__*/Effectable.Prototype({
+    label: "IndexedDbQuery.Delete",
+    evaluate() {
+      return applyDelete(this);
+    }
+  }),
+  limit(limit) {
+    return makeDelete({
+      ...this,
+      limitValue: limit
+    });
+  },
+  filter(filter) {
+    const prev = this.predicate;
+    return makeDelete({
+      delete: this.delete,
+      predicate: prev ? item => prev(item) && filter(item) : filter
+    });
+  },
+  invalidate(keys) {
+    keys ??= this.only !== undefined ? {
+      [this.delete.from.table.tableName]: [this.only]
+    } : [this.delete.from.table.tableName];
+    return this.delete.from.reactivity.mutation(keys, this);
+  }
+};
+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 ?? false;
+  self.excludeUpperBound = options.excludeUpperBound ?? false;
+  self.predicate = options.predicate;
+  return self;
+};
+const CountProto = {
+  ...CommonProto,
+  ... /*#__PURE__*/Effectable.Prototype({
+    label: "IndexedDbQuery.Count",
+    evaluate() {
+      return getCount(this);
+    }
+  }),
+  equals(value) {
+    return makeCount({
+      from: this.from,
+      index: this.index,
+      only: value
+    });
+  },
+  gte(value) {
+    return makeCount({
+      from: this.from,
+      index: this.index,
+      lowerBound: value,
+      excludeLowerBound: false
+    });
+  },
+  lte(value) {
+    return makeCount({
+      from: this.from,
+      index: this.index,
+      upperBound: value,
+      excludeUpperBound: false
+    });
+  },
+  gt(value) {
+    return makeCount({
+      from: this.from,
+      index: this.index,
+      lowerBound: value,
+      excludeLowerBound: true
+    });
+  },
+  lt(value) {
+    return makeCount({
+      from: this.from,
+      index: this.index,
+      upperBound: value,
+      excludeUpperBound: true
+    });
+  },
+  between(lowerBound, upperBound, queryOptions) {
+    return makeCount({
+      from: this.from,
+      index: this.index,
+      lowerBound,
+      upperBound,
+      excludeLowerBound: queryOptions?.excludeLowerBound ?? false,
+      excludeUpperBound: queryOptions?.excludeUpperBound ?? false
+    });
+  }
+};
+const makeCount = options => {
+  const self = Object.create(CountProto);
+  self.from = options.from;
+  self.index = options.index;
+  self.only = options.only;
+  self.lowerBound = options.lowerBound;
+  self.upperBound = options.upperBound;
+  self.excludeLowerBound = options.excludeLowerBound;
+  self.excludeUpperBound = options.excludeUpperBound;
+  return self;
+};
+const SelectProto = {
+  ...CommonProto,
+  ... /*#__PURE__*/Effectable.Prototype({
+    label: "IndexedDbQuery.Select",
+    evaluate() {
+      return applySelect(this);
+    }
+  }),
+  limit(limit) {
+    return makeSelect({
+      ...this,
+      limitValue: limit
+    });
+  },
+  offset(offset) {
+    return makeSelect({
+      ...this,
+      offsetValue: offset
+    });
+  },
+  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
+    });
+  },
+  reverse() {
+    return makeSelect({
+      ...this,
+      reverseValue: true
+    });
+  },
+  first() {
+    return makeFirst({
+      select: this
+    });
+  },
+  filter(filter) {
+    const prev = this.predicate;
+    return makeSelect({
+      ...this,
+      predicate: prev ? item => prev(item) && filter(item) : filter
+    });
+  },
+  stream(options) {
+    const limit = this.limitValue;
+    const chunkSize = Math.min(options?.chunkSize ?? 100, limit ?? Number.MAX_SAFE_INTEGER);
+    const initial = this.limit(chunkSize);
+    return Stream.suspend(() => {
+      let total = 0;
+      return Stream.paginate(initial, select => Effect.map(applySelect(select), data => {
+        total += data.length;
+        select.offsetValue = total;
+        const reachedLimit = limit && total >= limit;
+        const isPartial = data.length < chunkSize;
+        return [data, isPartial || reachedLimit ? Option.none() : Option.some(select)];
+      }));
+    });
+  },
+  reactive(keys) {
+    keys ??= [this.from.table.tableName];
+    return this.from.reactivity.stream(keys, this);
+  },
+  reactiveQueue(keys) {
+    keys ??= [this.from.table.tableName];
+    return this.from.reactivity.query(keys, this);
+  }
+};
+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.offsetValue = options.offsetValue;
+  self.reverseValue = options.reverseValue;
+  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,
+  ... /*#__PURE__*/Effectable.Prototype({
+    label: "IndexedDbQuery.First",
+    evaluate() {
+      return applyFirst(this);
+    }
+  }),
+  reactive(keys) {
+    keys ??= this.select.only !== undefined ? [`${this.select.from.table.tableName}:${String(this.select.only)}`] : [this.select.from.table.tableName];
+    return this.select.from.reactivity.stream(keys, this);
+  },
+  reactiveQueue(keys) {
+    keys ??= this.select.only !== undefined ? [`${this.select.from.table.tableName}:${this.select.only}`] : [this.select.from.table.tableName];
+    return this.select.from.reactivity.query(keys, this);
+  }
+};
+const makeFirst = options => {
+  const self = Object.create(FirstProto);
+  self.select = options.select;
+  return self;
+};
+const ModifyProto = {
+  ...CommonProto,
+  ... /*#__PURE__*/Effectable.Prototype({
+    label: "IndexedDbQuery.Modify",
+    evaluate() {
+      return applyModify({
+        query: this,
+        value: this.value
+      });
+    }
+  }),
+  invalidate(keys) {
+    const keyPath = this.from.table.keyPath;
+    keys ??= typeof keyPath === "string" && this.value[keyPath] !== undefined ? {
+      [this.from.table.tableName]: [this.value[keyPath]]
+    } : [this.from.table.tableName];
+    return this.from.reactivity.mutation(keys, this);
+  }
+};
+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,
+  ... /*#__PURE__*/Effectable.Prototype({
+    label: "IndexedDbQuery.ModifyAll",
+    evaluate() {
+      return applyModifyAll({
+        query: this,
+        values: this.values
+      });
+    }
+  }),
+  invalidate(keys) {
+    keys ??= [this.from.table.tableName];
+    return this.from.reactivity.mutation(keys, this);
+  }
+};
+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.try({
+      try: () => f(this.database.current),
+      catch: error => new IndexedDbQueryError({
+        reason: "UnknownError",
+        cause: error
+      })
+    });
+  },
+  from(table) {
+    let cached = this.fromCache.get(table);
+    if (cached === undefined) {
+      cached = makeFrom({
+        database: this.database,
+        IDBKeyRange: this.IDBKeyRange,
+        table: this.tables.get(table),
+        reactivity: this.reactivity
+      });
+      this.fromCache.set(table, cached);
+    }
+    return cached;
+  },
+  get clearAll() {
+    const self = this;
+    return applyClearAll({
+      database: self.database.current
+    });
+  },
+  withTransaction(options) {
+    return effect => Effect.suspend(() => {
+      const transaction = this.database.current.transaction(options.tables, options.mode, options);
+      return Effect.provideService(effect, IndexedDbTransaction, transaction);
+    }).pipe(
+    // To prevent async gaps between transaction queries
+    Effect.provideService(References.PreventSchedulerYield, true));
+  }
+};
+/**
+ * Creates an `IndexedDbQueryBuilder` from an open database reference, key-range constructor, table map, and reactivity service.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const make = ({
+  IDBKeyRange,
+  database,
+  tables,
+  reactivity
+}) => {
+  const self = Object.create(QueryBuilderProto);
+  self.tables = tables;
+  self.database = database;
+  self.reactivity = reactivity;
+  self.IDBKeyRange = IDBKeyRange;
+  self.fromCache = new Map();
+  return self;
+};
+const getOrCreateTransaction = (database, tables, mode, options) => {
+  const fiber = Fiber.getCurrent();
+  return Context.getOrUndefined(fiber.context, IndexedDbTransaction) ?? database.transaction(tables, mode, options);
+};
+//# sourceMappingURL=IndexedDbQueryBuilder.js.map