asljs-dali 0.1.1

package/LICENSE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2026 Alexandrite Software Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,85 @@
+# dali
+
+> Part of [Alexandrite Software Library][#1] - a set of high-quality,
+performant JavaScript libraries for everyday use.
+
+## Overview
+
+`asljs-dali` is a data layer for apps that store data in IndexedDB. It is for
+developers who want a typed, event-aware table abstraction instead of
+hand-writing low-level request and transaction plumbing. Use it to model
+stores as `Table<T>`, keep CRUD operations consistent, and optionally enforce
+optimistic concurrency with version strategies.
+
+## Installation
+
+```bash
+npm install asljs-dali
+```
+
+NPM Package: [asljs-dali](https://www.npmjs.com/package/asljs-dali)
+
+## Usage
+
+```ts
+import {
+    dbOpen,
+    Table,
+  } from 'asljs-dali';
+
+type Note =
+  { id: string;
+    title: string; };
+
+const db =
+  await dbOpen(
+    'notes-db',
+    [ targetDb => {
+        targetDb.createObjectStore(
+          'notes',
+          { keyPath: 'id' });
+      } ]);
+
+const notes =
+  new Table<Note>(
+    'notes',
+    db);
+
+await notes.add(
+  { id: '1',
+    title: 'Hello' });
+
+const row =
+  await notes.getOne('1');
+```
+
+## API Reference
+
+Core:
+
+- `dbOpen(name, upgrades)`
+- `dbDelete(name)`
+- `dbRequestAsync(request)`
+- `Table<T>`
+
+Versioning:
+
+- `TableVersionStrategy<T>`
+- `TableVersionConflictError`
+- `IncrementTableVersionStrategy<T>`
+- `UuidTableVersionStrategy<T>`
+
+Transactions:
+
+- `TxMode`
+- `txRead(db, storeName, tx?)`
+- `txWrite(db, storeName, tx?)`
+- `txDone(tx)`
+- `txEnsure(tx, storeName, mode)`
+- `txReuseOrCreate(tx, storeNames, mode, db)`
+
+## License
+
+MIT License. See [LICENSE](LICENSE.md) for details.
+
+[#1]: https://github.com/AlexandriteSoftware/asljs

package/dist/db.d.ts

@@ -0,0 +1,3 @@
+export declare function dbRequestAsync<T>(request: IDBRequest<T>): Promise<T>;
+export declare function dbOpen(name: string, upgrades: ((db: IDBDatabase) => void)[]): Promise<IDBDatabase>;
+export declare function dbDelete(name: string): Promise<void>;

package/dist/db.js

@@ -0,0 +1,48 @@
+export function dbRequestAsync(request) {
+    return new Promise((resolve, reject) => {
+        request.addEventListener('success', () => {
+            resolve(request.result);
+        });
+        request.addEventListener('error', () => {
+            reject(request.error
+                ?? new Error('IndexedDB request failed'));
+        });
+    });
+}
+export function dbOpen(name, upgrades) {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(name, upgrades.length);
+        request.addEventListener('upgradeneeded', e => {
+            const updates = upgrades.slice(e.oldVersion - 1, e.newVersion
+                ?? upgrades.length - 1);
+            for (const update of updates) {
+                update(request.result);
+            }
+        });
+        request.addEventListener('success', () => {
+            resolve(request.result);
+        });
+        request.addEventListener('blocked', () => {
+            reject(new Error('Database opening is blocked'));
+        });
+        request.addEventListener('error', () => {
+            reject(request.error
+                ?? new Error('Failed to open database'));
+        });
+    });
+}
+export function dbDelete(name) {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.deleteDatabase(name);
+        request.addEventListener('success', () => {
+            resolve();
+        });
+        request.addEventListener('blocked', () => {
+            reject(new Error('Database deletion is blocked'));
+        });
+        request.addEventListener('error', () => {
+            reject(request.error
+                ?? new Error('Failed to delete database'));
+        });
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { dbDelete, dbOpen, dbRequestAsync, } from './db.js';
+export { IncrementVersionStrategy as IncrementTableVersionStrategy, } from './version-strategy-increment.js';
+export { Table, type TableEvents, type TableEventsReceiver, } from './table.js';
+export { VersionConflictError as TableVersionConflictError, } from './version-conflict-error.js';
+export { type VersionStrategy as TableVersionStrategy, } from './version-strategy.js';
+export { txDone, txRead, txReuseOrCreate, txWrite, TxMode, txEnsure, } from './transactions.js';
+export { UuidVersionStrategy as UuidTableVersionStrategy, } from './version-strategy-uuid.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { dbDelete, dbOpen, dbRequestAsync, } from './db.js';
+export { IncrementVersionStrategy as IncrementTableVersionStrategy, } from './version-strategy-increment.js';
+export { Table, } from './table.js';
+export { VersionConflictError as TableVersionConflictError, } from './version-conflict-error.js';
+export { txDone, txRead, txReuseOrCreate, txWrite, TxMode, txEnsure, } from './transactions.js';
+export { UuidVersionStrategy as UuidTableVersionStrategy, } from './version-strategy-uuid.js';

package/dist/keys.d.ts

@@ -0,0 +1,11 @@
+export type KeyRecord = {
+    [key: string]: any;
+};
+export type KeyPath<R extends KeyRecord> = (string & keyof R)[] | (string & keyof R);
+export declare function keyPathValid(keyPath: string | string[]): boolean;
+export declare function keyPathAssert(keyPath: string | string[]): asserts keyPath is string | string[];
+export declare function keyValueValid(value: any): boolean;
+export declare function keyValueAssert(value: any): asserts value is IDBValidKey;
+export declare function keyValid(keyPath: string | string[], key: IDBValidKey): boolean;
+export declare function keyAssert(keyPath: string | string[], key: IDBValidKey): asserts key is IDBValidKey;
+export declare function keyGet<R extends KeyRecord>(keyPath: KeyPath<R>, record: R): IDBValidKey;

package/dist/keys.js

@@ -0,0 +1,90 @@
+function keyPathItemValid(keyPathItem) {
+    return typeof keyPathItem === 'string'
+        && keyPathItem.length > 0;
+}
+export function keyPathValid(keyPath) {
+    if (Array.isArray(keyPath)) {
+        if (keyPath.length < 1)
+            return false;
+        return keyPath.every(keyPathItemValid);
+    }
+    return keyPathItemValid(keyPath);
+}
+export function keyPathAssert(keyPath) {
+    if (!keyPathValid(keyPath)) {
+        throw new TypeError('Key path must be a non-empty string or an array of non-empty strings.');
+    }
+}
+export function keyValueValid(value) {
+    if (value === null
+        || value === undefined) {
+        return false;
+    }
+    if (typeof value === 'string')
+        return true;
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (value instanceof Date)
+        return !Number.isNaN(value.getTime());
+    if (value instanceof ArrayBuffer)
+        return true;
+    if (ArrayBuffer.isView(value))
+        return true;
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            if (!(i in value))
+                return false;
+            if (!keyValueValid(value[i]))
+                return false;
+        }
+        return true;
+    }
+    return false;
+}
+export function keyValueAssert(value) {
+    if (!keyValueValid(value)) {
+        throw new TypeError('Value is not a valid IndexedDB key value.');
+    }
+}
+export function keyValid(keyPath, key) {
+    if (!Array.isArray(keyPath)) {
+        return !Array.isArray(key)
+            && keyValueValid(key);
+    }
+    if (keyPath.length === 1) {
+        return !Array.isArray(key)
+            && keyValueValid(key);
+    }
+    return Array.isArray(key)
+        && key.length === keyPath.length
+        && key.every(keyValueValid);
+}
+export function keyAssert(keyPath, key) {
+    const keyPathLength = Array.isArray(keyPath)
+        ? keyPath.length
+        : 1;
+    if (!keyValid(keyPath, key)) {
+        throw new TypeError(keyPathLength === 1
+            ? 'Key must be a single value.'
+            : `Key must be an array of length ${keyPathLength}.`);
+    }
+}
+export function keyGet(keyPath, record) {
+    if (!Array.isArray(keyPath)) {
+        const keyValue = record[keyPath];
+        keyValueAssert(keyValue);
+        return keyValue;
+    }
+    if (keyPath.length === 1) {
+        const keyValue = record[keyPath[0]];
+        keyValueAssert(keyValue);
+        return keyValue;
+    }
+    const key = new Array(keyPath.length);
+    for (let i = 0; i < keyPath.length; i++) {
+        const keyValue = record[keyPath[i]];
+        keyValueAssert(keyValue);
+        key[i] = keyValue;
+    }
+    return key;
+}

package/dist/table.d.ts

@@ -0,0 +1,28 @@
+import { EventfulBase } from 'asljs-eventful';
+import { type KeyPath } from './keys.js';
+import { type VersionStrategy } from './version-strategy.js';
+export type TableEvents<T extends Record<string, any>> = {
+    add: [record: T];
+    update: [record: T, previousRecord: T];
+    delete: [record: T];
+    clear: [records: T[]];
+};
+export type TableEventsReceiver<T extends Record<string, any>> = Partial<{
+    [K in keyof TableEvents<T>]: (...args: TableEvents<T>[K]) => void;
+}>;
+export declare class Table<T extends Record<string, any>> extends EventfulBase<TableEvents<T>> {
+    #private;
+    readonly storeName: string;
+    readonly db: IDBDatabase;
+    readonly key: KeyPath<T>;
+    constructor(storeName: string, db: IDBDatabase, strategy?: VersionStrategy<T>);
+    getOne(key: IDBValidKey, tx?: IDBTransaction | null): Promise<T | null>;
+    get(index: string, key: IDBValidKey, tx?: IDBTransaction | null): Promise<T[]>;
+    notify(receiver: TableEventsReceiver<T>): () => boolean;
+    getAll(tx?: IDBTransaction | null): Promise<T[]>;
+    scan(predicate: (record: T) => boolean, tx?: IDBTransaction | null): Promise<T[]>;
+    add(record: T, tx?: IDBTransaction | null): Promise<T>;
+    update(record: T, expectedVersion?: unknown, tx?: IDBTransaction | null): Promise<T>;
+    delete(key: IDBValidKey, expectedVersion?: unknown, tx?: IDBTransaction | null): Promise<void>;
+    clear(tx?: IDBTransaction | null): Promise<void>;
+}

package/dist/table.js

@@ -0,0 +1,226 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Table_instances, _Table_receivers, _Table_strategy, _Table_onTransactionCompleted, _Table_notify;
+import { EventfulBase } from 'asljs-eventful';
+import { dbRequestAsync } from './db.js';
+import { keyAssert, keyGet, keyPathAssert, } from './keys.js';
+import { VersionConflictError } from './version-conflict-error.js';
+import { txDone, txRead, txWrite, } from './transactions.js';
+export class Table extends EventfulBase {
+    constructor(storeName, db, strategy) {
+        super();
+        _Table_instances.add(this);
+        this.storeName = storeName;
+        this.db = db;
+        _Table_receivers.set(this, []);
+        _Table_strategy.set(this, void 0);
+        __classPrivateFieldSet(this, _Table_strategy, strategy, "f");
+        const key = txRead(this.db, this.storeName)
+            .objectStore(this.storeName)
+            .keyPath;
+        keyPathAssert(key);
+        this.key = key;
+    }
+    getOne(key, tx = null) {
+        keyAssert(this.key, key);
+        return new Promise((resolve, reject) => {
+            const request = txRead(this.db, this.storeName, tx)
+                .objectStore(this.storeName)
+                .get(key);
+            request.onsuccess =
+                () => {
+                    const fields = request.result;
+                    if (fields === undefined) {
+                        resolve(null);
+                        return;
+                    }
+                    resolve(fields);
+                };
+            request.onerror =
+                () => {
+                    reject(request.error
+                        ?? new Error(`${this.storeName}: getOne request failed`));
+                };
+        });
+    }
+    get(index, key, tx = null) {
+        const store = txRead(this.db, this.storeName, tx)
+            .objectStore(this.storeName);
+        const idx = store.index(index);
+        const keyPath = idx.keyPath;
+        keyPathAssert(keyPath);
+        keyAssert(keyPath, key);
+        return new Promise((resolve, reject) => {
+            const request = idx.getAll(key);
+            request.onsuccess =
+                () => {
+                    const records = request.result;
+                    resolve(records);
+                };
+            request.onerror =
+                () => {
+                    reject(request.error
+                        ?? new Error(`${this.storeName}: get request failed for index ${index}`));
+                };
+        });
+    }
+    notify(receiver) {
+        __classPrivateFieldGet(this, _Table_receivers, "f").push(receiver);
+        return () => {
+            const index = __classPrivateFieldGet(this, _Table_receivers, "f").indexOf(receiver);
+            if (index < 0)
+                return false;
+            __classPrivateFieldGet(this, _Table_receivers, "f").splice(index, 1);
+            return true;
+        };
+    }
+    async getAll(tx = null) {
+        const records = await dbRequestAsync(txRead(this.db, this.storeName, tx)
+            .objectStore(this.storeName)
+            .getAll());
+        return records;
+    }
+    scan(predicate, tx = null) {
+        return new Promise((resolve, reject) => {
+            const request = txRead(this.db, this.storeName, tx)
+                .objectStore(this.storeName)
+                .openCursor();
+            const result = [];
+            request.onsuccess =
+                () => {
+                    const cursor = request.result;
+                    if (cursor === null) {
+                        resolve(result);
+                        return;
+                    }
+                    const record = cursor.value;
+                    try {
+                        if (predicate(record)) {
+                            result.push(record);
+                        }
+                    }
+                    catch (error) {
+                        reject(error);
+                        return;
+                    }
+                    cursor.continue();
+                };
+            request.onerror =
+                () => {
+                    reject(request.error
+                        ?? new Error(`${this.storeName}: scan request failed`));
+                };
+        });
+    }
+    async add(record, tx = null) {
+        const storedRecord = __classPrivateFieldGet(this, _Table_strategy, "f")
+            ? __classPrivateFieldGet(this, _Table_strategy, "f").initialise(record)
+            : record;
+        const ltx = txWrite(this.db, this.storeName, tx);
+        const store = ltx.objectStore(this.storeName);
+        await dbRequestAsync(store.add(storedRecord));
+        __classPrivateFieldGet(this, _Table_instances, "m", _Table_onTransactionCompleted).call(this, store.transaction, () => {
+            this.emit('add', storedRecord);
+            __classPrivateFieldGet(this, _Table_instances, "m", _Table_notify).call(this, 'add', [storedRecord]);
+        });
+        if (tx === null)
+            await txDone(ltx);
+        return storedRecord;
+    }
+    async update(record, expectedVersion, tx = null) {
+        const key = keyGet(this.key, record);
+        const ltx = txWrite(this.db, this.storeName, tx);
+        const store = ltx.objectStore(this.storeName);
+        const existing = await dbRequestAsync(store.get(key));
+        if (!existing) {
+            throw new Error(`Record with key ${String(key)} not found.`);
+        }
+        let storedRecord = record;
+        if (__classPrivateFieldGet(this, _Table_strategy, "f")) {
+            if (expectedVersion === undefined) {
+                throw new Error(`${this.storeName}: expectedVersion is required when a version strategy is configured.`);
+            }
+            if (!__classPrivateFieldGet(this, _Table_strategy, "f").verify(existing, expectedVersion)) {
+                throw new VersionConflictError(key, expectedVersion, __classPrivateFieldGet(this, _Table_strategy, "f").getVersion(existing));
+            }
+            storedRecord = __classPrivateFieldGet(this, _Table_strategy, "f").update(record);
+        }
+        await dbRequestAsync(store.put(storedRecord));
+        __classPrivateFieldGet(this, _Table_instances, "m", _Table_onTransactionCompleted).call(this, store.transaction, () => {
+            this.emit('update', storedRecord, existing);
+            __classPrivateFieldGet(this, _Table_instances, "m", _Table_notify).call(this, 'update', [storedRecord,
+                existing]);
+        });
+        if (tx === null)
+            await txDone(ltx);
+        return storedRecord;
+    }
+    async delete(key, expectedVersion, tx = null) {
+        keyAssert(this.key, key);
+        const ltx = txWrite(this.db, this.storeName, tx);
+        const store = ltx.objectStore(this.storeName);
+        const existing = await dbRequestAsync(store.get(key));
+        if (existing === undefined)
+            return;
+        if (__classPrivateFieldGet(this, _Table_strategy, "f")) {
+            if (expectedVersion === undefined) {
+                throw new Error(`${this.storeName}: expectedVersion is required when a version strategy is configured.`);
+            }
+            if (!__classPrivateFieldGet(this, _Table_strategy, "f").verify(existing, expectedVersion)) {
+                throw new VersionConflictError(key, expectedVersion, __classPrivateFieldGet(this, _Table_strategy, "f").getVersion(existing));
+            }
+        }
+        await dbRequestAsync(store.delete(key));
+        __classPrivateFieldGet(this, _Table_instances, "m", _Table_onTransactionCompleted).call(this, store.transaction, () => {
+            this.emit('delete', existing);
+            __classPrivateFieldGet(this, _Table_instances, "m", _Table_notify).call(this, 'delete', [existing]);
+        });
+        if (tx === null)
+            await txDone(ltx);
+    }
+    async clear(tx = null) {
+        const ltx = txWrite(this.db, this.storeName, tx);
+        const store = ltx.objectStore(this.storeName);
+        const records = await dbRequestAsync(store.getAll());
+        await dbRequestAsync(store.clear());
+        __classPrivateFieldGet(this, _Table_instances, "m", _Table_onTransactionCompleted).call(this, store.transaction, () => {
+            this.emit('clear', records);
+            __classPrivateFieldGet(this, _Table_instances, "m", _Table_notify).call(this, 'clear', [records]);
+        });
+        if (tx === null)
+            await txDone(ltx);
+    }
+}
+_Table_receivers = new WeakMap(), _Table_strategy = new WeakMap(), _Table_instances = new WeakSet(), _Table_onTransactionCompleted = function _Table_onTransactionCompleted(tx, action) {
+    tx.addEventListener('complete', () => {
+        try {
+            action();
+        }
+        catch (error) {
+            console.error(`${this.storeName}: on complete action failed`, error);
+        }
+    }, { once: true });
+}, _Table_notify = function _Table_notify(eventName, args) {
+    if (__classPrivateFieldGet(this, _Table_receivers, "f").length === 0)
+        return;
+    for (const receiver of __classPrivateFieldGet(this, _Table_receivers, "f")) {
+        const handler = receiver[eventName];
+        if (typeof handler !== 'function')
+            continue;
+        try {
+            handler(...args);
+        }
+        catch (error) {
+            console.error(`${this.storeName}: notify handler failed for event ${String(eventName)}`, error);
+        }
+    }
+};

package/dist/transactions.d.ts

@@ -0,0 +1,21 @@
+export declare const TxMode: {
+    read: IDBTransactionMode;
+    readWrite: IDBTransactionMode;
+};
+export declare function txDone(tx: IDBTransaction): Promise<void>;
+export declare function txReuseOrCreate(tx: IDBTransaction | null, storeNames: string | string[], mode: IDBTransactionMode, db: IDBDatabase): IDBTransaction;
+export declare function txEnsure(tx: IDBTransaction, storeName: string, mode: IDBTransactionMode): void;
+export declare class UnsupportedTransactionModeError extends Error {
+    constructor(mode: IDBTransactionMode);
+}
+export declare class TransactionReadModeRequiredError extends Error {
+    constructor(storeName: string);
+}
+export declare class TransactionWriteModeRequiredError extends Error {
+    constructor(storeName: string);
+}
+export declare class TransactionStoreAccessError extends Error {
+    constructor(storeName: string);
+}
+export declare function txRead(db: IDBDatabase, storeName: string, tx?: IDBTransaction | null): IDBTransaction;
+export declare function txWrite(db: IDBDatabase, storeName: string, tx?: IDBTransaction | null): IDBTransaction;

package/dist/transactions.js

@@ -0,0 +1,85 @@
+export const TxMode = { read: 'readonly',
+    readWrite: 'readwrite' };
+export function txDone(tx) {
+    return new Promise((resolve, reject) => {
+        tx.addEventListener('complete', () => {
+            resolve();
+        });
+        tx.addEventListener('abort', () => {
+            reject(tx.error);
+        });
+        tx.addEventListener('error', () => {
+            reject(tx.error);
+        });
+    });
+}
+export function txReuseOrCreate(tx, storeNames, mode, db) {
+    if (tx) {
+        const storeNamesArray = Array.isArray(storeNames)
+            ? storeNames
+            : [storeNames];
+        for (const storeName of storeNamesArray) {
+            txEnsure(tx, storeName, mode);
+        }
+        return tx;
+    }
+    return db.transaction(storeNames, mode);
+}
+export function txEnsure(tx, storeName, mode) {
+    if (!tx.objectStoreNames.contains(storeName)) {
+        throw new TransactionStoreAccessError(storeName);
+    }
+    switch (mode) {
+        case TxMode.read:
+            if (tx.mode !== TxMode.read
+                && tx.mode !== TxMode.readWrite) {
+                throw new TransactionReadModeRequiredError(storeName);
+            }
+            break;
+        case TxMode.readWrite:
+            if (tx.mode !== TxMode.readWrite) {
+                throw new TransactionWriteModeRequiredError(storeName);
+            }
+            break;
+        default:
+            throw new UnsupportedTransactionModeError(mode);
+    }
+}
+export class UnsupportedTransactionModeError extends Error {
+    constructor(mode) {
+        super(`Unsupported transaction mode "${mode}"`);
+        this.name = 'UnsupportedTransactionModeError';
+    }
+}
+export class TransactionReadModeRequiredError extends Error {
+    constructor(storeName) {
+        super(`Transaction does not have read access to the store "${storeName}".`);
+        this.name = 'TransactionReadModeRequiredError';
+    }
+}
+export class TransactionWriteModeRequiredError extends Error {
+    constructor(storeName) {
+        super(`Transaction does not have write access to the store "${storeName}".`);
+        this.name = 'TransactionWriteModeRequiredError';
+    }
+}
+export class TransactionStoreAccessError extends Error {
+    constructor(storeName) {
+        super(`Transaction does not have access to the store "${storeName}".`);
+        this.name = 'TransactionStoreAccessError';
+    }
+}
+export function txRead(db, storeName, tx = null) {
+    if (tx !== null) {
+        txEnsure(tx, storeName, TxMode.read);
+        return tx;
+    }
+    return db.transaction([storeName], TxMode.read);
+}
+export function txWrite(db, storeName, tx = null) {
+    if (tx !== null) {
+        txEnsure(tx, storeName, TxMode.readWrite);
+        return tx;
+    }
+    return db.transaction([storeName], TxMode.readWrite);
+}

package/dist/version-conflict-error.d.ts

@@ -0,0 +1,6 @@
+export declare class VersionConflictError extends Error {
+    readonly key: IDBValidKey;
+    readonly expectedVersion: unknown;
+    readonly actualVersion: unknown;
+    constructor(key: IDBValidKey, expectedVersion: unknown, actualVersion: unknown);
+}

package/dist/version-conflict-error.js

@@ -0,0 +1,9 @@
+export class VersionConflictError extends Error {
+    constructor(key, expectedVersion, actualVersion) {
+        super(`Version conflict for key ${String(key)}.`);
+        this.key = key;
+        this.expectedVersion = expectedVersion;
+        this.actualVersion = actualVersion;
+        this.name = 'VersionConflictError';
+    }
+}

package/dist/version-strategy-increment.d.ts

@@ -0,0 +1,9 @@
+import { type VersionStrategy } from './version-strategy.js';
+export declare class IncrementVersionStrategy<T extends Record<string, any>> implements VersionStrategy<T> {
+    private readonly field;
+    constructor(field: string & keyof T);
+    getVersion(record: T): unknown;
+    initialise(record: T): T;
+    verify(record: T, expectedVersion: unknown): boolean;
+    update(record: T): T;
+}

package/dist/version-strategy-increment.js

@@ -0,0 +1,27 @@
+export class IncrementVersionStrategy {
+    constructor(field) {
+        this.field = field;
+    }
+    getVersion(record) {
+        return record[this.field];
+    }
+    initialise(record) {
+        const version = record[this.field];
+        if (typeof version === 'number'
+            && Number.isFinite(version)) {
+            return record;
+        }
+        return { ...record, [this.field]: 1 };
+    }
+    verify(record, expectedVersion) {
+        return record[this.field] === expectedVersion;
+    }
+    update(record) {
+        const version = record[this.field];
+        if (typeof version !== 'number'
+            || !Number.isFinite(version)) {
+            throw new Error(`Version field "${String(this.field)}" does not contain a valid number.`);
+        }
+        return { ...record, [this.field]: version + 1 };
+    }
+}

package/dist/version-strategy-uuid.d.ts

@@ -0,0 +1,9 @@
+import { type VersionStrategy } from './version-strategy.js';
+export declare class UuidVersionStrategy<T extends Record<string, any>> implements VersionStrategy<T> {
+    private readonly field;
+    constructor(field: string & keyof T);
+    getVersion(record: T): unknown;
+    initialise(record: T): T;
+    verify(record: T, expectedVersion: unknown): boolean;
+    update(record: T): T;
+}

package/dist/version-strategy-uuid.js

@@ -0,0 +1,23 @@
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export class UuidVersionStrategy {
+    constructor(field) {
+        this.field = field;
+    }
+    getVersion(record) {
+        return record[this.field];
+    }
+    initialise(record) {
+        const version = record[this.field];
+        if (typeof version === 'string'
+            && UUID_PATTERN.test(version)) {
+            return record;
+        }
+        return { ...record, [this.field]: crypto.randomUUID() };
+    }
+    verify(record, expectedVersion) {
+        return record[this.field] === expectedVersion;
+    }
+    update(record) {
+        return { ...record, [this.field]: crypto.randomUUID() };
+    }
+}

package/dist/version-strategy.d.ts

@@ -0,0 +1,6 @@
+export interface VersionStrategy<T extends Record<string, any>> {
+    getVersion(record: T): unknown;
+    initialise(record: T): T;
+    verify(record: T, expectedVersion: unknown): boolean;
+    update(record: T): T;
+}

package/dist/version-strategy.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "asljs-dali",
+  "version": "0.1.1",
+  "description": "IndexedDB data layer with a typed Table abstraction.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/**",
+    "README.md",
+    "LICENSE.md"
+  ],
+  "scripts": {
+    "clean": "node ../toolkit.js clean-dist",
+    "build": "npx tsc -p tsconfig.build.json",
+    "build:test": "npx tsc -p tsconfig.test.json",
+    "lint": "npx eslint .",
+    "lint:fix": "npx eslint . --fix",
+    "guard:clean-git": "node ../toolkit.js ensure-clean-working-folder",
+    "prepack": "npm run clean && npm run build",
+    "prepublishOnly": "npm run guard:clean-git && npm run prepack",
+    "postpublish": "node ../toolkit.js tag-commit-with-release-id",
+    "test": "npm run build:test && node --test dist/*.test.js",
+    "test:watch": "npm run build:test && node --watch --test dist/*.test.js",
+    "coverage": "npm run build:test && NODE_V8_COVERAGE=.coverage node --test dist/*.test.js && node -e \"console.log('Coverage in .coverage (use c8/istanbul if you want reports)')\""
+  },
+  "keywords": [
+    "indexeddb",
+    "table",
+    "data-layer",
+    "javascript"
+  ],
+  "author": "\"Alex Netkachov\" <alex.netkachov@gmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/AlexandriteSoftware/asljs#readme",
+  "bugs": {
+    "url": "https://github.com/AlexandriteSoftware/asljs/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AlexandriteSoftware/asljs.git"
+  },
+  "dependencies": {
+    "asljs-eventful": "^0.4.8"
+  },
+  "devDependencies": {
+    "fake-indexeddb": "^6.2.4"
+  }
+}