@tblabs/storage 5.2.7 → 5.2.8

package/Dataset.d.ts

@@ -12,7 +12,6 @@ export declare class Dataset<T extends object> implements IRepo<T> {
     private get DatasetPath();
     CanUserDo(action: keyof IStorageUserPrivileges): boolean;
     GetOne(id: string): Promise<T>;
-    FindOne(id: string): Promise<T | null>;
     GetAll(): Promise<T[]>;
     Add(id: string, item: T): Promise<void>;
     Update(id: string, item: T): Promise<void>;

package/Dataset.js

@@ -1,7 +1,6 @@
 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 { GetQuery } from "./Messages/GetQuery";
 import { UpdateCommand } from "./Messages/UpdateCommand";
@@ -21,14 +20,11 @@ export class Dataset {
         return this._db.DatabaseDir + "/Datasets/" + this.dataset;
     }
     CanUserDo(action) {
-        // console.log("ACTION", action);
-        // console.log("PRIVILEGES", this._db.User.Privileges);
         if (!this._db.User.Privileges) {
-            // console.warn("User not logged in (even if Anonymous)");
             return false;
         }
         if (typeof this._db.User.Privileges[action] === "object" && this._db.User.Privileges[action]) {
-            return this._db.User.Privileges[action].Datasets == "all" || this._db.User.Privileges[action].Datasets.includes(this.dataset);
+            return (this._db.User.Privileges[action].Datasets == "all" || this._db.User.Privileges[action].Datasets?.includes(this.dataset)) ?? false;
         }
         if (typeof this._db.User.Privileges[action] === "boolean" && this._db.User.Privileges[action]) {
             return this._db.User.Privileges[action];
@@ -38,83 +34,41 @@ export class Dataset {
     async GetOne(id) {
         this._db.Log(`Fetching "${id}"...`);
         const queryResult = await this._db.Send(new GetQuery(this._db.DatabaseDir, this.dataset, id));
-        if (!queryResult.IsSuccess) {
-            throw new Error(`Could not fetch file: ${queryResult.ErrorMessage}`);
-        }
         const rawItem = queryResult.Result;
         const item = this._converter.FromRaw(rawItem);
         this._db.Log(`Fetched "${id}" from "${this.DatasetPath}".`);
         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) {
-            throw new Error(`Could not find file: ${queryResult.ErrorMessage}`);
-        }
-        const rawItem = queryResult.Result;
-        const item = this._converter.FromRaw(rawItem);
-        this._db.Log(`Found "${id}" in "${this.DatasetPath}".`);
-        return item;
-    }
     async GetAll() {
         this._db.Log(`Fetching all from "${this.DatasetPath}"...`);
         const queryResult = await this._db.Send(new ListQuery(this._db.DatabaseDir, this.dataset));
-        if (!queryResult.IsSuccess) {
-            throw new Error(`Could not fetch items: ${queryResult.ErrorMessage}`);
-        }
         const rawItems = queryResult.Result;
         const items = rawItems.map((raw) => this._converter.FromRaw(raw));
         this._db.Log(`Fetched ${items.length} items from "${this.DatasetPath}".`);
         return items;
     }
-    // public async GetAllIds(): Promise<string[]>
-    // {
-    // 	this._db.Log(`Fetching all ids from "${this.DatasetPath}"...`);
-    // 	const queryResult = await this._db.Send(new ListQuery(this.DatasetPath, false));
-    // 	if (!queryResult.IsSuccess)
-    // 	{
-    // 		this._db.Log(`Could not fetch all ids from "${this.DatasetPath}": ${queryResult.ErrorMessage}`);
-    // 		return [];
-    // 	}
-    // 	const itemsIds = Object.values(queryResult.Result);
-    // 	this._db.Log(`Fetched ${itemsIds.length} items ids from "${this.DatasetPath}".`);
-    // 	return itemsIds as string[];
-    // }
     async Add(id, item) {
         this._db.Log(`Adding "${id}" to "${this.DatasetPath}"...`);
         const rawItem = this._converter.ToRaw(item);
-        const result = await this._db.Send(new AddCommand(this._db.DatabaseDir, this.dataset, id, rawItem));
-        if (!result.IsSuccess) {
-            throw new Error(`Could not add file: ${result.ErrorMessage}`);
-        }
+        await this._db.Send(new AddCommand(this._db.DatabaseDir, this.dataset, id, rawItem));
         this._db.Log(`"${id}" added to "${this.DatasetPath}".`);
     }
     ;
     async Update(id, item) {
         this._db.Log(`Updating "${id}"...`);
         const rawItem = this._converter.ToRaw(item);
-        const result = await this._db.Send(new UpdateCommand(this._db.DatabaseDir, this.dataset, id, rawItem));
-        if (!result.IsSuccess) {
-            throw new Error(`Could not update file: ${result.ErrorMessage}`);
-        }
+        await this._db.Send(new UpdateCommand(this._db.DatabaseDir, this.dataset, id, rawItem));
         this._db.Log(`"${id}" updated in "${this.DatasetPath}".`);
     }
     ;
     async Delete(id) {
         this._db.Log(`Deleting "${id}" from "${this.DatasetPath}"...`);
-        const result = await this._db.Send(new DeleteCommand(this._db.DatabaseDir, this.dataset, id));
-        if (!result.IsSuccess) {
-            throw new Error(`Could not delete file: ${result.ErrorMessage}`);
-        }
+        await this._db.Send(new DeleteCommand(this._db.DatabaseDir, this.dataset, id));
         this._db.Log(`Deleted "${id}" from "${this.DatasetPath}".`);
     }
     async Drop() {
         this._db.Log(`Dropping "${this.DatasetPath}"...`);
-        const result = await this._db.Send(new DropCommand(this._db.DatabaseDir, this.dataset));
-        if (!result.IsSuccess) {
-            throw new Error(`Could not drop dataset: ${result.ErrorMessage}`);
-        }
+        await this._db.Send(new DropCommand(this._db.DatabaseDir, this.dataset));
         this._db.Log(`"${this.DatasetPath}" dropped.`);
     }
 }

package/IRepo.d.ts

@@ -1,8 +1,9 @@
+import { IStorageUserPrivileges } from "./IStorageUserPrivileges";
 export interface IRepo<T> {
+    CanUserDo(action: keyof IStorageUserPrivileges): boolean;
     Add(id: string, item: T): Promise<void>;
     GetAll(): Promise<T[]>;
     GetOne(id: string): Promise<T | null>;
-    FindOne(id: string): Promise<T | null>;
     Update(id: string, item: T): Promise<void>;
     Delete(id: string): Promise<void>;
     Drop(): Promise<void>;

package/IStorageUserPrivileges.d.ts

@@ -34,5 +34,8 @@ export interface IStorageUserPrivileges {
     Remove: {
         Datasets: IEntitiesSet;
     };
+    Search: {
+        Datasets: IEntitiesSet;
+    };
     Register: boolean;
 }

package/Messages/FindQuery.d.ts

@@ -1,4 +1,4 @@
 import { Message } from '../MessageBus/Message';
-export declare class FindQuery extends Message {
-    constructor(Id: string, Folder: string);
+export declare class SearchQuery extends Message {
+    constructor(Database: string, Id: string);
 }

package/Messages/FindQuery.js

@@ -1,6 +1,6 @@
 import { Message } from '../MessageBus/Message';
-export class FindQuery extends Message {
-    constructor(Id, Folder) {
-        super("Find", { Id, Folder });
+export class SearchQuery extends Message {
+    constructor(Database, Id) {
+        super("Search", { Database, Id });
     }
 }

package/OnlineStorage.d.ts

@@ -5,6 +5,7 @@ import { MessageBus } from "./MessageBus/MessageBus";
 import { MessageBusResponse } from "./MessageBus/MessageBusResponse";
 import { Dataset } from "./Dataset";
 import { IStorageUser } from "./IStorageUser";
+import { IConverter } from "./IConverter";
 export declare class OnlineStorage {
     private database;
     private ANONYMOUS_USER;
@@ -15,8 +16,7 @@ export declare class OnlineStorage {
     private readonly USER_LOCAL_STORAGE_KEY;
     get DatabaseDir(): dir;
     constructor(server: url, database: dir, sender?: ISender, bus?: MessageBus);
-    private WasAnonymousUserEverLoaded;
-    InitOnce(): Promise<void>;
+    GetDataset<T extends object>(datasetName: string, converter: IConverter<any, T>): Dataset<T>;
     private IsBrowserEnvironment;
     private LoadUserFromLocalStorage;
     get User(): IStorageUser;

package/OnlineStorage.js

@@ -1,5 +1,6 @@
 import { MessageBus } from "./MessageBus/MessageBus";
 import { CreateCommand, ExistsCommand, RemoveCommand } from "./Messages/AddDirCommand";
+import { Dataset } from "./Dataset";
 import { MoveCommand } from "./Messages/MoveCommand";
 import { LoginQuery } from "./Messages/LoginQuery";
 export class OnlineStorage {
@@ -17,38 +18,50 @@ export class OnlineStorage {
         this.database = database;
         this._bus = bus || new MessageBus(server, sender);
         this.USER_LOCAL_STORAGE_KEY = "OnlineStorage:User:" + this.database;
-        this.LoadUserFromLocalStorage(true);
-    }
-    WasAnonymousUserEverLoaded() {
-        // console.log( "aaaaAAA", this.user.Privileges)
-        return (this.User.Id === this.ANONYMOUS_USER.Id && this.user.Privileges !== undefined);
-    }
-    async InitOnce() {
-        // console.log("INIT", this.WasAnonymousUserEverLoaded());
-        if (this.WasAnonymousUserEverLoaded()) {
-            // console.log("INIT RETURN WasAnonymousUserEverLoaded()=true");
-            return;
+        if (this.LoadUserFromLocalStorage()) {
+            this.CallOnUserChanged(true);
         }
-        this.user = await this.Login("Anonymous"); // TODO: Tutaj można my zrobić dedykowaną metode do pobierania ustawień użytkownika Anonymous
     }
+    GetDataset(datasetName, converter) {
+        return new Dataset(this, converter, datasetName);
+    }
+    // private WasAnonymousUserEverLoaded(): boolean
+    // {
+    // 	return (this.User.Id === this.ANONYMOUS_USER.Id && this.user.Privileges !== undefined);
+    // }
+    // public SetAnonymousUserPrivileges(privileges: IStorageUserPrivileges): this
+    // {
+    // 	this.user.Privileges = privileges;
+    // 	return this;
+    // }
+    // public async InitOnce()
+    // {
+    // 	// console.log("INIT", this.WasAnonymousUserEverLoaded());
+    // 	if (this.WasAnonymousUserEverLoaded()) 
+    // 	{
+    // 		// console.log("INIT RETURN WasAnonymousUserEverLoaded()=true");
+    // 		return;
+    // 	}
+    // 	this.user = await this.Login("Anonymous"); // TODO: Tutaj można my zrobić dedykowaną metode do pobierania ustawień użytkownika Anonymous
+    // }
     IsBrowserEnvironment() {
         return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
     }
-    LoadUserFromLocalStorage(appStart) {
+    LoadUserFromLocalStorage() {
         if (this.IsBrowserEnvironment()) {
             const user = window.localStorage.getItem(this.USER_LOCAL_STORAGE_KEY);
             if (user) {
                 this.user = JSON.parse(user);
                 this.SetUser(this.user || this.ANONYMOUS_USER);
-                this.CallOnUserChanged(appStart);
+                return true;
             }
         }
+        return false;
     }
     get User() {
         return this.user;
     }
     async Login(password) {
-        // console.log("LOGIN", password);
         const result = await this._bus.SendMessage(new LoginQuery(this.DatabaseDir, password));
         if (!result.IsSuccess) {
             throw new Error(`Could not login: ${result.ErrorMessage}`);
@@ -57,7 +70,6 @@ export class OnlineStorage {
         this.SetUser(this.user);
         this.SaveUserInLocalStorage();
         this.CallOnUserChanged(false);
-        // console.log("USER LOGIN", this.user);
         return this.user;
     }
     SaveUserInLocalStorage() {
@@ -123,7 +135,11 @@ export class OnlineStorage {
         return await this._bus.Ping();
     }
     async Send(message) {
-        return await this._bus.SendMessage(message);
+        const result = await this._bus.SendMessage(message);
+        if (!result.IsSuccess) {
+            throw new Error(`Message resulted with error: ${result.ErrorMessage}`);
+        }
+        return result;
     }
     async CreateDataset(datasetName) {
         this.Log(`Creating dataset "${datasetName}"...`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tblabs/storage",
-  "version": "5.2.7",
+  "version": "5.2.8",
   "description": "online storage module with auth",
   "license": "beerware",
   "main": "index.js",