@enspirit/bmg-js 1.0.1 → 1.1.0

package/src/lib-definitions.ts

@@ -0,0 +1,292 @@
+// Auto-generated from types.ts
+// Run 'npm run generate:lib-definitions' to regenerate
+
+export const LIB_DEFINITIONS = `
+/**
+ * Type definitions for Bmg.js relational algebra library.
+ *
+ * This file defines all types needed for type-safe relational operations:
+ * - Base types (AttrName, Tuple)
+ * - Utility types for transformations (Renamed, Prefixed, Joined, etc.)
+ * - The Relation interface with all operators
+ * - Helper types for predicates, extensions, aggregators, etc.
+ */
+
+// ============================================================================
+// Base Types
+// ============================================================================
+
+/** Attribute name in a tuple */
+type AttrName = string
+
+/** A tuple is a record mapping attribute names to values */
+type Tuple = Record<AttrName, unknown>
+
+// ============================================================================
+// Rename Types
+// ============================================================================
+
+/** Map from old attribute names to new attribute names */
+type RenameMap<T> = { [K in keyof T]?: string };
+
+/** Transform tuple type by renaming keys according to RenameMap */
+type Renamed<T, R extends RenameMap<T>> = {
+  [K in keyof T as K extends keyof R ? (R[K] extends string ? R[K] : K) : K]: T[K];
+};
+
+// ============================================================================
+// Prefix/Suffix Types
+// ============================================================================
+
+/** Prefix all keys except those in Except */
+type Prefixed<T, P extends string, Except extends keyof T = never> = {
+  [K in keyof T as K extends Except ? K : \`\${P}\${K & string}\`]: T[K];
+};
+
+/** Suffix all keys except those in Except */
+type Suffixed<T, S extends string, Except extends keyof T = never> = {
+  [K in keyof T as K extends Except ? K : \`\${K & string}\${S}\`]: T[K];
+};
+
+// ============================================================================
+// Join Types
+// ============================================================================
+
+/** Extract common keys between two tuple types */
+type CommonKeys<L, R> = Extract<keyof L, keyof R>;
+
+/** Result of inner join: L & R with R's common keys removed */
+type Joined<L, R> = L & Omit<R, CommonKeys<L, R>>;
+
+/** Result of left join: L & optional R attributes (common keys removed) */
+type LeftJoined<L, R> = L & Partial<Omit<R, CommonKeys<L, R>>>;
+
+/**
+ * Typed join keys for array form: keys must exist on BOTH operands.
+ * Example: suppliers.join(parts, ['city']) - 'city' must be a key of both.
+ */
+type TypedJoinKeysArray<L, R> = (keyof L & keyof R & string)[];
+
+/**
+ * Typed join keys for object form: maps left keys to right keys.
+ * Example: suppliers.join(parts, { sid: 'supplier_id' })
+ * - Left key (sid) must exist on L
+ * - Right key (supplier_id) must exist on R
+ */
+type TypedJoinKeysObject<L, R> = { [K in keyof L & string]?: keyof R & string };
+
+// ============================================================================
+// Wrap/Unwrap Types
+// ============================================================================
+
+/** Result of wrap: remove wrapped attrs, add nested object */
+type Wrapped<T, K extends keyof T, As extends string> =
+  Omit<T, K> & Record<As, Pick<T, K>>;
+
+/** Result of unwrap: remove object attr, spread its properties */
+type Unwrapped<T, K extends keyof T> =
+  T[K] extends Record<string, unknown> ? Omit<T, K> & T[K] : Omit<T, K>;
+
+/** Result of ungroup: remove relation attr, flatten its tuple type */
+type Ungrouped<T, K extends keyof T> =
+  T[K] extends Relation<infer N> ? Omit<T, K> & N : Omit<T, K>;
+
+// ============================================================================
+// Aggregator Types
+// ============================================================================
+
+type AggregatorName = 'count' | 'sum' | 'min' | 'max' | 'avg' | 'collect'
+type AggregatorSpec = { op: AggregatorName, attr: AttrName }
+type AggregatorFunc = (tuples: Tuple[]) => unknown
+type Aggregator = AggregatorName | AggregatorSpec | AggregatorFunc
+type Aggregators = Record<AttrName, Aggregator>
+
+/** Infer result type from aggregator specification */
+type AggregatorResult<A> =
+  A extends 'count' ? number :
+  A extends { op: 'count' } ? number :
+  A extends { op: 'sum' | 'avg' | 'min' | 'max' } ? number | null :
+  A extends { op: 'collect' } ? unknown[] :
+  A extends (tuples: Tuple[]) => infer R ? R :
+  unknown;
+
+/** Map aggregator definitions to their result types */
+type AggregatorResults<Aggs extends Record<string, unknown>> = {
+  [K in keyof Aggs]: AggregatorResult<Aggs[K]>;
+};
+
+// ============================================================================
+// Predicate Types
+// ============================================================================
+
+/** Predicate function that receives a typed tuple */
+type TypedPredicateFunc<T> = (t: T) => boolean
+
+/** Predicate: either a partial tuple for equality matching, or a function */
+type TypedPredicate<T> = Partial<T> | TypedPredicateFunc<T>
+
+// Legacy predicate types (for backwards compatibility with standalone operators)
+type PredicateFunc = ((t: Tuple) => any)
+type Predicate = Tuple | PredicateFunc
+
+// ============================================================================
+// Extension Types
+// ============================================================================
+
+/** Extension function that receives a typed tuple */
+type TypedExtensionFunc<T, R> = (tuple: T) => R
+
+/** Extension definition: function returning value, or attribute name to copy */
+type TypedExtension<T, E extends Record<string, unknown>> = {
+  [K in keyof E]: TypedExtensionFunc<T, E[K]> | keyof T;
+}
+
+type ExtensionFunc = (tuple: Tuple) => unknown
+type Extension = Record<AttrName, ExtensionFunc | AttrName>
+
+// ============================================================================
+// Other Helper Types
+// ============================================================================
+
+interface PrefixOptions {
+  except?: AttrName[]
+}
+
+interface TextOptions {
+  /** Precision for floating point numbers (default: 3) */
+  floatPrecision?: number;
+  /** Maximum width to trim output at */
+  trimAt?: number;
+}
+
+interface SuffixOptions {
+  except?: AttrName[]
+}
+
+interface AutowrapOptions {
+  separator?: string
+}
+
+type Renaming = RenamingObj | RenamingFunc
+type RenamingFunc = (attr: AttrName) => AttrName
+type RenamingObj = Record<AttrName, AttrName>
+
+type JoinKeys = AttrName[] | Record<AttrName, AttrName>
+
+type TransformFunc = (value: unknown) => unknown
+type Transformation = TransformFunc | TransformFunc[] | Record<AttrName, TransformFunc | TransformFunc[]>
+
+// ============================================================================
+// Relation Interface
+// ============================================================================
+
+/**
+ * Relation interface with generic type parameter for tuple type.
+ * Default parameter \`Tuple\` ensures backwards compatibility.
+ *
+ * @typeParam T - The tuple type for this relation. Defaults to \`Tuple\` (Record<string, unknown>).
+ *
+ * @example
+ * // Untyped usage (backwards compatible)
+ * const r = Bmg([{ id: 1 }]);  // Relation<Tuple>
+ *
+ * @example
+ * // Typed usage with full type safety
+ * interface Person { id: number; name: string }
+ * const r = Bmg<Person>([{ id: 1, name: 'Alice' }]);
+ * r.project(['id']);  // Relation<{ id: number }>
+ */
+interface Relation<T = Tuple> {
+  // === Type-preserving operators ===
+
+  restrict(p: TypedPredicate<T>): Relation<T>
+  where(p: TypedPredicate<T>): Relation<T>
+  exclude(p: TypedPredicate<T>): Relation<T>
+
+  // === Projection operators ===
+
+  project<K extends keyof T>(attrs: K[]): Relation<Pick<T, K>>
+  allbut<K extends keyof T>(attrs: K[]): Relation<Omit<T, K>>
+
+  // === Extension operators ===
+
+  extend<E extends Record<string, unknown>>(e: TypedExtension<T, E>): Relation<T & E>
+  constants<C extends Tuple>(consts: C): Relation<T & C>
+
+  // === Rename operators ===
+
+  rename<R extends RenameMap<T>>(r: R): Relation<Renamed<T, R>>
+  prefix<P extends string, Ex extends keyof T = never>(pfx: P, options?: { except?: Ex[] }): Relation<Prefixed<T, P, Ex>>
+  suffix<S extends string, Ex extends keyof T = never>(sfx: S, options?: { except?: Ex[] }): Relation<Suffixed<T, S, Ex>>
+
+  // === Set operators (require same type) ===
+
+  union(right: RelationOperand<T>): Relation<T>
+  minus(right: RelationOperand<T>): Relation<T>
+  intersect(right: RelationOperand<T>): Relation<T>
+
+  // === Semi-join operators (preserve left type) ===
+
+  matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T>
+  not_matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T>
+
+  // === Join operators ===
+
+  join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<Joined<T, R>>
+  left_join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<LeftJoined<T, R>>
+  cross_product<R>(right: RelationOperand<R>): Relation<T & R>
+  cross_join<R>(right: RelationOperand<R>): Relation<T & R>
+
+  // === Nesting operators ===
+
+  image<R, As extends string>(right: RelationOperand<R>, as: As, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T & Record<As, Relation<Omit<R, keyof T & keyof R>>>>
+  group<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Omit<T, K> & Record<As, Relation<Pick<T, K>>>>
+  ungroup<K extends keyof T>(attr: K): Relation<Ungrouped<T, K>>
+  wrap<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Wrapped<T, K, As>>
+  unwrap<K extends keyof T>(attr: K): Relation<Unwrapped<T, K>>
+
+  // === Aggregation ===
+
+  summarize<By extends keyof T, Aggs extends Aggregators>(by: By[], aggs: Aggs): Relation<Pick<T, By> & AggregatorResults<Aggs>>
+
+  // === Transform ===
+
+  transform(t: Transformation): Relation<T>
+
+  // === Dynamic (loses type precision) ===
+
+  autowrap(options?: AutowrapOptions): Relation<Tuple>
+
+  // === Non-relational ===
+
+  one(): T
+  yByX<Y extends keyof T, X extends keyof T>(y: Y, x: X): Record<T[X] & PropertyKey, T[Y]>
+  toArray(): T[]
+  isEqual(right: any): boolean
+
+  // === Display ===
+
+  toText(options?: TextOptions): string
+}
+
+// ============================================================================
+// Operands
+// ============================================================================
+
+type RelationOperand<T = Tuple> = Relation<T> | T[]
+
+interface OperationalOperand<T = Tuple> {
+  tuples(): Iterable<T>
+  output(tuples: T[]): RelationOperand<T>
+}
+
+// ============================================================================
+// Bmg Function Declaration
+// ============================================================================
+
+/** Create a relation from an array of tuples */
+declare function Bmg<T>(tuples: T[]): Relation<T>
+declare namespace Bmg {
+  function isRelation(op: unknown): boolean
+}
+`

package/src/operators/index.ts

@@ -1,31 +1,2 @@
-export * from './restrict'
-export * from './where'
-export * from './exclude'
-export * from './constants'
-export * from './rename'
-export * from './prefix'
-export * from './suffix'
-export * from './project'
-export * from './allbut'
-export * from './extend'
-export * from './union'
-export * from './minus'
-export * from './intersect'
-export * from './matching'
-export * from './not_matching'
-export * from './join'
-export * from './left_join'
-export * from './cross_product'
-export * from './image'
-export * from './summarize'
-export * from './group'
-export * from './ungroup'
-export * from './wrap'
-export * from './unwrap'
-export * from './autowrap'
-export * from './transform'
-
-export * from './isRelation'
-export * from './isEqual'
-export * from './one'
-export * from './yByX'
+// Re-export sync operators for backward compatibility
+export * from '../sync/operators';

package/src/{Relation → sync/Relation}/Memory.ts

@@ -32,9 +32,9 @@ import {
 import type {
   AttrName,
   AutowrapOptions,
-  JoinKeys,
   Relation,
   RelationOperand,
+  TextOptions,
   Transformation,
   Tuple,
   TypedPredicate,
@@ -48,8 +48,11 @@ import type {
   Wrapped,
   Unwrapped,
   Ungrouped,
-} from "../types";
-import type { AggregatorResults } from "../utility-types";
+  AggregatorResults,
+  TypedJoinKeysArray,
+  TypedJoinKeysObject,
+} from "../../types";
+import { toText } from "../../writer";
 
 /**
  * In-memory implementation of the Relation interface.
@@ -126,22 +129,22 @@ export class MemoryRelation<T = Tuple> implements Relation<T> {
 
   // === Semi-join operators ===
 
-  matching<R>(right: RelationOperand<R>, keys?: JoinKeys): Relation<T> {
-    return matching(this as any, right as any, keys) as unknown as Relation<T>;
+  matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T> {
+    return matching(this as any, right as any, keys as any) as unknown as Relation<T>;
   }
 
-  not_matching<R>(right: RelationOperand<R>, keys?: JoinKeys): Relation<T> {
-    return not_matching(this as any, right as any, keys) as unknown as Relation<T>;
+  not_matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T> {
+    return not_matching(this as any, right as any, keys as any) as unknown as Relation<T>;
   }
 
   // === Join operators ===
 
-  join<R>(right: RelationOperand<R>, keys?: JoinKeys): Relation<Joined<T, R>> {
-    return join(this as any, right as any, keys) as unknown as Relation<Joined<T, R>>;
+  join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<Joined<T, R>> {
+    return join(this as any, right as any, keys as any) as unknown as Relation<Joined<T, R>>;
   }
 
-  left_join<R>(right: RelationOperand<R>, keys?: JoinKeys): Relation<LeftJoined<T, R>> {
-    return left_join(this as any, right as any, keys) as unknown as Relation<LeftJoined<T, R>>;
+  left_join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<LeftJoined<T, R>> {
+    return left_join(this as any, right as any, keys as any) as unknown as Relation<LeftJoined<T, R>>;
   }
 
   cross_product<R>(right: RelationOperand<R>): Relation<T & R> {
@@ -154,8 +157,8 @@ export class MemoryRelation<T = Tuple> implements Relation<T> {
 
   // === Nesting operators ===
 
-  image<R, As extends string>(right: RelationOperand<R>, as: As, keys?: JoinKeys): Relation<T & Record<As, Relation<Omit<R, keyof T & keyof R>>>> {
-    return image(this as any, right as any, as, keys) as unknown as Relation<T & Record<As, Relation<Omit<R, keyof T & keyof R>>>>;
+  image<R, As extends string>(right: RelationOperand<R>, as: As, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T & Record<As, Relation<Omit<R, keyof T & keyof R>>>> {
+    return image(this as any, right as any, as, keys as any) as unknown as Relation<T & Record<As, Relation<Omit<R, keyof T & keyof R>>>>;
   }
 
   group<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Omit<T, K> & Record<As, Relation<Pick<T, K>>>> {
@@ -210,4 +213,10 @@ export class MemoryRelation<T = Tuple> implements Relation<T> {
     return isEqual(this as any, right as any);
   }
 
+  // === Display ===
+
+  toText(options?: TextOptions): string {
+    return toText(this as any, options);
+  }
+
 }

package/{dist/src/Relation/index.d.ts → src/sync/Relation/index.ts}

@@ -1 +1 @@
-export * from './Memory';
+export * from './Memory';

package/src/{operators → sync/operators}/_helpers.ts

@@ -1,5 +1,5 @@
 import { OperationalOperand, Relation, RelationOperand, Renaming, RenamingFunc, Tuple, JoinKeys, AttrName } from "@/types";
-import { MemoryRelation } from '@/Relation';
+import { MemoryRelation } from '@/sync/Relation';
 import { isRelation } from "./isRelation";
 
 const valueKey = (value: unknown): unknown => {

package/src/{operators → sync/operators}/allbut.ts

@@ -1,4 +1,4 @@
-import { RelationOperand, AttrName, Tuple } from "../types";
+import { RelationOperand, AttrName, Tuple } from "../../types";
 import { toOperationalOperand, deduplicate } from "./_helpers";
 
 export const allbut = (operand: RelationOperand, attrs: AttrName[]): RelationOperand => {

package/src/{operators → sync/operators}/autowrap.ts

@@ -1,4 +1,4 @@
-import { AutowrapOptions, RelationOperand, Tuple } from "../types";
+import { AutowrapOptions, RelationOperand, Tuple } from "../../types";
 import { toOperationalOperand } from "./_helpers";
 
 export const autowrap = (operand: RelationOperand, options?: AutowrapOptions): RelationOperand => {

package/src/{operators → sync/operators}/constants.ts

@@ -1,4 +1,4 @@
-import { RelationOperand, Tuple } from "../types";
+import { RelationOperand, Tuple } from "../../types";
 import { toOperationalOperand } from "./_helpers";
 
 export const constants = (operand: RelationOperand, consts: Tuple): RelationOperand => {

package/src/{operators → sync/operators}/cross_product.ts

@@ -1,4 +1,4 @@
-import { RelationOperand, Tuple } from "../types";
+import { RelationOperand, Tuple } from "../../types";
 import { toOperationalOperand, deduplicate } from "./_helpers";
 
 export const cross_product = (left: RelationOperand, right: RelationOperand): RelationOperand => {

package/src/{operators → sync/operators}/exclude.ts

@@ -1,5 +1,5 @@
-import { toPredicateFunc } from "../support/toPredicateFunc";
-import { RelationOperand, Predicate, Tuple } from "../types";
+import { toPredicateFunc } from "../../support/toPredicateFunc";
+import { RelationOperand, Predicate, Tuple } from "../../types";
 import { toOperationalOperand } from "./_helpers";
 
 export const exclude = (operand: RelationOperand, p: Predicate): RelationOperand => {

package/src/{operators → sync/operators}/extend.ts

@@ -1,4 +1,4 @@
-import { RelationOperand, Extension, Tuple } from "../types";
+import { RelationOperand, Extension, Tuple } from "../../types";
 import { toOperationalOperand } from "./_helpers";
 
 export const extend = (operand: RelationOperand, extension: Extension): RelationOperand => {

package/src/{operators → sync/operators}/group.ts

@@ -1,6 +1,6 @@
-import { RelationOperand, AttrName, Tuple } from "../types";
+import { RelationOperand, AttrName, Tuple } from "../../types";
 import { toOperationalOperand } from "./_helpers";
-import { MemoryRelation } from "@/Relation";
+import { MemoryRelation } from "@/sync/Relation";
 
 const groupKey = (tuple: Tuple, byAttrs: AttrName[]): string => {
   const keyParts = byAttrs.map(attr => JSON.stringify(tuple[attr]));

package/src/{operators → sync/operators}/image.ts

@@ -1,6 +1,6 @@
-import { RelationOperand, JoinKeys, Tuple, AttrName } from "../types";
+import { RelationOperand, JoinKeys, Tuple, AttrName } from "../../types";
 import { toOperationalOperand, normalizeKeys, tuplesMatch, projectOutKeys } from "./_helpers";
-import { MemoryRelation } from "@/Relation";
+import { MemoryRelation } from "@/sync/Relation";
 
 export const image = (left: RelationOperand, right: RelationOperand, as: AttrName, keys?: JoinKeys): RelationOperand => {
   const opLeft = toOperationalOperand(left);

package/src/sync/operators/index.ts

@@ -0,0 +1,31 @@
+export * from './restrict'
+export * from './where'
+export * from './exclude'
+export * from './constants'
+export * from './rename'
+export * from './prefix'
+export * from './suffix'
+export * from './project'
+export * from './allbut'
+export * from './extend'
+export * from './union'
+export * from './minus'
+export * from './intersect'
+export * from './matching'
+export * from './not_matching'
+export * from './join'
+export * from './left_join'
+export * from './cross_product'
+export * from './image'
+export * from './summarize'
+export * from './group'
+export * from './ungroup'
+export * from './wrap'
+export * from './unwrap'
+export * from './autowrap'
+export * from './transform'
+
+export * from './isRelation'
+export * from './isEqual'
+export * from './one'
+export * from './yByX'

package/src/{operators → sync/operators}/intersect.ts

@@ -1,4 +1,4 @@
-import { RelationOperand, Tuple } from "../types";
+import { RelationOperand, Tuple } from "../../types";
 import { toOperationalOperand, tupleKey } from "./_helpers";
 
 export const intersect = (left: RelationOperand, right: RelationOperand): RelationOperand => {

package/src/{operators → sync/operators}/isEqual.ts

@@ -1,7 +1,6 @@
-import { RelationOperand } from "../types";
 import { toOperationalOperand, tupleKey } from "./_helpers";
 
-export const isEqual = (left: RelationOperand, right: RelationOperand): boolean => {
+export const isEqual = (left: any, right: any): boolean => {
   const opLeft = toOperationalOperand(left);
   const opRight = toOperationalOperand(right);
 

package/src/sync/operators/isRelation.ts

@@ -0,0 +1,6 @@
+import { MemoryRelation } from "@/sync/Relation";
+import { Relation } from "@/types";
+
+export const isRelation = (op: unknown): op is Relation => {
+  return op != null && (op as object).constructor === MemoryRelation;
+}

package/src/{operators → sync/operators}/join.ts

@@ -1,4 +1,4 @@
-import { RelationOperand, JoinKeys, Tuple, AttrName } from "../types";
+import { RelationOperand, JoinKeys, Tuple, AttrName } from "../../types";
 import { toOperationalOperand, normalizeKeys, tuplesMatch, projectOutKeys } from "./_helpers";
 
 const mergeTuples = (left: Tuple, right: Tuple, keyMap: Record<AttrName, AttrName>): Tuple => {

package/src/{operators → sync/operators}/left_join.ts

@@ -1,4 +1,4 @@
-import { RelationOperand, JoinKeys, Tuple, AttrName } from "../types";
+import { RelationOperand, JoinKeys, Tuple, AttrName } from "../../types";
 import { toOperationalOperand, normalizeKeys, tuplesMatch } from "./_helpers";
 
 const getRightAttrs = (rightTuples: Tuple[], keyMap: Record<AttrName, AttrName>): AttrName[] => {

package/src/{operators → sync/operators}/matching.ts

@@ -1,4 +1,4 @@
-import { RelationOperand, JoinKeys, Tuple } from "../types";
+import { RelationOperand, JoinKeys, Tuple } from "../../types";
 import { toOperationalOperand, normalizeKeys, matchKey } from "./_helpers";
 
 export const matching = (left: RelationOperand, right: RelationOperand, keys?: JoinKeys): RelationOperand => {

package/src/{operators → sync/operators}/minus.ts

@@ -1,4 +1,4 @@
-import { RelationOperand, Tuple } from "../types";
+import { RelationOperand, Tuple } from "../../types";
 import { toOperationalOperand, tupleKey } from "./_helpers";
 
 export const minus = (left: RelationOperand, right: RelationOperand): RelationOperand => {

package/src/{operators → sync/operators}/not_matching.ts

@@ -1,4 +1,4 @@
-import { RelationOperand, JoinKeys, Tuple } from "../types";
+import { RelationOperand, JoinKeys, Tuple } from "../../types";
 import { toOperationalOperand, normalizeKeys, matchKey } from "./_helpers";
 
 export const not_matching = (left: RelationOperand, right: RelationOperand, keys?: JoinKeys): RelationOperand => {

package/src/{operators → sync/operators}/one.ts

@@ -1,4 +1,4 @@
-import { RelationOperand, Tuple } from "../types";
+import { RelationOperand, Tuple } from "../../types";
 import { toOperationalOperand, error } from "./_helpers";
 
 export const one = (operand: RelationOperand): Tuple => {

package/src/{operators → sync/operators}/prefix.ts

@@ -1,4 +1,4 @@
-import { PrefixOptions, RelationOperand } from "../types";
+import { PrefixOptions, RelationOperand } from "../../types";
 import { rename } from "./rename";
 
 export const prefix = (operand: RelationOperand, pfx: string, options?: PrefixOptions): RelationOperand => {

package/src/{operators → sync/operators}/project.ts

@@ -1,4 +1,4 @@
-import { RelationOperand, AttrName, Tuple } from "../types";
+import { RelationOperand, AttrName, Tuple } from "../../types";
 import { toOperationalOperand, deduplicate } from "./_helpers";
 
 export const project = (operand: RelationOperand, attrs: AttrName[]): RelationOperand => {

package/src/{operators → sync/operators}/rename.ts

@@ -1,4 +1,4 @@
-import { RelationOperand, Renaming, Tuple } from "../types";
+import { RelationOperand, Renaming, Tuple } from "../../types";
 import { toOperationalOperand, toRenamingFunc } from "./_helpers";
 
 export const rename = (operand: RelationOperand, renaming: Renaming): RelationOperand => {

package/src/{operators → sync/operators}/restrict.ts

@@ -1,5 +1,5 @@
-import { toPredicateFunc } from "../support/toPredicateFunc";
-import { RelationOperand, Predicate, Tuple } from "../types";
+import { toPredicateFunc } from "../../support/toPredicateFunc";
+import { RelationOperand, Predicate, Tuple } from "../../types";
 import { toOperationalOperand } from "./_helpers";
 
 export const restrict = (operand: RelationOperand, p: Predicate): RelationOperand => {

package/src/{operators → sync/operators}/suffix.ts

@@ -1,4 +1,4 @@
-import { RelationOperand, SuffixOptions } from "../types";
+import { RelationOperand, SuffixOptions } from "../../types";
 import { rename } from "./rename";
 
 export const suffix = (operand: RelationOperand, sfx: string, options?: SuffixOptions): RelationOperand => {

package/src/{operators → sync/operators}/summarize.ts

@@ -1,4 +1,4 @@
-import { RelationOperand, AttrName, Tuple, Aggregator, Aggregators } from "../types";
+import { RelationOperand, AttrName, Tuple, Aggregator, Aggregators } from "../../types";
 import { toOperationalOperand } from "./_helpers";
 
 const groupKey = (tuple: Tuple, by: AttrName[]): string => {

package/src/{operators → sync/operators}/transform.ts

@@ -1,4 +1,4 @@
-import { RelationOperand, Transformation, Tuple } from "../types";
+import { RelationOperand, Transformation, Tuple } from "../../types";
 import { toOperationalOperand } from "./_helpers";
 
 export const transform = (operand: RelationOperand, transformation: Transformation): RelationOperand => {

package/src/{operators → sync/operators}/ungroup.ts

@@ -1,4 +1,4 @@
-import { RelationOperand, AttrName, Tuple, Relation } from "../types";
+import { RelationOperand, AttrName, Tuple, Relation } from "../../types";
 import { toOperationalOperand } from "./_helpers";
 import { isRelation } from "./isRelation";
 

package/src/{operators → sync/operators}/union.ts

@@ -1,4 +1,4 @@
-import { RelationOperand, Tuple } from "../types";
+import { RelationOperand, Tuple } from "../../types";
 import { toOperationalOperand, tupleKey } from "./_helpers";
 
 export const union = (left: RelationOperand, right: RelationOperand): RelationOperand => {