@tblabs/storage 5.7.2 → 5.8.1

package/Dataset.d.ts

@@ -7,8 +7,9 @@ export declare class Dataset<T extends object> implements IRepo<T> {
     private _db;
     private _converter;
     private dataset;
-    get Name(): string;
     constructor(_db: OnlineStorage, _converter: IConverter<any, T>, dataset: dir);
+    get Name(): string;
+    get Database(): OnlineStorage;
     private get DatasetPath();
     CanUserDo(action: keyof IStorageUserPrivileges): boolean;
     GetOne(id: string): Promise<T>;

package/Dataset.js

@@ -9,14 +9,17 @@ export class Dataset {
     _db;
     _converter;
     dataset;
-    get Name() {
-        return this.dataset;
-    }
     constructor(_db, _converter, dataset) {
         this._db = _db;
         this._converter = _converter;
         this.dataset = dataset;
     }
+    get Name() {
+        return this.dataset;
+    }
+    get Database() {
+        return this._db;
+    }
     get DatasetPath() {
         return this._db.DatabaseDir + "/Datasets/" + this.dataset;
     }

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.d.ts

@@ -34,9 +34,6 @@ export declare class OnlineStorage {
     private LoadUserFromLocalStorage;
     get User(): IStorageUser;
     Login(password: string, login?: string): Promise<IStorageUser>;
-    SetLoginPolicy(): void;
-    GetNextPassword(): void;
-    SetDefaultPrivileges(byRole: Record<string, IStorageUserPrivileges>): void;
     private SaveUserInLocalStorage;
     OnUserChange(handler: (user: IStorageUser, isAuthorized: boolean, appStart: boolean) => void): this;
     Logout(): this;

package/OnlineStorage.js

@@ -124,12 +124,6 @@ export class OnlineStorage {
         this.CallOnUserChanged(false);
         return this.user;
     }
-    SetLoginPolicy() {
-    }
-    GetNextPassword() {
-    }
-    SetDefaultPrivileges(byRole) {
-    }
     SaveUserInLocalStorage() {
         if (this.IsBrowserEnvironment()) {
             window.localStorage.setItem(this.USER_LOCAL_STORAGE_KEY, JSON.stringify(this.user));

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.2",
+  "version": "5.8.1",
   "description": "online storage module with auth",
   "license": "beerware",
   "main": "index.js",