@enspirit/bmg-js 1.0.2 → 1.1.1

package/src/async/Relation/Base.ts

@@ -0,0 +1,245 @@
+import type { AsyncRelation, AsyncRelationOperand } from '../types';
+import type { Tuple, TypedPredicate, TypedExtension, AttrName, Relation, RenameMap, Renamed, Prefixed, Suffixed, Transformation, JoinKeys, Aggregators, AutowrapOptions, TextOptions } from '../../types';
+import { MemoryRelation } from '../../sync/Relation';
+import {
+  restrict as restrictOp,
+  where as whereOp,
+  exclude as excludeOp,
+} from '../operators/restrict';
+import {
+  project as projectOp,
+  allbut as allbutOp,
+} from '../operators/project';
+import { extend as extendOp } from '../operators/extend';
+import { constants as constantsOp } from '../operators/constants';
+import { rename as renameOp } from '../operators/rename';
+import { prefix as prefixOp } from '../operators/prefix';
+import { suffix as suffixOp } from '../operators/suffix';
+import { transform as transformOp } from '../operators/transform';
+import { union as unionOp } from '../operators/union';
+import { minus as minusOp } from '../operators/minus';
+import { intersect as intersectOp } from '../operators/intersect';
+import { matching as matchingOp } from '../operators/matching';
+import { not_matching as notMatchingOp } from '../operators/not_matching';
+import { join as joinOp } from '../operators/join';
+import { left_join as leftJoinOp } from '../operators/left_join';
+import { cross_product as crossProductOp } from '../operators/cross_product';
+import { group as groupOp } from '../operators/group';
+import { ungroup as ungroupOp } from '../operators/ungroup';
+import { wrap as wrapOp } from '../operators/wrap';
+import { unwrap as unwrapOp } from '../operators/unwrap';
+import { image as imageOp } from '../operators/image';
+import { summarize as summarizeOp } from '../operators/summarize';
+import { autowrap as autowrapOp } from '../operators/autowrap';
+import { yByX as yByXOp } from '../operators/yByX';
+import { one as oneOp } from '../operators/one';
+import { toArray as toArrayOp } from '../operators/toArray';
+import { toText as toTextSync } from '../../writer';
+
+/**
+ * Base implementation of AsyncRelation using lazy evaluation.
+ * Each operator returns a new BaseAsyncRelation wrapping the transformed iterable.
+ */
+export class BaseAsyncRelation<T = Tuple> implements AsyncRelation<T> {
+  constructor(private source: AsyncIterable<T>) {}
+
+  // === Type-preserving operators ===
+
+  restrict(p: TypedPredicate<T>): AsyncRelation<T> {
+    return new BaseAsyncRelation(restrictOp(this.source, p as any));
+  }
+
+  where(p: TypedPredicate<T>): AsyncRelation<T> {
+    return new BaseAsyncRelation(whereOp(this.source, p as any));
+  }
+
+  exclude(p: TypedPredicate<T>): AsyncRelation<T> {
+    return new BaseAsyncRelation(excludeOp(this.source, p as any));
+  }
+
+  // === Projection operators ===
+
+  project<K extends keyof T>(attrs: K[]): AsyncRelation<Pick<T, K>> {
+    return new BaseAsyncRelation(
+      projectOp(this.source, attrs as AttrName[])
+    ) as unknown as AsyncRelation<Pick<T, K>>;
+  }
+
+  allbut<K extends keyof T>(attrs: K[]): AsyncRelation<Omit<T, K>> {
+    return new BaseAsyncRelation(
+      allbutOp(this.source, attrs as AttrName[])
+    ) as unknown as AsyncRelation<Omit<T, K>>;
+  }
+
+  // === Extension operators ===
+
+  extend<E extends Record<string, unknown>>(e: TypedExtension<T, E>): AsyncRelation<T & E> {
+    return new BaseAsyncRelation(
+      extendOp(this.source, e as any)
+    ) as unknown as AsyncRelation<T & E>;
+  }
+
+  constants<C extends Tuple>(consts: C): AsyncRelation<T & C> {
+    return new BaseAsyncRelation(
+      constantsOp(this.source, consts)
+    ) as unknown as AsyncRelation<T & C>;
+  }
+
+  // === Rename operators ===
+
+  rename<R extends RenameMap<T>>(r: R): AsyncRelation<Renamed<T, R>> {
+    return new BaseAsyncRelation(
+      renameOp(this.source, r as any)
+    ) as unknown as AsyncRelation<Renamed<T, R>>;
+  }
+
+  prefix<P extends string, Ex extends keyof T = never>(pfx: P, options?: { except?: Ex[] }): AsyncRelation<Prefixed<T, P, Ex>> {
+    return new BaseAsyncRelation(
+      prefixOp(this.source, pfx, options as any)
+    ) as unknown as AsyncRelation<Prefixed<T, P, Ex>>;
+  }
+
+  suffix<S extends string, Ex extends keyof T = never>(sfx: S, options?: { except?: Ex[] }): AsyncRelation<Suffixed<T, S, Ex>> {
+    return new BaseAsyncRelation(
+      suffixOp(this.source, sfx, options as any)
+    ) as unknown as AsyncRelation<Suffixed<T, S, Ex>>;
+  }
+
+  transform(t: Transformation): AsyncRelation<T> {
+    return new BaseAsyncRelation(
+      transformOp(this.source, t)
+    ) as unknown as AsyncRelation<T>;
+  }
+
+  // === Set operations ===
+
+  union(other: AsyncRelationOperand<T>): AsyncRelation<T> {
+    return new BaseAsyncRelation(
+      unionOp(this.source, other)
+    ) as unknown as AsyncRelation<T>;
+  }
+
+  minus(other: AsyncRelationOperand<T>): AsyncRelation<T> {
+    return new BaseAsyncRelation(
+      minusOp(this.source, other)
+    ) as unknown as AsyncRelation<T>;
+  }
+
+  intersect(other: AsyncRelationOperand<T>): AsyncRelation<T> {
+    return new BaseAsyncRelation(
+      intersectOp(this.source, other)
+    ) as unknown as AsyncRelation<T>;
+  }
+
+  // === Semi-joins ===
+
+  matching<U>(other: AsyncRelationOperand<U>, keys?: JoinKeys): AsyncRelation<T> {
+    return new BaseAsyncRelation(
+      matchingOp(this.source, other, keys)
+    ) as unknown as AsyncRelation<T>;
+  }
+
+  not_matching<U>(other: AsyncRelationOperand<U>, keys?: JoinKeys): AsyncRelation<T> {
+    return new BaseAsyncRelation(
+      notMatchingOp(this.source, other, keys)
+    ) as unknown as AsyncRelation<T>;
+  }
+
+  // === Joins ===
+
+  join<U>(other: AsyncRelationOperand<U>, keys?: JoinKeys): AsyncRelation<T & U> {
+    return new BaseAsyncRelation(
+      joinOp(this.source, other, keys)
+    ) as unknown as AsyncRelation<T & U>;
+  }
+
+  left_join<U>(other: AsyncRelationOperand<U>, keys?: JoinKeys): AsyncRelation<T & Partial<U>> {
+    return new BaseAsyncRelation(
+      leftJoinOp(this.source, other, keys)
+    ) as unknown as AsyncRelation<T & Partial<U>>;
+  }
+
+  cross_product<U>(other: AsyncRelationOperand<U>): AsyncRelation<T & U> {
+    return new BaseAsyncRelation(
+      crossProductOp(this.source, other)
+    ) as unknown as AsyncRelation<T & U>;
+  }
+
+  cross_join<U>(other: AsyncRelationOperand<U>): AsyncRelation<T & U> {
+    return this.cross_product(other);
+  }
+
+  // === Nesting/Grouping ===
+
+  group<K extends keyof T>(attrs: K[], as: string): AsyncRelation<Omit<T, K> & Record<string, Relation<Pick<T, K>>>> {
+    return new BaseAsyncRelation(
+      groupOp(this.source, attrs as string[], as)
+    ) as unknown as AsyncRelation<Omit<T, K> & Record<string, Relation<Pick<T, K>>>>;
+  }
+
+  ungroup(attr: string): AsyncRelation<Tuple> {
+    return new BaseAsyncRelation(
+      ungroupOp(this.source, attr)
+    ) as unknown as AsyncRelation<Tuple>;
+  }
+
+  wrap<K extends keyof T>(attrs: K[], as: string): AsyncRelation<Omit<T, K> & Record<string, Pick<T, K>>> {
+    return new BaseAsyncRelation(
+      wrapOp(this.source, attrs as string[], as)
+    ) as unknown as AsyncRelation<Omit<T, K> & Record<string, Pick<T, K>>>;
+  }
+
+  unwrap(attr: string): AsyncRelation<Tuple> {
+    return new BaseAsyncRelation(
+      unwrapOp(this.source, attr)
+    ) as unknown as AsyncRelation<Tuple>;
+  }
+
+  image<U>(other: AsyncRelationOperand<U>, as: string, keys?: JoinKeys): AsyncRelation<T & Record<string, Relation<U>>> {
+    return new BaseAsyncRelation(
+      imageOp(this.source, other, as, keys)
+    ) as unknown as AsyncRelation<T & Record<string, Relation<U>>>;
+  }
+
+  summarize<K extends keyof T>(by: K[], aggs: Aggregators): AsyncRelation<Pick<T, K> & Tuple> {
+    return new BaseAsyncRelation(
+      summarizeOp(this.source, by as string[], aggs)
+    ) as unknown as AsyncRelation<Pick<T, K> & Tuple>;
+  }
+
+  autowrap(options?: AutowrapOptions): AsyncRelation<Tuple> {
+    return new BaseAsyncRelation(
+      autowrapOp(this.source, options)
+    ) as unknown as AsyncRelation<Tuple>;
+  }
+
+  // === Terminal operations ===
+
+  one(): Promise<T> {
+    return oneOp(this.source);
+  }
+
+  toArray(): Promise<T[]> {
+    return toArrayOp(this.source);
+  }
+
+  async toRelation(): Promise<Relation<T>> {
+    const tuples = await toArrayOp(this.source);
+    return new MemoryRelation<T>(tuples);
+  }
+
+  yByX(y: string, x: string): Promise<Tuple> {
+    return yByXOp(this.source, y, x);
+  }
+
+  async toText(options?: TextOptions): Promise<string> {
+    const tuples = await toArrayOp(this.source);
+    return toTextSync(tuples as Tuple[], options);
+  }
+
+  // === Async iteration ===
+
+  [Symbol.asyncIterator](): AsyncIterator<T> {
+    return this.source[Symbol.asyncIterator]();
+  }
+}

package/src/async/Relation/index.ts

@@ -0,0 +1,31 @@
+import { BaseAsyncRelation } from './Base';
+import type { AsyncRelation, AsyncRelationOperand } from '../types';
+import { isEqual as isEqualOp } from '../operators/isEqual';
+
+export { BaseAsyncRelation };
+
+/**
+ * Creates a new async relation from an AsyncIterable source.
+ *
+ * @typeParam T - The tuple type. Inferred from input or explicitly provided.
+ *
+ * @example
+ * // From an async iterable
+ * const suppliers = AsyncBmg(fetchSuppliersFromDB());
+ *
+ * @example
+ * // Chained operations (lazy - no execution yet)
+ * const query = AsyncBmg(source)
+ *   .restrict({ city: 'London' })
+ *   .project(['sid', 'name']);
+ *
+ * // Terminal operation triggers execution
+ * const results = await query.toArray();
+ */
+export function AsyncBmg<T>(source: AsyncIterable<T>): AsyncRelation<T> {
+  return new BaseAsyncRelation<T>(source);
+}
+
+AsyncBmg.isEqual = <T, U>(left: AsyncRelationOperand<T>, right: AsyncRelationOperand<U>): Promise<boolean> => {
+  return isEqualOp(left, right);
+};

package/src/async/operators/_helpers.ts

@@ -0,0 +1,60 @@
+import type { AsyncRelationOperand, AsyncOperationalOperand, AsyncRelation } from '../types';
+import type { Tuple } from '../../types';
+import { tupleKey } from '../../sync/operators/_helpers';
+
+/**
+ * Type guard to check if a value implements AsyncRelation.
+ */
+export const isAsyncRelation = <T>(value: unknown): value is AsyncRelation<T> => {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    'restrict' in value &&
+    'project' in value &&
+    'one' in value &&
+    Symbol.asyncIterator in value
+  );
+};
+
+/**
+ * Converts an AsyncRelationOperand to an AsyncOperationalOperand
+ * that provides a uniform interface for async iteration and output.
+ */
+export const toAsyncOperationalOperand = <T>(
+  operand: AsyncRelationOperand<T>
+): AsyncOperationalOperand<T> => {
+  if (isAsyncRelation<T>(operand)) {
+    return {
+      tuples: () => operand,
+      output: (tuples) => tuples,
+    };
+  } else if (Symbol.asyncIterator in operand) {
+    return {
+      tuples: () => operand as AsyncIterable<T>,
+      output: (tuples) => tuples,
+    };
+  } else {
+    throw new Error(`Unable to iterate ${operand}`);
+  }
+};
+
+/**
+ * Async generator that removes duplicate tuples.
+ * Uses tupleKey() for equality comparison.
+ */
+export async function* deduplicateAsync<T>(
+  source: AsyncIterable<T>
+): AsyncGenerator<T> {
+  const seen = new Set<string>();
+  for await (const tuple of source) {
+    const key = tupleKey(tuple as Tuple);
+    if (!seen.has(key)) {
+      seen.add(key);
+      yield tuple;
+    }
+  }
+}
+
+export const error = (msg: string): never => {
+  throw new Error(msg);
+};

package/src/async/operators/autowrap.ts

@@ -0,0 +1,31 @@
+import type { AsyncRelationOperand } from '../types';
+import type { AutowrapOptions, Tuple } from '../../types';
+
+/**
+ * Automatically wraps attributes based on naming convention.
+ * Attributes with separator (default '_') are grouped into nested objects.
+ */
+export async function* autowrap<T>(
+  operand: AsyncRelationOperand<T>,
+  options?: AutowrapOptions
+): AsyncIterable<Tuple> {
+  const sep = options?.separator ?? '_';
+
+  for await (const tuple of operand) {
+    const t = tuple as Tuple;
+    const wrapped: Tuple = {};
+
+    for (const [attr, value] of Object.entries(t)) {
+      const parts = attr.split(sep);
+      if (parts.length === 1) {
+        wrapped[attr] = value;
+      } else {
+        const [prefix, ...rest] = parts;
+        wrapped[prefix] = wrapped[prefix] ?? {};
+        (wrapped[prefix] as Tuple)[rest.join(sep)] = value;
+      }
+    }
+
+    yield wrapped;
+  }
+}

package/src/async/operators/constants.ts

@@ -0,0 +1,26 @@
+import type { AsyncRelationOperand } from '../types';
+import type { Tuple } from '../../types';
+import { toAsyncOperationalOperand } from './_helpers';
+
+/**
+ * Async generator that adds constant attributes to each tuple.
+ */
+async function* constantsGen<T>(
+  source: AsyncIterable<T>,
+  consts: Tuple
+): AsyncGenerator<Tuple> {
+  for await (const tuple of source) {
+    yield { ...(tuple as Tuple), ...consts };
+  }
+}
+
+/**
+ * Adds constant attributes to each tuple.
+ */
+export const constants = <T>(
+  operand: AsyncRelationOperand<T>,
+  consts: Tuple
+): AsyncIterable<Tuple> => {
+  const op = toAsyncOperationalOperand(operand);
+  return constantsGen(op.tuples(), consts);
+};

package/src/async/operators/cross_product.ts

@@ -0,0 +1,39 @@
+import type { AsyncRelationOperand } from '../types';
+import type { Tuple } from '../../types';
+import { tupleKey } from '../../sync/operators/_helpers';
+
+/**
+ * Cartesian product: combines every left tuple with every right tuple.
+ * Left attributes override right on clash. Removes duplicates.
+ * Materializes both sides.
+ */
+export async function* cross_product<T, U>(
+  left: AsyncRelationOperand<T>,
+  right: AsyncRelationOperand<U>
+): AsyncIterable<Tuple> {
+  // Materialize both sides
+  const leftTuples: Tuple[] = [];
+  const rightTuples: Tuple[] = [];
+
+  for await (const tuple of left) {
+    leftTuples.push(tuple as Tuple);
+  }
+  for await (const tuple of right) {
+    rightTuples.push(tuple as Tuple);
+  }
+
+  // Cartesian product with deduplication
+  const seen = new Set<string>();
+  for (const l of leftTuples) {
+    for (const r of rightTuples) {
+      const combined = { ...r, ...l };
+      const key = tupleKey(combined);
+      if (!seen.has(key)) {
+        seen.add(key);
+        yield combined;
+      }
+    }
+  }
+}
+
+export { cross_product as cross_join };

package/src/async/operators/extend.ts

@@ -0,0 +1,36 @@
+import type { AsyncRelationOperand } from '../types';
+import type { Extension, Tuple } from '../../types';
+import { toAsyncOperationalOperand } from './_helpers';
+
+/**
+ * Async generator that extends tuples with computed or copied attributes.
+ */
+async function* extendGen<T>(
+  source: AsyncIterable<T>,
+  extension: Extension
+): AsyncGenerator<Tuple> {
+  for await (const tuple of source) {
+    const t = tuple as Tuple;
+    const extended = { ...t };
+    for (const [attr, spec] of Object.entries(extension)) {
+      if (typeof spec === 'function') {
+        extended[attr] = spec(t);
+      } else {
+        extended[attr] = t[spec];
+      }
+    }
+    yield extended;
+  }
+}
+
+/**
+ * Extends each tuple with new attributes.
+ * Extension can be functions (computed) or attribute names (copied).
+ */
+export const extend = <T>(
+  operand: AsyncRelationOperand<T>,
+  extension: Extension
+): AsyncIterable<Tuple> => {
+  const op = toAsyncOperationalOperand(operand);
+  return extendGen(op.tuples(), extension);
+};

package/src/async/operators/group.ts

@@ -0,0 +1,61 @@
+import type { AsyncRelationOperand } from '../types';
+import type { AttrName, Tuple } from '../../types';
+import { MemoryRelation } from '../../sync/Relation';
+
+const groupKey = (tuple: Tuple, byAttrs: AttrName[]): string => {
+  const keyParts = byAttrs.map(attr => JSON.stringify(tuple[attr]));
+  return keyParts.join('|');
+};
+
+const pickAttrs = (tuple: Tuple, attrs: AttrName[]): Tuple => {
+  return attrs.reduce((acc, attr) => {
+    acc[attr] = tuple[attr];
+    return acc;
+  }, {} as Tuple);
+};
+
+/**
+ * Groups specified attributes into a nested relation.
+ * Materializes all tuples to perform grouping.
+ */
+export async function* group<T>(
+  operand: AsyncRelationOperand<T>,
+  attrs: AttrName[],
+  as: AttrName
+): AsyncIterable<Tuple> {
+  // Materialize all tuples
+  const tuples: Tuple[] = [];
+  for await (const tuple of operand) {
+    tuples.push(tuple as Tuple);
+  }
+
+  if (tuples.length === 0) {
+    return;
+  }
+
+  // Determine which attributes to keep at the top level (all except grouped ones)
+  const allAttrs = Object.keys(tuples[0]);
+  const groupedSet = new Set(attrs);
+  const byAttrs = allAttrs.filter(a => !groupedSet.has(a));
+
+  // Group tuples
+  const groups = new Map<string, { base: Tuple; nested: Tuple[] }>();
+  for (const tuple of tuples) {
+    const key = groupKey(tuple, byAttrs);
+    if (!groups.has(key)) {
+      groups.set(key, {
+        base: pickAttrs(tuple, byAttrs),
+        nested: []
+      });
+    }
+    groups.get(key)!.nested.push(pickAttrs(tuple, attrs));
+  }
+
+  // Yield results with nested relations
+  for (const { base, nested } of groups.values()) {
+    yield {
+      ...base,
+      [as]: new MemoryRelation(nested)
+    };
+  }
+}

package/src/async/operators/image.ts

@@ -0,0 +1,42 @@
+import type { AsyncRelationOperand } from '../types';
+import type { JoinKeys, Tuple, AttrName } from '../../types';
+import { normalizeKeys, tuplesMatch, projectOutKeys } from '../../sync/operators/_helpers';
+import { MemoryRelation } from '../../sync/Relation';
+
+/**
+ * Adds a relation-valued attribute with matching tuples from right.
+ * Each left tuple gets a nested relation of matching right tuples.
+ * Materializes both sides.
+ */
+export async function* image<T, U>(
+  left: AsyncRelationOperand<T>,
+  right: AsyncRelationOperand<U>,
+  as: AttrName,
+  keys?: JoinKeys
+): AsyncIterable<Tuple> {
+  // Materialize both sides
+  const leftTuples: Tuple[] = [];
+  const rightTuples: Tuple[] = [];
+
+  for await (const tuple of left) {
+    leftTuples.push(tuple as Tuple);
+  }
+  for await (const tuple of right) {
+    rightTuples.push(tuple as Tuple);
+  }
+
+  const keyMap = normalizeKeys(keys, leftTuples, rightTuples);
+
+  for (const leftTuple of leftTuples) {
+    const matches: Tuple[] = [];
+    for (const rightTuple of rightTuples) {
+      if (tuplesMatch(leftTuple, rightTuple, keyMap)) {
+        matches.push(projectOutKeys(rightTuple, keyMap));
+      }
+    }
+    yield {
+      ...leftTuple,
+      [as]: new MemoryRelation(matches)
+    };
+  }
+}

package/src/async/operators/index.ts

@@ -0,0 +1,28 @@
+export { restrict, where, exclude } from './restrict';
+export { project, allbut } from './project';
+export { extend } from './extend';
+export { constants } from './constants';
+export { rename } from './rename';
+export { prefix } from './prefix';
+export { suffix } from './suffix';
+export { transform } from './transform';
+export { union } from './union';
+export { minus } from './minus';
+export { intersect } from './intersect';
+export { matching } from './matching';
+export { not_matching } from './not_matching';
+export { join } from './join';
+export { left_join } from './left_join';
+export { cross_product, cross_join } from './cross_product';
+export { group } from './group';
+export { ungroup } from './ungroup';
+export { wrap } from './wrap';
+export { unwrap } from './unwrap';
+export { image } from './image';
+export { summarize } from './summarize';
+export { autowrap } from './autowrap';
+export { yByX } from './yByX';
+export { isEqual } from './isEqual';
+export { one } from './one';
+export { toArray } from './toArray';
+export { isAsyncRelation, toAsyncOperationalOperand, deduplicateAsync } from './_helpers';

package/src/async/operators/intersect.ts

@@ -0,0 +1,28 @@
+import type { AsyncRelationOperand } from '../types';
+import type { Tuple } from '../../types';
+import { tupleKey } from '../../sync/operators/_helpers';
+
+/**
+ * Set intersection: returns tuples present in both relations.
+ * Materializes right side first, then streams left.
+ */
+export async function* intersect<T>(
+  left: AsyncRelationOperand<T>,
+  right: AsyncRelationOperand<T>
+): AsyncIterable<Tuple> {
+  // Materialize right side into a set of keys
+  const rightKeys = new Set<string>();
+  for await (const tuple of right) {
+    rightKeys.add(tupleKey(tuple as Tuple));
+  }
+
+  // Stream left, keeping tuples present in right
+  const seen = new Set<string>();
+  for await (const tuple of left) {
+    const key = tupleKey(tuple as Tuple);
+    if (rightKeys.has(key) && !seen.has(key)) {
+      seen.add(key);
+      yield tuple as Tuple;
+    }
+  }
+}

package/src/async/operators/isEqual.ts

@@ -0,0 +1,39 @@
+import type { AsyncRelationOperand } from '../types';
+import type { Tuple } from '../../types';
+import { toAsyncOperationalOperand } from './_helpers';
+import { tupleKey } from '../../sync/operators/_helpers';
+
+/**
+ * Compares two async relations for equality.
+ * Two relations are equal if they contain the exact same set of tuples.
+ * Terminal operation - returns a Promise.
+ */
+export const isEqual = async <T, U>(
+  left: AsyncRelationOperand<T>,
+  right: AsyncRelationOperand<U>
+): Promise<boolean> => {
+  const opLeft = toAsyncOperationalOperand(left);
+  const opRight = toAsyncOperationalOperand(right);
+
+  const leftKeys = new Set<string>();
+  for await (const tuple of opLeft.tuples()) {
+    leftKeys.add(tupleKey(tuple as Tuple));
+  }
+
+  const rightKeys = new Set<string>();
+  for await (const tuple of opRight.tuples()) {
+    rightKeys.add(tupleKey(tuple as Tuple));
+  }
+
+  if (leftKeys.size !== rightKeys.size) {
+    return false;
+  }
+
+  for (const key of leftKeys) {
+    if (!rightKeys.has(key)) {
+      return false;
+    }
+  }
+
+  return true;
+};