remult 3.3.19-next.2 → 3.3.19-next.3

package/esm/src/data-providers/in-memory-database.js

@@ -1,3 +1,4 @@
+import { getEntityMetadata, } from '../remult3/RepositoryImplementation.js';
 import { ArrayEntityDataProvider } from './array-entity-data-provider.js';
 export class InMemoryDataProvider {
     async transaction(action) {
@@ -15,7 +16,17 @@ export class InMemoryDataProvider {
         let name = entity.dbName;
         if (!this.rows[name])
             this.rows[name] = [];
-        return new ArrayEntityDataProvider(entity, () => this.rows[name]);
+        return new ArrayEntityDataProvider(entity, () => {
+            if (!this.rows[name])
+                this.rows[name] = [];
+            return this.rows[name];
+        });
+    }
+    async dropDatabase() {
+        this.rows = {};
+    }
+    async dropTable(entity) {
+        delete this.rows[getEntityMetadata(entity).dbName];
     }
     toString() {
         return 'InMemoryDataProvider';

package/esm/src/data-providers/indexed-db-data-provider.js

@@ -1,5 +1,5 @@
 import { dbNamesOf, isDbReadonly, } from '../filter/filter-consumer-bridge-to-sql-request.js';
-import { isAutoIncrement } from '../remult3/RepositoryImplementation.js';
+import { getEntityMetadata, isAutoIncrement, } from '../remult3/RepositoryImplementation.js';
 import { ArrayEntityDataProvider } from './array-entity-data-provider.js';
 export class IndexedDbIndexBuilder {
     //@internal
@@ -55,6 +55,29 @@ export class IndexedDbDataProvider {
         this.db?.close();
         this.db = undefined;
     }
+    async dropDatabase() {
+        await this.enqueue(async () => {
+            this.close();
+            this.dek = undefined;
+            await idbDeleteDatabase(this.dbName);
+        });
+    }
+    async dropTable(entity) {
+        await this.enqueue(async () => {
+            const name = storeNameOf(getEntityMetadata(entity));
+            const db = await this.open();
+            if (!db.objectStoreNames.contains(name))
+                return;
+            const nextVersion = db.version + 1;
+            this.forget(db);
+            db.close();
+            await this.open(nextVersion, (upgradeDb) => {
+                if (upgradeDb.objectStoreNames.contains(name)) {
+                    upgradeDb.deleteObjectStore(name);
+                }
+            });
+        });
+    }
     //@internal
     enqueue(fn) {
         const run = this.tail.then(fn, fn);
@@ -759,6 +782,16 @@ function idbReq(request) {
         request.onerror = () => reject(request.error);
     });
 }
+function idbDeleteDatabase(name) {
+    return new Promise((resolve, reject) => {
+        const req = indexedDB.deleteDatabase(name);
+        req.onsuccess = () => resolve();
+        req.onerror = () => reject(req.error);
+        req.onblocked = () => {
+            /* wait for onsuccess after other connections close */
+        };
+    });
+}
 function encAad(storeName, id) {
     return new TextEncoder().encode(storeName + '\0' + JSON.stringify(id));
 }

package/esm/src/remult3/RepositoryImplementation.js

@@ -323,6 +323,14 @@ export class RepositoryImplementation {
     }
     async insert(entity, options) {
         if (Array.isArray(entity)) {
+            if (!options?.bulk) {
+                const r = [];
+                for (const item of entity)
+                    r.push(await this.insert(item, options));
+                if (options?.select === 'none')
+                    return undefined;
+                return r;
+            }
             let refs = [];
             let raw = [];
             for (const item of entity) {

package/index.d.ts

@@ -23,7 +23,7 @@ export { IdEntity } from './src/remult3/IdEntity.js';
 export { describeClass, describeBackendMethods, describeEntity, } from './src/remult3/classDescribers.js';
 export type { EntityOptions, PreprocessFilterEvent } from './src/entity.js';
 export { EntityError } from './src/data-interfaces.js';
-export type { DataProvider, EntityDataProvider, EntityDataProviderGroupByOptions, EntityDataProviderFindOptions, ErrorInfo, RestDataProviderHttpProvider, } from './src/data-interfaces.js';
+export type { DataProvider, DroppableDataProvider, EntityDataProvider, EntityDataProviderGroupByOptions, EntityDataProviderFindOptions, ErrorInfo, RestDataProviderHttpProvider, } from './src/data-interfaces.js';
 export type { SqlCommand, SqlCommandWithParameters, SqlImplementation, SqlResult, } from './src/sql-command.js';
 export type { FieldMetadata, FieldOptions, FieldValidator, ValueConverter, ValueListItem, // reconsider, maybe it should go to remult angular as the abstraction ?
 ValueOrExpression, } from './src/column-interfaces.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "3.3.19-next.2",
+    "version": "3.3.19-next.3",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

package/src/data-interfaces.d.ts

@@ -1,6 +1,7 @@
 import type { FieldMetadata } from '../index.js';
 import type { Filter } from './filter/filter-interfaces.js';
 import type { GroupByOperators, EntityMetadata, MembersOnly, InsertOrUpdateOptions } from './remult3/remult3.js';
+import type { EntityMetadataOverloads } from './remult3/RepositoryImplementation.js';
 import { Sort } from './sort.js';
 export interface DataProvider {
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
@@ -8,6 +9,12 @@ export interface DataProvider {
     ensureSchema?(entities: EntityMetadata[]): Promise<void>;
     isProxy?: boolean;
 }
+/** `InMemoryDataProvider` + `IndexedDbDataProvider` — swap in tests. */
+export interface DroppableDataProvider extends DataProvider {
+    dropDatabase(): Promise<void>;
+    /** Recreated with indexes on next use (`ensureSchema` / first write). */
+    dropTable(entity: EntityMetadataOverloads): Promise<void>;
+}
 export interface Storage {
     ensureSchema(): Promise<void>;
 }

package/src/data-providers/in-memory-database.d.ts

@@ -1,9 +1,12 @@
 import type { __RowsOfDataForTesting } from '../__RowsOfDataForTesting.js';
-import type { DataProvider, EntityDataProvider } from '../data-interfaces.js';
+import type { DataProvider, DroppableDataProvider, EntityDataProvider } from '../data-interfaces.js';
+import { type EntityMetadataOverloads } from '../remult3/RepositoryImplementation.js';
 import type { EntityMetadata } from '../remult3/remult3.js';
-export declare class InMemoryDataProvider implements DataProvider, __RowsOfDataForTesting {
+export declare class InMemoryDataProvider implements DroppableDataProvider, __RowsOfDataForTesting {
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
     rows: any;
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
+    dropDatabase(): Promise<void>;
+    dropTable(entity: EntityMetadataOverloads): Promise<void>;
     toString(): string;
 }

package/src/data-providers/in-memory-database.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryDataProvider = void 0;
 var tslib_1 = require("tslib");
+var RepositoryImplementation_js_1 = require("../remult3/RepositoryImplementation.js");
 var array_entity_data_provider_js_1 = require("./array-entity-data-provider.js");
 var InMemoryDataProvider = /** @class */ (function () {
     function InMemoryDataProvider() {
@@ -35,7 +36,27 @@ var InMemoryDataProvider = /** @class */ (function () {
         var name = entity.dbName;
         if (!this.rows[name])
             this.rows[name] = [];
-        return new array_entity_data_provider_js_1.ArrayEntityDataProvider(entity, function () { return _this.rows[name]; });
+        return new array_entity_data_provider_js_1.ArrayEntityDataProvider(entity, function () {
+            if (!_this.rows[name])
+                _this.rows[name] = [];
+            return _this.rows[name];
+        });
+    };
+    InMemoryDataProvider.prototype.dropDatabase = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                this.rows = {};
+                return [2 /*return*/];
+            });
+        });
+    };
+    InMemoryDataProvider.prototype.dropTable = function (entity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                delete this.rows[(0, RepositoryImplementation_js_1.getEntityMetadata)(entity).dbName];
+                return [2 /*return*/];
+            });
+        });
     };
     InMemoryDataProvider.prototype.toString = function () {
         return 'InMemoryDataProvider';

package/src/data-providers/indexed-db-data-provider.d.ts

@@ -1,22 +1,44 @@
-import type { DataProvider, EntityDataProvider } from '../data-interfaces.js';
+import type { DataProvider, DroppableDataProvider, EntityDataProvider } from '../data-interfaces.js';
 import type { ClassType } from '../../classType.js';
 import type { EntityMetadata, MembersOnly } from '../remult3/remult3.js';
+import { type EntityMetadataOverloads } from '../remult3/RepositoryImplementation.js';
 export type IndexedDbIndexDef<entityType> = keyof MembersOnly<entityType> | readonly (keyof MembersOnly<entityType>)[];
 export declare class IndexedDbIndexBuilder {
     ensureIndexes<entityType>(entity: ClassType<entityType>, indexes: readonly IndexedDbIndexDef<entityType>[]): this;
 }
 export type IndexedDbDataProviderOptions = {
+    /** IDB-only indexes (not unique). PK is skipped. Compound names join db names with `_`. */
     indexes?: (x: IndexedDbIndexBuilder) => void;
+    /**
+     * AES-GCM 256 on non-indexed fields (`_enc` + `_iv`). Requires `crypto.subtle`.
+     *
+     * Not full security. Stops casual disk/profile dump and other origins
+     * (non-extractable `CryptoKey` wrapped by the browser). Does **not** protect
+     * against same-origin XSS / any JS that can use the stored `CryptoKey` to decrypt.
+     *
+     * PK + `ensureIndexes` fields stay plaintext (required for IDB keyPath/indexes).
+     * Only non-indexed fields go into `_enc`.
+     *
+     * Default auto-key is origin-bound theater vs XSS. Pass `getEncryptionKey` for
+     * a stronger secret you control.
+     */
     encrypt?: boolean;
+    /**
+     * Your AES-GCM `CryptoKey` (or Promise). Skips `__remult_keys`. Stronger than
+     * the default origin-bound auto-key — still not XSS-safe if same-origin JS can
+     * call this and decrypt.
+     */
     getEncryptionKey?: () => CryptoKey | Promise<CryptoKey>;
 };
-export declare class IndexedDbDataProvider implements DataProvider {
+export declare class IndexedDbDataProvider implements DroppableDataProvider {
     private dbName;
     constructor(dbName?: string, options?: IndexedDbDataProviderOptions);
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
     ensureSchema(entities: EntityMetadata[]): Promise<void>;
     close(): void;
+    dropDatabase(): Promise<void>;
+    dropTable(entity: EntityMetadataOverloads): Promise<void>;
 }
 export type IdbFetchOp = {
     type: 'keys';

package/src/data-providers/indexed-db-data-provider.js

@@ -74,6 +74,68 @@ var IndexedDbDataProvider = /** @class */ (function () {
         (_a = this.db) === null || _a === void 0 ? void 0 : _a.close();
         this.db = undefined;
     };
+    IndexedDbDataProvider.prototype.dropDatabase = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.enqueue(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        this.close();
+                                        this.dek = undefined;
+                                        return [4 /*yield*/, idbDeleteDatabase(this.dbName)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    IndexedDbDataProvider.prototype.dropTable = function (entity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.enqueue(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var name, db, nextVersion;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        name = storeNameOf((0, RepositoryImplementation_js_1.getEntityMetadata)(entity));
+                                        return [4 /*yield*/, this.open()];
+                                    case 1:
+                                        db = _a.sent();
+                                        if (!db.objectStoreNames.contains(name))
+                                            return [2 /*return*/];
+                                        nextVersion = db.version + 1;
+                                        this.forget(db);
+                                        db.close();
+                                        return [4 /*yield*/, this.open(nextVersion, function (upgradeDb) {
+                                                if (upgradeDb.objectStoreNames.contains(name)) {
+                                                    upgradeDb.deleteObjectStore(name);
+                                                }
+                                            })];
+                                    case 2:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     //@internal
     IndexedDbDataProvider.prototype.enqueue = function (fn) {
         var run = this.tail.then(fn, fn);
@@ -1299,6 +1361,16 @@ function idbReq(request) {
         request.onerror = function () { return reject(request.error); };
     });
 }
+function idbDeleteDatabase(name) {
+    return new Promise(function (resolve, reject) {
+        var req = indexedDB.deleteDatabase(name);
+        req.onsuccess = function () { return resolve(); };
+        req.onerror = function () { return reject(req.error); };
+        req.onblocked = function () {
+            /* wait for onsuccess after other connections close */
+        };
+    });
+}
 function encAad(storeName, id) {
     return new TextEncoder().encode(storeName + '\0' + JSON.stringify(id));
 }

package/src/remult3/RepositoryImplementation.d.ts

@@ -341,8 +341,8 @@ export declare class ControllerBase {
     get $(): FieldsRefForEntityBase<this>;
     get _(): ControllerRefForControllerBase<this>;
 }
-export declare function getEntityMetadata<entityType>(entity: EntityMetadataOverloads<entityType>): EntityMetadata<entityType>;
+export declare function getEntityMetadata<entityType = unknown>(entity: EntityMetadataOverloads<entityType>): EntityMetadata<entityType>;
 export declare function getRepository<entityType>(entity: RepositoryOverloads<entityType>): Repository<entityType>;
-export type EntityMetadataOverloads<entityType> = Repository<entityType> | EntityMetadata<entityType> | ClassType<entityType>;
+export type EntityMetadataOverloads<entityType = unknown> = Repository<entityType> | EntityMetadata<entityType> | ClassType<entityType>;
 export type RepositoryOverloads<entityType> = Repository<entityType> | ClassType<entityType>;
 export {};