asljs-dali 0.1.1 → 0.1.2

package/README.md

@@ -43,7 +43,8 @@ const db =
 const notes =
   new Table<Note>(
     'notes',
-    db);
+    db,
+    { /* options */ });
 
 await notes.add(
   { id: '1',
@@ -69,6 +70,11 @@ Versioning:
 - `IncrementTableVersionStrategy<T>`
 - `UuidTableVersionStrategy<T>`
 
+Delete strategies:
+
+- `TableDeleteStrategy<T>`
+- `UuidSoftDeleteTableDeleteStrategy<T>`
+
 Transactions:
 
 - `TxMode`

package/dist/delete-strategy-uuid-soft-delete-strategy.d.ts

@@ -0,0 +1,18 @@
+import { type DeleteStrategy } from './delete-strategy.js';
+type IndexQueryMapping = {
+    index: string;
+    key: IDBValidKey;
+};
+type IndexQueryMapper = (index: string, key: IDBValidKey) => IndexQueryMapping | null;
+export declare class UuidSoftDeleteStrategy<T extends Record<string, any>> implements DeleteStrategy<T> {
+    private readonly deletedField;
+    private readonly mapActiveIndexQuery?;
+    constructor(deletedField: keyof T & string, mapActiveIndexQuery?: IndexQueryMapper | undefined);
+    isDeleted(record: T): boolean;
+    delete(record: T): T;
+    mapIndexQuery(index: string, key: IDBValidKey): {
+        index: string;
+        key: IDBValidKey;
+    } | null;
+}
+export {};

package/dist/delete-strategy-uuid-soft-delete-strategy.js

@@ -0,0 +1,23 @@
+export class UuidSoftDeleteStrategy {
+    constructor(deletedField, mapActiveIndexQuery) {
+        this.deletedField = deletedField;
+        this.mapActiveIndexQuery = mapActiveIndexQuery;
+    }
+    isDeleted(record) {
+        const marker = record[this.deletedField];
+        return typeof marker === 'string'
+            && marker.length > 0;
+    }
+    delete(record) {
+        if (this.isDeleted(record))
+            return record;
+        return {
+            ...record,
+            [this.deletedField]: crypto.randomUUID()
+        };
+    }
+    mapIndexQuery(index, key) {
+        return this.mapActiveIndexQuery?.(index, key)
+            ?? null;
+    }
+}

package/dist/delete-strategy.d.ts

@@ -0,0 +1,8 @@
+export interface DeleteStrategy<T extends Record<string, any>> {
+    isDeleted(record: T): boolean;
+    delete(record: T): T;
+    mapIndexQuery?(index: string, key: IDBValidKey): {
+        index: string;
+        key: IDBValidKey;
+    } | null;
+}

package/dist/delete-strategy.js

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

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 export { dbDelete, dbOpen, dbRequestAsync, } from './db.js';
 export { IncrementVersionStrategy as IncrementTableVersionStrategy, } from './version-strategy-increment.js';
+export { type DeleteStrategy as TableDeleteStrategy, } from './delete-strategy.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 { UuidSoftDeleteStrategy as UuidSoftDeleteTableDeleteStrategy, } from './delete-strategy-uuid-soft-delete-strategy.js';
 export { UuidVersionStrategy as UuidTableVersionStrategy, } from './version-strategy-uuid.js';

package/dist/index.js

@@ -3,4 +3,5 @@ export { IncrementVersionStrategy as IncrementTableVersionStrategy, } from './ve
 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 { UuidSoftDeleteStrategy as UuidSoftDeleteTableDeleteStrategy, } from './delete-strategy-uuid-soft-delete-strategy.js';
 export { UuidVersionStrategy as UuidTableVersionStrategy, } from './version-strategy-uuid.js';

package/dist/table.d.ts

@@ -1,5 +1,6 @@
 import { EventfulBase } from 'asljs-eventful';
 import { type KeyPath } from './keys.js';
+import { type DeleteStrategy } from './delete-strategy.js';
 import { type VersionStrategy } from './version-strategy.js';
 export type TableEvents<T extends Record<string, any>> = {
     add: [record: T];
@@ -15,7 +16,10 @@ export declare class Table<T extends Record<string, any>> extends EventfulBase<T
     readonly storeName: string;
     readonly db: IDBDatabase;
     readonly key: KeyPath<T>;
-    constructor(storeName: string, db: IDBDatabase, strategy?: VersionStrategy<T>);
+    constructor(storeName: string, db: IDBDatabase, options?: {
+        versionStrategy?: VersionStrategy<T>;
+        deleteStrategy?: DeleteStrategy<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;

package/dist/table.js

@@ -9,21 +9,23 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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;
+var _Table_instances, _Table_receivers, _Table_versionStrategy, _Table_deleteStrategy, _Table_activeRecords, _Table_getActiveByIndex, _Table_getByIndex, _Table_isDeleted, _Table_canFallbackMappedQuery, _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) {
+    constructor(storeName, db, options) {
         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");
+        _Table_versionStrategy.set(this, void 0);
+        _Table_deleteStrategy.set(this, void 0);
+        __classPrivateFieldSet(this, _Table_versionStrategy, options?.versionStrategy, "f");
+        __classPrivateFieldSet(this, _Table_deleteStrategy, options?.deleteStrategy, "f");
         const key = txRead(this.db, this.storeName)
             .objectStore(this.storeName)
             .keyPath;
@@ -43,6 +45,10 @@ export class Table extends EventfulBase {
                         resolve(null);
                         return;
                     }
+                    if (__classPrivateFieldGet(this, _Table_instances, "m", _Table_isDeleted).call(this, fields)) {
+                        resolve(null);
+                        return;
+                    }
                     resolve(fields);
                 };
             request.onerror =
@@ -53,25 +59,9 @@ export class Table extends EventfulBase {
         });
     }
     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}`));
-                };
-        });
+        if (__classPrivateFieldGet(this, _Table_deleteStrategy, "f") === undefined)
+            return __classPrivateFieldGet(this, _Table_instances, "m", _Table_getByIndex).call(this, index, key, tx);
+        return __classPrivateFieldGet(this, _Table_instances, "m", _Table_getActiveByIndex).call(this, index, key, tx);
     }
     notify(receiver) {
         __classPrivateFieldGet(this, _Table_receivers, "f").push(receiver);
@@ -87,7 +77,7 @@ export class Table extends EventfulBase {
         const records = await dbRequestAsync(txRead(this.db, this.storeName, tx)
             .objectStore(this.storeName)
             .getAll());
-        return records;
+        return __classPrivateFieldGet(this, _Table_instances, "m", _Table_activeRecords).call(this, records);
     }
     scan(predicate, tx = null) {
         return new Promise((resolve, reject) => {
@@ -103,6 +93,10 @@ export class Table extends EventfulBase {
                         return;
                     }
                     const record = cursor.value;
+                    if (__classPrivateFieldGet(this, _Table_instances, "m", _Table_isDeleted).call(this, record)) {
+                        cursor.continue();
+                        return;
+                    }
                     try {
                         if (predicate(record)) {
                             result.push(record);
@@ -122,8 +116,8 @@ export class Table extends EventfulBase {
         });
     }
     async add(record, tx = null) {
-        const storedRecord = __classPrivateFieldGet(this, _Table_strategy, "f")
-            ? __classPrivateFieldGet(this, _Table_strategy, "f").initialise(record)
+        const storedRecord = __classPrivateFieldGet(this, _Table_versionStrategy, "f")
+            ? __classPrivateFieldGet(this, _Table_versionStrategy, "f").initialise(record)
             : record;
         const ltx = txWrite(this.db, this.storeName, tx);
         const store = ltx.objectStore(this.storeName);
@@ -145,14 +139,14 @@ export class Table extends EventfulBase {
             throw new Error(`Record with key ${String(key)} not found.`);
         }
         let storedRecord = record;
-        if (__classPrivateFieldGet(this, _Table_strategy, "f")) {
+        if (__classPrivateFieldGet(this, _Table_versionStrategy, "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));
+            if (!__classPrivateFieldGet(this, _Table_versionStrategy, "f").verify(existing, expectedVersion)) {
+                throw new VersionConflictError(key, expectedVersion, __classPrivateFieldGet(this, _Table_versionStrategy, "f").getVersion(existing));
             }
-            storedRecord = __classPrivateFieldGet(this, _Table_strategy, "f").update(record);
+            storedRecord = __classPrivateFieldGet(this, _Table_versionStrategy, "f").update(record);
         }
         await dbRequestAsync(store.put(storedRecord));
         __classPrivateFieldGet(this, _Table_instances, "m", _Table_onTransactionCompleted).call(this, store.transaction, () => {
@@ -171,18 +165,41 @@ export class Table extends EventfulBase {
         const existing = await dbRequestAsync(store.get(key));
         if (existing === undefined)
             return;
-        if (__classPrivateFieldGet(this, _Table_strategy, "f")) {
+        if (__classPrivateFieldGet(this, _Table_deleteStrategy, "f") === undefined) {
+            if (__classPrivateFieldGet(this, _Table_versionStrategy, "f")) {
+                if (expectedVersion === undefined) {
+                    throw new Error(`${this.storeName}: expectedVersion is required when a version strategy is configured.`);
+                }
+                if (!__classPrivateFieldGet(this, _Table_versionStrategy, "f").verify(existing, expectedVersion)) {
+                    throw new VersionConflictError(key, expectedVersion, __classPrivateFieldGet(this, _Table_versionStrategy, "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);
+            return;
+        }
+        if (__classPrivateFieldGet(this, _Table_deleteStrategy, "f").isDeleted(existing))
+            return;
+        if (__classPrivateFieldGet(this, _Table_versionStrategy, "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));
+            if (!__classPrivateFieldGet(this, _Table_versionStrategy, "f").verify(existing, expectedVersion)) {
+                throw new VersionConflictError(key, expectedVersion, __classPrivateFieldGet(this, _Table_versionStrategy, "f").getVersion(existing));
             }
         }
-        await dbRequestAsync(store.delete(key));
+        let storedRecord = __classPrivateFieldGet(this, _Table_deleteStrategy, "f").delete(existing);
+        if (__classPrivateFieldGet(this, _Table_versionStrategy, "f"))
+            storedRecord = __classPrivateFieldGet(this, _Table_versionStrategy, "f").update(storedRecord);
+        await dbRequestAsync(store.put(storedRecord));
         __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]);
+            this.emit('delete', storedRecord);
+            __classPrivateFieldGet(this, _Table_instances, "m", _Table_notify).call(this, 'delete', [storedRecord]);
         });
         if (tx === null)
             await txDone(ltx);
@@ -200,7 +217,57 @@ export class Table extends EventfulBase {
             await txDone(ltx);
     }
 }
-_Table_receivers = new WeakMap(), _Table_strategy = new WeakMap(), _Table_instances = new WeakSet(), _Table_onTransactionCompleted = function _Table_onTransactionCompleted(tx, action) {
+_Table_receivers = new WeakMap(), _Table_versionStrategy = new WeakMap(), _Table_deleteStrategy = new WeakMap(), _Table_instances = new WeakSet(), _Table_activeRecords = function _Table_activeRecords(records) {
+    const deleteStrategy = __classPrivateFieldGet(this, _Table_deleteStrategy, "f");
+    if (deleteStrategy === undefined)
+        return records;
+    return records.filter(record => !deleteStrategy.isDeleted(record));
+}, _Table_getActiveByIndex = async function _Table_getActiveByIndex(index, key, tx) {
+    const mapped = __classPrivateFieldGet(this, _Table_deleteStrategy, "f")?.mapIndexQuery?.(index, key);
+    if (mapped) {
+        try {
+            const records = await __classPrivateFieldGet(this, _Table_instances, "m", _Table_getByIndex).call(this, mapped.index, mapped.key, tx, false);
+            return __classPrivateFieldGet(this, _Table_instances, "m", _Table_activeRecords).call(this, records);
+        }
+        catch (error) {
+            // Degrade to filtering when mapped query cannot be executed.
+            if (!__classPrivateFieldGet(this, _Table_instances, "m", _Table_canFallbackMappedQuery).call(this, error))
+                throw error;
+        }
+    }
+    const records = await __classPrivateFieldGet(this, _Table_instances, "m", _Table_getByIndex).call(this, index, key, tx);
+    return __classPrivateFieldGet(this, _Table_instances, "m", _Table_activeRecords).call(this, records);
+}, _Table_getByIndex = function _Table_getByIndex(index, key, tx, validateKey = true) {
+    const store = txRead(this.db, this.storeName, tx)
+        .objectStore(this.storeName);
+    const idx = store.index(index);
+    const keyPath = idx.keyPath;
+    if (validateKey) {
+        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}`));
+            };
+    });
+}, _Table_isDeleted = function _Table_isDeleted(record) {
+    return __classPrivateFieldGet(this, _Table_deleteStrategy, "f")?.isDeleted(record)
+        ?? false;
+}, _Table_canFallbackMappedQuery = function _Table_canFallbackMappedQuery(error) {
+    if (!(error instanceof DOMException))
+        return false;
+    return error.name === 'NotFoundError'
+        || error.name === 'DataError';
+}, _Table_onTransactionCompleted = function _Table_onTransactionCompleted(tx, action) {
     tx.addEventListener('complete', () => {
         try {
             action();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "asljs-dali",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "IndexedDB data layer with a typed Table abstraction.",
   "type": "module",
   "main": "dist/index.js",