@tblabs/storage 5.2.6 → 5.2.8

package/Dataset.d.ts

@@ -2,6 +2,7 @@ import { OnlineStorage } from "./OnlineStorage";
 import { IConverter } from "./IConverter";
 import { IRepo } from "./IRepo";
 import { dir } from "./Types/dir";
+import { IStorageUserPrivileges } from "./IStorageUserPrivileges";
 export declare class Dataset<T extends object> implements IRepo<T> {
     private _db;
     private _converter;
@@ -9,8 +10,8 @@ export declare class Dataset<T extends object> implements IRepo<T> {
     get Name(): string;
     constructor(_db: OnlineStorage, _converter: IConverter<any, T>, dataset: dir);
     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";
@@ -20,86 +19,56 @@ export class Dataset {
     get DatasetPath() {
         return this._db.DatabaseDir + "/Datasets/" + this.dataset;
     }
+    CanUserDo(action) {
+        if (!this._db.User.Privileges) {
+            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)) ?? false;
+        }
+        if (typeof this._db.User.Privileges[action] === "boolean" && this._db.User.Privileges[action]) {
+            return this._db.User.Privileges[action];
+        }
+        return false;
+    }
     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/IStorageUser.d.ts

@@ -1,46 +1,5 @@
+import { IStorageUserPrivileges } from "./IStorageUserPrivileges";
 import { ISender } from "./MessageBus/ISender";
-export type IEntitiesSet = string[] | "all" | "none";
-export type ICommandPrivilege = {
-    Datasets?: IEntitiesSet;
-    Files?: IEntitiesSet;
-};
-export interface IStorageUserPrivileges {
-    Add: {
-        Datasets: IEntitiesSet;
-    };
-    Update: {
-        Datasets: IEntitiesSet;
-        Files: IEntitiesSet;
-    };
-    Delete: {
-        Datasets: IEntitiesSet;
-        Files: IEntitiesSet;
-    };
-    List: {
-        Datasets: IEntitiesSet;
-    };
-    Get: {
-        Datasets: IEntitiesSet;
-        Files: IEntitiesSet;
-    };
-    Drop: {
-        Datasets: IEntitiesSet;
-    };
-    Move: {
-        Datasets: IEntitiesSet;
-        Files: IEntitiesSet;
-    };
-    Create: {
-        Datasets: IEntitiesSet;
-    };
-    Exists: {
-        Datasets: IEntitiesSet;
-    };
-    Remove: {
-        Datasets: IEntitiesSet;
-    };
-    Register: boolean;
-}
 export interface IStorageUser extends ISender {
     Id: string;
     Database: string;

package/IStorageUser.js

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

package/IStorageUserPrivileges.d.ts

@@ -0,0 +1,41 @@
+export type IEntitiesSet = string[] | "all" | "none";
+export interface IStorageUserPrivileges {
+    Add: {
+        Datasets: IEntitiesSet;
+    };
+    Update: {
+        Datasets: IEntitiesSet;
+        Files: IEntitiesSet;
+    };
+    Delete: {
+        Datasets: IEntitiesSet;
+        Files: IEntitiesSet;
+    };
+    List: {
+        Datasets: IEntitiesSet;
+    };
+    Get: {
+        Datasets: IEntitiesSet;
+        Files: IEntitiesSet;
+    };
+    Drop: {
+        Datasets: IEntitiesSet;
+    };
+    Move: {
+        Datasets: IEntitiesSet;
+        Files: IEntitiesSet;
+    };
+    Create: {
+        Datasets: IEntitiesSet;
+    };
+    Exists: {
+        Datasets: IEntitiesSet;
+    };
+    Remove: {
+        Datasets: IEntitiesSet;
+    };
+    Search: {
+        Datasets: IEntitiesSet;
+    };
+    Register: boolean;
+}

package/IStorageUserPrivileges.js

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

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/Messages/RegisterCommand.d.ts

@@ -1,4 +1,4 @@
-import { IStorageUserPrivileges } from "../IStorageUser";
+import { IStorageUserPrivileges } from "../IStorageUserPrivileges";
 import { Message } from "../MessageBus/Message";
 import { dir } from "../Types/dir";
 export declare class RegisterCommand extends Message {

package/OnlineStorage.d.ts

@@ -4,7 +4,8 @@ import { ISender } from "./MessageBus/ISender";
 import { MessageBus } from "./MessageBus/MessageBus";
 import { MessageBusResponse } from "./MessageBus/MessageBusResponse";
 import { Dataset } from "./Dataset";
-import { IStorageUser, IStorageUserPrivileges } from "./IStorageUser";
+import { IStorageUser } from "./IStorageUser";
+import { IConverter } from "./IConverter";
 export declare class OnlineStorage {
     private database;
     private ANONYMOUS_USER;
@@ -15,13 +16,13 @@ export declare class OnlineStorage {
     private readonly USER_LOCAL_STORAGE_KEY;
     get DatabaseDir(): dir;
     constructor(server: url, database: dir, sender?: ISender, bus?: MessageBus);
+    GetDataset<T extends object>(datasetName: string, converter: IConverter<any, T>): Dataset<T>;
     private IsBrowserEnvironment;
     private LoadUserFromLocalStorage;
     get User(): IStorageUser;
     Login(password: string): Promise<IStorageUser>;
     private SaveUserInLocalStorage;
     OnUserChange(handler: (user: IStorageUser, isAuthorized: boolean, appStart: boolean) => void): this;
-    Register(id: string, role: string, name: string, login: string, password: string, email: string, privileges: IStorageUserPrivileges, icon?: string, tags?: string[]): Promise<IStorageUser>;
     Logout(): this;
     private CallOnUserChanged;
     get IsAuthorized(): boolean;

package/OnlineStorage.js

@@ -1,8 +1,8 @@
 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";
-import { RegisterCommand } from "./Messages/RegisterCommand";
 export class OnlineStorage {
     database;
     ANONYMOUS_USER = { Id: "Anonymous" };
@@ -18,20 +18,45 @@ 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);
+        if (this.LoadUserFromLocalStorage()) {
+            this.CallOnUserChanged(true);
+        }
     }
+    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;
@@ -57,15 +82,25 @@ export class OnlineStorage {
         handler(this.user, this.IsAuthorized, true);
         return this;
     }
-    async Register(id, role, name, login, password, email, privileges, icon, tags) {
-        const createdAt = new Date();
-        const result = await this._bus.SendMessage(new RegisterCommand(this.DatabaseDir, id, role, name, login, password, email, privileges, icon, tags, createdAt));
-        if (!result.IsSuccess) {
-            throw new Error(`Could not register: ${result.ErrorMessage}`);
-        }
-        const user = result.Result;
-        return user;
-    }
+    //
+    // UWAGA!!!!!!!!!! TAK NIE MOŻNA REJESTROWAĆ Privileges!!!!!! TO MUSI SIĘ ODBYWAĆ PRZEZ INNĄ METODE ALBO INNY MECHANIZM!!!!!!!
+    // Użytkownik nie może sam sobie nadawać uprawnień xddd
+    //
+    //
+    // public async Register(id: string, role: string, name: string,
+    // 	login: string, password: string, email: string,
+    // 	privileges: IStorageUserPrivileges,
+    // 	icon?: string, tags?: string[]): Promise<IStorageUser>
+    // {
+    // 	const createdAt = new Date();
+    // 	const result = await this._bus.SendMessage(new RegisterCommand(this.DatabaseDir, id, role, name, login, password, email, privileges, icon, tags, createdAt));
+    // 	if (!result.IsSuccess)
+    // 	{
+    // 		throw new Error(`Could not register: ${result.ErrorMessage}`);
+    // 	}
+    // 	const user = result.Result as IStorageUser;
+    // 	return user;
+    // }
     Logout() {
         this.SetUser(this.ANONYMOUS_USER);
         this.SaveUserInLocalStorage();
@@ -100,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.6",
+  "version": "5.2.8",
   "description": "online storage module with auth",
   "license": "beerware",
   "main": "index.js",