@incoqnito.io/bajadab 1.1.0

package/src/main/fileio.ts

@@ -0,0 +1,154 @@
+import { IBCollectionConfig, IBDatabase, IBDatabaseConfig, IBFunctionRegistry, } from "./base.js";
+import { BCollection, BDatabase, DEFAULT_DATABASE_CONFIG, } from "./basics.js";
+import { uuidv7 } from "uuidv7";
+import { access, constants, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+interface IStoredDatabase {
+    config: IBDatabaseConfig;
+    nameIDMap: { [k: string]: string; };
+}
+
+interface IStoredCollection<T> {
+    collectionID: string;
+    collectionName: string;
+    collectionConfig: IBCollectionConfig;
+    path: string;
+}
+
+const DB_META_FILE_NAME = "dbmeta.json";
+const DB_COLLECTION_FOLDER_SUFFIX = "_data";
+const DB_COLLECTION_META_FILE_SUFFIX = ".json";
+const DB_COLLECTION_DATA_FILE = "data.json";
+const RESTRICTED_FILE_MODE = 0o600;
+const RESTRICTED_DIR_MODE = 0o700;
+
+async function atomicWriteFile(targetPath: string, data: string): Promise<void> {
+    const tempPath = `${targetPath}.${uuidv7()}.tmp`;
+    await writeFile(tempPath, data, { encoding: "utf-8", mode: RESTRICTED_FILE_MODE });
+    await rename(tempPath, targetPath);
+}
+
+export class IODatabase {
+    readonly basePath: string;
+    private readonly nameIDMap: Map<string, string>;
+    private databaseConfig: IBDatabaseConfig;
+
+    public constructor(basePath: string, databaseConfig: IBDatabaseConfig, nameIDMap?: Map<string, string>) {
+        this.basePath = basePath;
+        this.databaseConfig = databaseConfig;
+        this.nameIDMap = nameIDMap ?? new Map();
+    }
+
+    private async loadCollectionMeta(id: string, database: BDatabase): Promise<BCollection> {
+        const meta: IStoredCollection<any> = JSON.parse(await readFile(join(this.basePath, id + DB_COLLECTION_META_FILE_SUFFIX), { encoding: "utf-8" }));
+        return new BCollection(database, id, meta.collectionName, meta.collectionConfig);
+    }
+
+    public static async createOrLoad(basePath: string, functionRegistry?: IBFunctionRegistry): Promise<BDatabase> {
+        const metaPath = join(basePath, DB_META_FILE_NAME);
+        let data: string;
+        try {
+            await access(metaPath, constants.F_OK);
+            data = await readFile(metaPath, { encoding: "utf-8" })
+        }
+        catch (err: any) {
+            if (err.code === 'ENOENT') {
+                const iodb = new IODatabase(basePath, DEFAULT_DATABASE_CONFIG);
+                return new BDatabase(iodb, DEFAULT_DATABASE_CONFIG, functionRegistry);
+            }
+            throw err;
+        }
+        const meta: IStoredDatabase = JSON.parse(data);
+        const nameIDMap = new Map(Object.entries(meta.nameIDMap));
+        const iodb = new IODatabase(basePath, meta.config, nameIDMap);
+        const database = new BDatabase(iodb, meta.config, functionRegistry);
+        const collections = await Promise.all(
+            nameIDMap.values()
+                .map(id => iodb.loadCollectionMeta(id, database))
+                .toArray());
+        collections.forEach(c => database.addCollection(c));
+        return database;
+    }
+
+    public async flush(): Promise<void> {
+        const meta: IStoredDatabase = {
+            config: this.databaseConfig,
+            nameIDMap: Object.fromEntries(this.nameIDMap),
+        };
+        const data = JSON.stringify(meta);
+        await atomicWriteFile(join(this.basePath, DB_META_FILE_NAME), data);
+    }
+
+    public async createCollection<T = any>(collection: BCollection<T>): Promise<BCollection<T>> {
+        const id = collection.collectionID;
+        const collectionPath = join(this.basePath, id + DB_COLLECTION_FOLDER_SUFFIX);
+        await mkdir(collectionPath, { recursive: true, mode: RESTRICTED_DIR_MODE });
+        const meta: IStoredCollection<T> = {
+            collectionConfig: collection.collectionConfig,
+            collectionName: collection.collectionName,
+            collectionID: id,
+            path: collectionPath,
+        };
+        const data = JSON.stringify(meta);
+        await atomicWriteFile(join(this.basePath, id + DB_COLLECTION_META_FILE_SUFFIX), data);
+        this.nameIDMap.set(collection.collectionName, id);
+        await this.flush();
+        return collection;
+    }
+
+    public async deleteCollection(collectionName: string): Promise<void> {
+        const id = this.nameIDMap.get(collectionName);
+        if (!id) {
+            throw new Error(`no such database ${collectionName}`);
+        }
+        const collectionPath = join(this.basePath, id + DB_COLLECTION_FOLDER_SUFFIX);
+        await rm(collectionPath, { recursive: true, force: true });
+        const metaPath = join(this.basePath, id + DB_COLLECTION_META_FILE_SUFFIX);
+        await rm(metaPath, { force: true });
+        this.nameIDMap.delete(collectionName);
+    }
+
+    private async loadData(collectionID: string): Promise<any> {
+        try {
+            const data = await readFile(join(this.basePath, collectionID + DB_COLLECTION_FOLDER_SUFFIX, DB_COLLECTION_DATA_FILE), { encoding: "utf-8" });
+            return JSON.parse(data);
+        }
+        catch (err: any) {
+            if (err.code === 'ENOENT') {
+                return null;
+            }
+            throw err;
+        }
+    }
+
+    public async loadArrayData<T>(collectionID: string): Promise<T[]> {
+        const data = await this.loadData(collectionID);
+        return data || [];
+    }
+
+    public async loadMapData<T>(collectionID: string): Promise<Map<string, T>> {
+        const data = await this.loadData(collectionID);
+        return data ? new Map(Object.entries(data)) : new Map();
+    }
+
+    private async writeData(collectionID: string, data: any): Promise<void> {
+        return atomicWriteFile(join(this.basePath, collectionID + DB_COLLECTION_FOLDER_SUFFIX, DB_COLLECTION_DATA_FILE), JSON.stringify(data));
+    }
+
+    public async writeArrayData<T = any>(collectionID: string, arrayData: T[]): Promise<void> {
+        return this.writeData(collectionID, arrayData);
+    }
+
+    public async writeMapData<T = any>(collectionID: string, mapData: Map<string, T>): Promise<void> {
+        return this.writeData(collectionID, Object.fromEntries(mapData));
+    }
+}
+
+/**
+ * Opens the database at `basePath`, creating it if it doesn't exist yet.
+ * `functionRegistry` resolves any {@link IBCollectionConfig.getID}/`setID` keys used by its collections.
+ */
+export async function getDatabase(basePath: string, functionRegistry?: IBFunctionRegistry): Promise<IBDatabase> {
+    return IODatabase.createOrLoad(basePath, functionRegistry);
+}

package/src/main/utils.ts

@@ -0,0 +1,7 @@
+export function canonicalName(name?: string): string {
+    if (!name) {
+        name = "";
+    }
+    return name.trim().toLowerCase();
+}
+