schema-idb 0.0.3 → 0.0.5

package/README.md

@@ -2,10 +2,12 @@
 
 A type-safe IndexedDB layer that brings structure to client-side storage.
 
+[Live Example](https://stackblitz.com/edit/schema-idb)
+
 ```ts
 const db = openDB({
   name: "MyApp",
-  version: 1,
+  versionStrategy: "auto",
   stores: [usersStore] as const,
 });
 
@@ -58,7 +60,7 @@ import { openDB } from "schema-idb";
 
 const db = openDB({
   name: "MyApp",
-  version: 1,
+  versionStrategy: "auto",
   stores: [usersStore] as const,
 });
 ```
@@ -221,6 +223,10 @@ const user = await db.users
 schema-idb exposes transactions as synchronous write batches across multiple stores.
 
 ```ts
+// Single store
+const tx = db.startTransaction("accounts");
+
+// Multiple stores
 const tx = db.startTransaction(["accounts", "logs"]);
 
 // Queue operations (no await between them)
@@ -233,9 +239,12 @@ await tx.commit();
 
 // Or abort
 tx.abort();
+
+// Access underlying IDBTransaction if needed
+tx.raw;
 ```
 
-Read operations are not available inside transactions. IndexedDB transactions auto-commit after any `await`, so reads must happen outside the transaction.
+Read operations are not available inside transactions. IndexedDB transactions auto-commit after any `await`, so schema-idb only supports synchronous write batching.
 
 ---
 
@@ -310,11 +319,38 @@ const db = openDB({
 - Index modifications
 - Index deletions
 
-### Requires manual migration (throws error)
+### Requires manual migration (throws error by default)
 
 - Store deletions (data loss)
 - keyPath changes (requires store recreation)
 
+### Handling removed stores
+
+When a store is removed from the schema, you can choose how to handle it:
+
+```ts
+const db = openDB({
+  name: "MyApp",
+  versionStrategy: "auto",
+  // 'error' (default): Throws an error when stores are removed
+  // 'preserve': Renames removed stores to __storeName_deleted__ as backup.
+  //             Preserved stores are isolated from the typed API to avoid future name collisions.
+  removedStoreStrategy: "preserve",
+  stores: [usersStore] as const,
+});
+```
+
+To explicitly delete a store (including backups), use a migration:
+
+```ts
+const usersStore = defineStore("users", {
+  // ...
+}).addMigration("003-delete-old-store", (db) => {
+  db.deleteObjectStore("oldStore");
+  db.deleteObjectStore("__oldStore_deleted__"); // Remove backup too
+});
+```
+
 ---
 
 ## Type Inference
@@ -331,39 +367,689 @@ type User = InferStore<typeof usersStore>;
 
 ## API Reference
 
-### Database
+> This section is intended as a complete, authoritative reference.
+> Most users will not need to read it top-to-bottom.
+> For a guided introduction and examples, see the sections above.
+
+### openDB
+
+Opens a database connection with the given configuration.
+
+```ts
+function openDB<T extends readonly SchemaStoreDefinition[]>(options: {
+  name: string;
+  stores: T;
+  versionStrategy?: "auto" | "explicit";
+  version?: number;
+  removedStoreStrategy?: "error" | "preserve";
+}): SchemaDatabase<T>;
+```
+
+| Option | Type | Description |
+| ------ | ---- | ----------- |
+| `name` | `string` | Database name |
+| `stores` | `readonly SchemaStoreDefinition[]` | Store definitions created with `defineStore` |
+| `versionStrategy` | `"auto" \| "explicit"` | `"auto"` detects schema changes automatically. Default: `"explicit"` (recommended for production control) |
+| `version` | `number` | Required when `versionStrategy` is `"explicit"` |
+| `removedStoreStrategy` | `"error" \| "preserve"` | How to handle removed stores. Default: `"error"` |
+
+### SchemaDatabase
+
+The database object returned by `openDB`.
+
+| Property | Type | Description |
+| -------- | ---- | ----------- |
+| `name` | `string` | Database name |
+| `version` | `number` | Current schema version |
+| `ready` | `boolean` | Whether the database is ready |
+| `raw` | `IDBDatabase` | Underlying IndexedDB instance |
+| `[storeName]` | `StoreAccessor` | Direct access to stores (e.g., `db.users`) |
+
+| Method | Signature | Description |
+| ------ | --------- | ----------- |
+| `waitForReady` | `() => Promise<void>` | Wait for database initialization |
+| `close` | `() => void` | Close the database connection |
+| `startTransaction` | `(stores, options?) => Transaction` | Start a multi-store transaction |
+
+### Store Accessor
+
+Each store is accessible as a property on the database object (e.g., `db.users`).
+
+#### get
+
+```ts
+get(key: K): Promise<T | undefined>
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `key` | `K` | Primary key value |
+
+Returns the record matching the key, or `undefined` if not found.
+
+#### getAll
+
+```ts
+getAll(): Promise<T[]>
+```
+
+Returns all records in the store.
+
+#### getBy
+
+```ts
+getBy<I extends IndexedFields>(indexName: I, query: V | IDBKeyRange): Promise<T | undefined>
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `indexName` | `I` | Name of the index to query |
+| `query` | `V \| IDBKeyRange` | Value to match or key range |
+
+Returns the first record matching the index value.
+
+#### getAllBy
+
+```ts
+getAllBy<I extends IndexedFields>(indexName: I, query?: V | IDBKeyRange): Promise<T[]>
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `indexName` | `I` | Name of the index to query |
+| `query` | `V \| IDBKeyRange` | Value to match or key range (optional) |
+
+Returns all records matching the index value. If `query` is omitted, returns all records ordered by the index.
+
+#### put
+
+```ts
+put(value: T, key?: K): Promise<K>
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `value` | `T` | Record to insert or update |
+| `key` | `K` | Optional key (only needed if store has no keyPath) |
+
+Inserts a new record or updates an existing one. Returns the primary key.
+
+#### add
+
+```ts
+add(value: T, key?: K): Promise<K>
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `value` | `T` | Record to insert |
+| `key` | `K` | Optional key (only needed if store has no keyPath) |
+
+Inserts a new record. Throws an error if the key already exists.
+
+#### delete
+
+```ts
+delete(key: K | IDBKeyRange): Promise<void>
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `key` | `K \| IDBKeyRange` | Primary key or key range to delete |
+
+Deletes record(s) matching the key or range.
+
+#### clear
+
+```ts
+clear(): Promise<void>
+```
+
+Deletes all records in the store.
+
+#### count
+
+```ts
+count(query?: IDBKeyRange | IDBValidKey): Promise<number>
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `query` | `IDBKeyRange \| IDBValidKey` | Optional key or range to count |
+
+Returns the number of records. If `query` is provided, counts only matching records.
+
+#### query
+
+```ts
+query(options: QueryOptions): Promise<T[]>
+query(): QueryBuilder
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `options` | `QueryOptions` | Query configuration (optional) |
+
+When called with options, executes the query and returns results. When called without arguments, returns a `QueryBuilder` for chaining.
+
+### Query Options
+
+Used with `db.store.query(options)`.
+
+```ts
+interface QueryOptions {
+  index: string;
+  where?: WhereCondition;
+  orderBy?: "asc" | "desc";
+  limit?: number;
+  offset?: number;
+}
+```
+
+| Option | Type | Description |
+| ------ | ---- | ----------- |
+| `index` | `string` | Index name to query on |
+| `where` | `WhereCondition` | Filter conditions (optional) |
+| `orderBy` | `"asc" \| "desc"` | Sort order. Default: `"asc"` |
+| `limit` | `number` | Maximum number of results (optional) |
+| `offset` | `number` | Number of results to skip. Default: `0` |
+
+#### WhereCondition
+
+```ts
+interface WhereCondition {
+  eq?: T;
+  gt?: T;
+  gte?: T;
+  lt?: T;
+  lte?: T;
+  between?: [T, T];
+  startsWith?: string;
+}
+```
+
+| Option | Type | Description |
+| ------ | ---- | ----------- |
+| `eq` | `T` | Exact match |
+| `gt` | `T` | Greater than |
+| `gte` | `T` | Greater than or equal |
+| `lt` | `T` | Less than |
+| `lte` | `T` | Less than or equal |
+| `between` | `[T, T]` | Inclusive range `[lower, upper]` |
+| `startsWith` | `string` | Prefix match (string indexes only) |
+
+### Query Builder
+
+Returned when calling `db.store.query()` without arguments.
+
+#### index
+
+```ts
+index<I extends IndexedFields>(name: I): IndexQueryBuilder
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `name` | `I` | Index name to query on |
+
+Returns an `IndexQueryBuilder` for the specified index.
+
+#### key
+
+```ts
+key(): IndexQueryBuilder
+```
+
+Returns an `IndexQueryBuilder` that queries by primary key.
+
+#### findAll
+
+```ts
+findAll(): Promise<T[]>
+```
+
+Executes the query and returns all matching records.
+
+### IndexQueryBuilder
+
+Provides condition methods for filtering. All methods return a `FinalQueryBuilder`.
+
+#### equals
+
+```ts
+equals(value: V): FinalQueryBuilder
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `value` | `V` | Value to match exactly |
+
+#### gt / gte / lt / lte
+
+```ts
+gt(value: V): FinalQueryBuilder   // Greater than
+gte(value: V): FinalQueryBuilder  // Greater than or equal
+lt(value: V): FinalQueryBuilder   // Less than
+lte(value: V): FinalQueryBuilder  // Less than or equal
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `value` | `V` | Boundary value for comparison |
+
+#### between
+
+```ts
+between(lower: V, upper: V): FinalQueryBuilder
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `lower` | `V` | Lower bound (inclusive) |
+| `upper` | `V` | Upper bound (inclusive) |
+
+#### startsWith
+
+```ts
+startsWith(prefix: string): FinalQueryBuilder
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `prefix` | `string` | Prefix to match |
+
+Only available for string indexes.
+
+### FinalQueryBuilder
+
+Provides result modifiers and execution methods.
+
+#### orderBy
+
+```ts
+orderBy(order: "asc" | "desc"): FinalQueryBuilder
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `order` | `"asc" \| "desc"` | Sort direction |
+
+#### limit
+
+```ts
+limit(count: number): FinalQueryBuilder
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `count` | `number` | Maximum number of results |
+
+#### offset
+
+```ts
+offset(count: number): FinalQueryBuilder
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `count` | `number` | Number of results to skip |
+
+#### findAll
+
+```ts
+findAll(): Promise<T[]>
+```
+
+Executes the query and returns all matching records.
+
+#### find
+
+```ts
+find(): Promise<T | undefined>
+```
+
+Executes the query and returns the first matching record, or `undefined` if none found.
+
+#### count
+
+```ts
+count(): Promise<number>
+```
+
+Returns the number of matching records without fetching them.
+
+### Transaction
+
+#### startTransaction
+
+```ts
+startTransaction(
+  stores: string | string[],
+  options?: TransactionOptions
+): Transaction
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `stores` | `string \| string[]` | Store name(s) to include in the transaction |
+| `options` | `TransactionOptions` | Transaction configuration (optional) |
+
+##### TransactionOptions
+
+| Option | Type | Description |
+| ------ | ---- | ----------- |
+| `mode` | `"write"` | Transaction mode. Currently only `"write"` is supported |
+| `durability` | `"default" \| "strict" \| "relaxed"` | Durability hint for the transaction. Default: `"default"` |
+
+#### Transaction Object
+
+| Property | Type | Description |
+| -------- | ---- | ----------- |
+| `raw` | `IDBTransaction` | Underlying IndexedDB transaction |
+| `[storeName]` | `TransactionStoreAccessor` | Synchronous store accessor for each included store |
+
+##### commit
+
+```ts
+commit(): Promise<void>
+```
+
+Commits all queued operations and waits for completion.
+
+##### abort
+
+```ts
+abort(): void
+```
+
+Aborts the transaction, discarding all queued operations.
+
+#### TransactionStoreAccessor
+
+Synchronous operations for use within transactions. Operations are queued and executed when `commit()` is called.
+
+##### put
+
+```ts
+put(value: T, key?: K): void
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `value` | `T` | Record to insert or update |
+| `key` | `K` | Optional key (only needed if store has no keyPath) |
+
+##### add
+
+```ts
+add(value: T, key?: K): void
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `value` | `T` | Record to insert |
+| `key` | `K` | Optional key (only needed if store has no keyPath) |
+
+##### delete
+
+```ts
+delete(key: K | IDBKeyRange): void
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `key` | `K \| IDBKeyRange` | Primary key or key range to delete |
+
+##### clear
+
+```ts
+clear(): void
+```
+
+Queues deletion of all records in the store.
+
+### defineStore
+
+Creates a store definition with schema.
+
+```ts
+defineStore<N extends string, S extends StoreSchema>(
+  name: N,
+  schema: S
+): SchemaStoreDefinition<N, S>
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `name` | `N` | Store name (used as `db.name` accessor) |
+| `schema` | `S` | Object defining fields using `field` builders |
+
+Returns a `SchemaStoreDefinition` with the following method:
+
+#### addMigration
+
+```ts
+addMigration(
+  name: string,
+  fn: (db: IDBDatabase, tx: IDBTransaction) => void
+): this
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `name` | `string` | Unique migration identifier (sorted alphabetically) |
+| `fn` | `MigrationFn` | Migration function with access to database and transaction |
+
+Migrations run during version upgrades in alphabetical order by name.
+
+### field
+
+Field type builders for schema definition.
+
+#### field.string
+
+```ts
+field.string(): FieldBuilder<string>
+```
+
+Creates a string field.
+
+#### field.number
+
+```ts
+field.number(): FieldBuilder<number>
+```
+
+Creates a number field.
+
+#### field.boolean
+
+```ts
+field.boolean(): FieldBuilder<boolean>
+```
+
+Creates a boolean field.
+
+#### field.date
+
+```ts
+field.date(): FieldBuilder<Date>
+```
+
+Creates a Date field.
+
+#### field.object
+
+```ts
+field.object<S>(schema: (t: TypeFactory) => S): FieldBuilder<InferObjectType<S>>
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `schema` | `(t: TypeFactory) => S` | Function returning an object schema using type builders |
+
+Creates a nested object field.
+
+```ts
+field.object(t => ({
+  street: t.string(),
+  city: t.string(),
+  zipCode: t.number().optional(),
+}))
+```
+
+#### field.tuple
+
+```ts
+field.tuple<T>(schema: (t: TypeFactory) => T): FieldBuilder<InferTupleType<T>>
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `schema` | `(t: TypeFactory) => T` | Function returning a tuple schema as array |
+
+Creates a fixed-length tuple field.
 
 ```ts
-const db = openDB({ name, version, stores });
+field.tuple(t => [t.number(), t.number()])  // [number, number]
+```
+
+#### field.enum
 
-db.waitForReady(); // Promise<void>
-db.ready; // boolean
-db.close(); // Close connection
-db.version; // Current version number
-db.raw; // Underlying IDBDatabase
+```ts
+field.enum<T extends readonly string[]>(values: T): FieldBuilder<T[number]>
 ```
 
-### Store operations
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `values` | `readonly string[]` | Array of allowed string values |
+
+Creates a string union type field.
 
 ```ts
-db.store.get(key); // Get by primary key
-db.store.getAll(); // Get all records
-db.store.getAllByIndex(index, value); // Get by index value
-db.store.put(value); // Insert or update
-db.store.add(value); // Insert (fails if exists)
-db.store.delete(key); // Delete by key
-db.store.clear(); // Delete all
-db.store.count(); // Count records
-db.store.query(options); // Query with conditions
+field.enum(['active', 'inactive', 'pending'] as const)
 ```
 
-### Utilities
+#### field.nativeEnum
 
 ```ts
-import { deleteDB, isIndexedDBAvailable } from "schema-idb";
+field.nativeEnum<T extends Record<string, string | number>>(enumObj: T): FieldBuilder<T[keyof T]>
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `enumObj` | `T` | TypeScript enum object |
+
+Creates a field from a TypeScript enum.
+
+```ts
+enum Status { Active = 'active', Inactive = 'inactive' }
+field.nativeEnum(Status)
+```
+
+### FieldBuilder
+
+Methods available on all field builders. All methods return `this` for chaining.
+
+#### primaryKey
+
+```ts
+primaryKey(): FieldBuilder
+```
+
+Marks the field as the store's primary key. Exactly one field per store must be marked as primary key.
+
+#### index
+
+```ts
+index(options?: IndexOptions): FieldBuilder
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `options.unique` | `boolean` | If `true`, enforces unique values. Default: `false` |
+| `options.multiEntry` | `boolean` | If `true`, indexes each array element separately. Default: `false` |
+
+Creates an index on this field, enabling queries via `query()`, `getBy()`, and `getAllBy()`.
+
+#### optional
+
+```ts
+optional(): FieldBuilder
+```
+
+Marks the field as optional, allowing `undefined` values.
+
+#### default
 
-await deleteDB("MyApp");
-isIndexedDBAvailable();
+```ts
+default(value: T | (() => T)): FieldBuilder
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `value` | `T \| (() => T)` | Default value or factory function |
+
+Sets a default value applied on read when the field is missing. Factory functions are called for each read.
+
+```ts
+field.number().default(0)
+field.date().default(() => new Date())
+```
+
+#### array
+
+```ts
+array(): FieldBuilder<T[]>
+```
+
+Converts the field type to an array.
+
+```ts
+field.string().array()  // string[]
+```
+
+### Utility Functions
+
+#### deleteDB
+
+```ts
+deleteDB(name: string): Promise<void>
+```
+
+| Param | Type | Description |
+| ----- | ---- | ----------- |
+| `name` | `string` | Database name to delete |
+
+Deletes the database and all its data.
+
+#### isIndexedDBAvailable
+
+```ts
+isIndexedDBAvailable(): boolean
+```
+
+Returns `true` if IndexedDB is available in the current environment.
+
+### Type Utilities
+
+#### InferStore
+
+```ts
+type InferStore<T> = /* inferred output type from store definition */
+```
+
+Extracts the TypeScript type from a store definition:
+
+```ts
+const usersStore = defineStore("users", {
+  id: field.string().primaryKey(),
+  name: field.string(),
+  age: field.number().optional().default(0),
+});
+
+type User = InferStore<typeof usersStore>;
+// { id: string; name: string; age: number }
 ```
 
 ---

package/dist/createSchemaDB.d.ts

@@ -1,4 +1,4 @@
-import type { StoreSchema, InferInput, InferOutput, PrimaryKeyType, IndexedFields } from './field.js';
+import type { StoreSchema, InferInput, InferOutput, PrimaryKeyType, IndexedFields, IndexFieldTypes } from './field.js';
 import type { SchemaStoreDefinition } from './schema.js';
 import type { TypedQueryOptions, TypedQueryBuilder } from './query.js';
 import type { Transaction, TransactionOptions } from './transaction.js';
@@ -7,7 +7,8 @@ type StoreNames<TStores extends readonly AnySchemaStore[]> = TStores[number]['na
 export interface SchemaStoreAccessor<S extends StoreSchema> {
     get(key: PrimaryKeyType<S>): Promise<InferOutput<S> | undefined>;
     getAll(): Promise<InferOutput<S>[]>;
-    getAllByIndex<I extends IndexedFields<S> & string>(indexName: I, query?: IDBKeyRange | IDBValidKey): Promise<InferOutput<S>[]>;
+    getBy<I extends IndexedFields<S> & string>(indexName: I, query: IDBKeyRange | IndexFieldTypes<S>[I]): Promise<InferOutput<S> | undefined>;
+    getAllBy<I extends IndexedFields<S> & string>(indexName: I, query?: IDBKeyRange | IndexFieldTypes<S>[I]): Promise<InferOutput<S>[]>;
     put(value: InferInput<S>, key?: PrimaryKeyType<S>): Promise<PrimaryKeyType<S>>;
     add(value: InferInput<S>, key?: PrimaryKeyType<S>): Promise<PrimaryKeyType<S>>;
     delete(key: PrimaryKeyType<S> | IDBKeyRange): Promise<void>;
@@ -20,6 +21,7 @@ export interface SchemaDBConfig<TStores extends readonly AnySchemaStore[]> {
     name: string;
     version?: number;
     versionStrategy?: 'explicit' | 'auto';
+    removedStoreStrategy?: 'error' | 'preserve';
     stores: TStores;
     onBlocked?: () => void;
     onVersionChange?: () => void;

package/dist/createSchemaDB.js

@@ -1 +1 @@
-"use strict";var P=Object.defineProperty;var c=(e,r)=>P(e,"name",{value:r,configurable:!0});import{openDatabase as T}from"./utils.js";import{createStoreAccessor as b}from"./storeAccessor.js";import{createStartTransaction as v}from"./transaction.js";import{determineAutoVersion as D,applySafeChanges as E,openDatabaseForSchemaRead as h}from"./schemaDetection.js";import{ensureSchemaHistoryStore as A,getAppliedMigrations as p,recordMigrationApplied as R,initializeSchemaHistory as x}from"./migrationHistory.js";function G(e){return e}c(G,"getKeyPathString");function z(e,r,o){const t=c(async()=>{if(await e.readyPromise,!e.idb)throw new Error("Database initialization failed");return b(e.idb,r,o)},"getAccessor");return new Proxy({},{get(n,d){return d==="query"?s=>s?t().then(i=>i.query(s)):M(e,r,o):async(...s)=>(await t())[d](...s)}})}c(z,"createLazyStoreAccessor");function M(e,r,o){const t=c(async()=>{if(await e.readyPromise,!e.idb)throw new Error("Database initialization failed");return b(e.idb,r,o).query()},"getQueryBuilder"),n=c(d=>new Proxy({},{get(s,i){return i==="findAll"||i==="find"||i==="count"?()=>d().then(a=>a[i]()):(...a)=>n(c(()=>d().then(l=>l[i](...a)),"newGetBuilder"))}}),"createBuilderProxy");return n(t)}c(M,"createLazyQueryBuilder");function k(e,r){const o={get name(){return e.idb?.name??r},get version(){return e.idb?.version??0},get raw(){if(!e.idb)throw new Error("Database not ready. Call waitForReady() first or check ready property.");return e.idb},get ready(){return e.ready},waitForReady(){return e.readyPromise},close(){e.idb?.close()},startTransaction(...t){if(!e.startTransaction){const[n,d]=t,s=Array.isArray(n)?n:[n];return j(e,s,d)}return e.startTransaction(...t)}};for(const t of e.stores)Object.defineProperty(o,t.name,{get(){return z(e,t.name,t.defaults)},enumerable:!0});return o}c(k,"buildSchemaDatabase");function j(e,r,o){const t={get raw(){throw new Error("Transaction raw is not available before ready state. Use await db.waitForReady() before starting transactions.")},async commit(){if(await e.readyPromise,!e.startTransaction)throw new Error("Database initialization failed");return e.startTransaction(r,o).commit()},abort(){}};for(const n of r)e.stores.find(s=>s.name===n)&&Object.defineProperty(t,n,{get(){throw new Error("Transaction operations before ready state are not yet supported. Use await db.waitForReady() before starting transactions.")},enumerable:!0});return t}c(j,"createLazyTransaction");function q(e){const r=[],o=new Set;for(const t of e)for(const n of t.migrations){if(o.has(n.name))throw new Error(`Duplicate migration name "${n.name}" found across stores`);o.add(n.name),r.push(n)}return r.sort((t,n)=>t.name.localeCompare(n.name))}c(q,"collectMigrations");function S(e,r){const o=new Set(r);return e.filter(t=>!o.has(t.name)).sort((t,n)=>t.name.localeCompare(n.name))}c(S,"filterPendingMigrations");function B(e,r,o,t,n,d,s){if(A(e),o===0){for(const a of t){const f=e.createObjectStore(a.name,{keyPath:a.keyPath});for(const l of a.indexes)f.createIndex(l.name,l.keyPath,{unique:l.unique??!1,multiEntry:l.multiEntry??!1})}x(r)}else s&&s.safe.length>0&&E(e,r,s.safe,t);let i=[...d];for(const a of n)try{const f=a.up(e,r);f instanceof Promise&&f.catch(l=>{console.error(`Migration "${a.name}" failed:`,l),r.abort()}),R(r,a.name,i),i=[...i,a.name].sort()}catch(f){throw console.error(`Migration "${a.name}" failed:`,f),r.abort(),f}}c(B,"handleUpgrade");export function openDB(e){const{name:r,version:o,versionStrategy:t="explicit",stores:n,onBlocked:d,onVersionChange:s}=e,i=new Set;for(const m of n){if(i.has(m.name))throw new Error(`Duplicate store name: "${m.name}"`);i.add(m.name)}const a=q(n);let f=c(()=>{},"readyResolve"),l=c(()=>{},"readyReject");const w={idb:null,ready:!1,error:null,readyPromise:new Promise((m,y)=>{f=m,l=y}),readyResolve:f,readyReject:l,stores:n,startTransaction:null},u=k(w,r);return C(w,r,o,t,n,a,d,s),u}c(openDB,"openDB");async function C(e,r,o,t,n,d,s,i){try{let a=[],f=null,l;if(t==="auto"){const u=await D(r,n);if(l=u.version,f=u.changes,u.version>1){const y=await h(r);y&&(a=await p(y),y.close())}S(d,a).length>0&&!u.needsUpgrade&&(l=u.version+1)}else{if(o===void 0)throw new Error('Version is required when versionStrategy is "explicit"');l=o;const u=await h(r);u&&(a=await p(u),u.close())}const g=S(d,a),w=await T(r,l,(u,m,y)=>{B(u,m,y,n,g,a,f)},s);i&&(w.onversionchange=i),e.idb=w,e.startTransaction=v(w,n),e.ready=!0,e.readyResolve()}catch(a){e.error=a instanceof Error?a:new Error(String(a)),e.readyReject(e.error)}}c(C,"initializeDatabase");
+"use strict";var v=Object.defineProperty;var l=(e,r)=>v(e,"name",{value:r,configurable:!0});import{openDatabase as T}from"./utils.js";import{createStoreAccessor as h}from"./storeAccessor.js";import{createStartTransaction as D}from"./transaction.js";import{determineAutoVersion as E,applySafeChanges as A,openDatabaseForSchemaRead as p}from"./schemaDetection.js";import{ensureSchemaHistoryStore as R,getAppliedMigrations as S,recordMigrationApplied as x,initializeSchemaHistory as z}from"./migrationHistory.js";function H(e){return e}l(H,"getKeyPathString");function M(e,r,o){const n=l(async()=>{if(await e.readyPromise,!e.idb)throw new Error("Database initialization failed");return h(e.idb,r,o)},"getAccessor");return new Proxy({},{get(t,i){return i==="query"?c=>c?n().then(d=>d.query(c)):k(e,r,o):async(...c)=>(await n())[i](...c)}})}l(M,"createLazyStoreAccessor");function k(e,r,o){const n=l(async()=>{if(await e.readyPromise,!e.idb)throw new Error("Database initialization failed");return h(e.idb,r,o).query()},"getQueryBuilder"),t=l(i=>new Proxy({},{get(c,d){return d==="findAll"||d==="find"||d==="count"?()=>i().then(s=>s[d]()):(...s)=>t(l(()=>i().then(f=>f[d](...s)),"newGetBuilder"))}}),"createBuilderProxy");return t(n)}l(k,"createLazyQueryBuilder");function j(e,r){const o={get name(){return e.idb?.name??r},get version(){return e.idb?.version??0},get raw(){if(!e.idb)throw new Error("Database not ready. Call waitForReady() first or check ready property.");return e.idb},get ready(){return e.ready},waitForReady(){return e.readyPromise},close(){e.idb?.close()},startTransaction(...n){if(!e.startTransaction){const[t,i]=n,c=Array.isArray(t)?t:[t];return q(e,c,i)}return e.startTransaction(...n)}};for(const n of e.stores)Object.defineProperty(o,n.name,{get(){return M(e,n.name,n.defaults)},enumerable:!0});return o}l(j,"buildSchemaDatabase");function q(e,r,o){const n={get raw(){throw new Error("Transaction raw is not available before ready state. Use await db.waitForReady() before starting transactions.")},async commit(){if(await e.readyPromise,!e.startTransaction)throw new Error("Database initialization failed");return e.startTransaction(r,o).commit()},abort(){}};for(const t of r)e.stores.find(c=>c.name===t)&&Object.defineProperty(n,t,{get(){throw new Error("Transaction operations before ready state are not yet supported. Use await db.waitForReady() before starting transactions.")},enumerable:!0});return n}l(q,"createLazyTransaction");function B(e){const r=[],o=new Set;for(const n of e)for(const t of n.migrations){if(o.has(t.name))throw new Error(`Duplicate migration name "${t.name}" found across stores`);o.add(t.name),r.push(t)}return r.sort((n,t)=>n.name.localeCompare(t.name))}l(B,"collectMigrations");function P(e,r){const o=new Set(r);return e.filter(n=>!o.has(n.name)).sort((n,t)=>n.name.localeCompare(t.name))}l(P,"filterPendingMigrations");function C(e,r,o,n,t,i,c){if(R(e),o===0){for(const s of n){const a=e.createObjectStore(s.name,{keyPath:s.keyPath});for(const f of s.indexes)a.createIndex(f.name,f.keyPath,{unique:f.unique??!1,multiEntry:f.multiEntry??!1})}z(r)}else c&&c.safe.length>0&&A(e,r,c.safe,n);let d=[...i];for(const s of t)try{const a=s.up(e,r);a instanceof Promise&&a.catch(f=>{console.error(`Migration "${s.name}" failed:`,f),r.abort()}),x(r,s.name,d),d=[...d,s.name].sort()}catch(a){throw console.error(`Migration "${s.name}" failed:`,a),r.abort(),a}}l(C,"handleUpgrade");export function openDB(e){const{name:r,version:o,versionStrategy:n="explicit",removedStoreStrategy:t="error",stores:i,onBlocked:c,onVersionChange:d}=e,s=new Set;for(const m of i){if(s.has(m.name))throw new Error(`Duplicate store name: "${m.name}"`);s.add(m.name)}const a=B(i);let f=l(()=>{},"readyResolve"),y=l(()=>{},"readyReject");const g={idb:null,ready:!1,error:null,readyPromise:new Promise((m,w)=>{f=m,y=w}),readyResolve:f,readyReject:y,stores:i,startTransaction:null},u=j(g,r);return F(g,r,o,n,t,i,a,c,d),u}l(openDB,"openDB");async function F(e,r,o,n,t,i,c,d,s){try{let a=[],f=null,y;if(n==="auto"){const u=await E(r,i,{removedStoreStrategy:t});if(y=u.version,f=u.changes,u.version>1){const w=await p(r);w&&(a=await S(w),w.close())}P(c,a).length>0&&!u.needsUpgrade&&(y=u.version+1)}else{if(o===void 0)throw new Error('Version is required when versionStrategy is "explicit"');y=o;const u=await p(r);u&&(a=await S(u),u.close())}const b=P(c,a),g=await T(r,y,(u,m,w)=>{C(u,m,w,i,b,a,f)},d);s&&(g.onversionchange=s),e.idb=g,e.startTransaction=D(g,i),e.ready=!0,e.readyResolve()}catch(a){e.error=a instanceof Error?a:new Error(String(a)),e.readyReject(e.error)}}l(F,"initializeDatabase");

package/dist/field.d.ts

@@ -92,6 +92,7 @@ export type IndexedFields<S extends StoreSchema> = {
 export type IndexFieldTypes<S extends StoreSchema> = {
     [K in IndexedFields<S>]: S[K] extends FieldBuilder<infer T, boolean, boolean, boolean> ? T : never;
 };
+export type FieldType<S extends StoreSchema, K extends keyof S> = S[K] extends FieldBuilder<infer T, boolean, boolean, boolean> ? T : never;
 export type InferStore<TStore> = TStore extends {
     schema: infer S;
 } ? S extends StoreSchema ? InferOutput<S> : never : never;

package/dist/query.d.ts

@@ -9,6 +9,22 @@ export interface WhereCondition<T = unknown> {
     between?: [T, T];
     startsWith?: string;
 }
+export type TypedWhereCondition<T> = T extends string ? {
+    eq?: T;
+    gt?: T;
+    gte?: T;
+    lt?: T;
+    lte?: T;
+    between?: [T, T];
+    startsWith?: string;
+} : {
+    eq?: T;
+    gt?: T;
+    gte?: T;
+    lt?: T;
+    lte?: T;
+    between?: [T, T];
+};
 export interface QueryOptions {
     index?: string;
     where?: WhereCondition;
@@ -16,13 +32,21 @@ export interface QueryOptions {
     limit?: number;
     offset?: number;
 }
-export interface TypedQueryOptions<S extends StoreSchema> {
-    index?: IndexedFields<S>;
+export type TypedQueryOptions<S extends StoreSchema> = {
+    [I in IndexedFields<S>]: {
+        index: I;
+        where?: TypedWhereCondition<IndexFieldTypes<S>[I]>;
+        orderBy?: SortOrder;
+        limit?: number;
+        offset?: number;
+    };
+}[IndexedFields<S>] | {
+    index?: undefined;
     where?: WhereCondition<unknown>;
     orderBy?: SortOrder;
     limit?: number;
     offset?: number;
-}
+};
 interface QueryState {
     indexName?: string;
     useKey: boolean;
@@ -125,20 +149,23 @@ export interface IndexQueryBuilder<T> {
     findAll(): Promise<T[]>;
     find(): Promise<T | undefined>;
 }
-export interface TypedIndexQueryBuilder<T, S extends StoreSchema, I extends IndexedFields<S>> {
-    equals(value: IndexFieldTypes<S>[I]): FinalQueryBuilder<T>;
-    gt(value: IndexFieldTypes<S>[I]): FinalQueryBuilder<T>;
-    gte(value: IndexFieldTypes<S>[I]): FinalQueryBuilder<T>;
-    lt(value: IndexFieldTypes<S>[I]): FinalQueryBuilder<T>;
-    lte(value: IndexFieldTypes<S>[I]): FinalQueryBuilder<T>;
-    between(lower: IndexFieldTypes<S>[I], upper: IndexFieldTypes<S>[I]): FinalQueryBuilder<T>;
-    startsWith(prefix: IndexFieldTypes<S>[I] extends string ? string : never): FinalQueryBuilder<T>;
+interface BaseIndexQueryBuilder<T, V> {
+    equals(value: V): FinalQueryBuilder<T>;
+    gt(value: V): FinalQueryBuilder<T>;
+    gte(value: V): FinalQueryBuilder<T>;
+    lt(value: V): FinalQueryBuilder<T>;
+    lte(value: V): FinalQueryBuilder<T>;
+    between(lower: V, upper: V): FinalQueryBuilder<T>;
     orderBy(order: SortOrder): FinalQueryBuilder<T>;
     limit(count: number): FinalQueryBuilder<T>;
     offset(count: number): FinalQueryBuilder<T>;
     findAll(): Promise<T[]>;
     find(): Promise<T | undefined>;
 }
+interface StringIndexQueryBuilder<T> {
+    startsWith(prefix: string): FinalQueryBuilder<T>;
+}
+export type TypedIndexQueryBuilder<T, S extends StoreSchema, I extends IndexedFields<S>> = BaseIndexQueryBuilder<T, IndexFieldTypes<S>[I]> & (IndexFieldTypes<S>[I] extends string ? StringIndexQueryBuilder<T> : {});
 export interface FinalQueryBuilder<T> {
     orderBy(order: SortOrder): FinalQueryBuilder<T>;
     limit(count: number): FinalQueryBuilder<T>;

package/dist/schemaDetection.d.ts

@@ -19,6 +19,10 @@ export type SchemaChangeType = {
 } | {
     type: 'store_delete';
     storeName: string;
+} | {
+    type: 'store_rename';
+    oldName: string;
+    newName: string;
 } | {
     type: 'keypath_change';
     storeName: string;
@@ -69,11 +73,14 @@ export declare function generateSchemaFingerprint(stores: readonly {
 export declare function hashFingerprint(fingerprint: string): number;
 export declare function getCurrentDatabaseVersion(dbName: string): Promise<number>;
 export declare function openDatabaseForSchemaRead(dbName: string): Promise<IDBDatabase | null>;
+export interface AutoVersionOptions {
+    removedStoreStrategy?: 'error' | 'preserve';
+}
 export declare function determineAutoVersion(dbName: string, stores: readonly {
     name: string;
     keyPath: string | string[] | undefined;
     indexes: IndexDefinition[];
-}[]): Promise<{
+}[], options?: AutoVersionOptions): Promise<{
     version: number;
     changes: SchemaChanges | null;
     needsUpgrade: boolean;

package/dist/schemaDetection.js

@@ -1,5 +1,5 @@
-"use strict";var y=Object.defineProperty;var c=(t,n)=>y(t,"name",{value:n,configurable:!0});function x(t){return t.startsWith("__")}c(x,"isInternalStore");export function readExistingSchema(t){const n=new Map,e=Array.from({length:t.objectStoreNames.length},(a,r)=>t.objectStoreNames.item(r)).filter(a=>!x(a));for(const a of e){const r=t.transaction(a,"readonly"),o=r.objectStore(a),i=new Map,u=Array.from({length:o.indexNames.length},(s,d)=>o.indexNames.item(d));for(const s of u){const d=o.index(s);i.set(s,{keyPath:d.keyPath,unique:d.unique,multiEntry:d.multiEntry})}n.set(a,{name:a,keyPath:o.keyPath,indexes:i}),r.abort()}return n}c(readExistingSchema,"readExistingSchema");export function toDesiredSchema(t){const n=new Map;for(const e of t)n.set(e.name,{name:e.name,keyPath:e.keyPath,indexes:e.indexes});return n}c(toDesiredSchema,"toDesiredSchema");function h(t,n){return t===n||t==null&&n==null?!0:t==null||n==null?!1:Array.isArray(t)&&Array.isArray(n)?t.length!==n.length?!1:t.every((e,a)=>e===n[a]):t===n}c(h,"keyPathEquals");export function detectSchemaChanges(t,n){const e=[],a=[];for(const[r,o]of n){const i=t.get(r);if(!i){e.push({type:"store_add",storeName:r});continue}if(!h(i.keyPath,o.keyPath)){a.push({type:"keypath_change",storeName:r,oldKeyPath:i.keyPath,newKeyPath:o.keyPath});continue}for(const s of o.indexes){const d=i.indexes.get(s.name);if(!d)e.push({type:"index_add",storeName:r,indexName:s.name,index:s});else{const m=!h(d.keyPath,s.keyPath),l=d.unique!==(s.unique??!1),f=d.multiEntry!==(s.multiEntry??!1);(m||l||f)&&(e.push({type:"index_delete",storeName:r,indexName:s.name}),e.push({type:"index_add",storeName:r,indexName:s.name,index:s}))}}const u=new Set(o.indexes.map(s=>s.name));for(const s of i.indexes.keys())u.has(s)||e.push({type:"index_delete",storeName:r,indexName:s})}for(const r of t.keys())n.has(r)||a.push({type:"store_delete",storeName:r});return{safe:e,dangerous:a,hasChanges:e.length>0||a.length>0}}c(detectSchemaChanges,"detectSchemaChanges");export function applySafeChanges(t,n,e,a){for(const r of e)switch(r.type){case"store_add":{const o=a.find(i=>i.name===r.storeName);if(o){const i=t.createObjectStore(o.name,{keyPath:o.keyPath});for(const u of o.indexes)i.createIndex(u.name,u.keyPath,{unique:u.unique??!1,multiEntry:u.multiEntry??!1})}break}case"index_add":{n.objectStore(r.storeName).createIndex(r.indexName,r.index.keyPath,{unique:r.index.unique??!1,multiEntry:r.index.multiEntry??!1});break}case"index_delete":{n.objectStore(r.storeName).deleteIndex(r.indexName);break}}}c(applySafeChanges,"applySafeChanges");export function generateSchemaFingerprint(t){const n=t.map(e=>({name:e.name,keyPath:e.keyPath,indexes:e.indexes.map(a=>({name:a.name,keyPath:a.keyPath,unique:a.unique??!1,multiEntry:a.multiEntry??!1})).sort((a,r)=>a.name.localeCompare(r.name))})).sort((e,a)=>e.name.localeCompare(a.name));return JSON.stringify(n)}c(generateSchemaFingerprint,"generateSchemaFingerprint");export function hashFingerprint(t){let n=0;for(let e=0;e<t.length;e++){const a=t.charCodeAt(e);n=(n<<5)-n+a,n=n&n}return Math.abs(n)}c(hashFingerprint,"hashFingerprint");export async function getCurrentDatabaseVersion(t){return new Promise(n=>{const e=indexedDB.open(t);e.onsuccess=()=>{const a=e.result,r=a.version;a.close(),n(r)},e.onerror=()=>{n(0)}})}c(getCurrentDatabaseVersion,"getCurrentDatabaseVersion");export async function openDatabaseForSchemaRead(t){return new Promise(n=>{const e=indexedDB.open(t);e.onsuccess=()=>{n(e.result)},e.onerror=()=>{n(null)},e.onupgradeneeded=()=>{e.transaction?.abort()}})}c(openDatabaseForSchemaRead,"openDatabaseForSchemaRead");export async function determineAutoVersion(t,n){const e=await openDatabaseForSchemaRead(t);if(!e)return{version:1,changes:null,needsUpgrade:!0};const a=e.version,r=readExistingSchema(e),o=toDesiredSchema(n);e.close();const i=detectSchemaChanges(r,o);if(!i.hasChanges)return{version:a,changes:null,needsUpgrade:!1};if(i.dangerous.length>0){const u=i.dangerous.map(s=>{switch(s.type){case"store_delete":return`Store "${s.storeName}" would be deleted. Use a manual migration to handle this.`;case"keypath_change":return`Store "${s.storeName}" keyPath changed from "${s.oldKeyPath}" to "${s.newKeyPath}". This requires recreating the store with a manual migration.`;default:return"Unknown dangerous change"}});throw new Error(`Dangerous schema changes detected:
-${u.join(`
+"use strict";var g=Object.defineProperty;var h=(n,t)=>g(n,"name",{value:t,configurable:!0});function p(n){return n.startsWith("__")}h(p,"isInternalStore");export function readExistingSchema(n){const t=new Map,e=Array.from({length:n.objectStoreNames.length},(a,o)=>n.objectStoreNames.item(o)).filter(a=>!p(a));for(const a of e){const o=n.transaction(a,"readonly"),d=o.objectStore(a),s=new Map,c=Array.from({length:d.indexNames.length},(r,i)=>d.indexNames.item(i));for(const r of c){const i=d.index(r);s.set(r,{keyPath:i.keyPath,unique:i.unique,multiEntry:i.multiEntry})}t.set(a,{name:a,keyPath:d.keyPath,indexes:s}),o.abort()}return t}h(readExistingSchema,"readExistingSchema");export function toDesiredSchema(n){const t=new Map;for(const e of n)t.set(e.name,{name:e.name,keyPath:e.keyPath,indexes:e.indexes});return t}h(toDesiredSchema,"toDesiredSchema");function x(n,t){return n===t||n==null&&t==null?!0:n==null||t==null?!1:Array.isArray(n)&&Array.isArray(t)?n.length!==t.length?!1:n.every((e,a)=>e===t[a]):n===t}h(x,"keyPathEquals");export function detectSchemaChanges(n,t){const e=[],a=[];for(const[o,d]of t){const s=n.get(o);if(!s){e.push({type:"store_add",storeName:o});continue}if(!x(s.keyPath,d.keyPath)){a.push({type:"keypath_change",storeName:o,oldKeyPath:s.keyPath,newKeyPath:d.keyPath});continue}for(const r of d.indexes){const i=s.indexes.get(r.name);if(!i)e.push({type:"index_add",storeName:o,indexName:r.name,index:r});else{const m=!x(i.keyPath,r.keyPath),u=i.unique!==(r.unique??!1),l=i.multiEntry!==(r.multiEntry??!1);(m||u||l)&&(e.push({type:"index_delete",storeName:o,indexName:r.name}),e.push({type:"index_add",storeName:o,indexName:r.name,index:r}))}}const c=new Set(d.indexes.map(r=>r.name));for(const r of s.indexes.keys())c.has(r)||e.push({type:"index_delete",storeName:o,indexName:r})}for(const o of n.keys())t.has(o)||a.push({type:"store_delete",storeName:o});return{safe:e,dangerous:a,hasChanges:e.length>0||a.length>0}}h(detectSchemaChanges,"detectSchemaChanges");export function applySafeChanges(n,t,e,a){const o=e.filter(s=>s.type==="store_rename"),d=new Map;for(const s of o){const c=t.objectStore(s.oldName),r=[],i=Array.from({length:c.indexNames.length},(u,l)=>c.indexNames.item(l));for(const u of i){const l=c.index(u);r.push({name:u,keyPath:l.keyPath,unique:l.unique,multiEntry:l.multiEntry})}d.set(s.oldName,{keyPath:c.keyPath,indexes:r,newName:s.newName});const m=c.getAll();m.onsuccess=()=>{const u=m.result,l=d.get(s.oldName),f=n.createObjectStore(l.newName,{keyPath:l.keyPath});for(const y of l.indexes)f.createIndex(y.name,y.keyPath,{unique:y.unique,multiEntry:y.multiEntry});for(const y of u)f.put(y)},n.deleteObjectStore(s.oldName)}for(const s of e)switch(s.type){case"store_add":{const c=a.find(r=>r.name===s.storeName);if(c){const r=n.createObjectStore(c.name,{keyPath:c.keyPath});for(const i of c.indexes)r.createIndex(i.name,i.keyPath,{unique:i.unique??!1,multiEntry:i.multiEntry??!1})}break}case"index_add":{t.objectStore(s.storeName).createIndex(s.indexName,s.index.keyPath,{unique:s.index.unique??!1,multiEntry:s.index.multiEntry??!1});break}case"index_delete":{t.objectStore(s.storeName).deleteIndex(s.indexName);break}}}h(applySafeChanges,"applySafeChanges");export function generateSchemaFingerprint(n){const t=n.map(e=>({name:e.name,keyPath:e.keyPath,indexes:e.indexes.map(a=>({name:a.name,keyPath:a.keyPath,unique:a.unique??!1,multiEntry:a.multiEntry??!1})).sort((a,o)=>a.name.localeCompare(o.name))})).sort((e,a)=>e.name.localeCompare(a.name));return JSON.stringify(t)}h(generateSchemaFingerprint,"generateSchemaFingerprint");export function hashFingerprint(n){let t=0;for(let e=0;e<n.length;e++){const a=n.charCodeAt(e);t=(t<<5)-t+a,t=t&t}return Math.abs(t)}h(hashFingerprint,"hashFingerprint");export async function getCurrentDatabaseVersion(n){return new Promise(t=>{const e=indexedDB.open(n);e.onsuccess=()=>{const a=e.result,o=a.version;a.close(),t(o)},e.onerror=()=>{t(0)}})}h(getCurrentDatabaseVersion,"getCurrentDatabaseVersion");export async function openDatabaseForSchemaRead(n){return new Promise(t=>{const e=indexedDB.open(n);e.onsuccess=()=>{t(e.result)},e.onerror=()=>{t(null)},e.onupgradeneeded=()=>{e.transaction?.abort()}})}h(openDatabaseForSchemaRead,"openDatabaseForSchemaRead");export async function determineAutoVersion(n,t,e={}){const{removedStoreStrategy:a="error"}=e,o=await openDatabaseForSchemaRead(n);if(!o)return{version:1,changes:null,needsUpgrade:!0};const d=o.version,s=readExistingSchema(o),c=toDesiredSchema(t);o.close();const r=detectSchemaChanges(s,c);if(!r.hasChanges)return{version:d,changes:null,needsUpgrade:!1};const i=[];for(const m of r.dangerous)m.type==="store_delete"&&a==="preserve"?r.safe.push({type:"store_rename",oldName:m.storeName,newName:`__${m.storeName}_deleted__`}):i.push(m);if(r.dangerous=i,r.dangerous.length>0){const m=r.dangerous.map(u=>{switch(u.type){case"store_delete":return`Store "${u.storeName}" would be deleted. Use removedStoreStrategy: 'preserve' to backup, or add a migration to explicitly delete it.`;case"keypath_change":return`Store "${u.storeName}" keyPath changed from "${u.oldKeyPath}" to "${u.newKeyPath}". This requires recreating the store with a manual migration.`;default:return"Unknown dangerous change"}});throw new Error(`Dangerous schema changes detected:
+${m.join(`
 `)}
 
-Add explicit migrations to handle these changes safely.`)}return{version:a+1,changes:i,needsUpgrade:!0}}c(determineAutoVersion,"determineAutoVersion");
+Add explicit migrations to handle these changes safely.`)}return{version:d+1,changes:r,needsUpgrade:!0}}h(determineAutoVersion,"determineAutoVersion");

package/dist/storeAccessor.js

@@ -1 +1 @@
-"use strict";var p=Object.defineProperty;var a=(r,t)=>p(r,"name",{value:t,configurable:!0});import{promisifyTransaction as i}from"./utils.js";import{createQueryFunction as S}from"./query.js";async function u(r,t){return await i(r),t.result}a(u,"getResult");function f(r,t){if(r!==void 0)return{...t,...r}}a(f,"applyDefaults");function w(r,t){return Object.keys(t).length===0?r:r.map(s=>({...t,...s}))}a(w,"applyDefaultsToArray");export function createStoreAccessor(r,t,s={}){const y=Object.keys(s).length>0,x=S(r,t,s);return{async get(c){const n=r.transaction(t,"readonly"),e=n.objectStore(t),o=await u(n,e.get(c));return y?f(o,s):o},async getAll(c){const n=r.transaction(t,"readonly"),e=n.objectStore(t),o=await u(n,e.getAll(c?.query,c?.count));return y?w(o,s):o},async getAllByIndex(c,n){const e=r.transaction(t,"readonly"),j=e.objectStore(t).index(c),l=await u(e,j.getAll(n));return y?w(l,s):l},async put(c,n){const e=r.transaction(t,"readwrite"),o=e.objectStore(t);return u(e,o.put(c,n))},async add(c,n){const e=r.transaction(t,"readwrite"),o=e.objectStore(t);return u(e,o.add(c,n))},async delete(c){const n=r.transaction(t,"readwrite");n.objectStore(t).delete(c),await i(n)},async clear(){const c=r.transaction(t,"readwrite");c.objectStore(t).clear(),await i(c)},async count(c){const n=r.transaction(t,"readonly"),o=n.objectStore(t).count(c);return await i(n),o.result},async raw(c){const n=r.transaction(t,"readwrite"),e=n.objectStore(t),o=c(e);return await i(n),o.result},query:x}}a(createStoreAccessor,"createStoreAccessor");
+"use strict";var S=Object.defineProperty;var u=(r,t)=>S(r,"name",{value:t,configurable:!0});import{promisifyTransaction as y}from"./utils.js";import{createQueryFunction as p}from"./query.js";async function a(r,t){return await y(r),t.result}u(a,"getResult");function x(r,t){if(r!==void 0)return{...t,...r}}u(x,"applyDefaults");function j(r,t){return Object.keys(t).length===0?r:r.map(s=>({...t,...s}))}u(j,"applyDefaultsToArray");export function createStoreAccessor(r,t,s={}){const l=Object.keys(s).length>0,g=p(r,t,s);return{async get(c){const n=r.transaction(t,"readonly"),o=n.objectStore(t),e=await a(n,o.get(c));return l?x(e,s):e},async getAll(c){const n=r.transaction(t,"readonly"),o=n.objectStore(t),e=await a(n,o.getAll(c?.query,c?.count));return l?j(e,s):e},async getBy(c,n){const o=r.transaction(t,"readonly"),w=o.objectStore(t).index(c),i=await a(o,w.get(n));return l?x(i,s):i},async getAllBy(c,n){const o=r.transaction(t,"readonly"),w=o.objectStore(t).index(c),i=await a(o,w.getAll(n));return l?j(i,s):i},async put(c,n){const o=r.transaction(t,"readwrite"),e=o.objectStore(t);return a(o,e.put(c,n))},async add(c,n){const o=r.transaction(t,"readwrite"),e=o.objectStore(t);return a(o,e.add(c,n))},async delete(c){const n=r.transaction(t,"readwrite");n.objectStore(t).delete(c),await y(n)},async clear(){const c=r.transaction(t,"readwrite");c.objectStore(t).clear(),await y(c)},async count(c){const n=r.transaction(t,"readonly"),e=n.objectStore(t).count(c);return await y(n),e.result},async raw(c){const n=r.transaction(t,"readwrite"),o=n.objectStore(t),e=c(o);return await y(n),e.result},query:g}}u(createStoreAccessor,"createStoreAccessor");

package/dist/types.d.ts

@@ -83,7 +83,8 @@ export interface WriteChain<TStores extends readonly StoreDefinition[]> {
 export interface StoreAccessor<T, K> {
     get(key: K): Promise<T | undefined>;
     getAll(options?: GetAllOptions): Promise<T[]>;
-    getAllByIndex(indexName: string, query?: IDBKeyRange | IDBValidKey): Promise<T[]>;
+    getBy(indexName: string, query: IDBKeyRange | IDBValidKey): Promise<T | undefined>;
+    getAllBy(indexName: string, query?: IDBKeyRange | IDBValidKey): Promise<T[]>;
     put(value: T, key?: K): Promise<K>;
     add(value: T, key?: K): Promise<K>;
     delete(key: K | IDBKeyRange): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "schema-idb",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Type-safe IndexedDB wrapper with chainable transactions",
   "main": "./dist/index.js",
   "module": "./dist/index.js",