@tanstack/db 0.0.14 → 0.0.16

package/dist/esm/utils.d.ts

@@ -1,3 +0,0 @@
-export declare function getLockedObjects(): Set<string>;
-export declare function getGlobalVersion(): number;
-export declare function advanceGlobalVersion(): number;

package/dist/esm/utils.js

@@ -1,17 +0,0 @@
-function getLockedObjects() {
-  return /* @__PURE__ */ new Set();
-}
-let globalVersion = 0;
-function getGlobalVersion() {
-  return globalVersion;
-}
-function advanceGlobalVersion() {
-  console.log(`==== advancing global version`, globalVersion + 1);
-  return globalVersion++;
-}
-export {
-  advanceGlobalVersion,
-  getGlobalVersion,
-  getLockedObjects
-};
-//# sourceMappingURL=utils.js.map

package/dist/esm/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sources":["../../src/utils.ts"],"sourcesContent":["export function getLockedObjects(): Set<string> {\n  // Stub implementation that returns an empty Set\n  return new Set()\n}\n\nlet globalVersion = 0\n\nexport function getGlobalVersion(): number {\n  return globalVersion\n}\n\nexport function advanceGlobalVersion(): number {\n  console.log(`==== advancing global version`, globalVersion + 1)\n  return globalVersion++\n}\n"],"names":[],"mappings":"AAAO,SAAS,mBAAgC;AAE9C,6BAAW,IAAI;AACjB;AAEA,IAAI,gBAAgB;AAEb,SAAS,mBAA2B;AAClC,SAAA;AACT;AAEO,SAAS,uBAA+B;AACrC,UAAA,IAAI,iCAAiC,gBAAgB,CAAC;AACvD,SAAA;AACT;"}

package/src/query/compiled-query.ts

@@ -1,234 +0,0 @@
-import { D2, MultiSet, output } from "@electric-sql/d2mini"
-import { createCollection } from "../collection.js"
-import { compileQueryPipeline } from "./pipeline-compiler.js"
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import type { Collection } from "../collection.js"
-import type { ChangeMessage, ResolveType, SyncConfig } from "../types.js"
-import type {
-  IStreamBuilder,
-  MultiSetArray,
-  RootStreamBuilder,
-} from "@electric-sql/d2mini"
-import type { QueryBuilder, ResultsFromContext } from "./query-builder.js"
-import type { Context, Schema } from "./types.js"
-
-export function compileQuery<TContext extends Context<Schema>>(
-  queryBuilder: QueryBuilder<TContext>
-) {
-  return new CompiledQuery<
-    ResultsFromContext<TContext> & { _key?: string | number }
-  >(queryBuilder)
-}
-
-export class CompiledQuery<TResults extends object = Record<string, unknown>> {
-  private graph: D2
-  private inputs: Record<string, RootStreamBuilder<any>>
-  private inputCollections: Record<string, Collection<any>>
-  private resultCollection: Collection<TResults>
-  public state: `compiled` | `running` | `stopped` = `compiled`
-  private unsubscribeCallbacks: Array<() => void> = []
-
-  constructor(queryBuilder: QueryBuilder<Context<Schema>>) {
-    const query = queryBuilder._query
-    const collections = query.collections
-
-    if (!collections) {
-      throw new Error(`No collections provided`)
-    }
-
-    this.inputCollections = collections
-
-    const graph = new D2()
-    const inputs = Object.fromEntries(
-      Object.entries(collections).map(([key]) => [key, graph.newInput<any>()])
-    )
-
-    // Use TResults directly to ensure type compatibility
-    const sync: SyncConfig<TResults>[`sync`] = ({
-      begin,
-      write,
-      commit,
-      collection,
-    }) => {
-      compileQueryPipeline<IStreamBuilder<[unknown, TResults]>>(
-        query,
-        inputs
-      ).pipe(
-        output((data) => {
-          begin()
-          data
-            .getInner()
-            .reduce((acc, [[key, value], multiplicity]) => {
-              const changes = acc.get(key) || {
-                deletes: 0,
-                inserts: 0,
-                value,
-              }
-              if (multiplicity < 0) {
-                changes.deletes += Math.abs(multiplicity)
-              } else if (multiplicity > 0) {
-                changes.inserts += multiplicity
-                changes.value = value
-              }
-              acc.set(key, changes)
-              return acc
-            }, new Map<unknown, { deletes: number; inserts: number; value: TResults }>())
-            .forEach((changes, rawKey) => {
-              const { deletes, inserts, value } = changes
-              const valueWithKey = { ...value, _key: rawKey }
-
-              // Simple singular insert.
-              if (inserts && deletes === 0) {
-                write({
-                  value: valueWithKey,
-                  type: `insert`,
-                })
-              } else if (
-                // Insert & update(s) (updates are a delete & insert)
-                inserts > deletes ||
-                // Just update(s) but the item is already in the collection (so
-                // was inserted previously).
-                (inserts === deletes &&
-                  collection.has(valueWithKey._key as string | number))
-              ) {
-                write({
-                  value: valueWithKey,
-                  type: `update`,
-                })
-                // Only delete is left as an option
-              } else if (deletes > 0) {
-                write({
-                  value: valueWithKey,
-                  type: `delete`,
-                })
-              } else {
-                throw new Error(
-                  `This should never happen ${JSON.stringify(changes)}`
-                )
-              }
-            })
-          commit()
-        })
-      )
-      graph.finalize()
-    }
-
-    this.graph = graph
-    this.inputs = inputs
-
-    const compare = query.orderBy
-      ? (
-          val1: ResolveType<
-            TResults,
-            StandardSchemaV1,
-            Record<string, unknown>
-          >,
-          val2: ResolveType<TResults, StandardSchemaV1, Record<string, unknown>>
-        ): number => {
-          // The query builder always adds an _orderByIndex property if the results are ordered
-          const x = val1 as TResults & { _orderByIndex: number }
-          const y = val2 as TResults & { _orderByIndex: number }
-          if (x._orderByIndex < y._orderByIndex) {
-            return -1
-          } else if (x._orderByIndex > y._orderByIndex) {
-            return 1
-          } else {
-            return 0
-          }
-        }
-      : undefined
-
-    this.resultCollection = createCollection<TResults>({
-      getKey: (val: unknown) => {
-        return (val as any)._key
-      },
-      gcTime: 0,
-      startSync: true,
-      compare,
-      sync: {
-        sync: sync as unknown as (params: {
-          collection: Collection<
-            ResolveType<TResults, never, Record<string, unknown>>,
-            string | number,
-            {}
-          >
-          begin: () => void
-          write: (
-            message: Omit<
-              ChangeMessage<
-                ResolveType<TResults, never, Record<string, unknown>>,
-                string | number
-              >,
-              `key`
-            >
-          ) => void
-          commit: () => void
-        }) => void,
-      },
-    }) as unknown as Collection<TResults, string | number, {}>
-  }
-
-  get results() {
-    return this.resultCollection
-  }
-
-  private sendChangesToInput(
-    inputKey: string,
-    changes: Array<ChangeMessage>,
-    getKey: (item: ChangeMessage[`value`]) => any
-  ) {
-    const input = this.inputs[inputKey]!
-    const multiSetArray: MultiSetArray<unknown> = []
-    for (const change of changes) {
-      const key = getKey(change.value)
-      if (change.type === `insert`) {
-        multiSetArray.push([[key, change.value], 1])
-      } else if (change.type === `update`) {
-        multiSetArray.push([[key, change.previousValue], -1])
-        multiSetArray.push([[key, change.value], 1])
-      } else {
-        // change.type === `delete`
-        multiSetArray.push([[key, change.value], -1])
-      }
-    }
-    input.sendData(new MultiSet(multiSetArray))
-  }
-
-  private runGraph() {
-    this.graph.run()
-  }
-
-  start() {
-    if (this.state === `running`) {
-      throw new Error(`Query is already running`)
-    } else if (this.state === `stopped`) {
-      throw new Error(`Query is stopped`)
-    }
-
-    // Subscribe to changes
-    Object.entries(this.inputCollections).forEach(([key, collection]) => {
-      const unsubscribe = collection.subscribeChanges(
-        (changes) => {
-          this.sendChangesToInput(key, changes, collection.config.getKey)
-          this.runGraph()
-        },
-        { includeInitialState: true }
-      )
-
-      this.unsubscribeCallbacks.push(unsubscribe)
-    })
-
-    this.runGraph()
-
-    this.state = `running`
-    return () => {
-      this.stop()
-    }
-  }
-
-  stop() {
-    this.unsubscribeCallbacks.forEach((unsubscribe) => unsubscribe())
-    this.unsubscribeCallbacks = []
-    this.state = `stopped`
-  }
-}

package/src/query/evaluators.ts

@@ -1,250 +0,0 @@
-import { evaluateOperandOnNamespacedRow } from "./extractors.js"
-import { compareValues, convertLikeToRegex, isValueInArray } from "./utils.js"
-import type {
-  Comparator,
-  Condition,
-  ConditionOperand,
-  LogicalOperator,
-  SimpleCondition,
-  Where,
-  WhereCallback,
-} from "./schema.js"
-import type { NamespacedRow } from "../types.js"
-
-/**
- * Evaluates a Where clause (which is always an array of conditions and/or callbacks) against a nested row structure
- */
-export function evaluateWhereOnNamespacedRow(
-  namespacedRow: NamespacedRow,
-  where: Where,
-  mainTableAlias?: string,
-  joinedTableAlias?: string
-): boolean {
-  // Where is always an array of conditions and/or callbacks
-  // Evaluate all items and combine with AND logic
-  return where.every((item) => {
-    if (typeof item === `function`) {
-      return (item as WhereCallback)(namespacedRow)
-    } else {
-      return evaluateConditionOnNamespacedRow(
-        namespacedRow,
-        item as Condition,
-        mainTableAlias,
-        joinedTableAlias
-      )
-    }
-  })
-}
-
-/**
- * Evaluates a condition against a nested row structure
- */
-export function evaluateConditionOnNamespacedRow(
-  namespacedRow: NamespacedRow,
-  condition: Condition,
-  mainTableAlias?: string,
-  joinedTableAlias?: string
-): boolean {
-  // Handle simple conditions with exactly 3 elements
-  if (condition.length === 3 && !Array.isArray(condition[0])) {
-    const [left, comparator, right] = condition as SimpleCondition
-    return evaluateSimpleConditionOnNamespacedRow(
-      namespacedRow,
-      left,
-      comparator,
-      right,
-      mainTableAlias,
-      joinedTableAlias
-    )
-  }
-
-  // Handle flat composite conditions (multiple conditions in a single array)
-  if (
-    condition.length > 3 &&
-    !Array.isArray(condition[0]) &&
-    typeof condition[1] === `string` &&
-    ![`and`, `or`].includes(condition[1] as string)
-  ) {
-    // Start with the first condition (first 3 elements)
-    let result = evaluateSimpleConditionOnNamespacedRow(
-      namespacedRow,
-      condition[0],
-      condition[1] as Comparator,
-      condition[2],
-      mainTableAlias,
-      joinedTableAlias
-    )
-
-    // Process the rest in groups: logical operator, then 3 elements for each condition
-    for (let i = 3; i < condition.length; i += 4) {
-      const logicalOp = condition[i] as LogicalOperator
-
-      // Make sure we have a complete condition to evaluate
-      if (i + 3 <= condition.length) {
-        const nextResult = evaluateSimpleConditionOnNamespacedRow(
-          namespacedRow,
-          condition[i + 1],
-          condition[i + 2] as Comparator,
-          condition[i + 3],
-          mainTableAlias,
-          joinedTableAlias
-        )
-
-        // Apply the logical operator
-        if (logicalOp === `and`) {
-          result = result && nextResult
-        } else {
-          // logicalOp === `or`
-          result = result || nextResult
-        }
-      }
-    }
-
-    return result
-  }
-
-  // Handle nested composite conditions where the first element is an array
-  if (condition.length > 0 && Array.isArray(condition[0])) {
-    // Start with the first condition
-    let result = evaluateConditionOnNamespacedRow(
-      namespacedRow,
-      condition[0] as Condition,
-      mainTableAlias,
-      joinedTableAlias
-    )
-
-    // Process the rest of the conditions and logical operators in pairs
-    for (let i = 1; i < condition.length; i += 2) {
-      if (i + 1 >= condition.length) break // Make sure we have a pair
-
-      const operator = condition[i] as LogicalOperator
-      const nextCondition = condition[i + 1] as Condition
-
-      // Apply the logical operator
-      if (operator === `and`) {
-        result =
-          result &&
-          evaluateConditionOnNamespacedRow(
-            namespacedRow,
-            nextCondition,
-            mainTableAlias,
-            joinedTableAlias
-          )
-      } else {
-        // logicalOp === `or`
-        result =
-          result ||
-          evaluateConditionOnNamespacedRow(
-            namespacedRow,
-            nextCondition,
-            mainTableAlias,
-            joinedTableAlias
-          )
-      }
-    }
-
-    return result
-  }
-
-  // Fallback - this should not happen with valid conditions
-  return true
-}
-
-/**
- * Evaluates a simple condition against a nested row structure
- */
-export function evaluateSimpleConditionOnNamespacedRow(
-  namespacedRow: Record<string, unknown>,
-  left: ConditionOperand,
-  comparator: Comparator,
-  right: ConditionOperand,
-  mainTableAlias?: string,
-  joinedTableAlias?: string
-): boolean {
-  const leftValue = evaluateOperandOnNamespacedRow(
-    namespacedRow,
-    left,
-    mainTableAlias,
-    joinedTableAlias
-  )
-
-  const rightValue = evaluateOperandOnNamespacedRow(
-    namespacedRow,
-    right,
-    mainTableAlias,
-    joinedTableAlias
-  )
-
-  // The rest of the function remains the same as evaluateSimpleCondition
-  switch (comparator) {
-    case `=`:
-      return leftValue === rightValue
-    case `!=`:
-      return leftValue !== rightValue
-    case `<`:
-      return compareValues(leftValue, rightValue, `<`)
-    case `<=`:
-      return compareValues(leftValue, rightValue, `<=`)
-    case `>`:
-      return compareValues(leftValue, rightValue, `>`)
-    case `>=`:
-      return compareValues(leftValue, rightValue, `>=`)
-    case `like`:
-    case `not like`:
-      if (typeof leftValue === `string` && typeof rightValue === `string`) {
-        // Convert SQL LIKE pattern to proper regex pattern
-        const pattern = convertLikeToRegex(rightValue)
-        const matches = new RegExp(`^${pattern}$`, `i`).test(leftValue)
-        return comparator === `like` ? matches : !matches
-      }
-      return comparator === `like` ? false : true
-    case `in`:
-      // If right value is not an array, we can't do an IN operation
-      if (!Array.isArray(rightValue)) {
-        return false
-      }
-
-      // For empty arrays, nothing is contained in them
-      if (rightValue.length === 0) {
-        return false
-      }
-
-      // Handle array-to-array comparison (check if any element in leftValue exists in rightValue)
-      if (Array.isArray(leftValue)) {
-        return leftValue.some((item) => isValueInArray(item, rightValue))
-      }
-
-      // Handle single value comparison
-      return isValueInArray(leftValue, rightValue)
-
-    case `not in`:
-      // If right value is not an array, everything is "not in" it
-      if (!Array.isArray(rightValue)) {
-        return true
-      }
-
-      // For empty arrays, everything is "not in" them
-      if (rightValue.length === 0) {
-        return true
-      }
-
-      // Handle array-to-array comparison (check if no element in leftValue exists in rightValue)
-      if (Array.isArray(leftValue)) {
-        return !leftValue.some((item) => isValueInArray(item, rightValue))
-      }
-
-      // Handle single value comparison
-      return !isValueInArray(leftValue, rightValue)
-
-    case `is`:
-      return leftValue === rightValue
-    case `is not`:
-      // Properly handle null/undefined checks
-      if (rightValue === null) {
-        return leftValue !== null && leftValue !== undefined
-      }
-      return leftValue !== rightValue
-    default:
-      return false
-  }
-}