@tblabs/storage 5.0.0 → 5.0.2

package/Dataset.d.ts

@@ -9,7 +9,7 @@ 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();
-    GetOne(id: string): Promise<T | null>;
+    GetOne(id: string): Promise<T>;
     FindOne(id: string): Promise<T | null>;
     GetAll(): Promise<T[]>;
     Add(id: string, item: T): Promise<void>;

package/Dataset.js

@@ -24,32 +24,29 @@ export class Dataset {
         this._db.Log(`Fetching "${id}"...`);
         const queryResult = await this._db.Send(new GetQuery(this._db.DatabaseDir, this.dataset, id));
         if (!queryResult.IsSuccess) {
-            this._db.Log(`"${this.DatasetPath}/${id}" not found.`);
-            return null;
+            throw new Error(`Could not fetch file: ${queryResult.ErrorMessage}`);
         }
-        this._db.Log(`Found "${id}" in "${this.DatasetPath}".`);
         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) {
-            this._db.Log(`Not found "${id}".`);
-            return null;
+            throw new Error(`Could not find file: ${queryResult.ErrorMessage}`);
         }
-        this._db.Log(`Found "${id}".`);
         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) {
-            this._db.Log(`Could not fetch items from "${this.DatasetPath}": ${queryResult.ErrorMessage}`);
-            return [];
+            throw new Error(`Could not fetch items: ${queryResult.ErrorMessage}`);
         }
         const rawItems = queryResult.Result;
         const items = rawItems.map((raw) => this._converter.FromRaw(raw));
@@ -73,7 +70,7 @@ export class Dataset {
         this._db.Log(`Adding "${id}" to "${this.DatasetPath}"...`);
         const result = await this._db.Send(new AddCommand(this._db.DatabaseDir, this.dataset, id, item));
         if (!result.IsSuccess) {
-            throw new Error(`Could not add "${id}" to "${this.DatasetPath}": ${result.ErrorMessage}`);
+            throw new Error(`Could not add file: ${result.ErrorMessage}`);
         }
         this._db.Log(`"${id}" added to "${this.DatasetPath}".`);
     }
@@ -82,7 +79,7 @@ export class Dataset {
         this._db.Log(`Updating "${id}"...`);
         const result = await this._db.Send(new UpdateCommand(this._db.DatabaseDir, this.dataset, id, item));
         if (!result.IsSuccess) {
-            throw new Error(`Could not update "${id}" in "${this.DatasetPath}": ${result.ErrorMessage}`);
+            throw new Error(`Could not update file: ${result.ErrorMessage}`);
         }
         this._db.Log(`"${id}" updated in "${this.DatasetPath}".`);
     }
@@ -91,7 +88,7 @@ export class Dataset {
         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 "${id}" from "${this.DatasetPath}": ${result.ErrorMessage}`);
+            throw new Error(`Could not delete file: ${result.ErrorMessage}`);
         }
         this._db.Log(`Deleted "${id}" from "${this.DatasetPath}".`);
     }
@@ -99,7 +96,7 @@ export class Dataset {
         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 "${this.DatasetPath}": ${result.ErrorMessage}`);
+            throw new Error(`Could not drop dataset: ${result.ErrorMessage}`);
         }
         this._db.Log(`"${this.DatasetPath}" dropped.`);
     }

package/IStorageUser.d.ts

@@ -0,0 +1,50 @@
+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: {
+        Files: IEntitiesSet;
+    };
+    Delete: {
+        Files: IEntitiesSet;
+    };
+    List: {
+        Datasets: IEntitiesSet;
+    };
+    Get: {
+        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;
+    Name: string;
+    Role: string;
+    Icon: string;
+    Password: string;
+    Privileges: IStorageUserPrivileges;
+    Tags: string[];
+}

package/IStorageUser.js

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

package/Messages/LoginQuery.d.ts

@@ -0,0 +1,5 @@
+import { Message } from "../MessageBus/Message";
+import { dir } from "../Types/dir";
+export declare class LoginQuery extends Message {
+    constructor(Database: dir, Password: string);
+}

package/Messages/LoginQuery.js

@@ -0,0 +1,6 @@
+import { Message } from "../MessageBus/Message";
+export class LoginQuery extends Message {
+    constructor(Database, Password) {
+        super("Login", { Database, Password });
+    }
+}

package/Messages/RegisterCommand.d.ts

@@ -0,0 +1,6 @@
+import { IStorageUserPrivileges } from "../IStorageUser";
+import { Message } from "../MessageBus/Message";
+import { dir } from "../Types/dir";
+export declare class RegisterCommand extends Message {
+    constructor(Database: dir, Id: string, Role: string, Name: string, Password: string, Privileges: IStorageUserPrivileges, Icon?: string, Tags?: string[]);
+}

package/Messages/RegisterCommand.js

@@ -0,0 +1,6 @@
+import { Message } from "../MessageBus/Message";
+export class RegisterCommand extends Message {
+    constructor(Database, Id, Role, Name, Password, Privileges, Icon, Tags) {
+        super("Register", { Database, Id, Role, Icon, Name, Password, Privileges, Tags });
+    }
+}

package/OnlineStorage.d.ts

@@ -3,68 +3,20 @@ import { IMessage } from "./MessageBus/IMessage";
 import { ISender } from "./MessageBus/ISender";
 import { MessageBus } from "./MessageBus/MessageBus";
 import { MessageBusResponse } from "./MessageBus/MessageBusResponse";
-import { Message } from "./MessageBus/Message";
 import { Dataset } from "./Dataset";
-export type IEntitiesSet = string[] | "all" | "none";
-export interface IUser {
-    Id: string;
-    Name: string;
-    Database: string;
-    Privileges: {
-        Add: {
-            Datasets: IEntitiesSet;
-        };
-        Update: {
-            Datasets: IEntitiesSet;
-            Files: IEntitiesSet;
-        };
-        Delete: {
-            Datasets: IEntitiesSet;
-            Files: IEntitiesSet;
-        };
-        List: {
-            Datasets: IEntitiesSet;
-        };
-        Get: {
-            Files: IEntitiesSet;
-        };
-        Drop: {
-            Datasets: IEntitiesSet;
-        };
-        Move: {
-            Datasets: IEntitiesSet;
-            Files: IEntitiesSet;
-        };
-        Backup: {
-            Datasets: IEntitiesSet;
-        };
-        Find: {
-            Files: IEntitiesSet;
-        };
-        Create: {
-            Datasets: IEntitiesSet;
-        };
-        Exists: {
-            Datasets: IEntitiesSet;
-        };
-        Remove: {
-            Datasets: IEntitiesSet;
-        };
-    };
-}
-export declare class AuthQuery extends Message {
-    constructor(Database: dir, Password: string);
-}
+import { IStorageUser, IStorageUserPrivileges } from "./IStorageUser";
 export declare class OnlineStorage {
     private database;
     private logEnabled;
     private readonly _bus;
     get DatabaseDir(): dir;
     constructor(server: url, database: dir, sender?: ISender, bus?: MessageBus);
-    Login(password: string): Promise<IUser>;
+    Login(password: string): Promise<IStorageUser>;
+    Register(id: string, role: string, name: string, password: string, privileges: IStorageUserPrivileges, icon?: string, tags?: string[]): Promise<IStorageUser>;
     Logout(): this;
+    Init(): Promise<void>;
     IsAuthorized(): boolean;
-    User(access: ISender): this;
+    User(sender: ISender): this;
     EnableLog(): this;
     DisableLog(): this;
     Log(...message: any[]): void;

package/OnlineStorage.js

@@ -1,12 +1,8 @@
 import { MessageBus } from "./MessageBus/MessageBus";
 import { CreateCommand, ExistsCommand, RemoveCommand } from "./Messages/AddDirCommand";
-import { Message } from "./MessageBus/Message";
 import { MoveCommand } from "./Messages/MoveCommand";
-export class AuthQuery extends Message {
-    constructor(Database, Password) {
-        super("LoginUser", { Database, Password });
-    }
-}
+import { LoginQuery } from "./Messages/LoginQuery";
+import { RegisterCommand } from "./Messages/RegisterCommand";
 export class OnlineStorage {
     database;
     logEnabled = false;
@@ -19,7 +15,7 @@ export class OnlineStorage {
         this._bus = bus || new MessageBus(server, sender);
     }
     async Login(password) {
-        const result = await this._bus.SendMessage(new AuthQuery(this.DatabaseDir, password));
+        const result = await this._bus.SendMessage(new LoginQuery(this.DatabaseDir, password));
         if (!result.IsSuccess) {
             throw new Error(`Could not login: ${result.ErrorMessage}`);
         }
@@ -27,15 +23,26 @@ export class OnlineStorage {
         this.User({ Id: user?.Id ?? "Anonymous" });
         return user;
     }
+    async Register(id, role, name, password, privileges, icon, tags) {
+        const result = await this._bus.SendMessage(new RegisterCommand(this.DatabaseDir, id, role, name, password, privileges, icon, tags));
+        if (!result.IsSuccess) {
+            throw new Error(`Could not register: ${result.ErrorMessage}`);
+        }
+        const user = result.Result;
+        return user;
+    }
     Logout() {
         this.User({ Id: "Anonymous" });
         return this;
     }
+    async Init() {
+        // TODO: Setup Anonymous user and Admin
+    }
     IsAuthorized() {
         return this._bus.Sender?.Id !== "Anonymous";
     }
-    User(access) {
-        this._bus.SetSender(access);
+    User(sender) {
+        this._bus.SetSender(sender);
         return this;
     }
     EnableLog() {
@@ -61,7 +68,7 @@ export class OnlineStorage {
         this.Log(`Creating dataset "${datasetName}"...`);
         const result = await this._bus.SendMessage(new CreateCommand(this.DatabaseDir, datasetName));
         if (!result.IsSuccess) {
-            throw new Error(`Could not add dataset "${datasetName}": ${result.ErrorMessage}`);
+            throw new Error(`Could not add dataset: ${result.ErrorMessage}`);
         }
         this.Log(`Dataset "${datasetName}" created.`);
     }
@@ -69,7 +76,7 @@ export class OnlineStorage {
         this.Log(`Checking if dataset "${datasetName}" exists...`);
         const result = await this._bus.SendMessage(new ExistsCommand(this.DatabaseDir, datasetName));
         if (!result.IsSuccess) {
-            throw new Error(`Could not check if dataset "${datasetName}" exists: ${result.ErrorMessage}`);
+            throw new Error(`Could not check if dataset exists: ${result.ErrorMessage}`);
         }
         this.Log(`Dataset "${datasetName}" ${result.Result ? "exists" : "does not exist"}.`);
         return result.Result;
@@ -78,7 +85,7 @@ export class OnlineStorage {
         this.Log(`Removing dataset "${datasetName}"...`);
         const result = await this._bus.SendMessage(new RemoveCommand(this.DatabaseDir, datasetName));
         if (!result.IsSuccess) {
-            throw new Error(`Could not remove dataset "${datasetName}": ${result.ErrorMessage}`);
+            throw new Error(`Could not remove dataset: ${result.ErrorMessage}`);
         }
         this.Log(`Dataset "${datasetName}" removed.`);
     }

package/package.json

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