@tblabs/storage 1.1.0 → 2.0.0

package/Converter.d.ts

@@ -0,0 +1,12 @@
+import { IConverter } from "./IConverter";
+export declare abstract class Converter<R extends object, T extends object> implements IConverter<R, T> {
+    protected abstract ConvertToRaw(obj: T): R;
+    protected abstract ConvertFromRaw(raw: R): T;
+    ToRaw(target: T): R;
+    FromRaw(raw: R): T;
+    protected GetArray<R, T>(value: R[], creator: (raw: R) => T): Array<T>;
+    protected GetString(value: any): string;
+    protected GetNumber(value: any): number;
+    protected GetBool(value: any): boolean;
+    protected GetDate(date: any): Date;
+}

package/Converter.js

@@ -0,0 +1,36 @@
+export class Converter {
+    ToRaw(target) {
+        try {
+            return this.ConvertToRaw(target);
+        }
+        catch (ex) {
+            console.error(`Conversion from object to raw problem: ${ex.message}\n\nStack trace: ${ex.stack}\n\nObject:`, target);
+            throw ex;
+        }
+    }
+    FromRaw(raw) {
+        try {
+            return this.ConvertFromRaw(raw);
+        }
+        catch (ex) {
+            console.error(`Conversion from raw to object problem: ${ex.message}\n\nStack trace: ${ex.stack}\n\nRaw:`, raw);
+            throw ex;
+        }
+    }
+    GetArray(value, creator) {
+        const items = value?.map(x => creator(x));
+        return items || [];
+    }
+    GetString(value) {
+        return value || "";
+    }
+    GetNumber(value) {
+        return +value || 0;
+    }
+    GetBool(value) {
+        return !!value || false;
+    }
+    GetDate(date) {
+        return date ? new Date(date) : new Date(0);
+    }
+}

package/Dataset.d.ts

@@ -0,0 +1,18 @@
+import { OnlineStorage } from "./OnlineStorage";
+import { IConverter } from "./IConverter";
+export declare class Dataset<T extends object> {
+    private _db;
+    private _converter;
+    private folder;
+    constructor(_db: OnlineStorage, _converter: IConverter<any, T>, folder: string);
+    private get FolderPath();
+    GetOne(id: string): Promise<T | null>;
+    FindOne(id: string): Promise<T | null>;
+    GetAll(): Promise<T[]>;
+    GetAllIds(): Promise<string[]>;
+    Add(id: string, item: T): Promise<void>;
+    Update(id: string, item: T): Promise<void>;
+    Delete(id: string): Promise<void>;
+    Drop(): Promise<void>;
+    Move(id: string, targetDataset: Dataset<any>): Promise<void>;
+}

package/Dataset.js

@@ -0,0 +1,111 @@
+import { AddCommand } from "./Messages/AddCommand";
+import { DeleteCommand } from "./Messages/DeleteCommand";
+import { DropCommand } from "./Messages/DropCommand";
+import { FindQuery } from "./Messages/FindQuery";
+import { ListQuery } from "./Messages/ListQuery";
+import { MoveCommand } from "./Messages/MoveCommand";
+import { ReadQuery } from "./Messages/ReadQuery";
+import { UpdateCommand } from "./Messages/UpdateCommand";
+export class Dataset {
+    _db;
+    _converter;
+    folder;
+    constructor(_db, _converter, folder) {
+        this._db = _db;
+        this._converter = _converter;
+        this.folder = folder;
+    }
+    get FolderPath() {
+        return this._db.DatabaseDir + "/" + this.folder;
+    }
+    async GetOne(id) {
+        this._db.Log(`Fetching "${id}"...`);
+        const queryResult = await this._db.Send(new ReadQuery(id, this.FolderPath));
+        if (!queryResult.IsSuccess) {
+            this._db.Log(`Not found "${id}" in "${this.FolderPath}".`);
+            return null;
+        }
+        this._db.Log(`Found "${id}" in "${this.FolderPath}".`);
+        const rawItem = queryResult.Result;
+        const item = this._converter.FromRaw(rawItem);
+        return item;
+    }
+    async FindOne(id) {
+        this._db.Log(`Searching for "${id}"...`);
+        const queryResult = await this._db.Send(new FindQuery(id, this._db.DatabaseDir));
+        if (!queryResult.IsSuccess) {
+            this._db.Log(`Not found "${id}".`);
+            return null;
+        }
+        this._db.Log(`Found "${id}".`);
+        const rawItem = queryResult.Result;
+        const item = this._converter.FromRaw(rawItem);
+        return item;
+    }
+    async GetAll() {
+        this._db.Log(`Fetching all from "${this._db.DatabaseDir}"...`);
+        const queryResult = await this._db.Send(new ListQuery(this.FolderPath, true));
+        if (!queryResult.IsSuccess) {
+            this._db.Log(`Could not fetch all items from "${this.FolderPath}": ${queryResult.ErrorMessage}`);
+            return [];
+        }
+        const rawItems = queryResult.Result;
+        const items = rawItems.map((raw) => this._converter.FromRaw(raw));
+        this._db.Log(`Fetched ${items.length} items from "${this.FolderPath}".`);
+        return items;
+    }
+    async GetAllIds() {
+        this._db.Log(`Fetching all ids from "${this.FolderPath}"...`);
+        const queryResult = await this._db.Send(new ListQuery(this.FolderPath, false));
+        if (!queryResult.IsSuccess) {
+            this._db.Log(`Could not fetch all ids from "${this.FolderPath}": ${queryResult.ErrorMessage}`);
+            return [];
+        }
+        const itemsIds = Object.values(queryResult.Result);
+        this._db.Log(`Fetched ${itemsIds.length} items ids from "${this.FolderPath}".`);
+        return itemsIds;
+    }
+    async Add(id, item) {
+        this._db.Log(`Adding "${id}" to "${this.FolderPath}"...`);
+        const result = await this._db.Send(new AddCommand(id, this.FolderPath, item));
+        if (!result.IsSuccess) {
+            throw new Error(`Could not add "${id}" to "${this.FolderPath}": ${result.ErrorMessage}`);
+        }
+        this._db.Log(`"${id}" added to "${this.FolderPath}".`);
+    }
+    ;
+    async Update(id, item) {
+        this._db.Log(`Updating "${id}"...`);
+        const result = await this._db.Send(new UpdateCommand(id, this.FolderPath, item));
+        if (!result.IsSuccess) {
+            throw new Error(`Could not update "${id}" in "${this.FolderPath}": ${result.ErrorMessage}`);
+        }
+        this._db.Log(`"${id}" updated in "${this.FolderPath}".`);
+    }
+    ;
+    async Delete(id) {
+        this._db.Log(`Deleting "${id}" from "${this.FolderPath}"...`);
+        const result = await this._db.Send(new DeleteCommand(id, this.FolderPath));
+        if (!result.IsSuccess) {
+            throw new Error(`Could not delete "${id}" from "${this.FolderPath}": ${result.ErrorMessage}`);
+        }
+        this._db.Log(`Deleted "${id}" from "${this.FolderPath}".`);
+    }
+    async Drop() {
+        this._db.Log(`Dropping "${this.FolderPath}"...`);
+        const result = await this._db.Send(new DropCommand(this.FolderPath));
+        if (!result.IsSuccess) {
+            throw new Error(`Could not drop "${this.FolderPath}": ${result.ErrorMessage}`);
+        }
+        this._db.Log(`Dropped "${this.FolderPath}".`);
+    }
+    async Move(id, targetDataset) {
+        const source = this.FolderPath;
+        const target = targetDataset.FolderPath;
+        this._db.Log(`Moving "${id}" from "${source}" to "${target}"...`);
+        const result = await this._db.Send(new MoveCommand(id, source, target));
+        if (!result.IsSuccess)
+            throw new Error(`Could not move "${id}" from "${source}" to "${target}": ${result.ErrorMessage}`);
+        this._db.Log(`Moved "${id}" from "${source}" to "${target}".`);
+    }
+}

package/IConverter.d.ts

@@ -0,0 +1,4 @@
+export interface IConverter<R extends object, T extends object> {
+    FromRaw(raw: R): T;
+    ToRaw(item: T): R;
+}

package/IConverter.js

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

package/OnlineStorage.d.ts

@@ -0,0 +1,17 @@
+import { IMessage } from "./MessageBus/IMessage";
+import { ISender } from "./MessageBus/ISender";
+import { MessageBusResponse } from "./MessageBus/MessageBusResponse";
+export declare class OnlineStorage {
+    private databaseFolder;
+    private access;
+    private logEnabled;
+    private readonly _bus;
+    get DatabaseDir(): string;
+    constructor(serverUrl: string, databaseFolder: string, access: ISender);
+    EnableLog(): void;
+    DisableLog(): void;
+    Log(...message: any[]): void;
+    Ping(): Promise<boolean>;
+    Send(message: IMessage): Promise<MessageBusResponse>;
+    AddDataset(datasetName: string): Promise<void>;
+}

package/OnlineStorage.js

@@ -0,0 +1,41 @@
+import { MessageBus } from "./MessageBus/MessageBus";
+import { AddDirCommand } from "./Messages/AddDirCommand";
+export class OnlineStorage {
+    databaseFolder;
+    access;
+    logEnabled = false;
+    _bus;
+    get DatabaseDir() {
+        return this.databaseFolder;
+    }
+    constructor(serverUrl, databaseFolder, access) {
+        this.databaseFolder = databaseFolder;
+        this.access = access;
+        this._bus = new MessageBus(serverUrl, access);
+    }
+    EnableLog() {
+        this.logEnabled = true;
+    }
+    DisableLog() {
+        this.logEnabled = false;
+    }
+    Log(...message) {
+        if (this.logEnabled)
+            console.log('[OnlineRepo]', ...message);
+    }
+    async Ping() {
+        return await this._bus.Ping();
+    }
+    async Send(message) {
+        return await this._bus.SendMessage(message);
+    }
+    async AddDataset(datasetName) {
+        const target = this.DatabaseDir + "/" + datasetName;
+        this.Log(`Creating dataset directory "${target}"...`);
+        const result = await this._bus.SendMessage(new AddDirCommand(target));
+        if (!result.IsSuccess) {
+            throw new Error(`Could not add directory "${target}": ${result.ErrorMessage}`);
+        }
+        this.Log(`Directory "${target}" added.`);
+    }
+}

package/index.d.ts

@@ -1,3 +1,6 @@
 export * from "./IRepo";
-export * from "./OnlineRepo";
+export * from "./IConverter";
+export * from "./OnlineStorage";
 export * from "./Utils/OperationRepeater";
+export * from "./Converter";
+export * from "./Dataset";

package/index.js

@@ -1,3 +1,6 @@
 export * from "./IRepo";
-export * from "./OnlineRepo";
+export * from "./IConverter";
+export * from "./OnlineStorage";
 export * from "./Utils/OperationRepeater";
+export * from "./Converter";
+export * from "./Dataset";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tblabs/storage",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "online storage module",
   "license": "beerware",
   "main": "index.js",
@@ -9,7 +9,7 @@
     "pack": "cd ./bin && npm pack",
     "clean": "rm ./bin -rf && rm *.tgz -rf",
     "build": "npm run clean && tsc ./src/index.ts --declaration --outDir ./bin && cp ./package.json ./bin/package.json",
-    "publish": "npm login && npm run build && npm run pack && cd ./bin && npm publish --access public"
+    "publish:npm": "npm login && npm run build && npm run pack && cd ./bin && npm publish --access public"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",

package/OnlineRepo.d.ts

@@ -1,22 +0,0 @@
-import { IRepo } from "./IRepo";
-import { ISender } from "./MessageBus/ISender";
-export declare class OnlineRepo<T extends object> implements IRepo<T> {
-    private server;
-    private databaseFolder;
-    private user;
-    LOG: boolean;
-    private readonly _bus;
-    constructor(server: string, databaseFolder: string, user: ISender);
-    private Log;
-    Ping(): Promise<boolean>;
-    GetOne(folder: string, id: string): Promise<T | null>;
-    FindOne(id: string): Promise<T | null>;
-    GetAll(folder: string): Promise<T[]>;
-    GetAllIds(folder: string): Promise<string[]>;
-    Add(folder: string, id: string, item: T): Promise<void>;
-    Update(folder: string, id: string, item: T): Promise<void>;
-    Delete(folder: string, id: string): Promise<void>;
-    Drop(): Promise<void>;
-    Move(id: string, sourceFolder: string, targetFolder: string): Promise<void>;
-    AddDir(targetFolder: string): Promise<void>;
-}

package/OnlineRepo.js

@@ -1,127 +0,0 @@
-import { DeleteCommand } from "./Messages/DeleteCommand";
-import { DropCommand } from "./Messages/DropCommand";
-import { FindQuery } from "./Messages/FindQuery";
-import { ListQuery } from "./Messages/ListQuery";
-import { MoveCommand } from "./Messages/MoveCommand";
-import { ReadQuery } from "./Messages/ReadQuery";
-import { UpdateCommand } from "./Messages/UpdateCommand";
-import { MessageBus } from "./MessageBus/MessageBus";
-import { AddCommand } from "./Messages/AddCommand";
-import { AddDirCommand } from "./Messages/AddDirCommand";
-export class OnlineRepo {
-    server;
-    databaseFolder;
-    user;
-    LOG = false;
-    _bus;
-    constructor(server, databaseFolder, user) {
-        this.server = server;
-        this.databaseFolder = databaseFolder;
-        this.user = user;
-        this._bus = new MessageBus(server, user);
-    }
-    Log(...message) {
-        if (this.LOG)
-            console.log('[OnlineRepo]', ...message);
-    }
-    async Ping() {
-        return await this._bus.Ping();
-    }
-    async GetOne(folder, id) {
-        this.Log(`Fetching "${id}"...`);
-        const folderPath = this.databaseFolder + "/" + folder;
-        const queryResult = await this._bus.SendMessage(new ReadQuery(id, folderPath));
-        if (queryResult.IsSuccess) {
-            const item = queryResult.Result;
-            this.Log(`Found "${id}" in "${folderPath}".`);
-            return item;
-        }
-        this.Log(`Not found "${id}" in "${folderPath}".`);
-        return null;
-    }
-    async FindOne(id) {
-        this.Log(`Fetching "${id}"...`);
-        const queryResult = await this._bus.SendMessage(new FindQuery(id, this.databaseFolder));
-        if (queryResult.IsSuccess) {
-            const item = queryResult.Result;
-            this.Log(`Found "${id}".`);
-            return item;
-        }
-        this.Log(`Not found "${id}".`);
-        return null;
-    }
-    async GetAll(folder) {
-        this.Log(`Fetching all from "${this.databaseFolder}"...`);
-        const folderPath = this.databaseFolder + "/" + folder;
-        const queryResult = await this._bus.SendMessage(new ListQuery(folderPath, true));
-        if (queryResult.IsSuccess) {
-            const items = queryResult.Result;
-            this.Log(`Fetched ${items.length} items from "${folderPath}".`);
-            return items;
-        }
-        else
-            throw new Error(`Could not fetch all from "${folder}": ${queryResult.ErrorMessage}`);
-    }
-    async GetAllIds(folder) {
-        this.Log(`Fetching all from "${this.databaseFolder}"...`);
-        const folderPath = this.databaseFolder + "/" + folder;
-        const queryResult = await this._bus.SendMessage(new ListQuery(folderPath, false));
-        if (queryResult.IsSuccess) {
-            const itemsIds = Object.values(queryResult.Result);
-            this.Log(`Fetched ${itemsIds.length} items ids from "${folderPath}".`);
-            return itemsIds;
-        }
-        else
-            throw new Error(`Could not fetch all ids from "${folder}": ${queryResult.ErrorMessage}`);
-    }
-    async Add(folder, id, item) {
-        this.Log(`Adding "${id}" to "${folder}"...`);
-        const folderPath = this.databaseFolder + "/" + folder;
-        const result = await this._bus.SendMessage(new AddCommand(id, folderPath, item));
-        if (!result.IsSuccess)
-            throw new Error(`Could not add "${id}" to "${folderPath}": ${result.ErrorMessage}`);
-        this.Log(`"${id}" added to "${folderPath}".`);
-    }
-    ;
-    async Update(folder, id, item) {
-        this.Log(`Updating "${id}"...`);
-        const folderPath = this.databaseFolder + "/" + folder;
-        const result = await this._bus.SendMessage(new UpdateCommand(id, folderPath, item));
-        if (!result.IsSuccess)
-            throw new Error(`Could not update "${id}" in "${folderPath}": ${result.ErrorMessage}`);
-        this.Log(`"${id}" updated in "${folderPath}".`);
-    }
-    ;
-    async Delete(folder, id) {
-        const folderPath = this.databaseFolder + "/" + folder;
-        this.Log(`Deleting "${id}" from "${folderPath}"...`);
-        const result = await this._bus.SendMessage(new DeleteCommand(id, folderPath));
-        if (!result.IsSuccess)
-            throw new Error(`Could not delete "${id}" from "${folderPath}": ${result.ErrorMessage}`);
-        this.Log(`Deleted "${id}" from "${folderPath}".`);
-    }
-    async Drop() {
-        this.Log(`Dropping "${this.databaseFolder}"...`);
-        const result = await this._bus.SendMessage(new DropCommand(this.databaseFolder));
-        if (!result.IsSuccess)
-            throw new Error(`Could not drop "${this.databaseFolder}": ${result.ErrorMessage}`);
-        this.Log(`Dropped "${this.databaseFolder}".`);
-    }
-    async Move(id, sourceFolder, targetFolder) {
-        const source = this.databaseFolder + "/" + sourceFolder;
-        const target = this.databaseFolder + "/" + targetFolder;
-        this.Log(`Moving "${id}" from "${source}" to "${target}"...`);
-        const result = await this._bus.SendMessage(new MoveCommand(id, source, target));
-        if (!result.IsSuccess)
-            throw new Error(`Could not move "${id}" from "${source}" to "${target}": ${result.ErrorMessage}`);
-        this.Log(`Moved "${id}" from "${source}" to "${target}".`);
-    }
-    async AddDir(targetFolder) {
-        const target = this.databaseFolder + "/" + targetFolder;
-        this.Log(`Adding directory "${target}"...`);
-        const result = await this._bus.SendMessage(new AddDirCommand(target));
-        if (!result.IsSuccess)
-            throw new Error(`Could not add directory "${target}": ${result.ErrorMessage}`);
-        this.Log(`Added directory "${target}".`);
-    }
-}