@tanstack/db 0.0.13 → 0.0.15

package/src/transactions.ts

@@ -2,6 +2,7 @@ import { createDeferred } from "./deferred"
 import type { Deferred } from "./deferred"
 import type {
   MutationFn,
+  OperationType,
   PendingMutation,
   TransactionConfig,
   TransactionState,
@@ -11,24 +12,13 @@ import type {
 const transactions: Array<Transaction<any>> = []
 let transactionStack: Array<Transaction<any>> = []
 
+let sequenceNumber = 0
+
 export function createTransaction<
   TData extends object = Record<string, unknown>,
 >(config: TransactionConfig<TData>): Transaction<TData> {
-  if (typeof config.mutationFn === `undefined`) {
-    throw `mutationFn is required when creating a transaction`
-  }
-
-  let transactionId = config.id
-  if (!transactionId) {
-    transactionId = crypto.randomUUID()
-  }
-  const newTransaction = new Transaction<TData>({
-    ...config,
-    id: transactionId,
-  })
-
+  const newTransaction = new Transaction<TData>(config)
   transactions.push(newTransaction)
-
   return newTransaction
 }
 
@@ -55,14 +45,18 @@ function removeFromPendingList(tx: Transaction<any>) {
   }
 }
 
-export class Transaction<T extends object = Record<string, unknown>> {
+class Transaction<
+  T extends object = Record<string, unknown>,
+  TOperation extends OperationType = OperationType,
+> {
   public id: string
   public state: TransactionState
   public mutationFn: MutationFn<T>
-  public mutations: Array<PendingMutation<T>>
-  public isPersisted: Deferred<Transaction<T>>
+  public mutations: Array<PendingMutation<T, TOperation>>
+  public isPersisted: Deferred<Transaction<T, TOperation>>
   public autoCommit: boolean
   public createdAt: Date
+  public sequenceNumber: number
   public metadata: Record<string, unknown>
   public error?: {
     message: string
@@ -70,13 +64,17 @@ export class Transaction<T extends object = Record<string, unknown>> {
   }
 
   constructor(config: TransactionConfig<T>) {
-    this.id = config.id!
+    if (typeof config.mutationFn === `undefined`) {
+      throw `mutationFn is required when creating a transaction`
+    }
+    this.id = config.id ?? crypto.randomUUID()
     this.mutationFn = config.mutationFn
     this.state = `pending`
     this.mutations = []
-    this.isPersisted = createDeferred<Transaction<T>>()
+    this.isPersisted = createDeferred<Transaction<T, TOperation>>()
     this.autoCommit = config.autoCommit ?? true
     this.createdAt = new Date()
+    this.sequenceNumber = sequenceNumber++
     this.metadata = config.metadata ?? {}
   }
 
@@ -206,4 +204,21 @@ export class Transaction<T extends object = Record<string, unknown>> {
 
     return this
   }
+
+  /**
+   * Compare two transactions by their createdAt time and sequence number in order
+   * to sort them in the order they were created.
+   * @param other - The other transaction to compare to
+   * @returns -1 if this transaction was created before the other, 1 if it was created after, 0 if they were created at the same time
+   */
+  compareCreatedAt(other: Transaction<any>): number {
+    const createdAtComparison =
+      this.createdAt.getTime() - other.createdAt.getTime()
+    if (createdAtComparison !== 0) {
+      return createdAtComparison
+    }
+    return this.sequenceNumber - other.sequenceNumber
+  }
 }
+
+export type { Transaction }

package/src/types.ts

@@ -97,7 +97,7 @@ export type NonEmptyArray<T> = [T, ...Array<T>]
 export type TransactionWithMutations<
   T extends object = Record<string, unknown>,
   TOperation extends OperationType = OperationType,
-> = Transaction<T> & {
+> = Transaction<T, TOperation> & {
   mutations: NonEmptyArray<PendingMutation<T, TOperation>>
 }
 
@@ -154,6 +154,15 @@ export interface SyncConfig<
    * @returns Record containing relation information
    */
   getSyncMetadata?: () => Record<string, unknown>
+
+  /**
+   * The row update mode used to sync to the collection.
+   * @default `partial`
+   * @description
+   * - `partial`: Updates contain only the changes to the row.
+   * - `full`: Updates contain the entire row.
+   */
+  rowUpdateMode?: `partial` | `full`
 }
 
 export interface ChangeMessage<
@@ -318,6 +327,12 @@ export type InputRow = [unknown, Record<string, unknown>]
  */
 export type KeyedStream = IStreamBuilder<InputRow>
 
+/**
+ * Result stream type representing the output of compiled queries
+ * Always returns [key, [result, orderByIndex]] where orderByIndex is undefined for unordered queries
+ */
+export type ResultStream = IStreamBuilder<[unknown, [any, string | undefined]]>
+
 /**
  * A namespaced row is a row withing a pipeline that had each table wrapped in its alias
  */

package/dist/cjs/query/compiled-query.cjs

@@ -1,160 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const d2mini = require("@electric-sql/d2mini");
-const collection = require("../collection.cjs");
-const pipelineCompiler = require("./pipeline-compiler.cjs");
-function compileQuery(queryBuilder) {
-  return new CompiledQuery(queryBuilder);
-}
-class CompiledQuery {
-  constructor(queryBuilder) {
-    this.state = `compiled`;
-    this.unsubscribeCallbacks = [];
-    const query = queryBuilder._query;
-    const collections = query.collections;
-    if (!collections) {
-      throw new Error(`No collections provided`);
-    }
-    this.inputCollections = collections;
-    const graph = new d2mini.D2();
-    const inputs = Object.fromEntries(
-      Object.entries(collections).map(([key]) => [key, graph.newInput()])
-    );
-    const sync = ({
-      begin,
-      write,
-      commit,
-      collection: collection2
-    }) => {
-      pipelineCompiler.compileQueryPipeline(
-        query,
-        inputs
-      ).pipe(
-        d2mini.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;
-          }, /* @__PURE__ */ new Map()).forEach((changes, rawKey) => {
-            const { deletes, inserts, value } = changes;
-            const valueWithKey = { ...value, _key: rawKey };
-            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 && collection2.has(valueWithKey._key)
-            ) {
-              write({
-                value: valueWithKey,
-                type: `update`
-              });
-            } 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, val2) => {
-      const x = val1;
-      const y = val2;
-      if (x._orderByIndex < y._orderByIndex) {
-        return -1;
-      } else if (x._orderByIndex > y._orderByIndex) {
-        return 1;
-      } else {
-        return 0;
-      }
-    } : void 0;
-    this.resultCollection = collection.createCollection({
-      getKey: (val) => {
-        return val._key;
-      },
-      gcTime: 0,
-      startSync: true,
-      compare,
-      sync: {
-        sync
-      }
-    });
-  }
-  get results() {
-    return this.resultCollection;
-  }
-  sendChangesToInput(inputKey, changes, getKey) {
-    const input = this.inputs[inputKey];
-    const multiSetArray = [];
-    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 {
-        multiSetArray.push([[key, change.value], -1]);
-      }
-    }
-    input.sendData(new d2mini.MultiSet(multiSetArray));
-  }
-  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`);
-    }
-    Object.entries(this.inputCollections).forEach(([key, collection2]) => {
-      const unsubscribe = collection2.subscribeChanges(
-        (changes) => {
-          this.sendChangesToInput(key, changes, collection2.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`;
-  }
-}
-exports.CompiledQuery = CompiledQuery;
-exports.compileQuery = compileQuery;
-//# sourceMappingURL=compiled-query.cjs.map

package/dist/cjs/query/compiled-query.cjs.map

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

package/dist/cjs/query/compiled-query.d.cts

@@ -1,20 +0,0 @@
-import { Collection } from '../collection.js';
-import { QueryBuilder } from './query-builder.js';
-import { Context, Schema } from './types.js';
-export declare function compileQuery<TContext extends Context<Schema>>(queryBuilder: QueryBuilder<TContext>): CompiledQuery<((TContext["result"] extends object ? TContext["result"] : TContext["hasJoin"] extends true ? TContext["schema"] : TContext["default"] extends keyof TContext["schema"] ? TContext["schema"][TContext["default"]] : never) extends infer T ? { [K in keyof T]: (TContext["result"] extends object ? TContext["result"] : TContext["hasJoin"] extends true ? TContext["schema"] : TContext["default"] extends keyof TContext["schema"] ? TContext["schema"][TContext["default"]] : never)[K]; } : never) & {
-    _key?: string | number;
-}>;
-export declare class CompiledQuery<TResults extends object = Record<string, unknown>> {
-    private graph;
-    private inputs;
-    private inputCollections;
-    private resultCollection;
-    state: `compiled` | `running` | `stopped`;
-    private unsubscribeCallbacks;
-    constructor(queryBuilder: QueryBuilder<Context<Schema>>);
-    get results(): Collection<TResults, string | number, {}>;
-    private sendChangesToInput;
-    private runGraph;
-    start(): () => void;
-    stop(): void;
-}

package/dist/cjs/query/evaluators.cjs

@@ -1,161 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const extractors = require("./extractors.cjs");
-const utils = require("./utils.cjs");
-function evaluateWhereOnNamespacedRow(namespacedRow, where, mainTableAlias, joinedTableAlias) {
-  return where.every((item) => {
-    if (typeof item === `function`) {
-      return item(namespacedRow);
-    } else {
-      return evaluateConditionOnNamespacedRow(
-        namespacedRow,
-        item,
-        mainTableAlias,
-        joinedTableAlias
-      );
-    }
-  });
-}
-function evaluateConditionOnNamespacedRow(namespacedRow, condition, mainTableAlias, joinedTableAlias) {
-  if (condition.length === 3 && !Array.isArray(condition[0])) {
-    const [left, comparator, right] = condition;
-    return evaluateSimpleConditionOnNamespacedRow(
-      namespacedRow,
-      left,
-      comparator,
-      right,
-      mainTableAlias,
-      joinedTableAlias
-    );
-  }
-  if (condition.length > 3 && !Array.isArray(condition[0]) && typeof condition[1] === `string` && ![`and`, `or`].includes(condition[1])) {
-    let result = evaluateSimpleConditionOnNamespacedRow(
-      namespacedRow,
-      condition[0],
-      condition[1],
-      condition[2],
-      mainTableAlias,
-      joinedTableAlias
-    );
-    for (let i = 3; i < condition.length; i += 4) {
-      const logicalOp = condition[i];
-      if (i + 3 <= condition.length) {
-        const nextResult = evaluateSimpleConditionOnNamespacedRow(
-          namespacedRow,
-          condition[i + 1],
-          condition[i + 2],
-          condition[i + 3],
-          mainTableAlias,
-          joinedTableAlias
-        );
-        if (logicalOp === `and`) {
-          result = result && nextResult;
-        } else {
-          result = result || nextResult;
-        }
-      }
-    }
-    return result;
-  }
-  if (condition.length > 0 && Array.isArray(condition[0])) {
-    let result = evaluateConditionOnNamespacedRow(
-      namespacedRow,
-      condition[0],
-      mainTableAlias,
-      joinedTableAlias
-    );
-    for (let i = 1; i < condition.length; i += 2) {
-      if (i + 1 >= condition.length) break;
-      const operator = condition[i];
-      const nextCondition = condition[i + 1];
-      if (operator === `and`) {
-        result = result && evaluateConditionOnNamespacedRow(
-          namespacedRow,
-          nextCondition,
-          mainTableAlias,
-          joinedTableAlias
-        );
-      } else {
-        result = result || evaluateConditionOnNamespacedRow(
-          namespacedRow,
-          nextCondition,
-          mainTableAlias,
-          joinedTableAlias
-        );
-      }
-    }
-    return result;
-  }
-  return true;
-}
-function evaluateSimpleConditionOnNamespacedRow(namespacedRow, left, comparator, right, mainTableAlias, joinedTableAlias) {
-  const leftValue = extractors.evaluateOperandOnNamespacedRow(
-    namespacedRow,
-    left,
-    mainTableAlias,
-    joinedTableAlias
-  );
-  const rightValue = extractors.evaluateOperandOnNamespacedRow(
-    namespacedRow,
-    right,
-    mainTableAlias,
-    joinedTableAlias
-  );
-  switch (comparator) {
-    case `=`:
-      return leftValue === rightValue;
-    case `!=`:
-      return leftValue !== rightValue;
-    case `<`:
-      return utils.compareValues(leftValue, rightValue, `<`);
-    case `<=`:
-      return utils.compareValues(leftValue, rightValue, `<=`);
-    case `>`:
-      return utils.compareValues(leftValue, rightValue, `>`);
-    case `>=`:
-      return utils.compareValues(leftValue, rightValue, `>=`);
-    case `like`:
-    case `not like`:
-      if (typeof leftValue === `string` && typeof rightValue === `string`) {
-        const pattern = utils.convertLikeToRegex(rightValue);
-        const matches = new RegExp(`^${pattern}$`, `i`).test(leftValue);
-        return comparator === `like` ? matches : !matches;
-      }
-      return comparator === `like` ? false : true;
-    case `in`:
-      if (!Array.isArray(rightValue)) {
-        return false;
-      }
-      if (rightValue.length === 0) {
-        return false;
-      }
-      if (Array.isArray(leftValue)) {
-        return leftValue.some((item) => utils.isValueInArray(item, rightValue));
-      }
-      return utils.isValueInArray(leftValue, rightValue);
-    case `not in`:
-      if (!Array.isArray(rightValue)) {
-        return true;
-      }
-      if (rightValue.length === 0) {
-        return true;
-      }
-      if (Array.isArray(leftValue)) {
-        return !leftValue.some((item) => utils.isValueInArray(item, rightValue));
-      }
-      return !utils.isValueInArray(leftValue, rightValue);
-    case `is`:
-      return leftValue === rightValue;
-    case `is not`:
-      if (rightValue === null) {
-        return leftValue !== null && leftValue !== void 0;
-      }
-      return leftValue !== rightValue;
-    default:
-      return false;
-  }
-}
-exports.evaluateConditionOnNamespacedRow = evaluateConditionOnNamespacedRow;
-exports.evaluateSimpleConditionOnNamespacedRow = evaluateSimpleConditionOnNamespacedRow;
-exports.evaluateWhereOnNamespacedRow = evaluateWhereOnNamespacedRow;
-//# sourceMappingURL=evaluators.cjs.map

package/dist/cjs/query/evaluators.cjs.map

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

package/dist/cjs/query/evaluators.d.cts

@@ -1,14 +0,0 @@
-import { Comparator, Condition, ConditionOperand, Where } from './schema.js';
-import { NamespacedRow } from '../types.js';
-/**
- * Evaluates a Where clause (which is always an array of conditions and/or callbacks) against a nested row structure
- */
-export declare function evaluateWhereOnNamespacedRow(namespacedRow: NamespacedRow, where: Where, mainTableAlias?: string, joinedTableAlias?: string): boolean;
-/**
- * Evaluates a condition against a nested row structure
- */
-export declare function evaluateConditionOnNamespacedRow(namespacedRow: NamespacedRow, condition: Condition, mainTableAlias?: string, joinedTableAlias?: string): boolean;
-/**
- * Evaluates a simple condition against a nested row structure
- */
-export declare function evaluateSimpleConditionOnNamespacedRow(namespacedRow: Record<string, unknown>, left: ConditionOperand, comparator: Comparator, right: ConditionOperand, mainTableAlias?: string, joinedTableAlias?: string): boolean;

package/dist/cjs/query/extractors.cjs

@@ -1,122 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const functions = require("./functions.cjs");
-function extractValueFromNamespacedRow(namespacedRow, columnRef, mainTableAlias, joinedTableAlias) {
-  if (columnRef.includes(`.`)) {
-    const [tableAlias, colName] = columnRef.split(`.`);
-    const tableData = namespacedRow[tableAlias];
-    if (!tableData) {
-      return null;
-    }
-    const value = tableData[colName];
-    return value;
-  } else {
-    if (mainTableAlias && namespacedRow[mainTableAlias]) {
-      const mainTableData = namespacedRow[mainTableAlias];
-      if (typeof mainTableData === `object` && columnRef in mainTableData) {
-        return mainTableData[columnRef];
-      }
-    }
-    if (joinedTableAlias && namespacedRow[joinedTableAlias]) {
-      const joinedTableData = namespacedRow[joinedTableAlias];
-      if (typeof joinedTableData === `object` && columnRef in joinedTableData) {
-        return joinedTableData[columnRef];
-      }
-    }
-    for (const [_tableAlias, tableData] of Object.entries(namespacedRow)) {
-      if (tableData && typeof tableData === `object` && columnRef in tableData) {
-        return tableData[columnRef];
-      }
-    }
-    return void 0;
-  }
-}
-function evaluateOperandOnNamespacedRow(namespacedRow, operand, mainTableAlias, joinedTableAlias) {
-  if (typeof operand === `string` && operand.startsWith(`@`)) {
-    const columnRef = operand.substring(1);
-    return extractValueFromNamespacedRow(
-      namespacedRow,
-      columnRef,
-      mainTableAlias,
-      joinedTableAlias
-    );
-  }
-  if (operand && typeof operand === `object` && `col` in operand) {
-    const colRef = operand.col;
-    if (typeof colRef === `string`) {
-      const nestedValue = extractValueFromNamespacedRow(
-        namespacedRow,
-        colRef,
-        mainTableAlias,
-        joinedTableAlias
-      );
-      if (nestedValue === void 0 && colRef in namespacedRow) {
-        return namespacedRow[colRef];
-      }
-      return nestedValue;
-    }
-    return void 0;
-  }
-  if (operand && typeof operand === `object` && functions.isFunctionCall(operand)) {
-    const functionName = Object.keys(operand)[0];
-    const args = operand[functionName];
-    const evaluatedArgs = Array.isArray(args) ? args.map(
-      (arg) => evaluateOperandOnNamespacedRow(
-        namespacedRow,
-        arg,
-        mainTableAlias,
-        joinedTableAlias
-      )
-    ) : evaluateOperandOnNamespacedRow(
-      namespacedRow,
-      args,
-      mainTableAlias,
-      joinedTableAlias
-    );
-    return functions.evaluateFunction(
-      functionName,
-      evaluatedArgs
-    );
-  }
-  if (operand && typeof operand === `object` && `value` in operand) {
-    return operand.value;
-  }
-  return operand;
-}
-function extractJoinKey(row, operand, defaultTableAlias) {
-  let keyValue;
-  if (typeof operand === `string` && operand.startsWith(`@`)) {
-    const columnRef = operand.substring(1);
-    if (columnRef.includes(`.`)) {
-      const [tableAlias, colName] = columnRef.split(`.`);
-      if (tableAlias === defaultTableAlias) {
-        keyValue = row[colName];
-      } else {
-        keyValue = void 0;
-      }
-    } else {
-      keyValue = row[columnRef];
-    }
-  } else if (operand && typeof operand === `object` && `col` in operand) {
-    const colRef = operand.col;
-    if (typeof colRef === `string`) {
-      if (colRef.includes(`.`)) {
-        const [tableAlias, colName] = colRef.split(`.`);
-        if (tableAlias === defaultTableAlias) {
-          keyValue = row[colName];
-        } else {
-          keyValue = void 0;
-        }
-      } else {
-        keyValue = row[colRef];
-      }
-    }
-  } else {
-    keyValue = operand;
-  }
-  return keyValue;
-}
-exports.evaluateOperandOnNamespacedRow = evaluateOperandOnNamespacedRow;
-exports.extractJoinKey = extractJoinKey;
-exports.extractValueFromNamespacedRow = extractValueFromNamespacedRow;
-//# sourceMappingURL=extractors.cjs.map