@tblabs/storage 5.7.3 → 5.8.2

package/Datasets.d.ts

@@ -0,0 +1,22 @@
+import { IConverter } from "./IConverter";
+import { IRepos } from "./IRepos";
+import { IStorageUserPrivileges } from "./IStorageUserPrivileges";
+import { OnlineStorage } from "./OnlineStorage";
+import { dir } from "./Types/dir";
+export declare class Datasets<T extends object> implements IRepos<T> {
+    private _db;
+    private _converter;
+    private datasets;
+    constructor(_db: OnlineStorage, _converter: IConverter<any, T>, datasets: dir[]);
+    get Names(): string[];
+    get Database(): OnlineStorage;
+    CanUserDo(action: keyof IStorageUserPrivileges): boolean;
+    GetOne(dataset: dir, id: string): Promise<T>;
+    GetAll(dataset: dir): Promise<T[]>;
+    GetAllIds(dataset: dir): Promise<string[]>;
+    Add(dataset: dir, id: string, item: T): Promise<void>;
+    Update(dataset: dir, id: string, item: T): Promise<void>;
+    Move(id: string, sourceDataset: dir, targetDataset: dir): Promise<void>;
+    Delete(dataset: dir, id: string): Promise<void>;
+    Drop(datasets?: dir[]): Promise<void>;
+}

package/Datasets.js

@@ -0,0 +1,147 @@
+import { AddFileCommand } from "./Messages/AddFileCommand";
+import { DeleteFileCommand } from "./Messages/DeleteFileCommand";
+import { DropDatasetCommand } from "./Messages/DropDatasetCommand";
+import { GetFileQuery } from "./Messages/GetFileQuery";
+import { ListFilesIdsQuery } from "./Messages/ListFilesIdsQuery";
+import { ListFilesQuery } from "./Messages/ListFilesQuery";
+import { MoveFileCommand } from "./Messages/MoveFileCommand";
+import { UpdateFileCommand } from "./Messages/UpdateFileCommand";
+export class Datasets {
+    _db;
+    _converter;
+    datasets;
+    constructor(_db, _converter, datasets) {
+        this._db = _db;
+        this._converter = _converter;
+        this.datasets = datasets;
+        if (datasets.length <= 1) {
+            throw new Error("Datasets must have at least 2 datasets. If one - use Dataset<T> instead.");
+        }
+    }
+    get Names() {
+        return this.datasets;
+    }
+    get Database() {
+        return this._db;
+    }
+    CanUserDo(action) {
+        if (!this._db.User.Privileges) {
+            return false;
+        }
+        const privilege = this._db.User.Privileges[action];
+        if (!privilege) {
+            return false;
+        }
+        // ex. AddFile: { Datasets: "all" } or AddFile: { Datasets: ["Public"] }
+        if (typeof privilege === "object") {
+            const allowedDatasets = privilege.Datasets;
+            // ex. AddFile: { Datasets: "all" }
+            if (typeof allowedDatasets === "string") {
+                if (allowedDatasets == "all") {
+                    return true;
+                }
+                else if (allowedDatasets == "none") {
+                    return false;
+                }
+                else {
+                    return false;
+                }
+            }
+            // ex. AddFile: { Datasets: ["Public"] }
+            else if (typeof allowedDatasets === "object") {
+                if (Array.isArray(allowedDatasets)) {
+                    for (const dataset of this.datasets) {
+                        if (allowedDatasets.includes(dataset)) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+            }
+        }
+        // ex. CreateUser: true
+        else if (typeof privilege === "boolean") {
+            return privilege;
+        }
+        return false;
+    }
+    async GetOne(dataset, id) {
+        this._db.Log(`Fetching "${id}" from "${dataset}"...`);
+        const queryResult = await this._db.Send(new GetFileQuery(this._db.DatabaseDir, dataset, id));
+        if (!queryResult.IsSuccess) {
+            throw new Error("Failed to get one item: " + queryResult.ErrorMessage);
+        }
+        const rawItem = queryResult.Result;
+        const item = this._converter.FromRaw(rawItem);
+        this._db.Log(`Fetched "${id}" from "${dataset}".`);
+        return item;
+    }
+    async GetAll(dataset) {
+        this._db.Log(`Fetching all from "${dataset}"...`);
+        const queryResult = await this._db.Send(new ListFilesQuery(this._db.DatabaseDir, dataset));
+        if (!queryResult.IsSuccess) {
+            throw new Error("Failed to fetch all items: " + queryResult.ErrorMessage);
+        }
+        const rawItems = queryResult.Result;
+        const items = rawItems.map((raw) => this._converter.FromRaw(raw));
+        this._db.Log(`Fetched ${items.length} items from "${dataset}".`);
+        return items;
+    }
+    async GetAllIds(dataset) {
+        this._db.Log(`Fetching all files IDs from "${dataset}"...`);
+        const queryResult = await this._db.Send(new ListFilesIdsQuery(this._db.DatabaseDir, dataset));
+        if (!queryResult.IsSuccess) {
+            throw new Error("Failed to fetch all items ids: " + queryResult.ErrorMessage);
+        }
+        const ids = queryResult.Result;
+        this._db.Log(`Found ${ids.length} files in "${dataset}".`);
+        return ids;
+    }
+    async Add(dataset, id, item) {
+        this._db.Log(`Adding "${id}" to "${dataset}"...`);
+        const rawItem = this._converter.ToRaw(item);
+        const result = await this._db.Send(new AddFileCommand(this._db.DatabaseDir, dataset, id, rawItem));
+        if (!result.IsSuccess) {
+            throw new Error("Failed to add item: " + result.ErrorMessage);
+        }
+        this._db.Log(`"${id}" added to "${dataset}".`);
+    }
+    ;
+    async Update(dataset, id, item) {
+        this._db.Log(`Updating "${id}"...`);
+        const rawItem = this._converter.ToRaw(item);
+        const result = await this._db.Send(new UpdateFileCommand(this._db.DatabaseDir, dataset, id, rawItem));
+        if (!result.IsSuccess) {
+            throw new Error("Failed to update item: " + result.ErrorMessage);
+        }
+        this._db.Log(`"${id}" updated in "${dataset}".`);
+    }
+    ;
+    async Move(id, sourceDataset, targetDataset) {
+        this._db.Log(`Moving "${id}" from "${sourceDataset}" to "${targetDataset}"...`);
+        const result = await this._db.Send(new MoveFileCommand(this._db.DatabaseDir, id, sourceDataset, targetDataset));
+        if (!result.IsSuccess) {
+            throw new Error("Failed to move item: " + result.ErrorMessage);
+        }
+        this._db.Log(`"${id}" moved from "${sourceDataset}" to "${targetDataset}".`);
+    }
+    async Delete(dataset, id) {
+        this._db.Log(`Deleting "${id}" from "${dataset}"...`);
+        const result = await this._db.Send(new DeleteFileCommand(this._db.DatabaseDir, dataset, id));
+        if (!result.IsSuccess) {
+            throw new Error("Failed to delete item: " + result.ErrorMessage);
+        }
+        this._db.Log(`Deleted "${id}" from "${dataset}".`);
+    }
+    async Drop(datasets) {
+        this._db.Log(`Dropping "${(datasets ? datasets.join(", ") : "all")}" datasets...`);
+        for (const dataset of datasets ?? this.datasets) {
+            const result = await this._db.Send(new DropDatasetCommand(this._db.DatabaseDir, dataset));
+            if (!result.IsSuccess) {
+                throw new Error("Failed to drop dataset: " + result.ErrorMessage);
+            }
+            this._db.Log(`"${dataset}" dropped.`);
+        }
+        ;
+    }
+}

package/IRepos.d.ts

@@ -0,0 +1,11 @@
+import { IStorageUserPrivileges } from "./IStorageUserPrivileges";
+export interface IRepos<T> {
+    CanUserDo(action: keyof IStorageUserPrivileges): boolean;
+    Add(dataset: string, id: string, item: T): Promise<void>;
+    GetAll(dataset: string): Promise<T[]>;
+    GetOne(dataset: string, id: string): Promise<T | null>;
+    Update(dataset: string, id: string, item: T): Promise<void>;
+    Delete(dataset: string, id: string): Promise<void>;
+    Drop(datasets?: string[]): Promise<void>;
+    Move(id: string, sourceDataset: string, targetDataset: string): Promise<void>;
+}

package/IRepos.js

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

package/OnlineStorage.js

@@ -57,39 +57,48 @@ export class OnlineStorage {
     async ListDatasets() {
         const result = await this._bus.SendMessage(new ListDatasetsQuery(this.DatabaseDir));
         if (!result.IsSuccess) {
-            throw new Error(`Could not list datasets: ${result.ErrorMessage}`);
+            throw new Error(`Failed to list datasets: ${result.ErrorMessage}`);
         }
         return result.Result;
     }
     async ListUsers() {
         const result = await this._bus.SendMessage(new ListUsersQuery(this.DatabaseDir));
         if (!result.IsSuccess) {
-            throw new Error(`Could not list users: ${result.ErrorMessage}`);
+            throw new Error(`Failed to list users: ${result.ErrorMessage}`);
         }
         return result.Result;
     }
     async GetUser(userId) {
         const result = await this._bus.SendMessage(new GetUserQuery(this.DatabaseDir, userId));
         if (!result.IsSuccess) {
-            throw new Error(`Could not get user: ${result.ErrorMessage}`);
+            throw new Error(`Failed to get user: ${result.ErrorMessage}`);
         }
         return result.Result;
     }
     async AddUser(user) {
         this.Log(`Adding user "${user.Id}"...`);
-        await this._bus.SendMessage(new AddUserCommand(this.DatabaseDir, user));
+        const result = await this._bus.SendMessage(new AddUserCommand(this.DatabaseDir, user));
+        if (!result.IsSuccess) {
+            throw new Error("Failed to add user: " + result.ErrorMessage);
+        }
         this.Log(`User "${user.Id}" added.`);
     }
     ;
     async UpdateUser(user) {
         this.Log(`Updating user "${user.Id}"...`);
-        await this._bus.SendMessage(new UpdateUserCommand(this.DatabaseDir, user));
+        const result = await this._bus.SendMessage(new UpdateUserCommand(this.DatabaseDir, user));
+        if (!result.IsSuccess) {
+            throw new Error("Failed to update user: " + result.ErrorMessage);
+        }
         this.Log(`User "${user.Id}" updated.`);
     }
     ;
     async DeleteUser(user) {
         this.Log(`Deleting user "${user.Id}"...`);
-        await this._bus.SendMessage(new DeleteUserCommand(this.DatabaseDir, user.Id));
+        const result = await this._bus.SendMessage(new DeleteUserCommand(this.DatabaseDir, user.Id));
+        if (!result.IsSuccess) {
+            throw new Error("Failed to delete user: " + result.ErrorMessage);
+        }
         this.Log(`User "${user.Id}" deleted.`);
     }
     ;
@@ -116,7 +125,7 @@ export class OnlineStorage {
     async Login(password, login) {
         const result = await this._bus.SendMessage(new LoginUserQuery(this.DatabaseDir, password, login));
         if (!result.IsSuccess) {
-            throw new Error(`Could not login: ${result.ErrorMessage}`);
+            throw new Error(`Failed to login: ${result.ErrorMessage}`);
         }
         this.user = result.Result || this.ANONYMOUS_USER;
         this.SetUser(this.user);
@@ -200,7 +209,7 @@ export class OnlineStorage {
         this.Log(`Creating dataset "${datasetName}"...`);
         const result = await this._bus.SendMessage(new CreateDatasetCommand(this.DatabaseDir, datasetName));
         if (!result.IsSuccess) {
-            throw new Error(`Could not add dataset: ${result.ErrorMessage}`);
+            throw new Error(`Failed to add dataset: ${result.ErrorMessage}`);
         }
         this.Log(`Dataset "${datasetName}" created.`);
     }
@@ -208,7 +217,7 @@ export class OnlineStorage {
         this.Log(`Checking if dataset "${datasetName}" exists...`);
         const result = await this._bus.SendMessage(new DatasetExistsCommand(this.DatabaseDir, datasetName));
         if (!result.IsSuccess) {
-            throw new Error(`Could not check if dataset exists: ${result.ErrorMessage}`);
+            throw new Error(`Failed to check if dataset exists: ${result.ErrorMessage}`);
         }
         this.Log(`Dataset "${datasetName}" ${result.Result ? "exists" : "does not exist"}.`);
         return result.Result;
@@ -217,7 +226,7 @@ export class OnlineStorage {
         this.Log(`Removing dataset "${datasetName}"...`);
         const result = await this._bus.SendMessage(new RemoveDatasetCommand(this.DatabaseDir, datasetName));
         if (!result.IsSuccess) {
-            throw new Error(`Could not remove dataset: ${result.ErrorMessage}`);
+            throw new Error(`Failed to remove dataset: ${result.ErrorMessage}`);
         }
         this.Log(`Dataset "${datasetName}" removed.`);
     }
@@ -225,21 +234,21 @@ export class OnlineStorage {
         this.Log(`Moving "${fileId}" from "${sourceDataset.Name}" to "${targetDataset.Name}"...`);
         const result = await this._bus.SendMessage(new MoveFileCommand(this.DatabaseDir, fileId, sourceDataset.Name, targetDataset.Name));
         if (!result.IsSuccess) {
-            throw new Error(`Could not move "${fileId}" from "${sourceDataset.Name}" to "${targetDataset.Name}": ${result.ErrorMessage}`);
+            throw new Error(`Failed to move "${fileId}" from "${sourceDataset.Name}" to "${targetDataset.Name}": ${result.ErrorMessage}`);
         }
         this.Log(`"${fileId}" moved from "${sourceDataset.Name}" to "${targetDataset.Name}".`);
     }
     async GetLogsList() {
         const result = await this._bus.SendMessage(new ListLogsIdsQuery(this.DatabaseDir));
         if (!result.IsSuccess) {
-            throw new Error(`Could not get logs list: ${result.ErrorMessage}`);
+            throw new Error(`Failed to get logs list: ${result.ErrorMessage}`);
         }
         return result.Result;
     }
     async GetLog(id) {
         const result = await this._bus.SendMessage(new GetLogQuery(this.DatabaseDir, id));
         if (!result.IsSuccess) {
-            throw new Error(`Could not get log '${id}': ${result.ErrorMessage}`);
+            throw new Error(`Failed to get log '${id}': ${result.ErrorMessage}`);
         }
         return result.Result;
     }
@@ -258,7 +267,7 @@ export class OnlineStorage {
     // 	const result = await this._bus.SendMessage(new SearchQuery(this.DatabaseDir, fileId));
     // 	if (!result.IsSuccess)
     // 	{
-    // 		throw new Error(`Could not find "${fileId}": ${result.ErrorMessage}`);
+    // 		throw new Error(`Failed to find "${fileId}": ${result.ErrorMessage}`);
     // 	}
     // 	const datasetName = result.Result.Dataset;
     // 	const dataset = this.GetDataset<T>(datasetName, converter); ?????????
@@ -268,20 +277,20 @@ export class OnlineStorage {
     async ListDatabases() {
         const result = await this._bus.SendMessage(new ListDatabasesQuery());
         if (!result.IsSuccess) {
-            throw new Error(`Could not list databases: ${result.ErrorMessage}`);
+            throw new Error(`Failed to list databases: ${result.ErrorMessage}`);
         }
         return result.Result;
     }
     async CreateDatabase(databaseDir) {
         const result = await this._bus.SendMessage(new CreateDatabaseCommand(databaseDir));
         if (!result.IsSuccess) {
-            throw new Error(`Could not create database: ${result.ErrorMessage}`);
+            throw new Error(`Failed to create database: ${result.ErrorMessage}`);
         }
     }
     async DeleteDatabase(databaseDir) {
         const result = await this._bus.SendMessage(new DeleteDatabaseCommand(databaseDir));
         if (!result.IsSuccess) {
-            throw new Error(`Could not delete database: ${result.ErrorMessage}`);
+            throw new Error(`Failed to delete database: ${result.ErrorMessage}`);
         }
     }
     CanUser(action) {

package/index.d.ts

@@ -5,6 +5,8 @@ export * from "./IStorageUser";
 export * from "./IConverter";
 export * from "./Converter";
 export * from "./IRepo";
+export * from "./IRepos";
 export * from "./Dataset";
+export * from "./Datasets";
 export * from "./OnlineStorage";
 export * from "./Utils/OperationRepeater";

package/index.js

@@ -5,6 +5,8 @@ export * from "./IStorageUser";
 export * from "./IConverter";
 export * from "./Converter";
 export * from "./IRepo";
+export * from "./IRepos";
 export * from "./Dataset";
+export * from "./Datasets";
 export * from "./OnlineStorage";
 export * from "./Utils/OperationRepeater";

package/package.json

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