@tanstack/db 0.0.14 → 0.0.16

package/dist/esm/query/builder/ref-proxy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref-proxy.js","sources":["../../../../src/query/builder/ref-proxy.ts"],"sourcesContent":["import { PropRef, Value } from \"../ir.js\"\nimport type { BasicExpression } from \"../ir.js\"\n\nexport interface RefProxy<T = any> {\n  /** @internal */\n  readonly __refProxy: true\n  /** @internal */\n  readonly __path: Array<string>\n  /** @internal */\n  readonly __type: T\n}\n\n/**\n * Creates a proxy object that records property access paths\n * Used in callbacks like where, select, etc. to create type-safe references\n */\nexport function createRefProxy<T extends Record<string, any>>(\n  aliases: Array<string>\n): RefProxy<T> & T {\n  const cache = new Map<string, any>()\n  const spreadSentinels = new Set<string>() // Track which aliases have been spread\n\n  function createProxy(path: Array<string>): any {\n    const pathKey = path.join(`.`)\n    if (cache.has(pathKey)) {\n      return cache.get(pathKey)\n    }\n\n    const proxy = new Proxy({} as any, {\n      get(target, prop, receiver) {\n        if (prop === `__refProxy`) return true\n        if (prop === `__path`) return path\n        if (prop === `__type`) return undefined // Type is only for TypeScript inference\n        if (typeof prop === `symbol`) return Reflect.get(target, prop, receiver)\n\n        const newPath = [...path, String(prop)]\n        return createProxy(newPath)\n      },\n\n      has(target, prop) {\n        if (prop === `__refProxy` || prop === `__path` || prop === `__type`)\n          return true\n        return Reflect.has(target, prop)\n      },\n\n      ownKeys(target) {\n        // If this is a table-level proxy (path length 1), mark it as spread\n        if (path.length === 1) {\n          const aliasName = path[0]!\n          spreadSentinels.add(aliasName)\n        }\n        return Reflect.ownKeys(target)\n      },\n\n      getOwnPropertyDescriptor(target, prop) {\n        if (prop === `__refProxy` || prop === `__path` || prop === `__type`) {\n          return { enumerable: false, configurable: true }\n        }\n        return Reflect.getOwnPropertyDescriptor(target, prop)\n      },\n    })\n\n    cache.set(pathKey, proxy)\n    return proxy\n  }\n\n  // Create the root proxy with all aliases as top-level properties\n  const rootProxy = new Proxy({} as any, {\n    get(target, prop, receiver) {\n      if (prop === `__refProxy`) return true\n      if (prop === `__path`) return []\n      if (prop === `__type`) return undefined // Type is only for TypeScript inference\n      if (prop === `__spreadSentinels`) return spreadSentinels // Expose spread sentinels\n      if (typeof prop === `symbol`) return Reflect.get(target, prop, receiver)\n\n      const propStr = String(prop)\n      if (aliases.includes(propStr)) {\n        return createProxy([propStr])\n      }\n\n      return undefined\n    },\n\n    has(target, prop) {\n      if (\n        prop === `__refProxy` ||\n        prop === `__path` ||\n        prop === `__type` ||\n        prop === `__spreadSentinels`\n      )\n        return true\n      if (typeof prop === `string` && aliases.includes(prop)) return true\n      return Reflect.has(target, prop)\n    },\n\n    ownKeys(_target) {\n      return [...aliases, `__refProxy`, `__path`, `__type`, `__spreadSentinels`]\n    },\n\n    getOwnPropertyDescriptor(target, prop) {\n      if (\n        prop === `__refProxy` ||\n        prop === `__path` ||\n        prop === `__type` ||\n        prop === `__spreadSentinels`\n      ) {\n        return { enumerable: false, configurable: true }\n      }\n      if (typeof prop === `string` && aliases.includes(prop)) {\n        return { enumerable: true, configurable: true }\n      }\n      return undefined\n    },\n  })\n\n  return rootProxy\n}\n\n/**\n * Converts a value to an Expression\n * If it's a RefProxy, creates a Ref, otherwise creates a Value\n */\nexport function toExpression<T = any>(value: T): BasicExpression<T>\nexport function toExpression(value: RefProxy<any>): BasicExpression<any>\nexport function toExpression(value: any): BasicExpression<any> {\n  if (isRefProxy(value)) {\n    return new PropRef(value.__path)\n  }\n  // If it's already an Expression (Func, Ref, Value) or Agg, return it directly\n  if (\n    value &&\n    typeof value === `object` &&\n    `type` in value &&\n    (value.type === `func` ||\n      value.type === `ref` ||\n      value.type === `val` ||\n      value.type === `agg`)\n  ) {\n    return value\n  }\n  return new Value(value)\n}\n\n/**\n * Type guard to check if a value is a RefProxy\n */\nexport function isRefProxy(value: any): value is RefProxy {\n  return value && typeof value === `object` && value.__refProxy === true\n}\n\n/**\n * Helper to create a Value expression from a literal\n */\nexport function val<T>(value: T): BasicExpression<T> {\n  return new Value(value)\n}\n"],"names":[],"mappings":";AAgBO,SAAS,eACd,SACiB;AACX,QAAA,4BAAY,IAAiB;AAC7B,QAAA,sCAAsB,IAAY;AAExC,WAAS,YAAY,MAA0B;AACvC,UAAA,UAAU,KAAK,KAAK,GAAG;AACzB,QAAA,MAAM,IAAI,OAAO,GAAG;AACf,aAAA,MAAM,IAAI,OAAO;AAAA,IAAA;AAG1B,UAAM,QAAQ,IAAI,MAAM,IAAW;AAAA,MACjC,IAAI,QAAQ,MAAM,UAAU;AACtB,YAAA,SAAS,aAAqB,QAAA;AAC9B,YAAA,SAAS,SAAiB,QAAA;AAC1B,YAAA,SAAS,SAAiB,QAAA;AAC1B,YAAA,OAAO,SAAS,SAAU,QAAO,QAAQ,IAAI,QAAQ,MAAM,QAAQ;AAEvE,cAAM,UAAU,CAAC,GAAG,MAAM,OAAO,IAAI,CAAC;AACtC,eAAO,YAAY,OAAO;AAAA,MAC5B;AAAA,MAEA,IAAI,QAAQ,MAAM;AAChB,YAAI,SAAS,gBAAgB,SAAS,YAAY,SAAS;AAClD,iBAAA;AACF,eAAA,QAAQ,IAAI,QAAQ,IAAI;AAAA,MACjC;AAAA,MAEA,QAAQ,QAAQ;AAEV,YAAA,KAAK,WAAW,GAAG;AACf,gBAAA,YAAY,KAAK,CAAC;AACxB,0BAAgB,IAAI,SAAS;AAAA,QAAA;AAExB,eAAA,QAAQ,QAAQ,MAAM;AAAA,MAC/B;AAAA,MAEA,yBAAyB,QAAQ,MAAM;AACrC,YAAI,SAAS,gBAAgB,SAAS,YAAY,SAAS,UAAU;AACnE,iBAAO,EAAE,YAAY,OAAO,cAAc,KAAK;AAAA,QAAA;AAE1C,eAAA,QAAQ,yBAAyB,QAAQ,IAAI;AAAA,MAAA;AAAA,IACtD,CACD;AAEK,UAAA,IAAI,SAAS,KAAK;AACjB,WAAA;AAAA,EAAA;AAIT,QAAM,YAAY,IAAI,MAAM,IAAW;AAAA,IACrC,IAAI,QAAQ,MAAM,UAAU;AACtB,UAAA,SAAS,aAAqB,QAAA;AAC9B,UAAA,SAAS,SAAU,QAAO,CAAC;AAC3B,UAAA,SAAS,SAAiB,QAAA;AAC1B,UAAA,SAAS,oBAA4B,QAAA;AACrC,UAAA,OAAO,SAAS,SAAU,QAAO,QAAQ,IAAI,QAAQ,MAAM,QAAQ;AAEjE,YAAA,UAAU,OAAO,IAAI;AACvB,UAAA,QAAQ,SAAS,OAAO,GAAG;AACtB,eAAA,YAAY,CAAC,OAAO,CAAC;AAAA,MAAA;AAGvB,aAAA;AAAA,IACT;AAAA,IAEA,IAAI,QAAQ,MAAM;AAChB,UACE,SAAS,gBACT,SAAS,YACT,SAAS,YACT,SAAS;AAEF,eAAA;AACT,UAAI,OAAO,SAAS,YAAY,QAAQ,SAAS,IAAI,EAAU,QAAA;AACxD,aAAA,QAAQ,IAAI,QAAQ,IAAI;AAAA,IACjC;AAAA,IAEA,QAAQ,SAAS;AACf,aAAO,CAAC,GAAG,SAAS,cAAc,UAAU,UAAU,mBAAmB;AAAA,IAC3E;AAAA,IAEA,yBAAyB,QAAQ,MAAM;AACrC,UACE,SAAS,gBACT,SAAS,YACT,SAAS,YACT,SAAS,qBACT;AACA,eAAO,EAAE,YAAY,OAAO,cAAc,KAAK;AAAA,MAAA;AAEjD,UAAI,OAAO,SAAS,YAAY,QAAQ,SAAS,IAAI,GAAG;AACtD,eAAO,EAAE,YAAY,MAAM,cAAc,KAAK;AAAA,MAAA;AAEzC,aAAA;AAAA,IAAA;AAAA,EACT,CACD;AAEM,SAAA;AACT;AAQO,SAAS,aAAa,OAAkC;AACzD,MAAA,WAAW,KAAK,GAAG;AACd,WAAA,IAAI,QAAQ,MAAM,MAAM;AAAA,EAAA;AAGjC,MACE,SACA,OAAO,UAAU,YACjB,UAAU,UACT,MAAM,SAAS,UACd,MAAM,SAAS,SACf,MAAM,SAAS,SACf,MAAM,SAAS,QACjB;AACO,WAAA;AAAA,EAAA;AAEF,SAAA,IAAI,MAAM,KAAK;AACxB;AAKO,SAAS,WAAW,OAA+B;AACxD,SAAO,SAAS,OAAO,UAAU,YAAY,MAAM,eAAe;AACpE;"}

package/dist/esm/query/builder/types.d.ts

@@ -0,0 +1,81 @@
+import { CollectionImpl } from '../../collection.js';
+import { Aggregate, BasicExpression } from '../ir.js';
+import { QueryBuilder } from './index.js';
+export interface Context {
+    baseSchema: ContextSchema;
+    schema: ContextSchema;
+    fromSourceName: string;
+    hasJoins?: boolean;
+    joinTypes?: Record<string, `inner` | `left` | `right` | `full` | `outer` | `cross`>;
+    result?: any;
+}
+export type ContextSchema = Record<string, unknown>;
+export type Source = {
+    [alias: string]: CollectionImpl<any, any> | QueryBuilder<Context>;
+};
+export type InferCollectionType<T> = T extends CollectionImpl<infer U> ? U : never;
+export type SchemaFromSource<T extends Source> = Prettify<{
+    [K in keyof T]: T[K] extends CollectionImpl<infer U> ? U : T[K] extends QueryBuilder<infer TContext> ? GetResult<TContext> : never;
+}>;
+export type GetAliases<TContext extends Context> = keyof TContext[`schema`];
+export type WhereCallback<TContext extends Context> = (refs: RefProxyForContext<TContext>) => any;
+export type SelectObject<T extends Record<string, BasicExpression | Aggregate | RefProxy | RefProxyFor<any>> = Record<string, BasicExpression | Aggregate | RefProxy | RefProxyFor<any>>> = T;
+export type ResultTypeFromSelect<TSelectObject> = {
+    [K in keyof TSelectObject]: TSelectObject[K] extends RefProxy<infer T> ? T : TSelectObject[K] extends BasicExpression<infer T> ? T : TSelectObject[K] extends Aggregate<infer T> ? T : TSelectObject[K] extends RefProxyFor<infer T> ? T : never;
+};
+export type OrderByCallback<TContext extends Context> = (refs: RefProxyForContext<TContext>) => any;
+export type GroupByCallback<TContext extends Context> = (refs: RefProxyForContext<TContext>) => any;
+export type JoinOnCallback<TContext extends Context> = (refs: RefProxyForContext<TContext>) => any;
+export type RefProxyForContext<TContext extends Context> = {
+    [K in keyof TContext[`schema`]]: RefProxyFor<TContext[`schema`][K]>;
+};
+type IsExactlyUndefined<T> = [T] extends [undefined] ? true : false;
+type IsOptional<T> = undefined extends T ? true : false;
+type NonUndefined<T> = T extends undefined ? never : T;
+export type RefProxyFor<T> = OmitRefProxy<IsExactlyUndefined<T> extends true ? RefProxy<T> : IsOptional<T> extends true ? NonUndefined<T> extends Record<string, any> ? {
+    [K in keyof NonUndefined<T>]: NonUndefined<T>[K] extends Record<string, any> ? RefProxyFor<NonUndefined<T>[K] | undefined> & RefProxy<NonUndefined<T>[K] | undefined> : RefProxy<NonUndefined<T>[K] | undefined>;
+} & RefProxy<T> : RefProxy<T> : T extends Record<string, any> ? {
+    [K in keyof T]: T[K] extends Record<string, any> ? RefProxyFor<T[K]> & RefProxy<T[K]> : RefProxy<T[K]>;
+} & RefProxy<T> : RefProxy<T>>;
+export type Ref<T> = RefProxyFor<T>;
+type OmitRefProxy<T> = Omit<T, `__refProxy` | `__path` | `__type`>;
+export interface RefProxy<T = any> {
+    /** @internal */
+    readonly __refProxy: true;
+    /** @internal */
+    readonly __path: Array<string>;
+    /** @internal */
+    readonly __type: T;
+}
+export type MergeContextWithJoinType<TContext extends Context, TNewSchema extends ContextSchema, TJoinType extends `inner` | `left` | `right` | `full` | `outer` | `cross`> = {
+    baseSchema: TContext[`baseSchema`];
+    schema: ApplyJoinOptionalityToMergedSchema<TContext[`schema`], TNewSchema, TJoinType, TContext[`fromSourceName`]>;
+    fromSourceName: TContext[`fromSourceName`];
+    hasJoins: true;
+    joinTypes: (TContext[`joinTypes`] extends Record<string, any> ? TContext[`joinTypes`] : {}) & {
+        [K in keyof TNewSchema & string]: TJoinType;
+    };
+    result: TContext[`result`];
+};
+export type ApplyJoinOptionalityToMergedSchema<TExistingSchema extends ContextSchema, TNewSchema extends ContextSchema, TJoinType extends `inner` | `left` | `right` | `full` | `outer` | `cross`, TFromSourceName extends string> = {
+    [K in keyof TExistingSchema]: K extends TFromSourceName ? TJoinType extends `right` | `full` ? TExistingSchema[K] | undefined : TExistingSchema[K] : TExistingSchema[K];
+} & {
+    [K in keyof TNewSchema]: TJoinType extends `left` | `full` ? // New table becomes optional for left and full joins
+    TNewSchema[K] | undefined : TNewSchema[K];
+};
+export type GetResult<TContext extends Context> = Prettify<TContext[`result`] extends object ? TContext[`result`] : TContext[`hasJoins`] extends true ? TContext[`schema`] : TContext[`schema`][TContext[`fromSourceName`]]>;
+export type ApplyJoinOptionalityToSchema<TSchema extends ContextSchema, TJoinTypes extends Record<string, string>, TFromSourceName extends string> = {
+    [K in keyof TSchema]: K extends TFromSourceName ? HasJoinType<TJoinTypes, `right` | `full`> extends true ? TSchema[K] | undefined : TSchema[K] : K extends keyof TJoinTypes ? TJoinTypes[K] extends `left` | `full` ? TSchema[K] | undefined : IsTableMadeOptionalBySubsequentJoins<K, TJoinTypes, TFromSourceName> extends true ? TSchema[K] | undefined : TSchema[K] : TSchema[K];
+};
+type IsTableMadeOptionalBySubsequentJoins<TTableAlias extends string | number | symbol, TJoinTypes extends Record<string, string>, TFromSourceName extends string> = TTableAlias extends TFromSourceName ? HasJoinType<TJoinTypes, `right` | `full`> : false;
+export type HasJoinType<TJoinTypes extends Record<string, string>, TTargetTypes extends string> = true extends {
+    [K in keyof TJoinTypes]: TJoinTypes[K] extends TTargetTypes ? true : false;
+}[keyof TJoinTypes] ? true : false;
+export type MergeContext<TContext extends Context, TNewSchema extends ContextSchema> = MergeContextWithJoinType<TContext, TNewSchema, `left`>;
+export type WithResult<TContext extends Context, TResult> = Prettify<Omit<TContext, `result`> & {
+    result: Prettify<TResult>;
+}>;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export {};

package/dist/esm/query/compiler/evaluators.d.ts

@@ -0,0 +1,11 @@
+import { BasicExpression } from '../ir.js';
+import { NamespacedRow } from '../../types.js';
+/**
+ * Compiled expression evaluator function type
+ */
+export type CompiledExpression = (namespacedRow: NamespacedRow) => any;
+/**
+ * Compiles an expression into an optimized evaluator function.
+ * This eliminates branching during evaluation by pre-compiling the expression structure.
+ */
+export declare function compileExpression(expr: BasicExpression): CompiledExpression;

package/dist/esm/query/compiler/evaluators.js

@@ -0,0 +1,261 @@
+function compileExpression(expr) {
+  switch (expr.type) {
+    case `val`: {
+      const value = expr.value;
+      return () => value;
+    }
+    case `ref`: {
+      return compileRef(expr);
+    }
+    case `func`: {
+      return compileFunction(expr);
+    }
+    default:
+      throw new Error(`Unknown expression type: ${expr.type}`);
+  }
+}
+function compileRef(ref) {
+  const [tableAlias, ...propertyPath] = ref.path;
+  if (!tableAlias) {
+    throw new Error(`Reference path cannot be empty`);
+  }
+  if (propertyPath.length === 0) {
+    return (namespacedRow) => namespacedRow[tableAlias];
+  } else if (propertyPath.length === 1) {
+    const prop = propertyPath[0];
+    return (namespacedRow) => {
+      const tableData = namespacedRow[tableAlias];
+      return tableData == null ? void 0 : tableData[prop];
+    };
+  } else {
+    return (namespacedRow) => {
+      const tableData = namespacedRow[tableAlias];
+      if (tableData === void 0) {
+        return void 0;
+      }
+      let value = tableData;
+      for (const prop of propertyPath) {
+        if (value == null) {
+          return value;
+        }
+        value = value[prop];
+      }
+      return value;
+    };
+  }
+}
+function compileFunction(func) {
+  const compiledArgs = func.args.map(compileExpression);
+  switch (func.name) {
+    // Comparison operators
+    case `eq`: {
+      const argA = compiledArgs[0];
+      const argB = compiledArgs[1];
+      return (namespacedRow) => {
+        const a = argA(namespacedRow);
+        const b = argB(namespacedRow);
+        return a === b;
+      };
+    }
+    case `gt`: {
+      const argA = compiledArgs[0];
+      const argB = compiledArgs[1];
+      return (namespacedRow) => {
+        const a = argA(namespacedRow);
+        const b = argB(namespacedRow);
+        return a > b;
+      };
+    }
+    case `gte`: {
+      const argA = compiledArgs[0];
+      const argB = compiledArgs[1];
+      return (namespacedRow) => {
+        const a = argA(namespacedRow);
+        const b = argB(namespacedRow);
+        return a >= b;
+      };
+    }
+    case `lt`: {
+      const argA = compiledArgs[0];
+      const argB = compiledArgs[1];
+      return (namespacedRow) => {
+        const a = argA(namespacedRow);
+        const b = argB(namespacedRow);
+        return a < b;
+      };
+    }
+    case `lte`: {
+      const argA = compiledArgs[0];
+      const argB = compiledArgs[1];
+      return (namespacedRow) => {
+        const a = argA(namespacedRow);
+        const b = argB(namespacedRow);
+        return a <= b;
+      };
+    }
+    // Boolean operators
+    case `and`:
+      return (namespacedRow) => {
+        for (const compiledArg of compiledArgs) {
+          if (!compiledArg(namespacedRow)) {
+            return false;
+          }
+        }
+        return true;
+      };
+    case `or`:
+      return (namespacedRow) => {
+        for (const compiledArg of compiledArgs) {
+          if (compiledArg(namespacedRow)) {
+            return true;
+          }
+        }
+        return false;
+      };
+    case `not`: {
+      const arg = compiledArgs[0];
+      return (namespacedRow) => !arg(namespacedRow);
+    }
+    // Array operators
+    case `in`: {
+      const valueEvaluator = compiledArgs[0];
+      const arrayEvaluator = compiledArgs[1];
+      return (namespacedRow) => {
+        const value = valueEvaluator(namespacedRow);
+        const array = arrayEvaluator(namespacedRow);
+        if (!Array.isArray(array)) {
+          return false;
+        }
+        return array.includes(value);
+      };
+    }
+    // String operators
+    case `like`: {
+      const valueEvaluator = compiledArgs[0];
+      const patternEvaluator = compiledArgs[1];
+      return (namespacedRow) => {
+        const value = valueEvaluator(namespacedRow);
+        const pattern = patternEvaluator(namespacedRow);
+        return evaluateLike(value, pattern, false);
+      };
+    }
+    case `ilike`: {
+      const valueEvaluator = compiledArgs[0];
+      const patternEvaluator = compiledArgs[1];
+      return (namespacedRow) => {
+        const value = valueEvaluator(namespacedRow);
+        const pattern = patternEvaluator(namespacedRow);
+        return evaluateLike(value, pattern, true);
+      };
+    }
+    // String functions
+    case `upper`: {
+      const arg = compiledArgs[0];
+      return (namespacedRow) => {
+        const value = arg(namespacedRow);
+        return typeof value === `string` ? value.toUpperCase() : value;
+      };
+    }
+    case `lower`: {
+      const arg = compiledArgs[0];
+      return (namespacedRow) => {
+        const value = arg(namespacedRow);
+        return typeof value === `string` ? value.toLowerCase() : value;
+      };
+    }
+    case `length`: {
+      const arg = compiledArgs[0];
+      return (namespacedRow) => {
+        const value = arg(namespacedRow);
+        if (typeof value === `string`) {
+          return value.length;
+        }
+        if (Array.isArray(value)) {
+          return value.length;
+        }
+        return 0;
+      };
+    }
+    case `concat`:
+      return (namespacedRow) => {
+        return compiledArgs.map((evaluator) => {
+          const arg = evaluator(namespacedRow);
+          try {
+            return String(arg ?? ``);
+          } catch {
+            try {
+              return JSON.stringify(arg) || ``;
+            } catch {
+              return `[object]`;
+            }
+          }
+        }).join(``);
+      };
+    case `coalesce`:
+      return (namespacedRow) => {
+        for (const evaluator of compiledArgs) {
+          const value = evaluator(namespacedRow);
+          if (value !== null && value !== void 0) {
+            return value;
+          }
+        }
+        return null;
+      };
+    // Math functions
+    case `add`: {
+      const argA = compiledArgs[0];
+      const argB = compiledArgs[1];
+      return (namespacedRow) => {
+        const a = argA(namespacedRow);
+        const b = argB(namespacedRow);
+        return (a ?? 0) + (b ?? 0);
+      };
+    }
+    case `subtract`: {
+      const argA = compiledArgs[0];
+      const argB = compiledArgs[1];
+      return (namespacedRow) => {
+        const a = argA(namespacedRow);
+        const b = argB(namespacedRow);
+        return (a ?? 0) - (b ?? 0);
+      };
+    }
+    case `multiply`: {
+      const argA = compiledArgs[0];
+      const argB = compiledArgs[1];
+      return (namespacedRow) => {
+        const a = argA(namespacedRow);
+        const b = argB(namespacedRow);
+        return (a ?? 0) * (b ?? 0);
+      };
+    }
+    case `divide`: {
+      const argA = compiledArgs[0];
+      const argB = compiledArgs[1];
+      return (namespacedRow) => {
+        const a = argA(namespacedRow);
+        const b = argB(namespacedRow);
+        const divisor = b ?? 0;
+        return divisor !== 0 ? (a ?? 0) / divisor : null;
+      };
+    }
+    default:
+      throw new Error(`Unknown function: ${func.name}`);
+  }
+}
+function evaluateLike(value, pattern, caseInsensitive) {
+  if (typeof value !== `string` || typeof pattern !== `string`) {
+    return false;
+  }
+  const searchValue = caseInsensitive ? value.toLowerCase() : value;
+  const searchPattern = caseInsensitive ? pattern.toLowerCase() : pattern;
+  let regexPattern = searchPattern.replace(/[.*+?^${}()|[\]\\]/g, `\\$&`);
+  regexPattern = regexPattern.replace(/%/g, `.*`);
+  regexPattern = regexPattern.replace(/_/g, `.`);
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(searchValue);
+}
+export {
+  compileExpression
+};
+//# sourceMappingURL=evaluators.js.map

package/dist/esm/query/compiler/evaluators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluators.js","sources":["../../../../src/query/compiler/evaluators.ts"],"sourcesContent":["import type { BasicExpression, Func, PropRef } from \"../ir.js\"\nimport type { NamespacedRow } from \"../../types.js\"\n\n/**\n * Compiled expression evaluator function type\n */\nexport type CompiledExpression = (namespacedRow: NamespacedRow) => any\n\n/**\n * Compiles an expression into an optimized evaluator function.\n * This eliminates branching during evaluation by pre-compiling the expression structure.\n */\nexport function compileExpression(expr: BasicExpression): CompiledExpression {\n  switch (expr.type) {\n    case `val`: {\n      // For constant values, return a function that just returns the value\n      const value = expr.value\n      return () => value\n    }\n\n    case `ref`: {\n      // For references, pre-compile the property path navigation\n      return compileRef(expr)\n    }\n\n    case `func`: {\n      // For functions, pre-compile the function and its arguments\n      return compileFunction(expr)\n    }\n\n    default:\n      throw new Error(`Unknown expression type: ${(expr as any).type}`)\n  }\n}\n\n/**\n * Compiles a reference expression into an optimized evaluator\n */\nfunction compileRef(ref: PropRef): CompiledExpression {\n  const [tableAlias, ...propertyPath] = ref.path\n\n  if (!tableAlias) {\n    throw new Error(`Reference path cannot be empty`)\n  }\n\n  // Pre-compile the property path navigation\n  if (propertyPath.length === 0) {\n    // Simple table reference\n    return (namespacedRow) => namespacedRow[tableAlias]\n  } else if (propertyPath.length === 1) {\n    // Single property access - most common case\n    const prop = propertyPath[0]!\n    return (namespacedRow) => {\n      const tableData = namespacedRow[tableAlias]\n      return tableData?.[prop]\n    }\n  } else {\n    // Multiple property navigation\n    return (namespacedRow) => {\n      const tableData = namespacedRow[tableAlias]\n      if (tableData === undefined) {\n        return undefined\n      }\n\n      let value: any = tableData\n      for (const prop of propertyPath) {\n        if (value == null) {\n          return value\n        }\n        value = value[prop]\n      }\n      return value\n    }\n  }\n}\n\n/**\n * Compiles a function expression into an optimized evaluator\n */\nfunction compileFunction(func: Func): CompiledExpression {\n  // Pre-compile all arguments\n  const compiledArgs = func.args.map(compileExpression)\n\n  switch (func.name) {\n    // Comparison operators\n    case `eq`: {\n      const argA = compiledArgs[0]!\n      const argB = compiledArgs[1]!\n      return (namespacedRow) => {\n        const a = argA(namespacedRow)\n        const b = argB(namespacedRow)\n        return a === b\n      }\n    }\n    case `gt`: {\n      const argA = compiledArgs[0]!\n      const argB = compiledArgs[1]!\n      return (namespacedRow) => {\n        const a = argA(namespacedRow)\n        const b = argB(namespacedRow)\n        return a > b\n      }\n    }\n    case `gte`: {\n      const argA = compiledArgs[0]!\n      const argB = compiledArgs[1]!\n      return (namespacedRow) => {\n        const a = argA(namespacedRow)\n        const b = argB(namespacedRow)\n        return a >= b\n      }\n    }\n    case `lt`: {\n      const argA = compiledArgs[0]!\n      const argB = compiledArgs[1]!\n      return (namespacedRow) => {\n        const a = argA(namespacedRow)\n        const b = argB(namespacedRow)\n        return a < b\n      }\n    }\n    case `lte`: {\n      const argA = compiledArgs[0]!\n      const argB = compiledArgs[1]!\n      return (namespacedRow) => {\n        const a = argA(namespacedRow)\n        const b = argB(namespacedRow)\n        return a <= b\n      }\n    }\n\n    // Boolean operators\n    case `and`:\n      return (namespacedRow) => {\n        for (const compiledArg of compiledArgs) {\n          if (!compiledArg(namespacedRow)) {\n            return false\n          }\n        }\n        return true\n      }\n    case `or`:\n      return (namespacedRow) => {\n        for (const compiledArg of compiledArgs) {\n          if (compiledArg(namespacedRow)) {\n            return true\n          }\n        }\n        return false\n      }\n    case `not`: {\n      const arg = compiledArgs[0]!\n      return (namespacedRow) => !arg(namespacedRow)\n    }\n\n    // Array operators\n    case `in`: {\n      const valueEvaluator = compiledArgs[0]!\n      const arrayEvaluator = compiledArgs[1]!\n      return (namespacedRow) => {\n        const value = valueEvaluator(namespacedRow)\n        const array = arrayEvaluator(namespacedRow)\n        if (!Array.isArray(array)) {\n          return false\n        }\n        return array.includes(value)\n      }\n    }\n\n    // String operators\n    case `like`: {\n      const valueEvaluator = compiledArgs[0]!\n      const patternEvaluator = compiledArgs[1]!\n      return (namespacedRow) => {\n        const value = valueEvaluator(namespacedRow)\n        const pattern = patternEvaluator(namespacedRow)\n        return evaluateLike(value, pattern, false)\n      }\n    }\n    case `ilike`: {\n      const valueEvaluator = compiledArgs[0]!\n      const patternEvaluator = compiledArgs[1]!\n      return (namespacedRow) => {\n        const value = valueEvaluator(namespacedRow)\n        const pattern = patternEvaluator(namespacedRow)\n        return evaluateLike(value, pattern, true)\n      }\n    }\n\n    // String functions\n    case `upper`: {\n      const arg = compiledArgs[0]!\n      return (namespacedRow) => {\n        const value = arg(namespacedRow)\n        return typeof value === `string` ? value.toUpperCase() : value\n      }\n    }\n    case `lower`: {\n      const arg = compiledArgs[0]!\n      return (namespacedRow) => {\n        const value = arg(namespacedRow)\n        return typeof value === `string` ? value.toLowerCase() : value\n      }\n    }\n    case `length`: {\n      const arg = compiledArgs[0]!\n      return (namespacedRow) => {\n        const value = arg(namespacedRow)\n        if (typeof value === `string`) {\n          return value.length\n        }\n        if (Array.isArray(value)) {\n          return value.length\n        }\n        return 0\n      }\n    }\n    case `concat`:\n      return (namespacedRow) => {\n        return compiledArgs\n          .map((evaluator) => {\n            const arg = evaluator(namespacedRow)\n            try {\n              return String(arg ?? ``)\n            } catch {\n              try {\n                return JSON.stringify(arg) || ``\n              } catch {\n                return `[object]`\n              }\n            }\n          })\n          .join(``)\n      }\n    case `coalesce`:\n      return (namespacedRow) => {\n        for (const evaluator of compiledArgs) {\n          const value = evaluator(namespacedRow)\n          if (value !== null && value !== undefined) {\n            return value\n          }\n        }\n        return null\n      }\n\n    // Math functions\n    case `add`: {\n      const argA = compiledArgs[0]!\n      const argB = compiledArgs[1]!\n      return (namespacedRow) => {\n        const a = argA(namespacedRow)\n        const b = argB(namespacedRow)\n        return (a ?? 0) + (b ?? 0)\n      }\n    }\n    case `subtract`: {\n      const argA = compiledArgs[0]!\n      const argB = compiledArgs[1]!\n      return (namespacedRow) => {\n        const a = argA(namespacedRow)\n        const b = argB(namespacedRow)\n        return (a ?? 0) - (b ?? 0)\n      }\n    }\n    case `multiply`: {\n      const argA = compiledArgs[0]!\n      const argB = compiledArgs[1]!\n      return (namespacedRow) => {\n        const a = argA(namespacedRow)\n        const b = argB(namespacedRow)\n        return (a ?? 0) * (b ?? 0)\n      }\n    }\n    case `divide`: {\n      const argA = compiledArgs[0]!\n      const argB = compiledArgs[1]!\n      return (namespacedRow) => {\n        const a = argA(namespacedRow)\n        const b = argB(namespacedRow)\n        const divisor = b ?? 0\n        return divisor !== 0 ? (a ?? 0) / divisor : null\n      }\n    }\n\n    default:\n      throw new Error(`Unknown function: ${func.name}`)\n  }\n}\n\n/**\n * Evaluates LIKE/ILIKE patterns\n */\nfunction evaluateLike(\n  value: any,\n  pattern: any,\n  caseInsensitive: boolean\n): boolean {\n  if (typeof value !== `string` || typeof pattern !== `string`) {\n    return false\n  }\n\n  const searchValue = caseInsensitive ? value.toLowerCase() : value\n  const searchPattern = caseInsensitive ? pattern.toLowerCase() : pattern\n\n  // Convert SQL LIKE pattern to regex\n  // First escape all regex special chars except % and _\n  let regexPattern = searchPattern.replace(/[.*+?^${}()|[\\]\\\\]/g, `\\\\$&`)\n\n  // Then convert SQL wildcards to regex\n  regexPattern = regexPattern.replace(/%/g, `.*`) // % matches any sequence\n  regexPattern = regexPattern.replace(/_/g, `.`) // _ matches any single char\n\n  const regex = new RegExp(`^${regexPattern}$`)\n  return regex.test(searchValue)\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/query/compiler/group-by.d.ts

@@ -0,0 +1,7 @@
+import { GroupBy, Having, Select } from '../ir.js';
+import { NamespacedAndKeyedStream } from '../../types.js';
+/**
+ * Processes the GROUP BY clause with optional HAVING and SELECT
+ * Works with the new __select_results structure from early SELECT processing
+ */
+export declare function processGroupBy(pipeline: NamespacedAndKeyedStream, groupByClause: GroupBy, havingClauses?: Array<Having>, selectClause?: Select, fnHavingClauses?: Array<(row: any) => any>): NamespacedAndKeyedStream;

package/dist/esm/query/compiler/group-by.js

@@ -0,0 +1,271 @@
+import { groupBy, map, filter, groupByOperators } from "@electric-sql/d2mini";
+import { PropRef, Func } from "../ir.js";
+import { compileExpression } from "./evaluators.js";
+const { sum, count, avg, min, max } = groupByOperators;
+function validateAndCreateMapping(groupByClause, selectClause) {
+  const selectToGroupByIndex = /* @__PURE__ */ new Map();
+  const groupByExpressions = [...groupByClause];
+  if (!selectClause) {
+    return { selectToGroupByIndex, groupByExpressions };
+  }
+  for (const [alias, expr] of Object.entries(selectClause)) {
+    if (expr.type === `agg`) {
+      continue;
+    }
+    const groupIndex = groupByExpressions.findIndex(
+      (groupExpr) => expressionsEqual(expr, groupExpr)
+    );
+    if (groupIndex === -1) {
+      throw new Error(
+        `Non-aggregate expression '${alias}' in SELECT must also appear in GROUP BY clause`
+      );
+    }
+    selectToGroupByIndex.set(alias, groupIndex);
+  }
+  return { selectToGroupByIndex, groupByExpressions };
+}
+function processGroupBy(pipeline, groupByClause, havingClauses, selectClause, fnHavingClauses) {
+  if (groupByClause.length === 0) {
+    const aggregates2 = {};
+    if (selectClause) {
+      for (const [alias, expr] of Object.entries(selectClause)) {
+        if (expr.type === `agg`) {
+          const aggExpr = expr;
+          aggregates2[alias] = getAggregateFunction(aggExpr);
+        }
+      }
+    }
+    const keyExtractor2 = () => ({ __singleGroup: true });
+    pipeline = pipeline.pipe(
+      groupBy(keyExtractor2, aggregates2)
+    );
+    pipeline = pipeline.pipe(
+      map(([, aggregatedRow]) => {
+        const selectResults = aggregatedRow.__select_results || {};
+        const finalResults = { ...selectResults };
+        if (selectClause) {
+          for (const [alias, expr] of Object.entries(selectClause)) {
+            if (expr.type === `agg`) {
+              finalResults[alias] = aggregatedRow[alias];
+            }
+          }
+        }
+        return [
+          `single_group`,
+          {
+            ...aggregatedRow,
+            __select_results: finalResults
+          }
+        ];
+      })
+    );
+    if (havingClauses && havingClauses.length > 0) {
+      for (const havingClause of havingClauses) {
+        const transformedHavingClause = transformHavingClause(
+          havingClause,
+          selectClause || {}
+        );
+        const compiledHaving = compileExpression(transformedHavingClause);
+        pipeline = pipeline.pipe(
+          filter(([, row]) => {
+            const namespacedRow = { result: row.__select_results };
+            return compiledHaving(namespacedRow);
+          })
+        );
+      }
+    }
+    if (fnHavingClauses && fnHavingClauses.length > 0) {
+      for (const fnHaving of fnHavingClauses) {
+        pipeline = pipeline.pipe(
+          filter(([, row]) => {
+            const namespacedRow = { result: row.__select_results };
+            return fnHaving(namespacedRow);
+          })
+        );
+      }
+    }
+    return pipeline;
+  }
+  const mapping = validateAndCreateMapping(groupByClause, selectClause);
+  const compiledGroupByExpressions = groupByClause.map(compileExpression);
+  const keyExtractor = ([, row]) => {
+    const namespacedRow = { ...row };
+    delete namespacedRow.__select_results;
+    const key = {};
+    for (let i = 0; i < groupByClause.length; i++) {
+      const compiledExpr = compiledGroupByExpressions[i];
+      const value = compiledExpr(namespacedRow);
+      key[`__key_${i}`] = value;
+    }
+    return key;
+  };
+  const aggregates = {};
+  if (selectClause) {
+    for (const [alias, expr] of Object.entries(selectClause)) {
+      if (expr.type === `agg`) {
+        const aggExpr = expr;
+        aggregates[alias] = getAggregateFunction(aggExpr);
+      }
+    }
+  }
+  pipeline = pipeline.pipe(groupBy(keyExtractor, aggregates));
+  pipeline = pipeline.pipe(
+    map(([, aggregatedRow]) => {
+      const selectResults = aggregatedRow.__select_results || {};
+      const finalResults = {};
+      if (selectClause) {
+        for (const [alias, expr] of Object.entries(selectClause)) {
+          if (expr.type !== `agg`) {
+            const groupIndex = mapping.selectToGroupByIndex.get(alias);
+            if (groupIndex !== void 0) {
+              finalResults[alias] = aggregatedRow[`__key_${groupIndex}`];
+            } else {
+              finalResults[alias] = selectResults[alias];
+            }
+          } else {
+            finalResults[alias] = aggregatedRow[alias];
+          }
+        }
+      } else {
+        for (let i = 0; i < groupByClause.length; i++) {
+          finalResults[`__key_${i}`] = aggregatedRow[`__key_${i}`];
+        }
+      }
+      let finalKey;
+      if (groupByClause.length === 1) {
+        finalKey = aggregatedRow[`__key_0`];
+      } else {
+        const keyParts = [];
+        for (let i = 0; i < groupByClause.length; i++) {
+          keyParts.push(aggregatedRow[`__key_${i}`]);
+        }
+        finalKey = JSON.stringify(keyParts);
+      }
+      return [
+        finalKey,
+        {
+          ...aggregatedRow,
+          __select_results: finalResults
+        }
+      ];
+    })
+  );
+  if (havingClauses && havingClauses.length > 0) {
+    for (const havingClause of havingClauses) {
+      const transformedHavingClause = transformHavingClause(
+        havingClause,
+        selectClause || {}
+      );
+      const compiledHaving = compileExpression(transformedHavingClause);
+      pipeline = pipeline.pipe(
+        filter(([, row]) => {
+          const namespacedRow = { result: row.__select_results };
+          return compiledHaving(namespacedRow);
+        })
+      );
+    }
+  }
+  if (fnHavingClauses && fnHavingClauses.length > 0) {
+    for (const fnHaving of fnHavingClauses) {
+      pipeline = pipeline.pipe(
+        filter(([, row]) => {
+          const namespacedRow = { result: row.__select_results };
+          return fnHaving(namespacedRow);
+        })
+      );
+    }
+  }
+  return pipeline;
+}
+function expressionsEqual(expr1, expr2) {
+  var _a, _b, _c, _d;
+  if (!expr1 || !expr2) return false;
+  if (expr1.type !== expr2.type) return false;
+  switch (expr1.type) {
+    case `ref`:
+      if (!expr1.path || !expr2.path) return false;
+      if (expr1.path.length !== expr2.path.length) return false;
+      return expr1.path.every(
+        (segment, i) => segment === expr2.path[i]
+      );
+    case `val`:
+      return expr1.value === expr2.value;
+    case `func`:
+      return expr1.name === expr2.name && ((_a = expr1.args) == null ? void 0 : _a.length) === ((_b = expr2.args) == null ? void 0 : _b.length) && (expr1.args || []).every(
+        (arg, i) => expressionsEqual(arg, expr2.args[i])
+      );
+    case `agg`:
+      return expr1.name === expr2.name && ((_c = expr1.args) == null ? void 0 : _c.length) === ((_d = expr2.args) == null ? void 0 : _d.length) && (expr1.args || []).every(
+        (arg, i) => expressionsEqual(arg, expr2.args[i])
+      );
+    default:
+      return false;
+  }
+}
+function getAggregateFunction(aggExpr) {
+  const compiledExpr = compileExpression(aggExpr.args[0]);
+  const valueExtractor = ([, namespacedRow]) => {
+    const value = compiledExpr(namespacedRow);
+    return typeof value === `number` ? value : value != null ? Number(value) : 0;
+  };
+  switch (aggExpr.name.toLowerCase()) {
+    case `sum`:
+      return sum(valueExtractor);
+    case `count`:
+      return count();
+    // count() doesn't need a value extractor
+    case `avg`:
+      return avg(valueExtractor);
+    case `min`:
+      return min(valueExtractor);
+    case `max`:
+      return max(valueExtractor);
+    default:
+      throw new Error(`Unsupported aggregate function: ${aggExpr.name}`);
+  }
+}
+function transformHavingClause(havingExpr, selectClause) {
+  switch (havingExpr.type) {
+    case `agg`: {
+      const aggExpr = havingExpr;
+      for (const [alias, selectExpr] of Object.entries(selectClause)) {
+        if (selectExpr.type === `agg` && aggregatesEqual(aggExpr, selectExpr)) {
+          return new PropRef([`result`, alias]);
+        }
+      }
+      throw new Error(
+        `Aggregate function in HAVING clause must also be in SELECT clause: ${aggExpr.name}`
+      );
+    }
+    case `func`: {
+      const funcExpr = havingExpr;
+      const transformedArgs = funcExpr.args.map(
+        (arg) => transformHavingClause(arg, selectClause)
+      );
+      return new Func(funcExpr.name, transformedArgs);
+    }
+    case `ref`: {
+      const refExpr = havingExpr;
+      if (refExpr.path.length === 1) {
+        const alias = refExpr.path[0];
+        if (selectClause[alias]) {
+          return new PropRef([`result`, alias]);
+        }
+      }
+      return havingExpr;
+    }
+    case `val`:
+      return havingExpr;
+    default:
+      throw new Error(
+        `Unknown expression type in HAVING clause: ${havingExpr.type}`
+      );
+  }
+}
+function aggregatesEqual(agg1, agg2) {
+  return agg1.name === agg2.name && agg1.args.length === agg2.args.length && agg1.args.every((arg, i) => expressionsEqual(arg, agg2.args[i]));
+}
+export {
+  processGroupBy
+};
+//# sourceMappingURL=group-by.js.map