@incoqnito.io/bajadab 1.1.0

package/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "@incoqnito.io/bajadab",
+    "version": "1.1.0",
+    "description": "a lightweight json-based database for small-scale single-machine setups",
+    "homepage": "https://bitbucket.org/incoqnito/bajadab#readme",
+    "bugs": {
+        "url": "https://bitbucket.org/incoqnito/bajadab/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+ssh://git@bitbucket.org/incoqnito/bajadab.git"
+    },
+    "license": "LicenseRef-LICENSE",
+    "publishConfig": {
+        "access": "public"
+    },
+    "author": "Incoqnito GmbH",
+    "type": "module",
+    "main": "./dist/bajadab.js",
+    "types": "./dist/bajadab.d.ts",
+    "scripts": {
+        "prepublishOnly": "npm run build",
+        "clean": "rimraf dist",
+        "prebuild": "npm run clean",
+        "build": "tsc --project ./tsconfig.json",
+        "test": "node --import tsx --test-global-setup ./src/tests/tests.global.ts --test --enable-source-maps --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info --test-reporter=spec --test-reporter-destination=stdout ./src/tests/**/*.test.ts"
+    },
+    "engines": {
+        "node": ">= 24"
+    },
+    "dependencies": {
+        "@incoqnito.io/ts-iq-core": "^2.1.0",
+        "uuidv7": "^1.2.1"
+    },
+    "devDependencies": {
+        "@types/node": "^26.1.2",
+        "rimraf": "^6.1.3",
+        "tsx": "^4.23.1",
+        "typescript": "^7.0.2"
+    },
+    "overrides": {
+        "minimatch": "^10.2.6",
+        "glob": "^13.0.6"
+    },
+    "files": [
+        "dist",
+        "src/main"
+    ],
+    "allowScripts": {
+        "esbuild": true
+    }
+}

package/src/main/bajadab.ts

@@ -0,0 +1,3 @@
+export * from "./base.js";
+export { getDatabase } from "./fileio.js";
+export { DEFAULT_COLLECTION_CONFIG, DEFAULT_DATABASE_CONFIG, DEFAULT_GET_ID, DEFAULT_SET_ID, } from "./basics.js";

package/src/main/base.ts

@@ -0,0 +1,125 @@
+/** How a missing id is handled on {@link IBCollection.add}. */
+export enum EBAutoIDStrategy {
+    /** Reject values without an id. */
+    NO_AUTO_ID = "NO_AUTO_ID",
+    /** Generate a `uuidv7` and assign it via the configured setter. */
+    AUTO_ID_UUID = "AUTO_ID_UUID",
+}
+
+/** In-memory representation of a collection's data. */
+export enum EBMemStorageStrategy {
+    /** Keyed by id; `add()` looks up existing entries by id in O(1). */
+    MAP = "MAP",
+    // LINKED_LIST = "LINKED_LIST",
+    /** Plain list; insertion order is preserved. */
+    ARRAY = "ARRAY",
+}
+
+/** What happens on {@link IBCollection.add} when a value's id already exists. */
+export enum EBDuplicateIDStrategy {
+    /** Replace the existing value. */
+    OVERWRITE = "OVERWRITE",
+    /** Reject the whole call. */
+    ERROR = "ERROR",
+    /** Keep the existing value, drop the new one. */
+    IGNORE = "IGNORE",
+}
+
+/** How {@link IBCollection.delete} removes matched items from an `ARRAY` collection. */
+export enum EBArrayDeletionStrategy {
+    /** Build a new array via `filter()`. */
+    NEW_ARRAY = "NEW_ARRAY",
+    /** Compact the existing array in place. */
+    IN_PLACE = "IN_PLACE",
+}
+
+/** When a collection is written to disk after a mutation. */
+export enum EBAutoFlushStrategy {
+    /** Only on an explicit {@link IBCollection.flush} call. */
+    NO_AUTO_FLUSH = "NO_AUTO_FLUSH",
+    /** After every mutating call (`add`/`update`/`delete`). */
+    ALWAYS_AUTO_FLUSH = "ALWAYS_AUTO_FLUSH",
+}
+
+/** What {@link IBCollection.unload} does with unsaved changes. */
+export enum EBDirtyUnloadStrategy {
+    /** Reject the unload. */
+    ERROR = "ERROR",
+    /** Flush first, then unload. */
+    FLUSH = "FLUSH",
+    /** Discard the unsaved changes silently. */
+    IGNORE = "IGNORE",
+}
+
+/** Resolves the id of a value; `undefined` means "no id yet". */
+export type TGetIDFunction = (v: any) => Promise<string | undefined>;
+
+/** Assigns an id onto a value. */
+export type TSetIDFunction = (v: any, id: string) => Promise<void>;
+
+/** Per-collection behavior. Passed to {@link IBDatabase.createCollection}/{@link IBDatabase.getCollection}. */
+export interface IBCollectionConfig {
+    autoIDStrategy: EBAutoIDStrategy;
+    duplicateIDStrategy: EBDuplicateIDStrategy;
+    memStorageStrategy: EBMemStorageStrategy;
+    arrayDeletionStrategy: EBArrayDeletionStrategy;
+    dirtyUnloadStrategy: EBDirtyUnloadStrategy;
+    autoFlushStrategy: EBAutoFlushStrategy;
+    /** Registry key for a custom {@link TGetIDFunction}. Omit to use the default (reads `.id`). */
+    getID?: string;
+    /** Registry key for a custom {@link TSetIDFunction}. Omit to use the default (sets `.id`). */
+    setID?: string;
+}
+
+/** Database-wide configuration. */
+export interface IBDatabaseConfig {
+    /** Used for any collection created without an explicit config. */
+    readonly defaultCollectionConfig: IBCollectionConfig;
+}
+
+/** A JSON-file-backed database. Obtain one via `getDatabase()`. */
+export interface IBDatabase {
+    readonly config: IBDatabaseConfig;
+    /** Creates a new collection. Rejects if one with the same (canonicalized) name already exists. */
+    createCollection<T>(collectionName: string, collectionConfig?: IBCollectionConfig): Promise<IBCollection<T>>;
+    /** Returns the named collection, creating it with `collectionConfig` (or the database default) if it doesn't exist yet. */
+    getCollection<T>(collectionName: string, collectionConfig?: IBCollectionConfig): Promise<IBCollection<T>>;
+    /** Whether a collection with this (canonicalized) name exists. */
+    hasCollection(collectionName: string): Promise<boolean>;
+    /** Deletes a collection and invalidates any handle still held on it. Rejects if it doesn't exist. */
+    dropCollection(collectionName: string): Promise<void>;
+}
+
+/** A single collection of values of type `T`. Obtain one via {@link IBDatabase}. */
+export interface IBCollection<T = any> {
+    readonly database: IBDatabase;
+    readonly collectionConfig: IBCollectionConfig;
+    /** Canonicalized (trimmed, lowercased) name. */
+    readonly collectionName: string;
+    /** Stable identity used to address this collection's storage, independent of its name. */
+    readonly collectionID: string;
+
+    /** All items, or only those matching `predicate`. Always a defensive copy, never the live storage. */
+    get(predicate?: (v: T) => boolean): Promise<T[]>;
+    /** Deletes matching items. Returns the number removed. */
+    delete(predicate: (v: T) => boolean): Promise<number>;
+    /** Whether any item matches `predicate`. */
+    has(predicate: (v: T) => boolean): Promise<boolean>;
+    /** Adds values, resolving/assigning ids per the collection's id strategies. Returns the number added. */
+    add(...v: T[]): Promise<number>;
+    /** Replaces each item matching `predicate` with the (defined) result of `updater`. Returns the number updated. */
+    update(predicate: (v: T) => boolean, updater: (v: T) => Promise<T>): Promise<number>;
+
+    /** Writes the current in-memory state to disk. */
+    flush(): Promise<void>;
+    /** Discards in-memory state and re-reads it from disk. */
+    reload(): Promise<void>;
+    /** Evicts the in-memory state (per the dirty-unload strategy if there are unsaved changes). */
+    unload(): Promise<void>;
+}
+
+/** Resolves the custom id functions referenced by {@link IBCollectionConfig.getID}/`setID`. */
+export interface IBFunctionRegistry {
+    /** Returns the function registered under `key`, or `undefined` if there is none. */
+    fetch(key?: string): Function | undefined;
+}

package/src/main/basics.ts

@@ -0,0 +1,482 @@
+import logger from "winston";
+
+import { uuidv7, } from "uuidv7";
+import { runMultiReentrantProtected, runReentrantProtected } from "@incoqnito.io/ts-iq-core";
+
+import type { IODatabase } from "./fileio.js";
+
+import {
+    EBArrayDeletionStrategy,
+    EBAutoFlushStrategy,
+    EBAutoIDStrategy,
+    EBDirtyUnloadStrategy,
+    EBDuplicateIDStrategy,
+    EBMemStorageStrategy,
+    IBCollection,
+    IBCollectionConfig,
+    IBDatabase,
+    IBDatabaseConfig,
+    IBFunctionRegistry,
+    TGetIDFunction,
+    TSetIDFunction,
+} from "./base.js";
+import { canonicalName } from "./utils.js";
+
+/** Default {@link TGetIDFunction}: reads `v.id`, `undefined` if absent. */
+export const DEFAULT_GET_ID: TGetIDFunction = (v: any) => ("id" in v) ? v.id : undefined;
+/** Default {@link TSetIDFunction}: assigns to `v.id`. */
+export const DEFAULT_SET_ID: TSetIDFunction = async (v: any, id: string) => { v.id = id; };
+
+const enum MutexKeys {
+    // because of the spaces this will never be a collection name and as such is safe to use as a mutex key
+    DATABASE = " database ",
+}
+
+/** {@link IBCollectionConfig} used when a collection is created without an explicit one. */
+export const DEFAULT_COLLECTION_CONFIG: IBCollectionConfig = {
+    arrayDeletionStrategy: EBArrayDeletionStrategy.IN_PLACE,
+    autoIDStrategy: EBAutoIDStrategy.AUTO_ID_UUID,
+    duplicateIDStrategy: EBDuplicateIDStrategy.OVERWRITE,
+    memStorageStrategy: EBMemStorageStrategy.MAP,
+    dirtyUnloadStrategy: EBDirtyUnloadStrategy.FLUSH,
+    autoFlushStrategy: EBAutoFlushStrategy.ALWAYS_AUTO_FLUSH,
+};
+
+/** {@link IBDatabaseConfig} used when `getDatabase()` creates a fresh database. */
+export const DEFAULT_DATABASE_CONFIG: IBDatabaseConfig = {
+    defaultCollectionConfig: DEFAULT_COLLECTION_CONFIG,
+};
+
+export class BDatabase implements IBDatabase {
+    public readonly config: IBDatabaseConfig;
+    private collections: Map<string, BCollection> = new Map();
+    readonly io: IODatabase;
+    readonly functionRegistry?: IBFunctionRegistry;
+
+    public constructor(io: IODatabase, config?: IBDatabaseConfig, functionRegistry?: IBFunctionRegistry) {
+        this.config = config ?? DEFAULT_DATABASE_CONFIG;
+        this.io = io;
+        this.functionRegistry = functionRegistry;
+    }
+
+    public addCollection(collection: BCollection): void {
+        this.collections.set(collection.collectionName, collection);
+    }
+
+    public async getCollection<T>(collectionName: string, collectionConfig?: IBCollectionConfig): Promise<IBCollection<T>> {
+        return runReentrantProtected(MutexKeys.DATABASE, async () => {
+            const cname = canonicalName(collectionName);
+            let ret: BCollection<T> | undefined = this.collections.get(cname);
+            if (!ret) {
+                ret = await this.createCollection(collectionName, collectionConfig);
+            }
+            return ret;
+        });
+    }
+
+    public async createCollection<T = any>(collectionName: string, collectionConfig?: IBCollectionConfig): Promise<BCollection<T>> {
+        return runReentrantProtected(MutexKeys.DATABASE, async () => {
+            const cname = canonicalName(collectionName);
+            if (this.collections.has(cname)) {
+                throw new Error(`cannot create already existing collection ${collectionName}`);
+            }
+            const id = uuidv7();
+            const ret: BCollection<T> = new BCollection<T>(this, id, collectionName, collectionConfig ?? this.config.defaultCollectionConfig);
+            this.addCollection(ret);
+            return this.io.createCollection<T>(ret);
+        });
+    }
+
+    public async hasCollection(collectionName: string): Promise<boolean> {
+        return runReentrantProtected(MutexKeys.DATABASE, async () => {
+            return this.collections.has(canonicalName(collectionName));
+        });
+    }
+
+    public async dropCollection(collectionName: string): Promise<void> {
+        const cname = canonicalName(collectionName);
+        return runMultiReentrantProtected([MutexKeys.DATABASE, cname], async () => {
+            const coll: BCollection = this.collections.get(cname) as BCollection;
+            if (coll) {
+                coll.markDropped();
+                this.collections.delete(cname);
+                return this.io.deleteCollection(cname);
+            }
+            else {
+                throw new Error(`no such collection ${collectionName}`);
+            }
+        });
+    }
+
+}
+
+export class BCollection<T = any> implements IBCollection<T> {
+    readonly database: BDatabase;
+    readonly collectionConfig: IBCollectionConfig;
+    readonly collectionName: string;
+    readonly collectionID: string;
+
+    private mapData: Map<string, T> = new Map();
+    private arrayData: Array<T> = [];
+    private loaded: boolean = false;
+    private dirty: boolean = false;
+    private dropped: boolean = false;
+
+    public constructor(database: BDatabase, collectionID: string, collectionName: string, collectionConfig: IBCollectionConfig) {
+        this.database = database;
+        this.collectionID = collectionID;
+        this.collectionName = canonicalName(collectionName);
+        this.collectionConfig = collectionConfig;
+        switch (collectionConfig.memStorageStrategy) {
+            case EBMemStorageStrategy.MAP:
+                // if (!collectionConfig.getID || !collectionConfig.setID) {
+                //     throw new Error("need id accessors configured when using map mem storage");
+                // }
+                break;
+            default:
+            case EBMemStorageStrategy.ARRAY:
+                break;
+        }
+    }
+
+    private async checkLoaded(): Promise<void> {
+        if (!this.loaded) {
+            await this.reload();
+        }
+    }
+
+    private async runProtected<R>(fn: () => Promise<R>): Promise<R> {
+        return runReentrantProtected(this.collectionName, async () => {
+            if (this.dropped) {
+                throw new Error(`collection "${this.collectionName}" has been dropped`);
+            }
+            return fn();
+        });
+    }
+
+    /**
+     * call this only within the proteing mutex
+     */
+    public markDropped(): void {
+        this.dropped = true;
+    }
+
+    public async get(predicate?: (v: T) => boolean): Promise<T[]> {
+        return this.runProtected(async () => {
+            await this.checkLoaded();
+            switch (this.collectionConfig.memStorageStrategy) {
+                case EBMemStorageStrategy.MAP:
+                    return !predicate ?
+                        this.mapData.values().toArray() :
+                        this.mapData.values().filter(predicate).toArray();
+                default:
+                case EBMemStorageStrategy.ARRAY:
+                    return !predicate ?
+                        // MARK this may be a bit slow for bigger collections    
+                        [...this.arrayData] :
+                        this.arrayData.filter(predicate);
+            }
+        });
+    }
+
+    public async delete(predicate: (v: T) => boolean): Promise<number> {
+        return this.runProtected(async () => {
+            await this.checkLoaded();
+            let ret = 0;
+            switch (this.collectionConfig.memStorageStrategy) {
+                case EBMemStorageStrategy.MAP:
+                    for (const [key, value] of this.mapData) {
+                        if (predicate(value)) {
+                            ret++;
+                            this.mapData.delete(key);
+                        }
+                    }
+                    break;
+                default:
+                case EBMemStorageStrategy.ARRAY:
+                    switch (this.collectionConfig.arrayDeletionStrategy) {
+                        case EBArrayDeletionStrategy.IN_PLACE:
+                            let writeIndex = 0;
+                            for (let readIndex = 0; readIndex < this.arrayData.length; readIndex++) {
+                                const item = this.arrayData[readIndex];
+                                if (!predicate(item!)) {
+                                    this.arrayData[writeIndex] = item!;
+                                    writeIndex++;
+                                }
+                                else {
+                                    ret++;
+                                }
+                            }
+                            this.arrayData.length = writeIndex;
+                            break;
+                        default:
+                        case EBArrayDeletionStrategy.NEW_ARRAY:
+                            const ol = this.arrayData.length;
+                            this.arrayData = this.arrayData.filter(v => !predicate(v));
+                            ret += (ol - this.arrayData.length);
+                            break;
+                    }
+                    break;
+            }
+            if (ret > 0) {
+                await this.doOnDirty();
+            }
+            return ret;
+        });
+    }
+
+    public async has(predicate: (v: T) => boolean): Promise<boolean> {
+        return this.runProtected(async () => {
+            await this.checkLoaded();
+            switch (this.collectionConfig.memStorageStrategy) {
+                case EBMemStorageStrategy.MAP:
+                    return this.mapData.values().find(predicate) !== undefined;
+                default:
+                case EBMemStorageStrategy.ARRAY:
+                    return this.arrayData.find(predicate) !== undefined;
+            }
+        });
+    }
+
+    private async getID(v: T): Promise<string> {
+        let getter: TGetIDFunction;
+        if (this.collectionConfig.getID) {
+            const found = this.database.functionRegistry?.fetch(this.collectionConfig.getID) as TGetIDFunction | undefined;
+            if (!found) {
+                throw new Error(`getID function "${this.collectionConfig.getID}" is not registered`);
+            }
+            getter = found;
+        }
+        else {
+            getter = DEFAULT_GET_ID;
+        }
+        let id = await getter(v);
+        if (!id) {
+            switch (this.collectionConfig.autoIDStrategy) {
+                case EBAutoIDStrategy.NO_AUTO_ID:
+                    throw new Error("cannot omit auto-ids and than trying to add a value without an id");
+                default:
+                case EBAutoIDStrategy.AUTO_ID_UUID:
+                    id = uuidv7();
+                    let setter: TSetIDFunction;
+                    if (this.collectionConfig.setID) {
+                        const found = this.database.functionRegistry?.fetch(this.collectionConfig.setID) as TSetIDFunction | undefined;
+                        if (!found) {
+                            throw new Error(`setID function "${this.collectionConfig.setID}" is not registered`);
+                        }
+                        setter = found;
+                    }
+                    else {
+                        setter = DEFAULT_SET_ID;
+                    }
+                    await setter(v, id);
+                    break;
+            }
+        }
+        return id;
+    }
+
+    public async add(...vs: T[]): Promise<number> {
+        return this.runProtected(async () => {
+            await this.checkLoaded();
+            switch (this.collectionConfig.memStorageStrategy) {
+                case EBMemStorageStrategy.MAP:
+                    let ret = 0;
+                    for (const v of vs) {
+                        const id = await this.getID(v);
+                        if (this.mapData.has(id)) {
+                            switch (this.collectionConfig.duplicateIDStrategy) {
+                                case EBDuplicateIDStrategy.ERROR:
+                                    throw new Error(`duplicate id ${id}`);
+                                case EBDuplicateIDStrategy.IGNORE:
+                                    // ignore the new value
+                                    break;
+                                default:
+                                case EBDuplicateIDStrategy.OVERWRITE:
+                                    // replace the new value
+                                    ret++;
+                                    this.mapData.set(id, v);
+                                    break;
+                            }
+                        }
+                        else {
+                            ret++;
+                            this.mapData.set(id, v);
+                        }
+                    }
+                    if (ret > 0) {
+                        await this.doOnDirty();
+                    }
+                    return ret;
+                default:
+                case EBMemStorageStrategy.ARRAY:
+                    switch (this.collectionConfig.duplicateIDStrategy) {
+                        case EBDuplicateIDStrategy.ERROR:
+                            const haveIDs = new Set<string>();
+                            for (const v of this.arrayData) {
+                                haveIDs.add(await this.getID(v));
+                            }
+                            for (const v of vs) {
+                                const id = await this.getID(v);
+                                if (haveIDs.has(id)) {
+                                    throw new Error(`duplicate id ${id}`);
+                                }
+                                haveIDs.add(id);
+                                this.arrayData.push(v);
+                            }
+                            break;
+                        case EBDuplicateIDStrategy.IGNORE:
+                            const seenIDs = new Set<string>();
+                            for (const v of this.arrayData) {
+                                seenIDs.add(await this.getID(v));
+                            }
+                            for (const v of vs) {
+                                const id = await this.getID(v);
+                                if (!seenIDs.has(id)) {
+                                    seenIDs.add(id);
+                                    this.arrayData.push(v);
+                                }
+                            }
+                            break;
+                        default:
+                        case EBDuplicateIDStrategy.OVERWRITE:
+                            const indexMap = new Map<string | number, number>();
+                            for (let i = 0; i < this.arrayData.length; i++) {
+                                indexMap.set(await this.getID(this.arrayData[i]!), i);
+                            }
+                            for (const v of vs) {
+                                const id = await this.getID(v);
+                                const existingIndex = indexMap.get(id);
+
+                                if (existingIndex !== undefined) {
+                                    this.arrayData[existingIndex] = v;
+                                }
+                                else {
+                                    // store new index in indexCache in the case this id appears again
+                                    indexMap.set(id, this.arrayData.length);
+                                    this.arrayData.push(v);
+                                }
+                            }
+                            break;
+                    }
+                    if (vs.length > 0) {
+                        await this.doOnDirty();
+                    }
+                    return vs.length;
+            }
+        });
+    }
+
+    public async update(predicate: (v: T) => boolean, updater: (v: T) => Promise<T>): Promise<number> {
+        return this.runProtected(async () => {
+            await this.checkLoaded();
+            let ret = 0;
+            switch (this.collectionConfig.memStorageStrategy) {
+                case EBMemStorageStrategy.MAP:
+                    for (const [key, value] of this.mapData) {
+                        if (predicate(value)) {
+                            const replacement = await updater(value);
+                            if (replacement !== undefined) {
+                                ret++;
+                                this.mapData.set(key, replacement);
+                            }
+                            else {
+                                throw new Error("updater gave undefined");
+                            }
+                        }
+                    }
+                    break;
+                default:
+                case EBMemStorageStrategy.ARRAY:
+                    for (let i = 0; i < this.arrayData.length; i++) {
+                        if (predicate(this.arrayData[i]!)) {
+                            const replacement = await updater(this.arrayData[i]!);
+                            if (replacement !== undefined) {
+                                ret++;
+                                this.arrayData[i] = replacement;
+                            }
+                            else {
+                                throw new Error("updater gave undefined");
+                            }
+                        }
+                    }
+                    break;
+            }
+            if (ret > 0) {
+                await this.doOnDirty();
+            }
+            return ret;
+        });
+    }
+
+    private async doOnDirty(): Promise<void> {
+        this.dirty = true;
+        if (this.collectionConfig.autoFlushStrategy == EBAutoFlushStrategy.ALWAYS_AUTO_FLUSH) {
+            await this.flush();
+        }
+    }
+
+    public async flush(): Promise<void> {
+        return this.runProtected(async () => {
+            if (this.loaded) {
+                switch (this.collectionConfig.memStorageStrategy) {
+                    case EBMemStorageStrategy.MAP:
+                        await this.database.io.writeMapData(this.collectionID, this.mapData);
+                        break;
+                    default:
+                    case EBMemStorageStrategy.ARRAY:
+                        await this.database.io.writeArrayData(this.collectionID, this.arrayData);
+                        break;
+                }
+                this.dirty = false;
+            }
+        });
+    }
+
+    public async reload(): Promise<void> {
+        return this.runProtected(async () => {
+            switch (this.collectionConfig.memStorageStrategy) {
+                case EBMemStorageStrategy.MAP:
+                    this.mapData = await this.database.io.loadMapData<T>(this.collectionID);
+                    break;
+                default:
+                case EBMemStorageStrategy.ARRAY:
+                    this.arrayData = await this.database.io.loadArrayData<T>(this.collectionID);
+                    break;
+            }
+            this.loaded = true;
+            this.dirty = false;
+        });
+    }
+
+    public async unload(): Promise<void> {
+        return this.runProtected(async () => {
+            if (this.dirty) {
+                switch (this.collectionConfig.dirtyUnloadStrategy) {
+                    case EBDirtyUnloadStrategy.FLUSH:
+                        await this.flush();
+                        break;
+                    case EBDirtyUnloadStrategy.ERROR:
+                        throw new Error("cannot unload unwritten collection");
+                    default:
+                    case EBDirtyUnloadStrategy.IGNORE:
+                        // do nothing
+                        break;
+
+                }
+            }
+            switch (this.collectionConfig.memStorageStrategy) {
+                case EBMemStorageStrategy.MAP:
+                    this.mapData = new Map();
+                    break;
+                default:
+                case EBMemStorageStrategy.ARRAY:
+                    this.arrayData = [];
+                    break;
+            }
+            this.loaded = false;
+            this.dirty = false;
+        });
+    }
+
+}