locality-idb 1.1.1 → 1.2.0

package/README.md

@@ -196,26 +196,182 @@ const multiPkSchema = defineSchema({
 
 Locality IDB supports a wide range of column types:
 
-| Type                   | Description                                                | Example                            |
-| ---------------------- | ---------------------------------------------------------- | ---------------------------------- |
-| `number()` / `float()` | Numeric values (integer or float)                          | `column.int()`                     |
-| `int()`                | Numeric values (only integer is allowed)                   | `column.int()`                     |
-| `numeric()`            | Number or numeric string                                   | `column.numeric()`                 |
-| `bigint()`             | Large integers                                             | `column.bigint()`                  |
-| `text()` / `string()`  | Text strings                                               | `column.text()`                    |
-| `char(length?)`        | Fixed-length string                                        | `column.char(10)`                  |
-| `varchar(length?)`     | Variable-length string                                     | `column.varchar(255)`              |
-| `bool()` / `boolean()` | Boolean values                                             | `column.bool()`                    |
-| `date()`               | Date objects                                               | `column.date()`                    |
-| `timestamp()`          | ISO 8601 timestamps ([auto-generated](#utility-functions)) | `column.timestamp()`               |
-| `uuid()`               | UUID strings ([auto-generated](#utility-functions) v4)     | `column.uuid()`                    |
-| `object<T>()`          | Generic objects                                            | `column.object<UserData>()`        |
-| `array<T>()`           | Arrays                                                     | `column.array<number>()`           |
-| `list<T>()`            | Read-only arrays                                           | `column.list<string>()`            |
-| `tuple<T>()`           | Fixed-size tuples                                          | `column.tuple<[string, number]>()` |
-| `set<T>()`             | Sets                                                       | `column.set<string>()`             |
-| `map<K,V>()`           | Maps                                                       | `column.map<string, number>()`     |
-| `custom<T>()`          | Custom types                                               | `column.custom<MyType>()`          |
+| Type                   | Description                                                | Example                          |
+| ---------------------- | ---------------------------------------------------------- | -------------------------------- |
+| `number()` / `float()` | Numeric values (integer or float)                          | `column.number()`                |
+| `int()`                | Numeric values (only integer is allowed)                   | `column.int()`                   |
+| `numeric()`            | Number or numeric string                                   | `column.numeric()`               |
+| `bigint()`             | Large integers                                             | `column.bigint()`                |
+| `text()` / `string()`  | Text strings                                               | `column.text()`                  |
+| `char(length?)`        | Fixed-length string                                        | `column.char(10)`                |
+| `varchar(length?)`     | Variable-length string                                     | `column.varchar(255)`            |
+| `bool()` / `boolean()` | Boolean values                                             | `column.bool()`                  |
+| `date()`               | Date objects                                               | `column.date()`                  |
+| `timestamp()`          | ISO 8601 timestamps ([auto-generated](#utility-functions)) | `column.timestamp()`             |
+| `uuid()`               | UUID strings ([auto-generated](#utility-functions) v4)     | `column.uuid()`                  |
+| `object<T>()`          | Generic objects                                            | `column.object<UserData>()`      |
+| `array<T>()`           | Arrays                                                     | `column.array<number>()`         |
+| `list<T>()`            | Read-only arrays                                           | `column.list<string>()`          |
+| `tuple<T>()`           | Fixed-size tuples                                          | `column.tuple<string, number>()` |
+| `set<T>()`             | Sets                                                       | `column.set<string>()`           |
+| `map<K,V>()`           | Maps                                                       | `column.map<string, number>()`   |
+| `custom<T>()`          | Custom types                                               | `column.custom<MyType>()`        |
+
+#### Type Extensions
+
+Most column types support **generic type parameters** for creating branded types, literal unions, or domain-specific types:
+
+##### Numeric Types (`int`, `float`, `number`)
+
+```typescript
+// Basic usage
+const age = column.int();
+const price = column.float();
+const score = column.number();
+
+// Branded types for type safety
+type UserId = Branded<number, 'UserId'>;
+type ProductId = Branded<number, 'ProductId'>;
+
+const schema = defineSchema({
+  users: {
+    id: column.int<UserId>().pk().auto(),
+    age: column.int(),
+  },
+  products: {
+    id: column.int<ProductId>().pk().auto(),
+    userId: column.int<UserId>(), // Type-safe foreign key
+    price: column.float(),
+  },
+});
+
+// ✅ Type safety prevents mixing IDs
+const userId: UserId = 1 as UserId;
+const productId: ProductId = 2 as ProductId;
+// userId = productId; // ❌ Type error!
+```
+
+##### String Types (`text`, `string`, `char`, `varchar`)
+
+```typescript
+// Literal unions for enum-like behavior
+type Role = 'admin' | 'user' | 'guest';
+type Status = 'draft' | 'published' | 'archived';
+
+const schema = defineSchema({
+  users: {
+    id: column.int().pk().auto(),
+    role: column.text<Role>().default('user'),
+    status: column.string<Status>().default('draft'),
+  },
+});
+
+// Branded types for domain-specific strings
+type Email = Branded<string, 'Email'>;
+type URL = Branded<string, 'URL'>;
+
+const profileSchema = defineSchema({
+  profiles: {
+    id: column.int().pk().auto(),
+    email: column.varchar<Email>(255).unique(),
+    website: column.varchar<URL>(500).optional(),
+  },
+});
+```
+
+##### Boolean Types (`bool`, `boolean`)
+
+```typescript
+// Branded booleans for clarity
+type EmailVerified = Branded<boolean, 'EmailVerified'>;
+type TwoFactorEnabled = Branded<boolean, 'TwoFactorEnabled'>;
+
+const schema = defineSchema({
+  users: {
+    id: column.int().pk().auto(),
+    emailVerified: column.bool<EmailVerified>().default(false as EmailVerified),
+    twoFactorEnabled: column.boolean<TwoFactorEnabled>().default(false as TwoFactorEnabled),
+  },
+});
+```
+
+##### Complex Types (`object`, `array`, `list`, `tuple`, `set`, `map`)
+
+```typescript
+// Object with typed structure
+interface UserProfile {
+  avatar: string;
+  bio: string;
+  socials: {
+    twitter?: string;
+    github?: string;
+  };
+}
+
+// Array of typed elements
+interface Comment {
+  author: string;
+  text: string;
+  date: string;
+}
+
+// Map with typed keys and values
+interface CacheEntry {
+  value: any;
+  expires: number;
+}
+
+const schema = defineSchema({
+  users: {
+    id: column.int().pk().auto(),
+    profile: column.object<UserProfile>(),
+    tags: column.array<string>(),
+    comments: column.array<Comment>(),
+    permissions: column.set<'read' | 'write' | 'delete'>(),
+    cache: column.map<string, CacheEntry>(),
+  },
+  
+  // Tuples for fixed structures
+  locations: {
+    id: column.int().pk().auto(),
+    coordinates: column.tuple<number, number>(), // [latitude, longitude]
+    rgbColor: column.tuple<number, number, number>(), // [r, g, b]
+  },
+  
+  // List (readonly array)
+  config: {
+    id: column.int().pk().auto(),
+    allowedOrigins: column.list<string>(), // Immutable at type level
+  },
+});
+```
+
+##### Numeric & Bigint with `Numeric` & `bigint` Types
+
+```typescript
+// Numeric accepts both number and numeric strings
+const schema = defineSchema({
+  products: {
+    id: column.int().pk().auto(),
+    serialNumber: column.numeric(), // Can be 123 or "123"
+    largeId: column.bigint(), // For very large integers
+  },
+});
+
+// Branded Numeric types
+type SerialNumber = Branded<Numeric, 'SerialNumber'>;
+type SnowflakeId = Branded<bigint, 'SnowflakeId'>;
+
+const advancedSchema = defineSchema({
+  items: {
+    id: column.int().pk().auto(),
+    serial: column.numeric<SerialNumber>(),
+    snowflake: column.bigint<SnowflakeId>(),
+  },
+});
+```
+
+> **Note:** Type extensions are compile-time only and do not affect runtime validation. Use [custom validators](#validatevalidator-value-t--string--null--undefined-column) for runtime type enforcement.
 
 ### Type Inference
 
@@ -340,6 +496,7 @@ const allUsers = await db.from('users').findAll();
 #### Filter with Where
 
 ```typescript
+// Predicate-based filtering (in-memory)
 const admins = await db
   .from('users')
   .where((user) => user.role === 'admin')
@@ -349,6 +506,18 @@ const activeUsers = await db
   .from('users')
   .where((user) => user.isActive && user.age >= 18)
   .findAll();
+
+// Index-based filtering (optimized) - requires index or primary key
+const usersByEmail = await db
+  .from('users')
+  .where('email', 'alice@example.com')
+  .findAll();
+
+// Range queries with IDBKeyRange
+const adults = await db
+  .from('users')
+  .where('age', IDBKeyRange.bound(18, 65))
+  .findAll();
 ```
 
 #### Select Specific Columns
@@ -627,7 +796,7 @@ Gets the underlying `IDBDatabase` instance.
 const idb = await db.getDBInstance();
 ```
 
-#### `seed<T>(table: T, data: InferInsertType<Schema[T]> | InferInsertType<Schema[T]>[]): Promise<InferSelectType<Schema[T]> | InferSelectType<Schema[T]>[]>`
+#### `seed<T>(table: T, data: InferInsertType<Schema[T]>[]): Promise<InferSelectType<Schema[T]>[]>`
 
 Inserts seed data into the specified table.
 
@@ -636,13 +805,14 @@ Inserts seed data into the specified table.
 > - This is a convenience method for inserting initial data.
 > - It uses the `insert` method internally.
 > - It does not clear existing data before inserting.
+> - Accepts only an **array** of records (for single record insertion, use `insert().values().run()`)
 
 **Parameters:**
 
 - `table`: Table name
-- `data`: Single record or array of records to insert
+- `data`: Array of records to insert
 
-**Returns:** Inserted record(s)
+**Returns:** Array of inserted record(s)
 
 **Example:**
 
@@ -761,6 +931,103 @@ column.bool().default(true)
 column.text().default('N/A')
 ```
 
+#### `validate(validator: (value: T) => string | null | undefined): Column`
+
+Adds custom validation logic to the column. The validation function receives the column value and should return:
+
+- `null` or `undefined` if the value is valid
+- An error message `string` if the value is invalid
+
+**When it runs:** During insert and update operations, before data is saved to `IndexedDB`.
+
+> **Error Handling:** If validation fails, a `TypeError` is thrown with details about the invalid field.
+
+**Precedence:** Custom validators override built-in type validation. If you provide a custom validator, the built-in type check for that column will be skipped.
+
+> **Note:**
+>
+> - Custom validation is not applied to auto-generated values (e.g. auto-increment, UUID, timestamp). But default values are validated if `.default(value)` is used.
+> - If multiple validators are chained, only the last one is used.
+> - Built-in type validation still applies to all other columns without custom validators.
+> - If the column is optional, the validator is only called when a value is provided (not `undefined`).
+
+```typescript
+// Email validation
+const schema = defineSchema({
+  users: {
+    id: column.int().pk().auto(),
+    email: column.text().validate((val) => {
+      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+      return emailRegex.test(val) ? null : 'Invalid email format';
+    }),
+    age: column.int().validate((val) => {
+      if (val < 0) return 'Age cannot be negative';
+      if (val > 120) return 'Age must be 120 or less';
+      return null; // Valid
+    }),
+    username: column.text().validate((val) => {
+      if (val.length < 3) return 'Username must be at least 3 characters';
+      if (!/^[a-zA-Z0-9_]+$/.test(val)) return 'Username can only contain letters, numbers, and underscores';
+      return null;
+    }),
+  },
+});
+
+// ✅ Valid insert
+await db.insert('users').values({
+  email: 'user@example.com',
+  age: 25,
+  username: 'john_doe'
+}).run();
+
+// ❌ Throws TypeError: Invalid value for field 'email' in table 'users': Invalid email format
+await db.insert('users').values({
+  email: 'invalid-email',
+  age: 25,
+  username: 'john_doe'
+}).run();
+
+// ❌ Throws TypeError: Invalid value for field 'age' in table 'users': Age cannot be negative
+await db.insert('users').values({
+  email: 'user@example.com',
+  age: -5,
+  username: 'john_doe'
+}).run();
+```
+
+**Combining with `.optional()`:**
+
+```typescript
+const schema = defineSchema({
+  users: {
+    id: column.int().pk().auto(),
+    // Custom validation only runs when value is provided
+    bio: column.text().optional().validate((val) => {
+      return val.length <= 500 ? null : 'Bio must be 500 characters or less';
+    }),
+  },
+});
+
+// ✅ Valid - bio is optional and omitted
+await db.insert('users').values({}).run();
+
+// ✅ Valid - bio is provided and valid
+await db.insert('users').values({ bio: 'Short bio' }).run();
+
+// ❌ Throws TypeError - bio provided but exceeds 500 chars
+await db.insert('users').values({ bio: 'x'.repeat(501) }).run();
+```
+
+**Access the `ValidateFn` symbol (advanced):**
+
+```typescript
+import { ValidateFn } from 'locality-idb';
+
+// Access validator function programmatically
+const emailColumn = column.text().validate((val) => { /* ... */ });
+const validatorFn = emailColumn[ValidateFn]; // Function reference
+```
+
 ---
 
 ### Query Methods
@@ -789,17 +1056,25 @@ db.from('users').where((user) => user.age >= 18)
 
 ##### `where<IdxKey>(indexName: IdxKey, query: T[IdxKey] | IDBKeyRange): SelectQuery`
 
-Filters rows using an indexed field.
+Filters rows using an indexed field or primary key.
+
+**Type Safety:** `indexName` must be either an indexed field or the primary key.
+
+**Performance:** Uses IndexedDB's optimized index/key query for efficient lookups.
 
 ```typescript
+// Using an indexed field
 db.from('users').where('age', IDBKeyRange.bound(18, 30))
+
+// Using primary key
+db.from('users').where('id', IDBKeyRange.bound(1, 100))
 ```
 
 ##### `sortByIndex<IdxKey>(indexName: IdxKey, dir?: 'asc' | 'desc'): SelectQuery`
 
 Sorts results by an indexed field using IndexedDB cursor iteration (avoiding in-memory sorting).
 
-**Type Safety:** `indexName` must be a field with an index.
+**Type Safety:** `indexName` must be a field with an index or the primary key.
 
 **Performance:** Uses IndexedDB's cursor for optimized sorting. For large datasets, this is significantly more efficient than in-memory sorting.
 
@@ -890,8 +1165,10 @@ const userCount = await db.from('users').where((user) => user.isActive).count()
 
 > **Note:**
 >
-> - This method internally uses IndexedDB's `count()` for optimal performance.
-> - If a `where()` filter is applied without index, it falls back to in-memory counting.
+> - Uses IndexedDB's optimized `count()` when:
+>   - No `where()` clause is applied, OR
+>   - `where()` uses an index or primary key
+> - Falls back to in-memory counting when `where()` uses a predicate function
 
 ##### `exists(): Promise<boolean>`
 

package/dist/index.cjs

@@ -153,6 +153,8 @@ const IsIndexed = Symbol("IsIndexed");
 const IsUnique = Symbol("IsUnique");
 /** Symbol key for default value */
 const DefaultValue = Symbol("DefaultValue");
+/** Symbol key for custom validation function */
+const ValidateFn = Symbol("ValidateFn");
 /** @class Represents a column definition. */
 var Column = class {
 	constructor(type) {
@@ -200,6 +202,34 @@ var Column = class {
 		this[IsOptional] = true;
 		return this;
 	}
+	/**
+	* @instance Sets a custom validation function for the column
+	*
+	* @param validator - Custom validation function that receives the value and returns `null`/`undefined` if valid, or an error message `string` if invalid
+	*
+	* @returns The column instance with the validation function attached
+	*
+	* @remarks
+	* - Custom validation is not applied to auto-generated values (e.g. auto-increment, UUID, timestamp). But default values are validated if {@link default()} is used.
+	* - If multiple validators are chained, only the last one is used.
+	* - Built-in type validation still applies to all other columns without custom validators.
+	* - If the column is optional, the validator is only called when a value is provided (not `undefined`).
+	*
+	* @example
+	* // Email validation
+	* email: text().validate((val) => {
+	*   return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(val) ? null : 'Invalid email format';
+	* })
+	*
+	* // Range validation
+	* age: int().validate((val) => {
+	*   return val >= 0 && val <= 120 ? null : 'Age must be between 0 and 120';
+	* })
+	*/
+	validate(validator) {
+		this[ValidateFn] = validator;
+		return this;
+	}
 };
 /** @class Represents a table. */
 var Table = class {
@@ -381,15 +411,15 @@ function validateColumnType(type, value) {
 		case "tuple":
 			if (isArray(value)) return null;
 			return `${strVal} is not a tuple`;
-		case "set":
-			if (isSet(value)) return null;
-			return `${strVal} is not a set`;
 		case "object":
 			if (isObject(value)) return null;
 			return `${strVal} is not an object`;
 		case "date":
 			if (isDate(value)) return null;
 			return `${strVal} is not a Date object`;
+		case "set":
+			if (isSet(value)) return null;
+			return `${strVal} is not a set`;
 		case "map":
 			if (isMap(value)) return null;
 			return `${strVal} is not a Map object`;
@@ -426,22 +456,48 @@ function validateColumnType(type, value) {
 * @returns The validated and prepared data object
 * @throws
 * - A {@link TypeError} if any value does not match the expected column type
-* - A {@link RangeError} if any field is not defined in the table schema
+* - A {@link RangeError} if any field is not defined in the table schema or required field is missing
 */
 function validateAndPrepareData(data, columns, keyPath, tableName, forUpdate = false) {
 	const prepared = { ...data };
 	if (columns) {
-		for (const fieldName of Object.keys(prepared)) if (!Object.keys(columns).includes(fieldName)) throw new RangeError(`'${fieldName}' is not defined in the table (${tableName}) schema!`);
+		for (const fieldName of Object.keys(prepared)) if (!Object.keys(columns).includes(fieldName)) throw new RangeError(`Field '${fieldName}' is not defined in the table '${tableName}' schema!`);
 		Object.entries(columns).forEach((entry) => {
 			const [fieldName, column] = entry;
-			const defaultValue = column[DefaultValue];
-			if (!(fieldName in prepared) && defaultValue !== void 0 && !forUpdate) prepared[fieldName] = defaultValue;
 			const columnType = column[ColumnType];
-			if (columnType === "uuid" && !(fieldName in prepared) && !forUpdate) prepared[fieldName] = uuidV4();
-			if (columnType === "timestamp" && !(fieldName in prepared) && !forUpdate) prepared[fieldName] = getTimestamp();
-			if (fieldName !== keyPath) {
-				const errorMsg = validateColumnType(columnType, prepared[fieldName]);
-				if (errorMsg) throw new TypeError(errorMsg);
+			const defaultValue = column[DefaultValue];
+			const isOptional = column[IsOptional] ?? false;
+			let fieldNotPresent = !(fieldName in prepared);
+			if (!forUpdate && fieldNotPresent) {
+				if (columnType === "uuid" && isUndefined(defaultValue)) {
+					prepared[fieldName] = uuidV4();
+					return;
+				}
+				if (columnType === "timestamp" && isUndefined(defaultValue)) {
+					prepared[fieldName] = getTimestamp();
+					return;
+				}
+				if (!isUndefined(defaultValue)) {
+					prepared[fieldName] = defaultValue;
+					fieldNotPresent = false;
+				}
+			}
+			const fieldValue = prepared[fieldName];
+			if (fieldNotPresent) {
+				if (forUpdate) return;
+				if (!isOptional && fieldName !== keyPath) throw new RangeError(`Required field '${String(fieldName)}' is missing in table '${tableName}'!`);
+				return;
+			}
+			if (isUndefined(fieldValue)) {
+				if (!isOptional && fieldName !== keyPath) throw new TypeError(`Field '${String(fieldName)}' in table '${tableName}' cannot be undefined. It is a required field.`);
+				return;
+			}
+			if (!(!forUpdate && fieldName === keyPath && (column[IsAutoInc] ?? false))) {
+				const customValidator = column[ValidateFn];
+				let errorMsg;
+				if (isFunction(customValidator)) errorMsg = customValidator(fieldValue);
+				else errorMsg = validateColumnType(columnType, fieldValue);
+				if (errorMsg) throw new TypeError(`Invalid value for field '${String(fieldName)}' in table '${tableName}': ${errorMsg}`);
 			}
 		});
 	}
@@ -473,11 +529,13 @@ var SelectQuery = class {
 		this.#dbGetter = dbGetter;
 		this.#readyPromise = readyPromise;
 	}
-	#createTransaction() {
-		return this.#dbGetter().transaction(this.#table, "readonly");
-	}
-	#getStoreWithTransaction() {
-		return this.#createTransaction().objectStore(this.#table);
+	/** @internal Create a readonly transaction and return the store */
+	#getStore() {
+		const transaction = this.#dbGetter().transaction(this.#table, "readonly");
+		return {
+			transaction,
+			store: transaction.objectStore(this.#table)
+		};
 	}
 	/** @internal Check if key is an index on the store for the `#whereIndexName` */
 	#isIndexKey(store) {
@@ -505,6 +563,12 @@ var SelectQuery = class {
 		});
 		return data;
 	}
+	/** @internal Apply sort, limit, and projection pipeline to results */
+	#applyPipeline(results) {
+		let processed = this.#sort(results);
+		if (this.#limitCount) processed = processed.slice(0, this.#limitCount);
+		return processed.map((row) => this.#projectRow(row));
+	}
 	/** Projects a row based on selected fields */
 	#projectRow(row) {
 		if (!isNotEmptyObject(this?.[Selected])) return row;
@@ -577,16 +641,13 @@ var SelectQuery = class {
 	async findAll() {
 		await this.#readyPromise;
 		return new Promise((resolve, reject) => {
-			const store = this.#getStoreWithTransaction();
+			const { store } = this.#getStore();
 			if (this.#whereIndexName && !isUndefined(this.#whereIndexQuery)) {
 				const source = this.#buildIndexedStore(store, reject);
 				if (!source) return;
 				const request = source.getAll(this.#whereIndexQuery);
 				request.onsuccess = () => {
-					let results = request.result;
-					results = this.#sort(results);
-					if (this.#limitCount) results = results.slice(0, this.#limitCount);
-					resolve(results.map((row) => this.#projectRow(row)));
+					resolve(this.#applyPipeline(request.result));
 				};
 				request.onerror = () => reject(request.error);
 				return;
@@ -615,9 +676,7 @@ var SelectQuery = class {
 				request.onsuccess = () => {
 					let results = request.result;
 					if (this.#whereCondition) results = results.filter(this.#whereCondition);
-					results = this.#sort(results);
-					if (this.#limitCount) results = results.slice(0, this.#limitCount);
-					resolve(results.map((row) => this.#projectRow(row)));
+					resolve(this.#applyPipeline(results));
 				};
 				request.onerror = () => reject(request.error);
 			}
@@ -626,15 +685,14 @@ var SelectQuery = class {
 	async findFirst() {
 		await this.#readyPromise;
 		return new Promise((resolve, reject) => {
-			const store = this.#getStoreWithTransaction();
+			const { store } = this.#getStore();
 			if (this.#whereIndexName && !isUndefined(this.#whereIndexQuery)) {
 				const source = this.#buildIndexedStore(store, reject);
 				if (!source) return;
 				const request = source.getAll(this.#whereIndexQuery);
 				request.onsuccess = () => {
 					const results = request.result;
-					if (results.length > 0) resolve(this.#projectRow(results[0]));
-					else resolve(null);
+					resolve(results.length > 0 ? this.#projectRow(results[0]) : null);
 				};
 				request.onerror = () => reject(request.error);
 				return;
@@ -643,8 +701,7 @@ var SelectQuery = class {
 			request.onsuccess = () => {
 				let results = request.result;
 				if (this.#whereCondition) results = results.filter(this.#whereCondition);
-				if (results.length > 0) resolve(this.#projectRow(results[0]));
-				else resolve(null);
+				resolve(results.length > 0 ? this.#projectRow(results[0]) : null);
 			};
 			request.onerror = () => reject(request.error);
 		});
@@ -661,7 +718,8 @@ var SelectQuery = class {
 	async findByPk(key) {
 		await this.#readyPromise;
 		return new Promise((resolve, reject) => {
-			const request = this.#getStoreWithTransaction().get(key);
+			const { store } = this.#getStore();
+			const request = store.get(key);
 			request.onsuccess = () => {
 				const result = request.result;
 				if (!result) {
@@ -690,18 +748,16 @@ var SelectQuery = class {
 	async findByIndex(indexName, query) {
 		await this.#readyPromise;
 		return new Promise((resolve, reject) => {
-			const store = this.#getStoreWithTransaction();
+			const { store } = this.#getStore();
 			if (!store.indexNames.contains(indexName)) {
-				reject(/* @__PURE__ */ new Error(`Index '${indexName}' does not exist on table '${this.#table}'`));
+				reject(/* @__PURE__ */ new RangeError(`Index '${indexName}' does not exist on table '${this.#table}'`));
 				return;
 			}
 			const request = store.index(indexName).getAll(query);
 			request.onsuccess = () => {
 				let results = request.result;
 				if (this.#whereCondition) results = results.filter(this.#whereCondition);
-				results = this.#sort(results);
-				if (this.#limitCount) results = results.slice(0, this.#limitCount);
-				resolve(results.map((row) => this.#projectRow(row)));
+				resolve(this.#applyPipeline(results));
 			};
 			request.onerror = () => reject(request.error);
 		});
@@ -710,7 +766,7 @@ var SelectQuery = class {
 	async count() {
 		await this.#readyPromise;
 		return new Promise((resolve, reject) => {
-			const store = this.#getStoreWithTransaction();
+			const { store } = this.#getStore();
 			if (this.#whereIndexName && !isUndefined(this.#whereIndexQuery)) {
 				const source = this.#buildIndexedStore(store, reject);
 				if (!source) return;
@@ -1224,6 +1280,7 @@ const column = {
 
 //#endregion
 exports.Locality = Locality;
+exports.ValidateFn = ValidateFn;
 exports.column = column;
 exports.defineSchema = defineSchema;
 exports.deleteDB = deleteDB;