@tanstack/db 0.0.26 → 0.0.29

package/dist/cjs/errors.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"errors.cjs","sources":["../../src/errors.ts"],"sourcesContent":["export class NonRetriableError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = `NonRetriableError`\n  }\n}\n"],"names":[],"mappings":";;AAAO,MAAM,0BAA0B,MAAM;AAAA,EAC3C,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;;"}
+{"version":3,"file":"errors.cjs","sources":["../../src/errors.ts"],"sourcesContent":["// Root error class for all TanStack DB errors\nexport class TanStackDBError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = `TanStackDBError`\n  }\n}\n\n// Base error classes\nexport class NonRetriableError extends TanStackDBError {\n  constructor(message: string) {\n    super(message)\n    this.name = `NonRetriableError`\n  }\n}\n\n// Schema validation error (exported from index for backward compatibility)\nexport class SchemaValidationError extends TanStackDBError {\n  type: `insert` | `update`\n  issues: ReadonlyArray<{\n    message: string\n    path?: ReadonlyArray<string | number | symbol>\n  }>\n\n  constructor(\n    type: `insert` | `update`,\n    issues: ReadonlyArray<{\n      message: string\n      path?: ReadonlyArray<string | number | symbol>\n    }>,\n    message?: string\n  ) {\n    const defaultMessage = `${type === `insert` ? `Insert` : `Update`} validation failed: ${issues\n      .map((issue) => `\\n- ${issue.message} - path: ${issue.path}`)\n      .join(``)}`\n\n    super(message || defaultMessage)\n    this.name = `SchemaValidationError`\n    this.type = type\n    this.issues = issues\n  }\n}\n\n// Collection Configuration Errors\nexport class CollectionConfigurationError extends TanStackDBError {\n  constructor(message: string) {\n    super(message)\n    this.name = `CollectionConfigurationError`\n  }\n}\n\nexport class CollectionRequiresConfigError extends CollectionConfigurationError {\n  constructor() {\n    super(`Collection requires a config`)\n  }\n}\n\nexport class CollectionRequiresSyncConfigError extends CollectionConfigurationError {\n  constructor() {\n    super(`Collection requires a sync config`)\n  }\n}\n\nexport class InvalidSchemaError extends CollectionConfigurationError {\n  constructor() {\n    super(`Schema must implement the standard-schema interface`)\n  }\n}\n\nexport class SchemaMustBeSynchronousError extends CollectionConfigurationError {\n  constructor() {\n    super(`Schema validation must be synchronous`)\n  }\n}\n\n// Collection State Errors\nexport class CollectionStateError extends TanStackDBError {\n  constructor(message: string) {\n    super(message)\n    this.name = `CollectionStateError`\n  }\n}\n\nexport class CollectionInErrorStateError extends CollectionStateError {\n  constructor(operation: string, collectionId: string) {\n    super(\n      `Cannot perform ${operation} on collection \"${collectionId}\" - collection is in error state. Try calling cleanup() and restarting the collection.`\n    )\n  }\n}\n\nexport class InvalidCollectionStatusTransitionError extends CollectionStateError {\n  constructor(from: string, to: string, collectionId: string) {\n    super(\n      `Invalid collection status transition from \"${from}\" to \"${to}\" for collection \"${collectionId}\"`\n    )\n  }\n}\n\nexport class CollectionIsInErrorStateError extends CollectionStateError {\n  constructor() {\n    super(`Collection is in error state`)\n  }\n}\n\nexport class NegativeActiveSubscribersError extends CollectionStateError {\n  constructor() {\n    super(`Active subscribers count is negative - this should never happen`)\n  }\n}\n\n// Collection Operation Errors\nexport class CollectionOperationError extends TanStackDBError {\n  constructor(message: string) {\n    super(message)\n    this.name = `CollectionOperationError`\n  }\n}\n\nexport class UndefinedKeyError extends CollectionOperationError {\n  constructor(item: any) {\n    super(\n      `An object was created without a defined key: ${JSON.stringify(item)}`\n    )\n  }\n}\n\nexport class DuplicateKeyError extends CollectionOperationError {\n  constructor(key: string | number) {\n    super(\n      `Cannot insert document with ID \"${key}\" because it already exists in the collection`\n    )\n  }\n}\n\nexport class DuplicateKeySyncError extends CollectionOperationError {\n  constructor(key: string | number, collectionId: string) {\n    super(\n      `Cannot insert document with key \"${key}\" from sync because it already exists in the collection \"${collectionId}\"`\n    )\n  }\n}\n\nexport class MissingUpdateArgumentError extends CollectionOperationError {\n  constructor() {\n    super(`The first argument to update is missing`)\n  }\n}\n\nexport class NoKeysPassedToUpdateError extends CollectionOperationError {\n  constructor() {\n    super(`No keys were passed to update`)\n  }\n}\n\nexport class UpdateKeyNotFoundError extends CollectionOperationError {\n  constructor(key: string | number) {\n    super(\n      `The key \"${key}\" was passed to update but an object for this key was not found in the collection`\n    )\n  }\n}\n\nexport class KeyUpdateNotAllowedError extends CollectionOperationError {\n  constructor(originalKey: string | number, newKey: string | number) {\n    super(\n      `Updating the key of an item is not allowed. Original key: \"${originalKey}\", Attempted new key: \"${newKey}\". Please delete the old item and create a new one if a key change is necessary.`\n    )\n  }\n}\n\nexport class NoKeysPassedToDeleteError extends CollectionOperationError {\n  constructor() {\n    super(`No keys were passed to delete`)\n  }\n}\n\nexport class DeleteKeyNotFoundError extends CollectionOperationError {\n  constructor(key: string | number) {\n    super(\n      `Collection.delete was called with key '${key}' but there is no item in the collection with this key`\n    )\n  }\n}\n\n// Collection Handler Errors\nexport class MissingHandlerError extends TanStackDBError {\n  constructor(message: string) {\n    super(message)\n    this.name = `MissingHandlerError`\n  }\n}\n\nexport class MissingInsertHandlerError extends MissingHandlerError {\n  constructor() {\n    super(\n      `Collection.insert called directly (not within an explicit transaction) but no 'onInsert' handler is configured.`\n    )\n  }\n}\n\nexport class MissingUpdateHandlerError extends MissingHandlerError {\n  constructor() {\n    super(\n      `Collection.update called directly (not within an explicit transaction) but no 'onUpdate' handler is configured.`\n    )\n  }\n}\n\nexport class MissingDeleteHandlerError extends MissingHandlerError {\n  constructor() {\n    super(\n      `Collection.delete called directly (not within an explicit transaction) but no 'onDelete' handler is configured.`\n    )\n  }\n}\n\n// Transaction Errors\nexport class TransactionError extends TanStackDBError {\n  constructor(message: string) {\n    super(message)\n    this.name = `TransactionError`\n  }\n}\n\nexport class MissingMutationFunctionError extends TransactionError {\n  constructor() {\n    super(`mutationFn is required when creating a transaction`)\n  }\n}\n\nexport class TransactionNotPendingMutateError extends TransactionError {\n  constructor() {\n    super(\n      `You can no longer call .mutate() as the transaction is no longer pending`\n    )\n  }\n}\n\nexport class TransactionAlreadyCompletedRollbackError extends TransactionError {\n  constructor() {\n    super(\n      `You can no longer call .rollback() as the transaction is already completed`\n    )\n  }\n}\n\nexport class TransactionNotPendingCommitError extends TransactionError {\n  constructor() {\n    super(\n      `You can no longer call .commit() as the transaction is no longer pending`\n    )\n  }\n}\n\nexport class NoPendingSyncTransactionWriteError extends TransactionError {\n  constructor() {\n    super(`No pending sync transaction to write to`)\n  }\n}\n\nexport class SyncTransactionAlreadyCommittedWriteError extends TransactionError {\n  constructor() {\n    super(\n      `The pending sync transaction is already committed, you can't still write to it.`\n    )\n  }\n}\n\nexport class NoPendingSyncTransactionCommitError extends TransactionError {\n  constructor() {\n    super(`No pending sync transaction to commit`)\n  }\n}\n\nexport class SyncTransactionAlreadyCommittedError extends TransactionError {\n  constructor() {\n    super(\n      `The pending sync transaction is already committed, you can't commit it again.`\n    )\n  }\n}\n\n// Query Builder Errors\nexport class QueryBuilderError extends TanStackDBError {\n  constructor(message: string) {\n    super(message)\n    this.name = `QueryBuilderError`\n  }\n}\n\nexport class OnlyOneSourceAllowedError extends QueryBuilderError {\n  constructor(context: string) {\n    super(`Only one source is allowed in the ${context}`)\n  }\n}\n\nexport class SubQueryMustHaveFromClauseError extends QueryBuilderError {\n  constructor(context: string) {\n    super(`A sub query passed to a ${context} must have a from clause itself`)\n  }\n}\n\nexport class InvalidSourceError extends QueryBuilderError {\n  constructor() {\n    super(`Invalid source`)\n  }\n}\n\nexport class JoinConditionMustBeEqualityError extends QueryBuilderError {\n  constructor() {\n    super(`Join condition must be an equality expression`)\n  }\n}\n\nexport class QueryMustHaveFromClauseError extends QueryBuilderError {\n  constructor() {\n    super(`Query must have a from clause`)\n  }\n}\n\n// Query Compilation Errors\nexport class QueryCompilationError extends TanStackDBError {\n  constructor(message: string) {\n    super(message)\n    this.name = `QueryCompilationError`\n  }\n}\n\nexport class DistinctRequiresSelectError extends QueryCompilationError {\n  constructor() {\n    super(`DISTINCT requires a SELECT clause.`)\n  }\n}\n\nexport class HavingRequiresGroupByError extends QueryCompilationError {\n  constructor() {\n    super(`HAVING clause requires GROUP BY clause`)\n  }\n}\n\nexport class LimitOffsetRequireOrderByError extends QueryCompilationError {\n  constructor() {\n    super(\n      `LIMIT and OFFSET require an ORDER BY clause to ensure deterministic results`\n    )\n  }\n}\n\nexport class CollectionInputNotFoundError extends QueryCompilationError {\n  constructor(collectionId: string) {\n    super(`Input for collection \"${collectionId}\" not found in inputs map`)\n  }\n}\n\nexport class UnsupportedFromTypeError extends QueryCompilationError {\n  constructor(type: string) {\n    super(`Unsupported FROM type: ${type}`)\n  }\n}\n\nexport class UnknownExpressionTypeError extends QueryCompilationError {\n  constructor(type: string) {\n    super(`Unknown expression type: ${type}`)\n  }\n}\n\nexport class EmptyReferencePathError extends QueryCompilationError {\n  constructor() {\n    super(`Reference path cannot be empty`)\n  }\n}\n\nexport class UnknownFunctionError extends QueryCompilationError {\n  constructor(functionName: string) {\n    super(`Unknown function: ${functionName}`)\n  }\n}\n\n// JOIN Operation Errors\nexport class JoinError extends TanStackDBError {\n  constructor(message: string) {\n    super(message)\n    this.name = `JoinError`\n  }\n}\n\nexport class UnsupportedJoinTypeError extends JoinError {\n  constructor(joinType: string) {\n    super(`Unsupported join type: ${joinType}`)\n  }\n}\n\nexport class InvalidJoinConditionSameTableError extends JoinError {\n  constructor(tableAlias: string) {\n    super(\n      `Invalid join condition: both expressions refer to the same table \"${tableAlias}\"`\n    )\n  }\n}\n\nexport class InvalidJoinConditionTableMismatchError extends JoinError {\n  constructor(mainTableAlias: string, joinedTableAlias: string) {\n    super(\n      `Invalid join condition: expressions must reference table aliases \"${mainTableAlias}\" and \"${joinedTableAlias}\"`\n    )\n  }\n}\n\nexport class InvalidJoinConditionWrongTablesError extends JoinError {\n  constructor(\n    leftTableAlias: string,\n    rightTableAlias: string,\n    mainTableAlias: string,\n    joinedTableAlias: string\n  ) {\n    super(\n      `Invalid join condition: expressions reference tables \"${leftTableAlias}\" and \"${rightTableAlias}\" but join is between \"${mainTableAlias}\" and \"${joinedTableAlias}\"`\n    )\n  }\n}\n\nexport class UnsupportedJoinSourceTypeError extends JoinError {\n  constructor(type: string) {\n    super(`Unsupported join source type: ${type}`)\n  }\n}\n\n// GROUP BY and Aggregation Errors\nexport class GroupByError extends TanStackDBError {\n  constructor(message: string) {\n    super(message)\n    this.name = `GroupByError`\n  }\n}\n\nexport class NonAggregateExpressionNotInGroupByError extends GroupByError {\n  constructor(alias: string) {\n    super(\n      `Non-aggregate expression '${alias}' in SELECT must also appear in GROUP BY clause`\n    )\n  }\n}\n\nexport class UnsupportedAggregateFunctionError extends GroupByError {\n  constructor(functionName: string) {\n    super(`Unsupported aggregate function: ${functionName}`)\n  }\n}\n\nexport class AggregateFunctionNotInSelectError extends GroupByError {\n  constructor(functionName: string) {\n    super(\n      `Aggregate function in HAVING clause must also be in SELECT clause: ${functionName}`\n    )\n  }\n}\n\nexport class UnknownHavingExpressionTypeError extends GroupByError {\n  constructor(type: string) {\n    super(`Unknown expression type in HAVING clause: ${type}`)\n  }\n}\n\n// Storage Errors\nexport class StorageError extends TanStackDBError {\n  constructor(message: string) {\n    super(message)\n    this.name = `StorageError`\n  }\n}\n\nexport class SerializationError extends StorageError {\n  constructor(operation: string, originalError: string) {\n    super(\n      `Cannot ${operation} item because it cannot be JSON serialized: ${originalError}`\n    )\n  }\n}\n\n// LocalStorage Collection Errors\nexport class LocalStorageCollectionError extends StorageError {\n  constructor(message: string) {\n    super(message)\n    this.name = `LocalStorageCollectionError`\n  }\n}\n\nexport class StorageKeyRequiredError extends LocalStorageCollectionError {\n  constructor() {\n    super(`[LocalStorageCollection] storageKey must be provided.`)\n  }\n}\n\nexport class NoStorageAvailableError extends LocalStorageCollectionError {\n  constructor() {\n    super(\n      `[LocalStorageCollection] No storage available. Please provide a storage option or ensure window.localStorage is available.`\n    )\n  }\n}\n\nexport class NoStorageEventApiError extends LocalStorageCollectionError {\n  constructor() {\n    super(\n      `[LocalStorageCollection] No storage event API available. Please provide a storageEventApi option or ensure window is available.`\n    )\n  }\n}\n\nexport class InvalidStorageDataFormatError extends LocalStorageCollectionError {\n  constructor(storageKey: string, key: string) {\n    super(\n      `[LocalStorageCollection] Invalid data format in storage key \"${storageKey}\" for key \"${key}\".`\n    )\n  }\n}\n\nexport class InvalidStorageObjectFormatError extends LocalStorageCollectionError {\n  constructor(storageKey: string) {\n    super(\n      `[LocalStorageCollection] Invalid data format in storage key \"${storageKey}\". Expected object format.`\n    )\n  }\n}\n\n// Sync Cleanup Errors\nexport class SyncCleanupError extends TanStackDBError {\n  constructor(collectionId: string, error: Error | string) {\n    const message = error instanceof Error ? error.message : String(error)\n    super(\n      `Collection \"${collectionId}\" sync cleanup function threw an error: ${message}`\n    )\n    this.name = `SyncCleanupError`\n  }\n}\n\n// Query Optimizer Errors\nexport class QueryOptimizerError extends TanStackDBError {\n  constructor(message: string) {\n    super(message)\n    this.name = `QueryOptimizerError`\n  }\n}\n\nexport class CannotCombineEmptyExpressionListError extends QueryOptimizerError {\n  constructor() {\n    super(`Cannot combine empty expression list`)\n  }\n}\n"],"names":[],"mappings":";;AACO,MAAM,wBAAwB,MAAM;AAAA,EACzC,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAGO,MAAM,0BAA0B,gBAAgB;AAAA,EACrD,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAGO,MAAM,8BAA8B,gBAAgB;AAAA,EAOzD,YACE,MACA,QAIA,SACA;AACA,UAAM,iBAAiB,GAAG,SAAS,WAAW,WAAW,QAAQ,uBAAuB,OACrF,IAAI,CAAC,UAAU;AAAA,IAAO,MAAM,OAAO,YAAY,MAAM,IAAI,EAAE,EAC3D,KAAK,EAAE,CAAC;AAEX,UAAM,WAAW,cAAc;AAC/B,SAAK,OAAO;AACZ,SAAK,OAAO;AACZ,SAAK,SAAS;AAAA,EAChB;AACF;AAGO,MAAM,qCAAqC,gBAAgB;AAAA,EAChE,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAEO,MAAM,sCAAsC,6BAA6B;AAAA,EAC9E,cAAc;AACZ,UAAM,8BAA8B;AAAA,EACtC;AACF;AAEO,MAAM,0CAA0C,6BAA6B;AAAA,EAClF,cAAc;AACZ,UAAM,mCAAmC;AAAA,EAC3C;AACF;AAEO,MAAM,2BAA2B,6BAA6B;AAAA,EACnE,cAAc;AACZ,UAAM,qDAAqD;AAAA,EAC7D;AACF;AAEO,MAAM,qCAAqC,6BAA6B;AAAA,EAC7E,cAAc;AACZ,UAAM,uCAAuC;AAAA,EAC/C;AACF;AAGO,MAAM,6BAA6B,gBAAgB;AAAA,EACxD,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAEO,MAAM,oCAAoC,qBAAqB;AAAA,EACpE,YAAY,WAAmB,cAAsB;AACnD;AAAA,MACE,kBAAkB,SAAS,mBAAmB,YAAY;AAAA,IAAA;AAAA,EAE9D;AACF;AAEO,MAAM,+CAA+C,qBAAqB;AAAA,EAC/E,YAAY,MAAc,IAAY,cAAsB;AAC1D;AAAA,MACE,8CAA8C,IAAI,SAAS,EAAE,qBAAqB,YAAY;AAAA,IAAA;AAAA,EAElG;AACF;AAEO,MAAM,sCAAsC,qBAAqB;AAAA,EACtE,cAAc;AACZ,UAAM,8BAA8B;AAAA,EACtC;AACF;AAEO,MAAM,uCAAuC,qBAAqB;AAAA,EACvE,cAAc;AACZ,UAAM,iEAAiE;AAAA,EACzE;AACF;AAGO,MAAM,iCAAiC,gBAAgB;AAAA,EAC5D,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAEO,MAAM,0BAA0B,yBAAyB;AAAA,EAC9D,YAAY,MAAW;AACrB;AAAA,MACE,gDAAgD,KAAK,UAAU,IAAI,CAAC;AAAA,IAAA;AAAA,EAExE;AACF;AAEO,MAAM,0BAA0B,yBAAyB;AAAA,EAC9D,YAAY,KAAsB;AAChC;AAAA,MACE,mCAAmC,GAAG;AAAA,IAAA;AAAA,EAE1C;AACF;AAEO,MAAM,8BAA8B,yBAAyB;AAAA,EAClE,YAAY,KAAsB,cAAsB;AACtD;AAAA,MACE,oCAAoC,GAAG,4DAA4D,YAAY;AAAA,IAAA;AAAA,EAEnH;AACF;AAEO,MAAM,mCAAmC,yBAAyB;AAAA,EACvE,cAAc;AACZ,UAAM,yCAAyC;AAAA,EACjD;AACF;AAEO,MAAM,kCAAkC,yBAAyB;AAAA,EACtE,cAAc;AACZ,UAAM,+BAA+B;AAAA,EACvC;AACF;AAEO,MAAM,+BAA+B,yBAAyB;AAAA,EACnE,YAAY,KAAsB;AAChC;AAAA,MACE,YAAY,GAAG;AAAA,IAAA;AAAA,EAEnB;AACF;AAEO,MAAM,iCAAiC,yBAAyB;AAAA,EACrE,YAAY,aAA8B,QAAyB;AACjE;AAAA,MACE,8DAA8D,WAAW,0BAA0B,MAAM;AAAA,IAAA;AAAA,EAE7G;AACF;AAEO,MAAM,kCAAkC,yBAAyB;AAAA,EACtE,cAAc;AACZ,UAAM,+BAA+B;AAAA,EACvC;AACF;AAEO,MAAM,+BAA+B,yBAAyB;AAAA,EACnE,YAAY,KAAsB;AAChC;AAAA,MACE,0CAA0C,GAAG;AAAA,IAAA;AAAA,EAEjD;AACF;AAGO,MAAM,4BAA4B,gBAAgB;AAAA,EACvD,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAEO,MAAM,kCAAkC,oBAAoB;AAAA,EACjE,cAAc;AACZ;AAAA,MACE;AAAA,IAAA;AAAA,EAEJ;AACF;AAEO,MAAM,kCAAkC,oBAAoB;AAAA,EACjE,cAAc;AACZ;AAAA,MACE;AAAA,IAAA;AAAA,EAEJ;AACF;AAEO,MAAM,kCAAkC,oBAAoB;AAAA,EACjE,cAAc;AACZ;AAAA,MACE;AAAA,IAAA;AAAA,EAEJ;AACF;AAGO,MAAM,yBAAyB,gBAAgB;AAAA,EACpD,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAEO,MAAM,qCAAqC,iBAAiB;AAAA,EACjE,cAAc;AACZ,UAAM,oDAAoD;AAAA,EAC5D;AACF;AAEO,MAAM,yCAAyC,iBAAiB;AAAA,EACrE,cAAc;AACZ;AAAA,MACE;AAAA,IAAA;AAAA,EAEJ;AACF;AAEO,MAAM,iDAAiD,iBAAiB;AAAA,EAC7E,cAAc;AACZ;AAAA,MACE;AAAA,IAAA;AAAA,EAEJ;AACF;AAEO,MAAM,yCAAyC,iBAAiB;AAAA,EACrE,cAAc;AACZ;AAAA,MACE;AAAA,IAAA;AAAA,EAEJ;AACF;AAEO,MAAM,2CAA2C,iBAAiB;AAAA,EACvE,cAAc;AACZ,UAAM,yCAAyC;AAAA,EACjD;AACF;AAEO,MAAM,kDAAkD,iBAAiB;AAAA,EAC9E,cAAc;AACZ;AAAA,MACE;AAAA,IAAA;AAAA,EAEJ;AACF;AAEO,MAAM,4CAA4C,iBAAiB;AAAA,EACxE,cAAc;AACZ,UAAM,uCAAuC;AAAA,EAC/C;AACF;AAEO,MAAM,6CAA6C,iBAAiB;AAAA,EACzE,cAAc;AACZ;AAAA,MACE;AAAA,IAAA;AAAA,EAEJ;AACF;AAGO,MAAM,0BAA0B,gBAAgB;AAAA,EACrD,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAEO,MAAM,kCAAkC,kBAAkB;AAAA,EAC/D,YAAY,SAAiB;AAC3B,UAAM,qCAAqC,OAAO,EAAE;AAAA,EACtD;AACF;AAEO,MAAM,wCAAwC,kBAAkB;AAAA,EACrE,YAAY,SAAiB;AAC3B,UAAM,2BAA2B,OAAO,iCAAiC;AAAA,EAC3E;AACF;AAEO,MAAM,2BAA2B,kBAAkB;AAAA,EACxD,cAAc;AACZ,UAAM,gBAAgB;AAAA,EACxB;AACF;AAEO,MAAM,yCAAyC,kBAAkB;AAAA,EACtE,cAAc;AACZ,UAAM,+CAA+C;AAAA,EACvD;AACF;AAEO,MAAM,qCAAqC,kBAAkB;AAAA,EAClE,cAAc;AACZ,UAAM,+BAA+B;AAAA,EACvC;AACF;AAGO,MAAM,8BAA8B,gBAAgB;AAAA,EACzD,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAEO,MAAM,oCAAoC,sBAAsB;AAAA,EACrE,cAAc;AACZ,UAAM,oCAAoC;AAAA,EAC5C;AACF;AAEO,MAAM,mCAAmC,sBAAsB;AAAA,EACpE,cAAc;AACZ,UAAM,wCAAwC;AAAA,EAChD;AACF;AAEO,MAAM,uCAAuC,sBAAsB;AAAA,EACxE,cAAc;AACZ;AAAA,MACE;AAAA,IAAA;AAAA,EAEJ;AACF;AAEO,MAAM,qCAAqC,sBAAsB;AAAA,EACtE,YAAY,cAAsB;AAChC,UAAM,yBAAyB,YAAY,2BAA2B;AAAA,EACxE;AACF;AAEO,MAAM,iCAAiC,sBAAsB;AAAA,EAClE,YAAY,MAAc;AACxB,UAAM,0BAA0B,IAAI,EAAE;AAAA,EACxC;AACF;AAEO,MAAM,mCAAmC,sBAAsB;AAAA,EACpE,YAAY,MAAc;AACxB,UAAM,4BAA4B,IAAI,EAAE;AAAA,EAC1C;AACF;AAEO,MAAM,gCAAgC,sBAAsB;AAAA,EACjE,cAAc;AACZ,UAAM,gCAAgC;AAAA,EACxC;AACF;AAEO,MAAM,6BAA6B,sBAAsB;AAAA,EAC9D,YAAY,cAAsB;AAChC,UAAM,qBAAqB,YAAY,EAAE;AAAA,EAC3C;AACF;AAGO,MAAM,kBAAkB,gBAAgB;AAAA,EAC7C,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAEO,MAAM,iCAAiC,UAAU;AAAA,EACtD,YAAY,UAAkB;AAC5B,UAAM,0BAA0B,QAAQ,EAAE;AAAA,EAC5C;AACF;AAEO,MAAM,2CAA2C,UAAU;AAAA,EAChE,YAAY,YAAoB;AAC9B;AAAA,MACE,qEAAqE,UAAU;AAAA,IAAA;AAAA,EAEnF;AACF;AAEO,MAAM,+CAA+C,UAAU;AAAA,EACpE,YAAY,gBAAwB,kBAA0B;AAC5D;AAAA,MACE,qEAAqE,cAAc,UAAU,gBAAgB;AAAA,IAAA;AAAA,EAEjH;AACF;AAEO,MAAM,6CAA6C,UAAU;AAAA,EAClE,YACE,gBACA,iBACA,gBACA,kBACA;AACA;AAAA,MACE,yDAAyD,cAAc,UAAU,eAAe,0BAA0B,cAAc,UAAU,gBAAgB;AAAA,IAAA;AAAA,EAEtK;AACF;AAEO,MAAM,uCAAuC,UAAU;AAAA,EAC5D,YAAY,MAAc;AACxB,UAAM,iCAAiC,IAAI,EAAE;AAAA,EAC/C;AACF;AAGO,MAAM,qBAAqB,gBAAgB;AAAA,EAChD,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAEO,MAAM,gDAAgD,aAAa;AAAA,EACxE,YAAY,OAAe;AACzB;AAAA,MACE,6BAA6B,KAAK;AAAA,IAAA;AAAA,EAEtC;AACF;AAEO,MAAM,0CAA0C,aAAa;AAAA,EAClE,YAAY,cAAsB;AAChC,UAAM,mCAAmC,YAAY,EAAE;AAAA,EACzD;AACF;AAEO,MAAM,0CAA0C,aAAa;AAAA,EAClE,YAAY,cAAsB;AAChC;AAAA,MACE,sEAAsE,YAAY;AAAA,IAAA;AAAA,EAEtF;AACF;AAEO,MAAM,yCAAyC,aAAa;AAAA,EACjE,YAAY,MAAc;AACxB,UAAM,6CAA6C,IAAI,EAAE;AAAA,EAC3D;AACF;AAGO,MAAM,qBAAqB,gBAAgB;AAAA,EAChD,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAEO,MAAM,2BAA2B,aAAa;AAAA,EACnD,YAAY,WAAmB,eAAuB;AACpD;AAAA,MACE,UAAU,SAAS,+CAA+C,aAAa;AAAA,IAAA;AAAA,EAEnF;AACF;AAGO,MAAM,oCAAoC,aAAa;AAAA,EAC5D,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAEO,MAAM,gCAAgC,4BAA4B;AAAA,EACvE,cAAc;AACZ,UAAM,uDAAuD;AAAA,EAC/D;AACF;AAEO,MAAM,gCAAgC,4BAA4B;AAAA,EACvE,cAAc;AACZ;AAAA,MACE;AAAA,IAAA;AAAA,EAEJ;AACF;AAEO,MAAM,+BAA+B,4BAA4B;AAAA,EACtE,cAAc;AACZ;AAAA,MACE;AAAA,IAAA;AAAA,EAEJ;AACF;AAEO,MAAM,sCAAsC,4BAA4B;AAAA,EAC7E,YAAY,YAAoB,KAAa;AAC3C;AAAA,MACE,gEAAgE,UAAU,cAAc,GAAG;AAAA,IAAA;AAAA,EAE/F;AACF;AAEO,MAAM,wCAAwC,4BAA4B;AAAA,EAC/E,YAAY,YAAoB;AAC9B;AAAA,MACE,gEAAgE,UAAU;AAAA,IAAA;AAAA,EAE9E;AACF;AAGO,MAAM,yBAAyB,gBAAgB;AAAA,EACpD,YAAY,cAAsB,OAAuB;AACvD,UAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AACrE;AAAA,MACE,eAAe,YAAY,2CAA2C,OAAO;AAAA,IAAA;AAE/E,SAAK,OAAO;AAAA,EACd;AACF;AAGO,MAAM,4BAA4B,gBAAgB;AAAA,EACvD,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAEO,MAAM,8CAA8C,oBAAoB;AAAA,EAC7E,cAAc;AACZ,UAAM,sCAAsC;AAAA,EAC9C;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/errors.d.cts

@@ -1,3 +1,227 @@
-export declare class NonRetriableError extends Error {
+export declare class TanStackDBError extends Error {
     constructor(message: string);
 }
+export declare class NonRetriableError extends TanStackDBError {
+    constructor(message: string);
+}
+export declare class SchemaValidationError extends TanStackDBError {
+    type: `insert` | `update`;
+    issues: ReadonlyArray<{
+        message: string;
+        path?: ReadonlyArray<string | number | symbol>;
+    }>;
+    constructor(type: `insert` | `update`, issues: ReadonlyArray<{
+        message: string;
+        path?: ReadonlyArray<string | number | symbol>;
+    }>, message?: string);
+}
+export declare class CollectionConfigurationError extends TanStackDBError {
+    constructor(message: string);
+}
+export declare class CollectionRequiresConfigError extends CollectionConfigurationError {
+    constructor();
+}
+export declare class CollectionRequiresSyncConfigError extends CollectionConfigurationError {
+    constructor();
+}
+export declare class InvalidSchemaError extends CollectionConfigurationError {
+    constructor();
+}
+export declare class SchemaMustBeSynchronousError extends CollectionConfigurationError {
+    constructor();
+}
+export declare class CollectionStateError extends TanStackDBError {
+    constructor(message: string);
+}
+export declare class CollectionInErrorStateError extends CollectionStateError {
+    constructor(operation: string, collectionId: string);
+}
+export declare class InvalidCollectionStatusTransitionError extends CollectionStateError {
+    constructor(from: string, to: string, collectionId: string);
+}
+export declare class CollectionIsInErrorStateError extends CollectionStateError {
+    constructor();
+}
+export declare class NegativeActiveSubscribersError extends CollectionStateError {
+    constructor();
+}
+export declare class CollectionOperationError extends TanStackDBError {
+    constructor(message: string);
+}
+export declare class UndefinedKeyError extends CollectionOperationError {
+    constructor(item: any);
+}
+export declare class DuplicateKeyError extends CollectionOperationError {
+    constructor(key: string | number);
+}
+export declare class DuplicateKeySyncError extends CollectionOperationError {
+    constructor(key: string | number, collectionId: string);
+}
+export declare class MissingUpdateArgumentError extends CollectionOperationError {
+    constructor();
+}
+export declare class NoKeysPassedToUpdateError extends CollectionOperationError {
+    constructor();
+}
+export declare class UpdateKeyNotFoundError extends CollectionOperationError {
+    constructor(key: string | number);
+}
+export declare class KeyUpdateNotAllowedError extends CollectionOperationError {
+    constructor(originalKey: string | number, newKey: string | number);
+}
+export declare class NoKeysPassedToDeleteError extends CollectionOperationError {
+    constructor();
+}
+export declare class DeleteKeyNotFoundError extends CollectionOperationError {
+    constructor(key: string | number);
+}
+export declare class MissingHandlerError extends TanStackDBError {
+    constructor(message: string);
+}
+export declare class MissingInsertHandlerError extends MissingHandlerError {
+    constructor();
+}
+export declare class MissingUpdateHandlerError extends MissingHandlerError {
+    constructor();
+}
+export declare class MissingDeleteHandlerError extends MissingHandlerError {
+    constructor();
+}
+export declare class TransactionError extends TanStackDBError {
+    constructor(message: string);
+}
+export declare class MissingMutationFunctionError extends TransactionError {
+    constructor();
+}
+export declare class TransactionNotPendingMutateError extends TransactionError {
+    constructor();
+}
+export declare class TransactionAlreadyCompletedRollbackError extends TransactionError {
+    constructor();
+}
+export declare class TransactionNotPendingCommitError extends TransactionError {
+    constructor();
+}
+export declare class NoPendingSyncTransactionWriteError extends TransactionError {
+    constructor();
+}
+export declare class SyncTransactionAlreadyCommittedWriteError extends TransactionError {
+    constructor();
+}
+export declare class NoPendingSyncTransactionCommitError extends TransactionError {
+    constructor();
+}
+export declare class SyncTransactionAlreadyCommittedError extends TransactionError {
+    constructor();
+}
+export declare class QueryBuilderError extends TanStackDBError {
+    constructor(message: string);
+}
+export declare class OnlyOneSourceAllowedError extends QueryBuilderError {
+    constructor(context: string);
+}
+export declare class SubQueryMustHaveFromClauseError extends QueryBuilderError {
+    constructor(context: string);
+}
+export declare class InvalidSourceError extends QueryBuilderError {
+    constructor();
+}
+export declare class JoinConditionMustBeEqualityError extends QueryBuilderError {
+    constructor();
+}
+export declare class QueryMustHaveFromClauseError extends QueryBuilderError {
+    constructor();
+}
+export declare class QueryCompilationError extends TanStackDBError {
+    constructor(message: string);
+}
+export declare class DistinctRequiresSelectError extends QueryCompilationError {
+    constructor();
+}
+export declare class HavingRequiresGroupByError extends QueryCompilationError {
+    constructor();
+}
+export declare class LimitOffsetRequireOrderByError extends QueryCompilationError {
+    constructor();
+}
+export declare class CollectionInputNotFoundError extends QueryCompilationError {
+    constructor(collectionId: string);
+}
+export declare class UnsupportedFromTypeError extends QueryCompilationError {
+    constructor(type: string);
+}
+export declare class UnknownExpressionTypeError extends QueryCompilationError {
+    constructor(type: string);
+}
+export declare class EmptyReferencePathError extends QueryCompilationError {
+    constructor();
+}
+export declare class UnknownFunctionError extends QueryCompilationError {
+    constructor(functionName: string);
+}
+export declare class JoinError extends TanStackDBError {
+    constructor(message: string);
+}
+export declare class UnsupportedJoinTypeError extends JoinError {
+    constructor(joinType: string);
+}
+export declare class InvalidJoinConditionSameTableError extends JoinError {
+    constructor(tableAlias: string);
+}
+export declare class InvalidJoinConditionTableMismatchError extends JoinError {
+    constructor(mainTableAlias: string, joinedTableAlias: string);
+}
+export declare class InvalidJoinConditionWrongTablesError extends JoinError {
+    constructor(leftTableAlias: string, rightTableAlias: string, mainTableAlias: string, joinedTableAlias: string);
+}
+export declare class UnsupportedJoinSourceTypeError extends JoinError {
+    constructor(type: string);
+}
+export declare class GroupByError extends TanStackDBError {
+    constructor(message: string);
+}
+export declare class NonAggregateExpressionNotInGroupByError extends GroupByError {
+    constructor(alias: string);
+}
+export declare class UnsupportedAggregateFunctionError extends GroupByError {
+    constructor(functionName: string);
+}
+export declare class AggregateFunctionNotInSelectError extends GroupByError {
+    constructor(functionName: string);
+}
+export declare class UnknownHavingExpressionTypeError extends GroupByError {
+    constructor(type: string);
+}
+export declare class StorageError extends TanStackDBError {
+    constructor(message: string);
+}
+export declare class SerializationError extends StorageError {
+    constructor(operation: string, originalError: string);
+}
+export declare class LocalStorageCollectionError extends StorageError {
+    constructor(message: string);
+}
+export declare class StorageKeyRequiredError extends LocalStorageCollectionError {
+    constructor();
+}
+export declare class NoStorageAvailableError extends LocalStorageCollectionError {
+    constructor();
+}
+export declare class NoStorageEventApiError extends LocalStorageCollectionError {
+    constructor();
+}
+export declare class InvalidStorageDataFormatError extends LocalStorageCollectionError {
+    constructor(storageKey: string, key: string);
+}
+export declare class InvalidStorageObjectFormatError extends LocalStorageCollectionError {
+    constructor(storageKey: string);
+}
+export declare class SyncCleanupError extends TanStackDBError {
+    constructor(collectionId: string, error: Error | string);
+}
+export declare class QueryOptimizerError extends TanStackDBError {
+    constructor(message: string);
+}
+export declare class CannotCombineEmptyExpressionListError extends QueryOptimizerError {
+    constructor();
+}

package/dist/cjs/index.cjs

@@ -3,23 +3,24 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const collection = require("./collection.cjs");
 const SortedMap = require("./SortedMap.cjs");
 const transactions = require("./transactions.cjs");
-const errors = require("./errors.cjs");
 const proxy = require("./proxy.cjs");
 const optimisticAction = require("./optimistic-action.cjs");
 const localOnly = require("./local-only.cjs");
 const localStorage = require("./local-storage.cjs");
+const errors = require("./errors.cjs");
+const baseIndex = require("./indexes/base-index.cjs");
+const orderedIndex = require("./indexes/ordered-index.cjs");
+const lazyIndex = require("./indexes/lazy-index.cjs");
 const index = require("./query/builder/index.cjs");
 const functions = require("./query/builder/functions.cjs");
 const index$1 = require("./query/compiler/index.cjs");
 const liveQueryCollection = require("./query/live-query-collection.cjs");
 exports.CollectionImpl = collection.CollectionImpl;
-exports.SchemaValidationError = collection.SchemaValidationError;
 exports.collectionsStore = collection.collectionsStore;
 exports.createCollection = collection.createCollection;
 exports.SortedMap = SortedMap.SortedMap;
 exports.createTransaction = transactions.createTransaction;
 exports.getActiveTransaction = transactions.getActiveTransaction;
-exports.NonRetriableError = errors.NonRetriableError;
 exports.createArrayChangeProxy = proxy.createArrayChangeProxy;
 exports.createChangeProxy = proxy.createChangeProxy;
 exports.withArrayChangeTracking = proxy.withArrayChangeTracking;
@@ -27,6 +28,84 @@ exports.withChangeTracking = proxy.withChangeTracking;
 exports.createOptimisticAction = optimisticAction.createOptimisticAction;
 exports.localOnlyCollectionOptions = localOnly.localOnlyCollectionOptions;
 exports.localStorageCollectionOptions = localStorage.localStorageCollectionOptions;
+exports.AggregateFunctionNotInSelectError = errors.AggregateFunctionNotInSelectError;
+exports.CannotCombineEmptyExpressionListError = errors.CannotCombineEmptyExpressionListError;
+exports.CollectionConfigurationError = errors.CollectionConfigurationError;
+exports.CollectionInErrorStateError = errors.CollectionInErrorStateError;
+exports.CollectionInputNotFoundError = errors.CollectionInputNotFoundError;
+exports.CollectionIsInErrorStateError = errors.CollectionIsInErrorStateError;
+exports.CollectionOperationError = errors.CollectionOperationError;
+exports.CollectionRequiresConfigError = errors.CollectionRequiresConfigError;
+exports.CollectionRequiresSyncConfigError = errors.CollectionRequiresSyncConfigError;
+exports.CollectionStateError = errors.CollectionStateError;
+exports.DeleteKeyNotFoundError = errors.DeleteKeyNotFoundError;
+exports.DistinctRequiresSelectError = errors.DistinctRequiresSelectError;
+exports.DuplicateKeyError = errors.DuplicateKeyError;
+exports.DuplicateKeySyncError = errors.DuplicateKeySyncError;
+exports.EmptyReferencePathError = errors.EmptyReferencePathError;
+exports.GroupByError = errors.GroupByError;
+exports.HavingRequiresGroupByError = errors.HavingRequiresGroupByError;
+exports.InvalidCollectionStatusTransitionError = errors.InvalidCollectionStatusTransitionError;
+exports.InvalidJoinConditionSameTableError = errors.InvalidJoinConditionSameTableError;
+exports.InvalidJoinConditionTableMismatchError = errors.InvalidJoinConditionTableMismatchError;
+exports.InvalidJoinConditionWrongTablesError = errors.InvalidJoinConditionWrongTablesError;
+exports.InvalidSchemaError = errors.InvalidSchemaError;
+exports.InvalidSourceError = errors.InvalidSourceError;
+exports.InvalidStorageDataFormatError = errors.InvalidStorageDataFormatError;
+exports.InvalidStorageObjectFormatError = errors.InvalidStorageObjectFormatError;
+exports.JoinConditionMustBeEqualityError = errors.JoinConditionMustBeEqualityError;
+exports.JoinError = errors.JoinError;
+exports.KeyUpdateNotAllowedError = errors.KeyUpdateNotAllowedError;
+exports.LimitOffsetRequireOrderByError = errors.LimitOffsetRequireOrderByError;
+exports.LocalStorageCollectionError = errors.LocalStorageCollectionError;
+exports.MissingDeleteHandlerError = errors.MissingDeleteHandlerError;
+exports.MissingHandlerError = errors.MissingHandlerError;
+exports.MissingInsertHandlerError = errors.MissingInsertHandlerError;
+exports.MissingMutationFunctionError = errors.MissingMutationFunctionError;
+exports.MissingUpdateArgumentError = errors.MissingUpdateArgumentError;
+exports.MissingUpdateHandlerError = errors.MissingUpdateHandlerError;
+exports.NegativeActiveSubscribersError = errors.NegativeActiveSubscribersError;
+exports.NoKeysPassedToDeleteError = errors.NoKeysPassedToDeleteError;
+exports.NoKeysPassedToUpdateError = errors.NoKeysPassedToUpdateError;
+exports.NoPendingSyncTransactionCommitError = errors.NoPendingSyncTransactionCommitError;
+exports.NoPendingSyncTransactionWriteError = errors.NoPendingSyncTransactionWriteError;
+exports.NoStorageAvailableError = errors.NoStorageAvailableError;
+exports.NoStorageEventApiError = errors.NoStorageEventApiError;
+exports.NonAggregateExpressionNotInGroupByError = errors.NonAggregateExpressionNotInGroupByError;
+exports.NonRetriableError = errors.NonRetriableError;
+exports.OnlyOneSourceAllowedError = errors.OnlyOneSourceAllowedError;
+exports.QueryBuilderError = errors.QueryBuilderError;
+exports.QueryCompilationError = errors.QueryCompilationError;
+exports.QueryMustHaveFromClauseError = errors.QueryMustHaveFromClauseError;
+exports.QueryOptimizerError = errors.QueryOptimizerError;
+exports.SchemaMustBeSynchronousError = errors.SchemaMustBeSynchronousError;
+exports.SchemaValidationError = errors.SchemaValidationError;
+exports.SerializationError = errors.SerializationError;
+exports.StorageError = errors.StorageError;
+exports.StorageKeyRequiredError = errors.StorageKeyRequiredError;
+exports.SubQueryMustHaveFromClauseError = errors.SubQueryMustHaveFromClauseError;
+exports.SyncCleanupError = errors.SyncCleanupError;
+exports.SyncTransactionAlreadyCommittedError = errors.SyncTransactionAlreadyCommittedError;
+exports.SyncTransactionAlreadyCommittedWriteError = errors.SyncTransactionAlreadyCommittedWriteError;
+exports.TanStackDBError = errors.TanStackDBError;
+exports.TransactionAlreadyCompletedRollbackError = errors.TransactionAlreadyCompletedRollbackError;
+exports.TransactionError = errors.TransactionError;
+exports.TransactionNotPendingCommitError = errors.TransactionNotPendingCommitError;
+exports.TransactionNotPendingMutateError = errors.TransactionNotPendingMutateError;
+exports.UndefinedKeyError = errors.UndefinedKeyError;
+exports.UnknownExpressionTypeError = errors.UnknownExpressionTypeError;
+exports.UnknownFunctionError = errors.UnknownFunctionError;
+exports.UnknownHavingExpressionTypeError = errors.UnknownHavingExpressionTypeError;
+exports.UnsupportedAggregateFunctionError = errors.UnsupportedAggregateFunctionError;
+exports.UnsupportedFromTypeError = errors.UnsupportedFromTypeError;
+exports.UnsupportedJoinSourceTypeError = errors.UnsupportedJoinSourceTypeError;
+exports.UnsupportedJoinTypeError = errors.UnsupportedJoinTypeError;
+exports.UpdateKeyNotFoundError = errors.UpdateKeyNotFoundError;
+exports.BaseIndex = baseIndex.BaseIndex;
+exports.IndexOperation = baseIndex.IndexOperation;
+exports.OrderedIndex = orderedIndex.OrderedIndex;
+exports.IndexProxy = lazyIndex.IndexProxy;
+exports.LazyIndexWrapper = lazyIndex.LazyIndexWrapper;
 exports.BaseQueryBuilder = index.BaseQueryBuilder;
 exports.Query = index.Query;
 exports.add = functions.add;

package/dist/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/index.d.cts

@@ -2,10 +2,14 @@ export * from './collection.cjs';
 export * from './SortedMap.cjs';
 export * from './transactions.cjs';
 export * from './types.cjs';
-export * from './errors.cjs';
 export * from './proxy.cjs';
 export * from './query/index.js';
 export * from './optimistic-action.cjs';
 export * from './local-only.cjs';
 export * from './local-storage.cjs';
+export * from './errors.cjs';
+export * from './indexes/base-index.js';
+export * from './indexes/ordered-index.js';
+export * from './indexes/lazy-index.js';
+export { type IndexOptions } from './indexes/index-options.js';
 export type { Collection } from './collection.cjs';

package/dist/cjs/indexes/auto-index.cjs

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const orderedIndex = require("./ordered-index.cjs");
+function ensureIndexForExpression(expression, collection) {
+  if (collection.config.autoIndex !== `eager`) {
+    return;
+  }
+  if (collection.status === `loading` || collection.status === `initialCommit`) {
+    return;
+  }
+  const indexableExpressions = extractIndexableExpressions(expression);
+  for (const { fieldName, fieldPath } of indexableExpressions) {
+    const existingIndex = Array.from(collection.indexes.values()).find(
+      (index) => index.matchesField(fieldPath)
+    );
+    if (existingIndex) {
+      continue;
+    }
+    try {
+      collection.createIndex((row) => row[fieldName], {
+        name: `auto_${fieldName}`,
+        indexType: orderedIndex.OrderedIndex
+      });
+    } catch (error) {
+      console.warn(
+        `Failed to create auto-index for field "${fieldName}":`,
+        error
+      );
+    }
+  }
+}
+function extractIndexableExpressions(expression) {
+  const results = [];
+  function extractFromExpression(expr) {
+    if (expr.type !== `func`) {
+      return;
+    }
+    const func = expr;
+    if (func.name === `and`) {
+      for (const arg of func.args) {
+        extractFromExpression(arg);
+      }
+      return;
+    }
+    const supportedOperations = [`eq`, `gt`, `gte`, `lt`, `lte`, `in`];
+    if (!supportedOperations.includes(func.name)) {
+      return;
+    }
+    if (func.args.length < 1 || func.args[0].type !== `ref`) {
+      return;
+    }
+    const fieldRef = func.args[0];
+    const fieldPath = fieldRef.path;
+    if (fieldPath.length !== 1) {
+      return;
+    }
+    const fieldName = fieldPath[0];
+    results.push({ fieldName, fieldPath });
+  }
+  extractFromExpression(expression);
+  return results;
+}
+exports.ensureIndexForExpression = ensureIndexForExpression;
+//# sourceMappingURL=auto-index.cjs.map

package/dist/cjs/indexes/auto-index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-index.cjs","sources":["../../../src/indexes/auto-index.ts"],"sourcesContent":["import { OrderedIndex } from \"./ordered-index\"\nimport type { BasicExpression } from \"../query/ir\"\nimport type { CollectionImpl } from \"../collection\"\n\nexport interface AutoIndexConfig {\n  autoIndex?: `off` | `eager`\n}\n\n/**\n * Analyzes a where expression and creates indexes for all simple operations on single fields\n */\nexport function ensureIndexForExpression<\n  T extends Record<string, any>,\n  TKey extends string | number,\n>(\n  expression: BasicExpression,\n  collection: CollectionImpl<T, TKey, any, any, any>\n): void {\n  // Only proceed if auto-indexing is enabled\n  if (collection.config.autoIndex !== `eager`) {\n    return\n  }\n\n  // Don't auto-index during sync operations\n  if (\n    collection.status === `loading` ||\n    collection.status === `initialCommit`\n  ) {\n    return\n  }\n\n  // Extract all indexable expressions and create indexes for them\n  const indexableExpressions = extractIndexableExpressions(expression)\n\n  for (const { fieldName, fieldPath } of indexableExpressions) {\n    // Check if we already have an index for this field\n    const existingIndex = Array.from(collection.indexes.values()).find(\n      (index) => index.matchesField(fieldPath)\n    )\n\n    if (existingIndex) {\n      continue // Index already exists\n    }\n\n    // Create a new index for this field using the collection's createIndex method\n    try {\n      collection.createIndex((row) => (row as any)[fieldName], {\n        name: `auto_${fieldName}`,\n        indexType: OrderedIndex,\n      })\n    } catch (error) {\n      console.warn(\n        `Failed to create auto-index for field \"${fieldName}\":`,\n        error\n      )\n    }\n  }\n}\n\n/**\n * Extracts all indexable expressions from a where expression\n */\nfunction extractIndexableExpressions(\n  expression: BasicExpression\n): Array<{ fieldName: string; fieldPath: Array<string> }> {\n  const results: Array<{ fieldName: string; fieldPath: Array<string> }> = []\n\n  function extractFromExpression(expr: BasicExpression): void {\n    if (expr.type !== `func`) {\n      return\n    }\n\n    const func = expr as any\n\n    // Handle 'and' expressions by recursively processing all arguments\n    if (func.name === `and`) {\n      for (const arg of func.args) {\n        extractFromExpression(arg)\n      }\n      return\n    }\n\n    // Check if this is a supported operation\n    const supportedOperations = [`eq`, `gt`, `gte`, `lt`, `lte`, `in`]\n    if (!supportedOperations.includes(func.name)) {\n      return\n    }\n\n    // Check if the first argument is a property reference (single field)\n    if (func.args.length < 1 || func.args[0].type !== `ref`) {\n      return\n    }\n\n    const fieldRef = func.args[0]\n    const fieldPath = fieldRef.path\n\n    // Skip if it's not a simple field (e.g., nested properties or array access)\n    if (fieldPath.length !== 1) {\n      return\n    }\n\n    const fieldName = fieldPath[0]\n    results.push({ fieldName, fieldPath })\n  }\n\n  extractFromExpression(expression)\n  return results\n}\n"],"names":["OrderedIndex"],"mappings":";;;AAWO,SAAS,yBAId,YACA,YACM;AAEN,MAAI,WAAW,OAAO,cAAc,SAAS;AAC3C;AAAA,EACF;AAGA,MACE,WAAW,WAAW,aACtB,WAAW,WAAW,iBACtB;AACA;AAAA,EACF;AAGA,QAAM,uBAAuB,4BAA4B,UAAU;AAEnE,aAAW,EAAE,WAAW,UAAA,KAAe,sBAAsB;AAE3D,UAAM,gBAAgB,MAAM,KAAK,WAAW,QAAQ,OAAA,CAAQ,EAAE;AAAA,MAC5D,CAAC,UAAU,MAAM,aAAa,SAAS;AAAA,IAAA;AAGzC,QAAI,eAAe;AACjB;AAAA,IACF;AAGA,QAAI;AACF,iBAAW,YAAY,CAAC,QAAS,IAAY,SAAS,GAAG;AAAA,QACvD,MAAM,QAAQ,SAAS;AAAA,QACvB,WAAWA,aAAAA;AAAAA,MAAA,CACZ;AAAA,IACH,SAAS,OAAO;AACd,cAAQ;AAAA,QACN,0CAA0C,SAAS;AAAA,QACnD;AAAA,MAAA;AAAA,IAEJ;AAAA,EACF;AACF;AAKA,SAAS,4BACP,YACwD;AACxD,QAAM,UAAkE,CAAA;AAExE,WAAS,sBAAsB,MAA6B;AAC1D,QAAI,KAAK,SAAS,QAAQ;AACxB;AAAA,IACF;AAEA,UAAM,OAAO;AAGb,QAAI,KAAK,SAAS,OAAO;AACvB,iBAAW,OAAO,KAAK,MAAM;AAC3B,8BAAsB,GAAG;AAAA,MAC3B;AACA;AAAA,IACF;AAGA,UAAM,sBAAsB,CAAC,MAAM,MAAM,OAAO,MAAM,OAAO,IAAI;AACjE,QAAI,CAAC,oBAAoB,SAAS,KAAK,IAAI,GAAG;AAC5C;AAAA,IACF;AAGA,QAAI,KAAK,KAAK,SAAS,KAAK,KAAK,KAAK,CAAC,EAAE,SAAS,OAAO;AACvD;AAAA,IACF;AAEA,UAAM,WAAW,KAAK,KAAK,CAAC;AAC5B,UAAM,YAAY,SAAS;AAG3B,QAAI,UAAU,WAAW,GAAG;AAC1B;AAAA,IACF;AAEA,UAAM,YAAY,UAAU,CAAC;AAC7B,YAAQ,KAAK,EAAE,WAAW,UAAA,CAAW;AAAA,EACvC;AAEA,wBAAsB,UAAU;AAChC,SAAO;AACT;;"}

package/dist/cjs/indexes/auto-index.d.cts

@@ -0,0 +1,9 @@
+import { BasicExpression } from '../query/ir.cjs';
+import { CollectionImpl } from '../collection.cjs';
+export interface AutoIndexConfig {
+    autoIndex?: `off` | `eager`;
+}
+/**
+ * Analyzes a where expression and creates indexes for all simple operations on single fields
+ */
+export declare function ensureIndexForExpression<T extends Record<string, any>, TKey extends string | number>(expression: BasicExpression, collection: CollectionImpl<T, TKey, any, any, any>): void;

package/dist/cjs/indexes/base-index.cjs

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const evaluators = require("../query/compiler/evaluators.cjs");
+const functions = require("../query/builder/functions.cjs");
+const IndexOperation = functions.comparisonFunctions;
+class BaseIndex {
+  constructor(id, expression, name, options) {
+    this.lookupCount = 0;
+    this.totalLookupTime = 0;
+    this.lastUpdated = /* @__PURE__ */ new Date();
+    this.id = id;
+    this.expression = expression;
+    this.name = name;
+    this.initialize(options);
+  }
+  // Common methods
+  supports(operation) {
+    return this.supportedOperations.has(operation);
+  }
+  matchesField(fieldPath) {
+    return this.expression.type === `ref` && this.expression.path.length === fieldPath.length && this.expression.path.every((part, i) => part === fieldPath[i]);
+  }
+  getStats() {
+    return {
+      entryCount: this.keyCount,
+      lookupCount: this.lookupCount,
+      averageLookupTime: this.lookupCount > 0 ? this.totalLookupTime / this.lookupCount : 0,
+      lastUpdated: this.lastUpdated
+    };
+  }
+  evaluateIndexExpression(item) {
+    const evaluator = evaluators.compileSingleRowExpression(this.expression);
+    return evaluator(item);
+  }
+  trackLookup(startTime) {
+    const duration = performance.now() - startTime;
+    this.lookupCount++;
+    this.totalLookupTime += duration;
+  }
+  updateTimestamp() {
+    this.lastUpdated = /* @__PURE__ */ new Date();
+  }
+}
+exports.BaseIndex = BaseIndex;
+exports.IndexOperation = IndexOperation;
+//# sourceMappingURL=base-index.cjs.map

package/dist/cjs/indexes/base-index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-index.cjs","sources":["../../../src/indexes/base-index.ts"],"sourcesContent":["import { compileSingleRowExpression } from \"../query/compiler/evaluators.js\"\nimport { comparisonFunctions } from \"../query/builder/functions.js\"\nimport type { BasicExpression } from \"../query/ir.js\"\n\n/**\n * Operations that indexes can support, imported from available comparison functions\n */\nexport const IndexOperation = comparisonFunctions\n\n/**\n * Type for index operation values\n */\nexport type IndexOperation = (typeof comparisonFunctions)[number]\n\n/**\n * Statistics about index usage and performance\n */\nexport interface IndexStats {\n  readonly entryCount: number\n  readonly lookupCount: number\n  readonly averageLookupTime: number\n  readonly lastUpdated: Date\n}\n\n/**\n * Base abstract class that all index types extend\n */\nexport abstract class BaseIndex<\n  TKey extends string | number = string | number,\n> {\n  public readonly id: number\n  public readonly name?: string\n  public readonly expression: BasicExpression\n  public abstract readonly supportedOperations: Set<IndexOperation>\n\n  protected lookupCount = 0\n  protected totalLookupTime = 0\n  protected lastUpdated = new Date()\n\n  constructor(\n    id: number,\n    expression: BasicExpression,\n    name?: string,\n    options?: any\n  ) {\n    this.id = id\n    this.expression = expression\n    this.name = name\n    this.initialize(options)\n  }\n\n  // Abstract methods that each index type must implement\n  abstract add(key: TKey, item: any): void\n  abstract remove(key: TKey, item: any): void\n  abstract update(key: TKey, oldItem: any, newItem: any): void\n  abstract build(entries: Iterable<[TKey, any]>): void\n  abstract clear(): void\n  abstract lookup(operation: IndexOperation, value: any): Set<TKey>\n  abstract get keyCount(): number\n\n  // Common methods\n  supports(operation: IndexOperation): boolean {\n    return this.supportedOperations.has(operation)\n  }\n\n  matchesField(fieldPath: Array<string>): boolean {\n    return (\n      this.expression.type === `ref` &&\n      this.expression.path.length === fieldPath.length &&\n      this.expression.path.every((part, i) => part === fieldPath[i])\n    )\n  }\n\n  getStats(): IndexStats {\n    return {\n      entryCount: this.keyCount,\n      lookupCount: this.lookupCount,\n      averageLookupTime:\n        this.lookupCount > 0 ? this.totalLookupTime / this.lookupCount : 0,\n      lastUpdated: this.lastUpdated,\n    }\n  }\n\n  // Protected methods for subclasses\n  protected abstract initialize(options?: any): void\n\n  protected evaluateIndexExpression(item: any): any {\n    const evaluator = compileSingleRowExpression(this.expression)\n    return evaluator(item as Record<string, unknown>)\n  }\n\n  protected trackLookup(startTime: number): void {\n    const duration = performance.now() - startTime\n    this.lookupCount++\n    this.totalLookupTime += duration\n  }\n\n  protected updateTimestamp(): void {\n    this.lastUpdated = new Date()\n  }\n}\n\n/**\n * Type for index constructor\n */\nexport type IndexConstructor<TKey extends string | number = string | number> =\n  new (\n    id: number,\n    expression: BasicExpression,\n    name?: string,\n    options?: any\n  ) => BaseIndex<TKey>\n\n/**\n * Index resolver can be either a class constructor or async loader\n */\nexport type IndexResolver<TKey extends string | number = string | number> =\n  | IndexConstructor<TKey>\n  | (() => Promise<IndexConstructor<TKey>>)\n"],"names":["comparisonFunctions","compileSingleRowExpression"],"mappings":";;;;AAOO,MAAM,iBAAiBA,UAAAA;AAoBvB,MAAe,UAEpB;AAAA,EAUA,YACE,IACA,YACA,MACA,SACA;AATF,SAAU,cAAc;AACxB,SAAU,kBAAkB;AAC5B,SAAU,kCAAkB,KAAA;AAQ1B,SAAK,KAAK;AACV,SAAK,aAAa;AAClB,SAAK,OAAO;AACZ,SAAK,WAAW,OAAO;AAAA,EACzB;AAAA;AAAA,EAYA,SAAS,WAAoC;AAC3C,WAAO,KAAK,oBAAoB,IAAI,SAAS;AAAA,EAC/C;AAAA,EAEA,aAAa,WAAmC;AAC9C,WACE,KAAK,WAAW,SAAS,SACzB,KAAK,WAAW,KAAK,WAAW,UAAU,UAC1C,KAAK,WAAW,KAAK,MAAM,CAAC,MAAM,MAAM,SAAS,UAAU,CAAC,CAAC;AAAA,EAEjE;AAAA,EAEA,WAAuB;AACrB,WAAO;AAAA,MACL,YAAY,KAAK;AAAA,MACjB,aAAa,KAAK;AAAA,MAClB,mBACE,KAAK,cAAc,IAAI,KAAK,kBAAkB,KAAK,cAAc;AAAA,MACnE,aAAa,KAAK;AAAA,IAAA;AAAA,EAEtB;AAAA,EAKU,wBAAwB,MAAgB;AAChD,UAAM,YAAYC,WAAAA,2BAA2B,KAAK,UAAU;AAC5D,WAAO,UAAU,IAA+B;AAAA,EAClD;AAAA,EAEU,YAAY,WAAyB;AAC7C,UAAM,WAAW,YAAY,IAAA,IAAQ;AACrC,SAAK;AACL,SAAK,mBAAmB;AAAA,EAC1B;AAAA,EAEU,kBAAwB;AAChC,SAAK,kCAAkB,KAAA;AAAA,EACzB;AACF;;;"}

package/dist/cjs/indexes/base-index.d.cts

@@ -0,0 +1,54 @@
+import { comparisonFunctions } from '../query/builder/functions.js';
+import { BasicExpression } from '../query/ir.js';
+/**
+ * Operations that indexes can support, imported from available comparison functions
+ */
+export declare const IndexOperation: readonly ["eq", "gt", "gte", "lt", "lte", "in", "like", "ilike"];
+/**
+ * Type for index operation values
+ */
+export type IndexOperation = (typeof comparisonFunctions)[number];
+/**
+ * Statistics about index usage and performance
+ */
+export interface IndexStats {
+    readonly entryCount: number;
+    readonly lookupCount: number;
+    readonly averageLookupTime: number;
+    readonly lastUpdated: Date;
+}
+/**
+ * Base abstract class that all index types extend
+ */
+export declare abstract class BaseIndex<TKey extends string | number = string | number> {
+    readonly id: number;
+    readonly name?: string;
+    readonly expression: BasicExpression;
+    abstract readonly supportedOperations: Set<IndexOperation>;
+    protected lookupCount: number;
+    protected totalLookupTime: number;
+    protected lastUpdated: Date;
+    constructor(id: number, expression: BasicExpression, name?: string, options?: any);
+    abstract add(key: TKey, item: any): void;
+    abstract remove(key: TKey, item: any): void;
+    abstract update(key: TKey, oldItem: any, newItem: any): void;
+    abstract build(entries: Iterable<[TKey, any]>): void;
+    abstract clear(): void;
+    abstract lookup(operation: IndexOperation, value: any): Set<TKey>;
+    abstract get keyCount(): number;
+    supports(operation: IndexOperation): boolean;
+    matchesField(fieldPath: Array<string>): boolean;
+    getStats(): IndexStats;
+    protected abstract initialize(options?: any): void;
+    protected evaluateIndexExpression(item: any): any;
+    protected trackLookup(startTime: number): void;
+    protected updateTimestamp(): void;
+}
+/**
+ * Type for index constructor
+ */
+export type IndexConstructor<TKey extends string | number = string | number> = new (id: number, expression: BasicExpression, name?: string, options?: any) => BaseIndex<TKey>;
+/**
+ * Index resolver can be either a class constructor or async loader
+ */
+export type IndexResolver<TKey extends string | number = string | number> = IndexConstructor<TKey> | (() => Promise<IndexConstructor<TKey>>);

package/dist/cjs/indexes/index-options.d.cts

@@ -0,0 +1,13 @@
+import { IndexConstructor, IndexResolver } from './base-index.js';
+/**
+ * Enhanced index options that support both sync and async resolvers
+ */
+export interface IndexOptions<TResolver extends IndexResolver = IndexResolver> {
+    name?: string;
+    indexType?: TResolver;
+    options?: TResolver extends IndexConstructor<any> ? TResolver extends new (id: string, expr: any, name?: string, options?: infer O) => any ? O : never : TResolver extends () => Promise<infer TCtor> ? TCtor extends new (id: string, expr: any, name?: string, options?: infer O) => any ? O : never : never;
+}
+/**
+ * Utility type to extract the constructed index type from a resolver
+ */
+export type ResolvedIndexType<TResolver extends IndexResolver> = TResolver extends IndexConstructor<any> ? InstanceType<TResolver> : TResolver extends () => Promise<IndexConstructor<any>> ? TResolver extends () => Promise<infer TCtor> ? TCtor extends IndexConstructor<any> ? InstanceType<TCtor> : never : never : never;