@tblabs/storage 2.0.1 → 5.0.0

package/Dataset.d.ts

@@ -1,19 +1,19 @@
 import { OnlineStorage } from "./OnlineStorage";
 import { IConverter } from "./IConverter";
 import { IRepo } from "./IRepo";
+import { dir } from "./Types/dir";
 export declare class Dataset<T extends object> implements IRepo<T> {
     private _db;
     private _converter;
-    private folder;
-    constructor(_db: OnlineStorage, _converter: IConverter<any, T>, folder: string);
-    private get FolderPath();
+    private dataset;
+    get Name(): string;
+    constructor(_db: OnlineStorage, _converter: IConverter<any, T>, dataset: dir);
+    private get DatasetPath();
     GetOne(id: string): Promise<T | null>;
     FindOne(id: string): Promise<T | null>;
     GetAll(): Promise<T[]>;
-    GetAllIds(): Promise<string[]>;
     Add(id: string, item: T): Promise<void>;
     Update(id: string, item: T): Promise<void>;
     Delete(id: string): Promise<void>;
     Drop(): Promise<void>;
-    Move(id: string, targetDataset: Dataset<any>): Promise<void>;
 }

package/Dataset.js

@@ -3,29 +3,31 @@ import { DeleteCommand } from "./Messages/DeleteCommand";
 import { DropCommand } from "./Messages/DropCommand";
 import { FindQuery } from "./Messages/FindQuery";
 import { ListQuery } from "./Messages/ListQuery";
-import { MoveCommand } from "./Messages/MoveCommand";
-import { ReadQuery } from "./Messages/ReadQuery";
+import { GetQuery } from "./Messages/GetQuery";
 import { UpdateCommand } from "./Messages/UpdateCommand";
 export class Dataset {
     _db;
     _converter;
-    folder;
-    constructor(_db, _converter, folder) {
+    dataset;
+    get Name() {
+        return this.dataset;
+    }
+    constructor(_db, _converter, dataset) {
         this._db = _db;
         this._converter = _converter;
-        this.folder = folder;
+        this.dataset = dataset;
     }
-    get FolderPath() {
-        return this._db.DatabaseDir + "/" + this.folder;
+    get DatasetPath() {
+        return this._db.DatabaseDir + "/Datasets/" + this.dataset;
     }
     async GetOne(id) {
         this._db.Log(`Fetching "${id}"...`);
-        const queryResult = await this._db.Send(new ReadQuery(id, this.FolderPath));
+        const queryResult = await this._db.Send(new GetQuery(this._db.DatabaseDir, this.dataset, id));
         if (!queryResult.IsSuccess) {
-            this._db.Log(`Not found "${id}" in "${this.FolderPath}".`);
+            this._db.Log(`"${this.DatasetPath}/${id}" not found.`);
             return null;
         }
-        this._db.Log(`Found "${id}" in "${this.FolderPath}".`);
+        this._db.Log(`Found "${id}" in "${this.DatasetPath}".`);
         const rawItem = queryResult.Result;
         const item = this._converter.FromRaw(rawItem);
         return item;
@@ -43,69 +45,62 @@ export class Dataset {
         return item;
     }
     async GetAll() {
-        this._db.Log(`Fetching all from "${this._db.DatabaseDir}"...`);
-        const queryResult = await this._db.Send(new ListQuery(this.FolderPath, true));
+        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 all items from "${this.FolderPath}": ${queryResult.ErrorMessage}`);
+            this._db.Log(`Could not fetch items from "${this.DatasetPath}": ${queryResult.ErrorMessage}`);
             return [];
         }
         const rawItems = queryResult.Result;
         const items = rawItems.map((raw) => this._converter.FromRaw(raw));
-        this._db.Log(`Fetched ${items.length} items from "${this.FolderPath}".`);
+        this._db.Log(`Fetched ${items.length} items from "${this.DatasetPath}".`);
         return items;
     }
-    async GetAllIds() {
-        this._db.Log(`Fetching all ids from "${this.FolderPath}"...`);
-        const queryResult = await this._db.Send(new ListQuery(this.FolderPath, false));
-        if (!queryResult.IsSuccess) {
-            this._db.Log(`Could not fetch all ids from "${this.FolderPath}": ${queryResult.ErrorMessage}`);
-            return [];
-        }
-        const itemsIds = Object.values(queryResult.Result);
-        this._db.Log(`Fetched ${itemsIds.length} items ids from "${this.FolderPath}".`);
-        return itemsIds;
-    }
+    // 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.FolderPath}"...`);
-        const result = await this._db.Send(new AddCommand(id, this.FolderPath, item));
+        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.FolderPath}": ${result.ErrorMessage}`);
+            throw new Error(`Could not add "${id}" to "${this.DatasetPath}": ${result.ErrorMessage}`);
         }
-        this._db.Log(`"${id}" added to "${this.FolderPath}".`);
+        this._db.Log(`"${id}" added to "${this.DatasetPath}".`);
     }
     ;
     async Update(id, item) {
         this._db.Log(`Updating "${id}"...`);
-        const result = await this._db.Send(new UpdateCommand(id, this.FolderPath, item));
+        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.FolderPath}": ${result.ErrorMessage}`);
+            throw new Error(`Could not update "${id}" in "${this.DatasetPath}": ${result.ErrorMessage}`);
         }
-        this._db.Log(`"${id}" updated in "${this.FolderPath}".`);
+        this._db.Log(`"${id}" updated in "${this.DatasetPath}".`);
     }
     ;
     async Delete(id) {
-        this._db.Log(`Deleting "${id}" from "${this.FolderPath}"...`);
-        const result = await this._db.Send(new DeleteCommand(id, this.FolderPath));
+        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.FolderPath}": ${result.ErrorMessage}`);
+            throw new Error(`Could not delete "${id}" from "${this.DatasetPath}": ${result.ErrorMessage}`);
         }
-        this._db.Log(`Deleted "${id}" from "${this.FolderPath}".`);
+        this._db.Log(`Deleted "${id}" from "${this.DatasetPath}".`);
     }
     async Drop() {
-        this._db.Log(`Dropping "${this.FolderPath}"...`);
-        const result = await this._db.Send(new DropCommand(this.FolderPath));
+        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.FolderPath}": ${result.ErrorMessage}`);
+            throw new Error(`Could not drop "${this.DatasetPath}": ${result.ErrorMessage}`);
         }
-        this._db.Log(`Dropped "${this.FolderPath}".`);
-    }
-    async Move(id, targetDataset) {
-        const source = this.FolderPath;
-        const target = targetDataset.FolderPath;
-        this._db.Log(`Moving "${id}" from "${source}" to "${target}"...`);
-        const result = await this._db.Send(new MoveCommand(id, source, target));
-        if (!result.IsSuccess)
-            throw new Error(`Could not move "${id}" from "${source}" to "${target}": ${result.ErrorMessage}`);
-        this._db.Log(`Moved "${id}" from "${source}" to "${target}".`);
+        this._db.Log(`"${this.DatasetPath}" dropped.`);
     }
 }

package/IRepo.d.ts

@@ -3,9 +3,7 @@ export interface IRepo<T> {
     GetAll(): Promise<T[]>;
     GetOne(id: string): Promise<T | null>;
     FindOne(id: string): Promise<T | null>;
-    GetAllIds(): Promise<string[]>;
     Update(id: string, item: T): Promise<void>;
     Delete(id: string): Promise<void>;
-    Move(id: string, target: IRepo<any>): Promise<void>;
     Drop(): Promise<void>;
 }

package/MessageBus/IMessage.d.ts

@@ -1,4 +1,4 @@
 export interface IMessage {
     Name: string;
-    Body?: any;
+    Body: any;
 }

package/MessageBus/ISender.d.ts

@@ -1,4 +1,3 @@
 export interface ISender {
     Id: string;
-    AuthToken?: string;
 }

package/MessageBus/Message.d.ts

@@ -1,5 +1,5 @@
 export declare class Message {
     Name: string;
-    Body?: any | undefined;
-    constructor(Name: string, Body?: any | undefined);
+    Body: any;
+    constructor(Name: string, Body: any);
 }

package/MessageBus/MessageBus.d.ts

@@ -3,8 +3,10 @@ import { ISender } from './ISender';
 import { MessageBusResponse } from './MessageBusResponse';
 export declare class MessageBus {
     private serverUrl;
-    private user?;
-    constructor(serverUrl: string, user?: ISender | undefined);
+    private sender?;
+    constructor(serverUrl: string, sender?: ISender | undefined);
+    get Sender(): ISender | undefined;
+    SetSender(sender: ISender): this;
     SendMessage(message: IMessage): Promise<MessageBusResponse>;
     private PostJSON;
     Ping(): Promise<boolean>;

package/MessageBus/MessageBus.js

@@ -1,5 +1,4 @@
 import { MessageBusResponse } from './MessageBusResponse';
-import { MessagePackage } from './MessagePackage';
 /*
     SAMPLE POST:
 
@@ -20,15 +19,23 @@ import { MessagePackage } from './MessagePackage';
 */
 export class MessageBus {
     serverUrl;
-    user;
-    constructor(serverUrl, user) {
+    sender;
+    constructor(serverUrl, sender) {
         this.serverUrl = serverUrl;
-        this.user = user;
+        this.sender = sender;
+    }
+    get Sender() {
+        return this.sender;
+    }
+    SetSender(sender) {
+        this.sender = sender;
+        return this;
     }
     async SendMessage(message) {
-        let messagePackage = new MessagePackage();
-        messagePackage.Message = message;
-        messagePackage.Sender = this.user || { Id: "Anonymous" };
+        let messagePackage = {
+            Sender: this.sender || { Id: "Anonymous" },
+            Message: message
+        };
         return await this.SendMessagePackage(messagePackage);
     }
     async PostJSON(data) {

package/MessageBus/MessagePackage.d.ts

@@ -1,6 +1,6 @@
 import { IMessage } from "./IMessage";
 import { ISender } from "./ISender";
-export declare class MessagePackage {
-    Sender?: ISender;
+export interface MessagePackage {
+    Sender: ISender;
     Message: IMessage;
 }

package/MessageBus/MessagePackage.js

@@ -1,4 +1 @@
-export class MessagePackage {
-    Sender;
-    Message;
-}
+export {};

package/Messages/AddCommand.d.ts

@@ -1,4 +1,5 @@
 import { Message } from '../MessageBus/Message';
+import { dir } from '../Types/dir';
 export declare class AddCommand extends Message {
-    constructor(Id: string, Folder: string, Content: object);
+    constructor(Database: dir, Dataset: dir, FileId: string, Content: object);
 }

package/Messages/AddCommand.js

@@ -1,12 +1,6 @@
 import { Message } from '../MessageBus/Message';
 export class AddCommand extends Message {
-    constructor(Id, Folder, Content) {
-        if (!Id) {
-            throw new Error(`Id not specified!`);
-        }
-        if (!Folder) {
-            throw new Error(`Folder not specified!`);
-        }
-        super("Add", { Id, Folder, Content });
+    constructor(Database, Dataset, FileId, Content) {
+        super("Add", { Database, Dataset, FileId, Content });
     }
 }

package/Messages/AddDirCommand.d.ts

@@ -1,4 +1,11 @@
 import { Message } from '../MessageBus/Message';
-export declare class AddDirCommand extends Message {
-    constructor(Folder: string);
+import { dir } from '../Types/dir';
+export declare class CreateCommand extends Message {
+    constructor(Database: dir, Dataset: dir);
+}
+export declare class ExistsCommand extends Message {
+    constructor(Database: dir, Dataset: dir);
+}
+export declare class RemoveCommand extends Message {
+    constructor(Database: dir, Dataset: dir);
 }

package/Messages/AddDirCommand.js

@@ -1,6 +1,16 @@
 import { Message } from '../MessageBus/Message';
-export class AddDirCommand extends Message {
-    constructor(Folder) {
-        super("AddDir", { Folder });
+export class CreateCommand extends Message {
+    constructor(Database, Dataset) {
+        super("Create", { Database, Dataset });
+    }
+}
+export class ExistsCommand extends Message {
+    constructor(Database, Dataset) {
+        super("Exists", { Database, Dataset });
+    }
+}
+export class RemoveCommand extends Message {
+    constructor(Database, Dataset) {
+        super("Remove", { Database, Dataset });
     }
 }

package/Messages/DeleteCommand.d.ts

@@ -1,4 +1,5 @@
 import { Message } from '../MessageBus/Message';
+import { dir } from '../Types/dir';
 export declare class DeleteCommand extends Message {
-    constructor(Id: string, Folder: string);
+    constructor(Database: dir, Dataset: dir, FileId: string);
 }

package/Messages/DeleteCommand.js

@@ -1,6 +1,6 @@
 import { Message } from '../MessageBus/Message';
 export class DeleteCommand extends Message {
-    constructor(Id, Folder) {
-        super("Delete", { Id, Folder });
+    constructor(Database, Dataset, FileId) {
+        super("Delete", { Database, Dataset, FileId });
     }
 }

package/Messages/DropCommand.d.ts

@@ -1,4 +1,5 @@
 import { Message } from '../MessageBus/Message';
+import { dir } from '../Types/dir';
 export declare class DropCommand extends Message {
-    constructor(Folder: string);
+    constructor(Database: dir, Dataset: dir);
 }

package/Messages/DropCommand.js

@@ -1,6 +1,6 @@
 import { Message } from '../MessageBus/Message';
 export class DropCommand extends Message {
-    constructor(Folder) {
-        super("Drop", { Folder });
+    constructor(Database, Dataset) {
+        super("Drop", { Database, Dataset });
     }
 }

package/Messages/GetQuery.d.ts

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

package/Messages/GetQuery.js

@@ -0,0 +1,6 @@
+import { Message } from '../MessageBus/Message';
+export class GetQuery extends Message {
+    constructor(Database, Dataset, FileId) {
+        super("Get", { Database, Dataset, FileId });
+    }
+}

package/Messages/ListQuery.d.ts

@@ -1,4 +1,5 @@
 import { Message } from '../MessageBus/Message';
+import { dir } from '../Types/dir';
 export declare class ListQuery extends Message {
-    constructor(Folder: string, AttachFilesContent: boolean);
+    constructor(Database: dir, Dataset: dir);
 }

package/Messages/ListQuery.js

@@ -1,6 +1,6 @@
 import { Message } from '../MessageBus/Message';
 export class ListQuery extends Message {
-    constructor(Folder, AttachFilesContent) {
-        super("List", { Folder, AttachFilesContent });
+    constructor(Database, Dataset) {
+        super("List", { Database, Dataset });
     }
 }

package/Messages/MoveCommand.d.ts

@@ -1,4 +1,5 @@
 import { Message } from '../MessageBus/Message';
+import { dir } from '../Types/dir';
 export declare class MoveCommand extends Message {
-    constructor(Id: string, From: string, To: string);
+    constructor(Database: dir, FileId: string, Source: dir, Target: dir);
 }

package/Messages/MoveCommand.js

@@ -1,6 +1,6 @@
 import { Message } from '../MessageBus/Message';
 export class MoveCommand extends Message {
-    constructor(Id, From, To) {
-        super("Move", { Id, From, To });
+    constructor(Database, FileId, Source, Target) {
+        super("Move", { Database, FileId, Source, Target });
     }
 }

package/Messages/UpdateCommand.d.ts

@@ -1,4 +1,5 @@
 import { Message } from '../MessageBus/Message';
+import { dir } from '../Types/dir';
 export declare class UpdateCommand extends Message {
-    constructor(Id: string, Folder: string, Content: object);
+    constructor(Database: dir, Dataset: dir, FileId: string, Content: object);
 }

package/Messages/UpdateCommand.js

@@ -1,6 +1,6 @@
 import { Message } from '../MessageBus/Message';
 export class UpdateCommand extends Message {
-    constructor(Id, Folder, Content) {
-        super("Update", { Id, Folder, Content });
+    constructor(Database, Dataset, FileId, Content) {
+        super("Update", { Database, Dataset, FileId, Content });
     }
 }

package/OnlineStorage.d.ts

@@ -1,17 +1,77 @@
+import { dir, url } from "./Types/dir";
 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);
+}
 export declare class OnlineStorage {
-    private databaseFolder;
-    private access;
+    private database;
     private logEnabled;
     private readonly _bus;
-    get DatabaseDir(): string;
-    constructor(serverUrl: string, databaseFolder: string, access: ISender);
-    EnableLog(): void;
-    DisableLog(): void;
+    get DatabaseDir(): dir;
+    constructor(server: url, database: dir, sender?: ISender, bus?: MessageBus);
+    Login(password: string): Promise<IUser>;
+    Logout(): this;
+    IsAuthorized(): boolean;
+    User(access: ISender): this;
+    EnableLog(): this;
+    DisableLog(): this;
     Log(...message: any[]): void;
     Ping(): Promise<boolean>;
     Send(message: IMessage): Promise<MessageBusResponse>;
-    AddDataset(datasetName: string): Promise<void>;
+    CreateDataset(datasetName: string): Promise<void>;
+    DatasetExists(datasetName: string): Promise<boolean>;
+    RemoveDataset(datasetName: string): Promise<void>;
+    Move(fileId: string, sourceDataset: Dataset<any>, targetDataset: Dataset<any>): Promise<void>;
 }

package/OnlineStorage.js

@@ -1,27 +1,55 @@
 import { MessageBus } from "./MessageBus/MessageBus";
-import { AddDirCommand } from "./Messages/AddDirCommand";
+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 });
+    }
+}
 export class OnlineStorage {
-    databaseFolder;
-    access;
+    database;
     logEnabled = false;
     _bus;
     get DatabaseDir() {
-        return this.databaseFolder;
+        return this.database;
+    }
+    constructor(server, database, sender = { Id: "Anonymous" }, bus) {
+        this.database = database;
+        this._bus = bus || new MessageBus(server, sender);
     }
-    constructor(serverUrl, databaseFolder, access) {
-        this.databaseFolder = databaseFolder;
-        this.access = access;
-        this._bus = new MessageBus(serverUrl, access);
+    async Login(password) {
+        const result = await this._bus.SendMessage(new AuthQuery(this.DatabaseDir, password));
+        if (!result.IsSuccess) {
+            throw new Error(`Could not login: ${result.ErrorMessage}`);
+        }
+        const user = result.Result;
+        this.User({ Id: user?.Id ?? "Anonymous" });
+        return user;
+    }
+    Logout() {
+        this.User({ Id: "Anonymous" });
+        return this;
+    }
+    IsAuthorized() {
+        return this._bus.Sender?.Id !== "Anonymous";
+    }
+    User(access) {
+        this._bus.SetSender(access);
+        return this;
     }
     EnableLog() {
         this.logEnabled = true;
+        return this;
     }
     DisableLog() {
         this.logEnabled = false;
+        return this;
     }
     Log(...message) {
-        if (this.logEnabled)
-            console.log('[OnlineRepo]', ...message);
+        if (this.logEnabled) {
+            console.log('[Storage]', ...message);
+        }
     }
     async Ping() {
         return await this._bus.Ping();
@@ -29,13 +57,37 @@ export class OnlineStorage {
     async Send(message) {
         return await this._bus.SendMessage(message);
     }
-    async AddDataset(datasetName) {
-        const target = this.DatabaseDir + "/" + datasetName;
-        this.Log(`Creating dataset directory "${target}"...`);
-        const result = await this._bus.SendMessage(new AddDirCommand(target));
+    async CreateDataset(datasetName) {
+        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}`);
+        }
+        this.Log(`Dataset "${datasetName}" created.`);
+    }
+    async DatasetExists(datasetName) {
+        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}`);
+        }
+        this.Log(`Dataset "${datasetName}" ${result.Result ? "exists" : "does not exist"}.`);
+        return result.Result;
+    }
+    async RemoveDataset(datasetName) {
+        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}`);
+        }
+        this.Log(`Dataset "${datasetName}" removed.`);
+    }
+    async Move(fileId, sourceDataset, targetDataset) {
+        this.Log(`Moving "${fileId}" from "${sourceDataset.Name}" to "${targetDataset.Name}"...`);
+        const result = await this._bus.SendMessage(new MoveCommand(this.DatabaseDir, fileId, sourceDataset.Name, targetDataset.Name));
         if (!result.IsSuccess) {
-            throw new Error(`Could not add directory "${target}": ${result.ErrorMessage}`);
+            throw new Error(`Could not move "${fileId}" from "${sourceDataset.Name}" to "${targetDataset.Name}": ${result.ErrorMessage}`);
         }
-        this.Log(`Directory "${target}" added.`);
+        this.Log(`"${fileId}" moved from "${sourceDataset.Name}" to "${targetDataset.Name}".`);
     }
 }

package/Types/dir.d.ts

@@ -0,0 +1,2 @@
+export type dir = string;
+export type url = string;

package/Types/dir.js

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

package/index.d.ts

@@ -1,6 +1,7 @@
-export * from "./IRepo";
+export * from "./Types/dir";
 export * from "./IConverter";
-export * from "./OnlineStorage";
-export * from "./Utils/OperationRepeater";
 export * from "./Converter";
+export * from "./IRepo";
 export * from "./Dataset";
+export * from "./OnlineStorage";
+export * from "./Utils/OperationRepeater";

package/index.js

@@ -1,6 +1,7 @@
-export * from "./IRepo";
+export * from "./Types/dir";
 export * from "./IConverter";
-export * from "./OnlineStorage";
-export * from "./Utils/OperationRepeater";
 export * from "./Converter";
+export * from "./IRepo";
 export * from "./Dataset";
+export * from "./OnlineStorage";
+export * from "./Utils/OperationRepeater";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tblabs/storage",
-  "version": "2.0.1",
-  "description": "online storage module",
+  "version": "5.0.0",
+  "description": "online storage module with auth",
   "license": "beerware",
   "main": "index.js",
   "types": "index.d.ts",
@@ -9,7 +9,7 @@
     "pack": "cd ./bin && npm pack",
     "clean": "rm ./bin -rf && rm *.tgz -rf",
     "build": "npm run clean && tsc ./src/index.ts --declaration --outDir ./bin && cp ./package.json ./bin/package.json",
-    "publish:npm": "npm run build &&npm login  && npm run pack && cd ./bin && npm publish --access public"
+    "publish:npm": "npm run build && npm login && npm run pack && cd ./bin && npm publish --access public"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",

package/Messages/ReadQuery.d.ts

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

package/Messages/ReadQuery.js

@@ -1,6 +0,0 @@
-import { Message } from '../MessageBus/Message';
-export class ReadQuery extends Message {
-    constructor(Id, Folder) {
-        super("Read", { Id, Folder });
-    }
-}