@tanstack/db 0.0.14 → 0.0.15

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

@@ -1,189 +0,0 @@
-import { ConditionOperand, ExplicitLiteral, FunctionCall, LiteralValue, Select } from './schema.js';
-export type Input = Record<string, unknown>;
-export type Schema = Record<string, Input>;
-export type Context<TBaseSchema extends Schema = Schema, TSchema extends Schema = Schema> = {
-    baseSchema: TBaseSchema;
-    schema: TSchema;
-    default?: keyof TSchema;
-    result?: Record<string, unknown>;
-    hasJoin?: boolean;
-};
-export type Flatten<T> = {
-    [K in keyof T]: T[K];
-} & {};
-type UniqueSecondLevelKeys<T> = {
-    [K in keyof T]: Exclude<keyof T[K], {
-        [P in Exclude<keyof T, K>]: keyof T[P];
-    }[Exclude<keyof T, K>]>;
-}[keyof T];
-type InputNames<TSchema extends Schema> = RemoveIndexSignature<{
-    [I in keyof TSchema]: I;
-}>[keyof RemoveIndexSignature<{
-    [I in keyof TSchema]: I;
-}>];
-type UniquePropertyNames<TSchema extends Schema> = UniqueSecondLevelKeys<RemoveIndexSignature<TSchema>>;
-export type RemoveIndexSignature<T> = {
-    [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K];
-};
-type QualifiedReferencesOfSchemaString<TSchema extends Schema> = RemoveIndexSignature<{
-    [I in keyof TSchema]: {
-        [P in keyof RemoveIndexSignature<TSchema[I]>]: `@${string & I}.${string & P}`;
-    }[keyof RemoveIndexSignature<TSchema[I]>];
-}>;
-type QualifiedReferenceString<TContext extends Context<Schema>> = QualifiedReferencesOfSchemaString<TContext[`schema`]>[keyof QualifiedReferencesOfSchemaString<TContext[`schema`]>];
-type QualifiedReferencesOfSchemaObject<TSchema extends Schema> = RemoveIndexSignature<{
-    [I in keyof TSchema]: {
-        [P in keyof RemoveIndexSignature<TSchema[I]>]: {
-            col: `${string & I}.${string & P}`;
-        };
-    }[keyof RemoveIndexSignature<TSchema[I]>];
-}>;
-type QualifiedReferenceObject<TContext extends Context<Schema>> = QualifiedReferencesOfSchemaObject<TContext[`schema`]>[keyof QualifiedReferencesOfSchemaObject<TContext[`schema`]>];
-type QualifiedReference<TContext extends Context<Schema>> = QualifiedReferenceString<TContext> | QualifiedReferenceObject<TContext>;
-type DefaultReferencesOfSchemaString<TSchema extends Schema, TDefault extends keyof TSchema> = RemoveIndexSignature<{
-    [P in keyof TSchema[TDefault]]: `@${string & P}`;
-}>;
-type DefaultReferenceString<TContext extends Context<Schema>> = TContext[`default`] extends undefined ? never : DefaultReferencesOfSchemaString<TContext[`schema`], Exclude<TContext[`default`], undefined>>[keyof DefaultReferencesOfSchemaString<TContext[`schema`], Exclude<TContext[`default`], undefined>>];
-type DefaultReferencesOfSchemaObject<TSchema extends Schema, TDefault extends keyof TSchema> = RemoveIndexSignature<{
-    [P in keyof TSchema[TDefault]]: {
-        col: `${string & P}`;
-    };
-}>;
-type DefaultReferenceObject<TContext extends Context<Schema>> = TContext[`default`] extends undefined ? never : DefaultReferencesOfSchemaObject<TContext[`schema`], Exclude<TContext[`default`], undefined>>[keyof DefaultReferencesOfSchemaObject<TContext[`schema`], Exclude<TContext[`default`], undefined>>];
-type DefaultReference<TContext extends Context<Schema>> = DefaultReferenceString<TContext> | DefaultReferenceObject<TContext>;
-type UniqueReferencesOfSchemaString<TSchema extends Schema> = RemoveIndexSignature<{
-    [I in keyof TSchema]: {
-        [P in keyof TSchema[I]]: P extends UniquePropertyNames<TSchema> ? `@${string & P}` : never;
-    }[keyof TSchema[I]];
-}>;
-type UniqueReferenceString<TContext extends Context<Schema>> = UniqueReferencesOfSchemaString<TContext[`schema`]>[keyof UniqueReferencesOfSchemaString<TContext[`schema`]>];
-type UniqueReferencesOfSchemaObject<TSchema extends Schema> = RemoveIndexSignature<{
-    [I in keyof TSchema]: {
-        [P in keyof TSchema[I]]: P extends UniquePropertyNames<TSchema> ? {
-            col: `${string & P}`;
-        } : never;
-    }[keyof TSchema[I]];
-}>;
-type UniqueReferenceObject<TContext extends Context<Schema>> = UniqueReferencesOfSchemaObject<TContext[`schema`]>[keyof UniqueReferencesOfSchemaObject<TContext[`schema`]>];
-type UniqueReference<TContext extends Context<Schema>> = UniqueReferenceString<TContext> | UniqueReferenceObject<TContext>;
-type InputWildcardString<TContext extends Context<Schema>> = Flatten<{
-    [I in InputNames<TContext[`schema`]>]: `@${I}.*`;
-}[InputNames<TContext[`schema`]>]>;
-type InputWildcardObject<TContext extends Context<Schema>> = Flatten<{
-    [I in InputNames<TContext[`schema`]>]: {
-        col: `${I}.*`;
-    };
-}[InputNames<TContext[`schema`]>]>;
-type InputWildcard<TContext extends Context<Schema>> = InputWildcardString<TContext> | InputWildcardObject<TContext>;
-type AllWildcardString = `@*`;
-type AllWildcardObject = {
-    col: `*`;
-};
-type AllWildcard = AllWildcardString | AllWildcardObject;
-export type PropertyReferenceString<TContext extends Context<Schema>> = DefaultReferenceString<TContext> | QualifiedReferenceString<TContext> | UniqueReferenceString<TContext>;
-export type WildcardReferenceString<TContext extends Context<Schema>> = InputWildcardString<TContext> | AllWildcardString;
-export type PropertyReferenceObject<TContext extends Context<Schema>> = DefaultReferenceObject<TContext> | QualifiedReferenceObject<TContext> | UniqueReferenceObject<TContext>;
-export type WildcardReferenceObject<TContext extends Context<Schema>> = InputWildcardObject<TContext> | AllWildcardObject;
-export type PropertyReference<TContext extends Context<Schema>> = DefaultReference<TContext> | QualifiedReference<TContext> | UniqueReference<TContext>;
-export type WildcardReference<TContext extends Context<Schema>> = InputWildcard<TContext> | AllWildcard;
-type InputWithProperty<TSchema extends Schema, TProperty extends string> = {
-    [I in keyof RemoveIndexSignature<TSchema>]: TProperty extends keyof TSchema[I] ? I : never;
-}[keyof RemoveIndexSignature<TSchema>];
-export type TypeFromPropertyReference<TContext extends Context<Schema>, TReference extends PropertyReference<TContext>> = TReference extends `@${infer InputName}.${infer PropName}` | {
-    col: `${infer InputName}.${infer PropName}`;
-} ? InputName extends keyof TContext[`schema`] ? PropName extends keyof TContext[`schema`][InputName] ? TContext[`schema`][InputName][PropName] : never : never : TReference extends `@${infer PropName}` | {
-    col: `${infer PropName}`;
-} ? PropName extends keyof TContext[`schema`][Exclude<TContext[`default`], undefined>] ? TContext[`schema`][Exclude<TContext[`default`], undefined>][PropName] : TContext[`schema`][InputWithProperty<TContext[`schema`], PropName>][PropName] : never;
-/**
- * Return the key that would be used in the result of the query for a given property
- * reference.
- * - `@id` -> `id`
- * - `@employees.id` -> `id`
- * - `{ col: 'id' }` -> `id`
- * - `{ col: 'employees.id' }` -> `id`
- */
-export type ResultKeyFromPropertyReference<TContext extends Context<Schema>, TReference extends PropertyReference<TContext>> = TReference extends `@${infer _InputName}.${infer PropName}` ? PropName : TReference extends {
-    col: `${infer _InputName}.${infer PropName}`;
-} ? PropName : TReference extends `@${infer PropName}` ? PropName : TReference extends {
-    col: `${infer PropName}`;
-} ? PropName : never;
-export type InputReference<TContext extends Context<Schema>> = {
-    [I in InputNames<TContext[`schema`]>]: I;
-}[InputNames<TContext[`schema`]>];
-export type RenameInput<TSchema extends Schema, TInput extends keyof TSchema, TNewName extends string> = Flatten<{
-    [K in Exclude<keyof TSchema, TInput>]: TSchema[K];
-} & {
-    [P in TNewName]: TSchema[TInput];
-}>;
-export type MaybeRenameInput<TSchema extends Schema, TInput extends keyof TSchema, TNewName extends string | undefined> = TNewName extends undefined ? TSchema : RenameInput<TSchema, TInput, Exclude<TNewName, undefined>>;
-/**
- * Helper type to combine result types from each select item in a tuple
- */
-export type InferResultTypeFromSelectTuple<TContext extends Context<Schema>, TSelects extends ReadonlyArray<Select<TContext>>> = UnionToIntersection<{
-    [K in keyof TSelects]: TSelects[K] extends Select<TContext> ? InferResultType<TContext, TSelects[K]> : never;
-}[number]>;
-/**
- * Convert a union type to an intersection type
- */
-type UnionToIntersection<TUnion> = (TUnion extends any ? (x: TUnion) => void : never) extends (x: infer I) => void ? I : never;
-/**
- * Infers the result type from a single select item
- */
-type InferResultType<TContext extends Context<Schema>, TSelect extends Select<TContext>> = TSelect extends PropertyReferenceString<TContext> ? {
-    [K in ResultKeyFromPropertyReference<TContext, TSelect>]: TypeFromPropertyReference<TContext, TSelect>;
-} : TSelect extends WildcardReferenceString<TContext> ? TSelect extends `@*` ? InferAllColumnsType<TContext> : TSelect extends `@${infer TableName}.*` ? TableName extends keyof TContext[`schema`] ? InferTableColumnsType<TContext, TableName> : {} : {} : TSelect extends {
-    [alias: string]: PropertyReference<TContext> | FunctionCall<TContext>;
-} ? {
-    [K in keyof TSelect]: TSelect[K] extends PropertyReference<TContext> ? TypeFromPropertyReference<TContext, TSelect[K]> : TSelect[K] extends FunctionCall<TContext> ? InferFunctionCallResultType<TContext, TSelect[K]> : never;
-} : {};
-/**
- * Infers the result type for all columns from all tables
- */
-type InferAllColumnsType<TContext extends Context<Schema>> = {
-    [K in keyof TContext[`schema`]]: {
-        [P in keyof TContext[`schema`][K]]: TContext[`schema`][K][P];
-    };
-}[keyof TContext[`schema`]];
-/**
- * Infers the result type for all columns from a specific table
- */
-type InferTableColumnsType<TContext extends Context<Schema>, TTable extends keyof TContext[`schema`]> = {
-    [P in keyof TContext[`schema`][TTable]]: TContext[`schema`][TTable][P];
-};
-/**
- * Infers the result type for a function call
- */
-type InferFunctionCallResultType<TContext extends Context<Schema>, TFunctionCall extends FunctionCall<TContext>> = TFunctionCall extends {
-    SUM: any;
-} ? number : TFunctionCall extends {
-    COUNT: any;
-} ? number : TFunctionCall extends {
-    AVG: any;
-} ? number : TFunctionCall extends {
-    MIN: any;
-} ? InferOperandType<TContext, TFunctionCall[`MIN`]> : TFunctionCall extends {
-    MAX: any;
-} ? InferOperandType<TContext, TFunctionCall[`MAX`]> : TFunctionCall extends {
-    DATE: any;
-} ? string : TFunctionCall extends {
-    JSON_EXTRACT: any;
-} ? unknown : TFunctionCall extends {
-    JSON_EXTRACT_PATH: any;
-} ? unknown : TFunctionCall extends {
-    UPPER: any;
-} ? string : TFunctionCall extends {
-    LOWER: any;
-} ? string : TFunctionCall extends {
-    COALESCE: any;
-} ? InferOperandType<TContext, TFunctionCall[`COALESCE`]> : TFunctionCall extends {
-    CONCAT: any;
-} ? string : TFunctionCall extends {
-    LENGTH: any;
-} ? number : TFunctionCall extends {
-    ORDER_INDEX: any;
-} ? number : unknown;
-/**
- * Infers the type of an operand
- */
-type InferOperandType<TContext extends Context<Schema>, TOperand extends ConditionOperand<TContext>> = TOperand extends PropertyReference<TContext> ? TypeFromPropertyReference<TContext, TOperand> : TOperand extends LiteralValue ? TOperand : TOperand extends ExplicitLiteral ? TOperand[`value`] : TOperand extends FunctionCall<TContext> ? InferFunctionCallResultType<TContext, TOperand> : TOperand extends Array<ConditionOperand<TContext>> ? InferOperandType<TContext, TOperand[number]> : unknown;
-export {};

package/dist/cjs/query/utils.cjs

@@ -1,154 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function isAggregateFunctionCall(obj) {
-  if (!obj || typeof obj !== `object`) return false;
-  const aggregateFunctions = [
-    `SUM`,
-    `COUNT`,
-    `AVG`,
-    `MIN`,
-    `MAX`,
-    `MEDIAN`,
-    `MODE`
-  ];
-  const keys = Object.keys(obj);
-  return keys.length === 1 && aggregateFunctions.includes(keys[0]);
-}
-function isOrderIndexFunctionCall(obj) {
-  if (!obj || typeof obj !== `object`) return false;
-  const keys = Object.keys(obj);
-  return keys.length === 1 && keys[0] === `ORDER_INDEX`;
-}
-function isComparable(value) {
-  return typeof value === `number` || typeof value === `string` || typeof value === `boolean` || value instanceof Date;
-}
-function compareValues(left, right, operator) {
-  if (!isComparable(left) || !isComparable(right)) {
-    throw new Error(
-      `Cannot compare non-comparable values: ${typeof left} and ${typeof right}`
-    );
-  }
-  if (typeof left !== typeof right && (typeof left === `string` || typeof left === `number`) && (typeof right === `string` || typeof right === `number`)) {
-    const leftStr = String(left);
-    const rightStr = String(right);
-    switch (operator) {
-      case `<`:
-        return leftStr < rightStr;
-      case `<=`:
-        return leftStr <= rightStr;
-      case `>`:
-        return leftStr > rightStr;
-      case `>=`:
-        return leftStr >= rightStr;
-    }
-  }
-  if (left instanceof Date && right instanceof Date) {
-    const leftTime = left.getTime();
-    const rightTime = right.getTime();
-    switch (operator) {
-      case `<`:
-        return leftTime < rightTime;
-      case `<=`:
-        return leftTime <= rightTime;
-      case `>`:
-        return leftTime > rightTime;
-      case `>=`:
-        return leftTime >= rightTime;
-    }
-  }
-  if (typeof left === typeof right) {
-    switch (operator) {
-      case `<`:
-        return left < right;
-      case `<=`:
-        return left <= right;
-      case `>`:
-        return left > right;
-      case `>=`:
-        return left >= right;
-    }
-  }
-  throw new Error(
-    `Cannot compare incompatible types: ${typeof left} and ${typeof right}`
-  );
-}
-function convertLikeToRegex(pattern) {
-  let finalPattern = ``;
-  let i = 0;
-  while (i < pattern.length) {
-    const char = pattern[i];
-    if (char === `\\` && i + 1 < pattern.length) {
-      finalPattern += pattern[i + 1];
-      i += 2;
-      continue;
-    }
-    switch (char) {
-      case `%`:
-        finalPattern += `.*`;
-        break;
-      case `_`:
-        finalPattern += `.`;
-        break;
-      // Handle regex special characters
-      case `.`:
-      case `^`:
-      case `$`:
-      case `*`:
-      case `+`:
-      case `?`:
-      case `(`:
-      case `)`:
-      case `[`:
-      case `]`:
-      case `{`:
-      case `}`:
-      case `|`:
-      case `/`:
-        finalPattern += `\\` + char;
-        break;
-      default:
-        finalPattern += char;
-    }
-    i++;
-  }
-  return finalPattern;
-}
-function isValueInArray(value, array, caseInsensitive = false) {
-  if (array.includes(value)) {
-    return true;
-  }
-  if (value === null || value === void 0) {
-    return array.some((item) => item === null || item === void 0);
-  }
-  if (typeof value === `number` || typeof value === `string`) {
-    return array.some((item) => {
-      if (typeof item === typeof value) {
-        if (typeof value === `string` && caseInsensitive) {
-          return value.toLowerCase() === item.toLowerCase();
-        }
-        return item === value;
-      }
-      if ((typeof item === `number` || typeof item === `string`) && (typeof value === `number` || typeof value === `string`)) {
-        return String(item) === String(value);
-      }
-      return false;
-    });
-  }
-  if (typeof value === `object`) {
-    const valueStr = JSON.stringify(value);
-    return array.some((item) => {
-      if (typeof item === `object` && item !== null) {
-        return JSON.stringify(item) === valueStr;
-      }
-      return false;
-    });
-  }
-  return false;
-}
-exports.compareValues = compareValues;
-exports.convertLikeToRegex = convertLikeToRegex;
-exports.isAggregateFunctionCall = isAggregateFunctionCall;
-exports.isComparable = isComparable;
-exports.isOrderIndexFunctionCall = isOrderIndexFunctionCall;
-exports.isValueInArray = isValueInArray;
-//# sourceMappingURL=utils.cjs.map

package/dist/cjs/query/utils.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.cjs","sources":["../../../src/query/utils.ts"],"sourcesContent":["/**\n * Helper function to determine if an object is a function call with an aggregate function\n */\nexport function isAggregateFunctionCall(obj: any): boolean {\n  if (!obj || typeof obj !== `object`) return false\n\n  const aggregateFunctions = [\n    `SUM`,\n    `COUNT`,\n    `AVG`,\n    `MIN`,\n    `MAX`,\n    `MEDIAN`,\n    `MODE`,\n  ]\n  const keys = Object.keys(obj)\n\n  return keys.length === 1 && aggregateFunctions.includes(keys[0]!)\n}\n\n/**\n * Helper function to determine if an object is an ORDER_INDEX function call\n */\nexport function isOrderIndexFunctionCall(obj: any): boolean {\n  if (!obj || typeof obj !== `object`) return false\n\n  const keys = Object.keys(obj)\n  return keys.length === 1 && keys[0] === `ORDER_INDEX`\n}\n\n/**\n * Type guard to check if a value is comparable (can be used with <, >, <=, >= operators)\n * @param value The value to check\n * @returns True if the value is comparable\n */\nexport function isComparable(\n  value: unknown\n): value is number | string | Date | boolean {\n  return (\n    typeof value === `number` ||\n    typeof value === `string` ||\n    typeof value === `boolean` ||\n    value instanceof Date\n  )\n}\n\n/**\n * Performs a comparison between two values, ensuring they are of compatible types\n * @param left The left operand\n * @param right The right operand\n * @param operator The comparison operator\n * @returns The result of the comparison\n * @throws Error if the values are not comparable\n */\nexport function compareValues(\n  left: unknown,\n  right: unknown,\n  operator: `<` | `<=` | `>` | `>=`\n): boolean {\n  // First check if both values are comparable\n  if (!isComparable(left) || !isComparable(right)) {\n    throw new Error(\n      `Cannot compare non-comparable values: ${typeof left} and ${typeof right}`\n    )\n  }\n\n  // If they're different types but both are strings or numbers, convert to strings\n  if (\n    typeof left !== typeof right &&\n    (typeof left === `string` || typeof left === `number`) &&\n    (typeof right === `string` || typeof right === `number`)\n  ) {\n    // Convert to strings for comparison (follows JavaScript's coercion rules)\n    const leftStr = String(left)\n    const rightStr = String(right)\n\n    switch (operator) {\n      case `<`:\n        return leftStr < rightStr\n      case `<=`:\n        return leftStr <= rightStr\n      case `>`:\n        return leftStr > rightStr\n      case `>=`:\n        return leftStr >= rightStr\n    }\n  }\n\n  // For Date objects, convert to timestamps\n  if (left instanceof Date && right instanceof Date) {\n    const leftTime = left.getTime()\n    const rightTime = right.getTime()\n\n    switch (operator) {\n      case `<`:\n        return leftTime < rightTime\n      case `<=`:\n        return leftTime <= rightTime\n      case `>`:\n        return leftTime > rightTime\n      case `>=`:\n        return leftTime >= rightTime\n    }\n  }\n\n  // For other cases where types match\n  if (typeof left === typeof right) {\n    switch (operator) {\n      case `<`:\n        return left < right\n      case `<=`:\n        return left <= right\n      case `>`:\n        return left > right\n      case `>=`:\n        return left >= right\n    }\n  }\n\n  // If we get here, it means the values are technically comparable but not compatible\n  throw new Error(\n    `Cannot compare incompatible types: ${typeof left} and ${typeof right}`\n  )\n}\n\n/**\n * Converts a SQL LIKE pattern to a JavaScript regex pattern\n * @param pattern The SQL LIKE pattern to convert\n * @returns A regex-compatible pattern string\n */\nexport function convertLikeToRegex(pattern: string): string {\n  let finalPattern = ``\n  let i = 0\n\n  while (i < pattern.length) {\n    const char = pattern[i]\n\n    // Handle escape character\n    if (char === `\\\\` && i + 1 < pattern.length) {\n      // Add the next character as a literal (escaped)\n      finalPattern += pattern[i + 1]\n      i += 2 // Skip both the escape and the escaped character\n      continue\n    }\n\n    // Handle SQL LIKE special characters\n    switch (char) {\n      case `%`:\n        // % matches any sequence of characters (including empty)\n        finalPattern += `.*`\n        break\n      case `_`:\n        // _ matches any single character\n        finalPattern += `.`\n        break\n      // Handle regex special characters\n      case `.`:\n      case `^`:\n      case `$`:\n      case `*`:\n      case `+`:\n      case `?`:\n      case `(`:\n      case `)`:\n      case `[`:\n      case `]`:\n      case `{`:\n      case `}`:\n      case `|`:\n      case `/`:\n        // Escape regex special characters\n        finalPattern += `\\\\` + char\n        break\n      default:\n        // Regular character, just add it\n        finalPattern += char\n    }\n\n    i++\n  }\n\n  return finalPattern\n}\n\n/**\n * Helper function to check if a value is in an array, with special handling for various types\n * @param value The value to check for\n * @param array The array to search in\n * @param caseInsensitive Optional flag to enable case-insensitive matching for strings (default: false)\n * @returns True if the value is found in the array\n */\nexport function isValueInArray(\n  value: unknown,\n  array: Array<unknown>,\n  caseInsensitive: boolean = false\n): boolean {\n  // Direct inclusion check first (fastest path)\n  if (array.includes(value)) {\n    return true\n  }\n\n  // Handle null/undefined\n  if (value === null || value === undefined) {\n    return array.some((item) => item === null || item === undefined)\n  }\n\n  // Handle numbers and strings with type coercion\n  if (typeof value === `number` || typeof value === `string`) {\n    return array.some((item) => {\n      // Same type, direct comparison\n      if (typeof item === typeof value) {\n        if (typeof value === `string` && caseInsensitive) {\n          // Case-insensitive comparison for strings (only if explicitly enabled)\n          return value.toLowerCase() === (item as string).toLowerCase()\n        }\n        return item === value\n      }\n\n      // Different types, try coercion for number/string\n      if (\n        (typeof item === `number` || typeof item === `string`) &&\n        (typeof value === `number` || typeof value === `string`)\n      ) {\n        // Convert both to strings for comparison\n        return String(item) === String(value)\n      }\n\n      return false\n    })\n  }\n\n  // Handle objects/arrays by comparing stringified versions\n  if (typeof value === `object`) {\n    const valueStr = JSON.stringify(value)\n    return array.some((item) => {\n      if (typeof item === `object` && item !== null) {\n        return JSON.stringify(item) === valueStr\n      }\n      return false\n    })\n  }\n\n  // Fallback\n  return false\n}\n"],"names":[],"mappings":"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"}

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

@@ -1,37 +0,0 @@
-/**
- * Helper function to determine if an object is a function call with an aggregate function
- */
-export declare function isAggregateFunctionCall(obj: any): boolean;
-/**
- * Helper function to determine if an object is an ORDER_INDEX function call
- */
-export declare function isOrderIndexFunctionCall(obj: any): boolean;
-/**
- * Type guard to check if a value is comparable (can be used with <, >, <=, >= operators)
- * @param value The value to check
- * @returns True if the value is comparable
- */
-export declare function isComparable(value: unknown): value is number | string | Date | boolean;
-/**
- * Performs a comparison between two values, ensuring they are of compatible types
- * @param left The left operand
- * @param right The right operand
- * @param operator The comparison operator
- * @returns The result of the comparison
- * @throws Error if the values are not comparable
- */
-export declare function compareValues(left: unknown, right: unknown, operator: `<` | `<=` | `>` | `>=`): boolean;
-/**
- * Converts a SQL LIKE pattern to a JavaScript regex pattern
- * @param pattern The SQL LIKE pattern to convert
- * @returns A regex-compatible pattern string
- */
-export declare function convertLikeToRegex(pattern: string): string;
-/**
- * Helper function to check if a value is in an array, with special handling for various types
- * @param value The value to check for
- * @param array The array to search in
- * @param caseInsensitive Optional flag to enable case-insensitive matching for strings (default: false)
- * @returns True if the value is found in the array
- */
-export declare function isValueInArray(value: unknown, array: Array<unknown>, caseInsensitive?: boolean): boolean;

package/dist/cjs/utils.cjs

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function getLockedObjects() {
-  return /* @__PURE__ */ new Set();
-}
-let globalVersion = 0;
-function getGlobalVersion() {
-  return globalVersion;
-}
-function advanceGlobalVersion() {
-  console.log(`==== advancing global version`, globalVersion + 1);
-  return globalVersion++;
-}
-exports.advanceGlobalVersion = advanceGlobalVersion;
-exports.getGlobalVersion = getGlobalVersion;
-exports.getLockedObjects = getLockedObjects;
-//# sourceMappingURL=utils.cjs.map

package/dist/cjs/utils.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.cjs","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/dist/cjs/utils.d.cts

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

package/dist/esm/query/compiled-query.d.ts

@@ -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/esm/query/compiled-query.js

@@ -1,160 +0,0 @@
-import { D2, MultiSet, output } from "@electric-sql/d2mini";
-import { createCollection } from "../collection.js";
-import { compileQueryPipeline } from "./pipeline-compiler.js";
-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 D2();
-    const inputs = Object.fromEntries(
-      Object.entries(collections).map(([key]) => [key, graph.newInput()])
-    );
-    const sync = ({
-      begin,
-      write,
-      commit,
-      collection
-    }) => {
-      compileQueryPipeline(
-        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;
-          }, /* @__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 && collection.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 = 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 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, 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`;
-  }
-}
-export {
-  CompiledQuery,
-  compileQuery
-};
-//# sourceMappingURL=compiled-query.js.map

package/dist/esm/query/compiled-query.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"compiled-query.js","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":[],"mappings":";;;AAcO,SAAS,aACd,cACA;AACO,SAAA,IAAI,cAET,YAAY;AAChB;AAEO,MAAM,cAAiE;AAAA,EAQ5E,YAAY,cAA6C;AAHzD,SAAO,QAA4C;AACnD,SAAQ,uBAA0C,CAAC;AAGjD,UAAM,QAAQ,aAAa;AAC3B,UAAM,cAAc,MAAM;AAE1B,QAAI,CAAC,aAAa;AACV,YAAA,IAAI,MAAM,yBAAyB;AAAA,IAAA;AAG3C,SAAK,mBAAmB;AAElB,UAAA,QAAQ,IAAI,GAAG;AACrB,UAAM,SAAS,OAAO;AAAA,MACpB,OAAO,QAAQ,WAAW,EAAE,IAAI,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,MAAM,SAAA,CAAe,CAAC;AAAA,IACzE;AAGA,UAAM,OAAqC,CAAC;AAAA,MAC1C;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IAAA,MACI;AACJ;AAAA,QACE;AAAA,QACA;AAAA,MAAA,EACA;AAAA,QACA,OAAO,CAAC,SAAS;AACT,gBAAA;AAEH,eAAA,WACA,OAAO,CAAC,KAAK,CAAC,CAAC,KAAK,KAAK,GAAG,YAAY,MAAM;AAC7C,kBAAM,UAAU,IAAI,IAAI,GAAG,KAAK;AAAA,cAC9B,SAAS;AAAA,cACT,SAAS;AAAA,cACT;AAAA,YACF;AACA,gBAAI,eAAe,GAAG;AACZ,sBAAA,WAAW,KAAK,IAAI,YAAY;AAAA,YAAA,WAC/B,eAAe,GAAG;AAC3B,sBAAQ,WAAW;AACnB,sBAAQ,QAAQ;AAAA,YAAA;AAEd,gBAAA,IAAI,KAAK,OAAO;AACb,mBAAA;AAAA,UAAA,uBACF,IAAoE,CAAC,EAC3E,QAAQ,CAAC,SAAS,WAAW;AAC5B,kBAAM,EAAE,SAAS,SAAS,MAAU,IAAA;AACpC,kBAAM,eAAe,EAAE,GAAG,OAAO,MAAM,OAAO;AAG1C,gBAAA,WAAW,YAAY,GAAG;AACtB,oBAAA;AAAA,gBACJ,OAAO;AAAA,gBACP,MAAM;AAAA,cAAA,CACP;AAAA,YAAA;AAAA;AAAA,cAGD,UAAU;AAAA;AAAA,cAGT,YAAY,WACX,WAAW,IAAI,aAAa,IAAuB;AAAA,cACrD;AACM,oBAAA;AAAA,gBACJ,OAAO;AAAA,gBACP,MAAM;AAAA,cAAA,CACP;AAAA,YAAA,WAEQ,UAAU,GAAG;AAChB,oBAAA;AAAA,gBACJ,OAAO;AAAA,gBACP,MAAM;AAAA,cAAA,CACP;AAAA,YAAA,OACI;AACL,oBAAM,IAAI;AAAA,gBACR,4BAA4B,KAAK,UAAU,OAAO,CAAC;AAAA,cACrD;AAAA,YAAA;AAAA,UACF,CACD;AACI,iBAAA;AAAA,QACR,CAAA;AAAA,MACH;AACA,YAAM,SAAS;AAAA,IACjB;AAEA,SAAK,QAAQ;AACb,SAAK,SAAS;AAEd,UAAM,UAAU,MAAM,UAClB,CACE,MAKA,SACW;AAEX,YAAM,IAAI;AACV,YAAM,IAAI;AACN,UAAA,EAAE,gBAAgB,EAAE,eAAe;AAC9B,eAAA;AAAA,MACE,WAAA,EAAE,gBAAgB,EAAE,eAAe;AACrC,eAAA;AAAA,MAAA,OACF;AACE,eAAA;AAAA,MAAA;AAAA,IACT,IAEF;AAEJ,SAAK,mBAAmB,iBAA2B;AAAA,MACjD,QAAQ,CAAC,QAAiB;AACxB,eAAQ,IAAY;AAAA,MACtB;AAAA,MACA,QAAQ;AAAA,MACR,WAAW;AAAA,MACX;AAAA,MACA,MAAM;AAAA,QACJ;AAAA,MAAA;AAAA,IAkBF,CACD;AAAA,EAAA;AAAA,EAGH,IAAI,UAAU;AACZ,WAAO,KAAK;AAAA,EAAA;AAAA,EAGN,mBACN,UACA,SACA,QACA;AACM,UAAA,QAAQ,KAAK,OAAO,QAAQ;AAClC,UAAM,gBAAwC,CAAC;AAC/C,eAAW,UAAU,SAAS;AACtB,YAAA,MAAM,OAAO,OAAO,KAAK;AAC3B,UAAA,OAAO,SAAS,UAAU;AACd,sBAAA,KAAK,CAAC,CAAC,KAAK,OAAO,KAAK,GAAG,CAAC,CAAC;AAAA,MAC7C,WAAW,OAAO,SAAS,UAAU;AACrB,sBAAA,KAAK,CAAC,CAAC,KAAK,OAAO,aAAa,GAAG,EAAE,CAAC;AACtC,sBAAA,KAAK,CAAC,CAAC,KAAK,OAAO,KAAK,GAAG,CAAC,CAAC;AAAA,MAAA,OACtC;AAES,sBAAA,KAAK,CAAC,CAAC,KAAK,OAAO,KAAK,GAAG,EAAE,CAAC;AAAA,MAAA;AAAA,IAC9C;AAEF,UAAM,SAAS,IAAI,SAAS,aAAa,CAAC;AAAA,EAAA;AAAA,EAGpC,WAAW;AACjB,SAAK,MAAM,IAAI;AAAA,EAAA;AAAA,EAGjB,QAAQ;AACF,QAAA,KAAK,UAAU,WAAW;AACtB,YAAA,IAAI,MAAM,0BAA0B;AAAA,IAC5C,WAAW,KAAK,UAAU,WAAW;AAC7B,YAAA,IAAI,MAAM,kBAAkB;AAAA,IAAA;AAI7B,WAAA,QAAQ,KAAK,gBAAgB,EAAE,QAAQ,CAAC,CAAC,KAAK,UAAU,MAAM;AACnE,YAAM,cAAc,WAAW;AAAA,QAC7B,CAAC,YAAY;AACX,eAAK,mBAAmB,KAAK,SAAS,WAAW,OAAO,MAAM;AAC9D,eAAK,SAAS;AAAA,QAChB;AAAA,QACA,EAAE,qBAAqB,KAAK;AAAA,MAC9B;AAEK,WAAA,qBAAqB,KAAK,WAAW;AAAA,IAAA,CAC3C;AAED,SAAK,SAAS;AAEd,SAAK,QAAQ;AACb,WAAO,MAAM;AACX,WAAK,KAAK;AAAA,IACZ;AAAA,EAAA;AAAA,EAGF,OAAO;AACL,SAAK,qBAAqB,QAAQ,CAAC,gBAAgB,aAAa;AAChE,SAAK,uBAAuB,CAAC;AAC7B,SAAK,QAAQ;AAAA,EAAA;AAEjB;"}

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

@@ -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;