@tblabs/storage 1.0.0

package/IRepo.d.ts

@@ -0,0 +1,11 @@
+export interface IRepo<T> {
+    Ping(): Promise<boolean>;
+    Delete(folder: string, id: string): Promise<void>;
+    Update(folder: string, id: string, item: T): Promise<void>;
+    GetOne(folder: string, id: string): Promise<T | null>;
+    FindOne(id: string): Promise<T | null>;
+    GetAll(folder: string): Promise<T[]>;
+    GetAllIds(folder: string): Promise<string[]>;
+    Move(id: string, sourceFolder: string, targetFolder: string): Promise<void>;
+    Drop(): Promise<void>;
+}

package/IRepo.js

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

package/MessageBus/HttpResponse.d.ts

@@ -0,0 +1,4 @@
+export interface HttpResponse {
+    status: number;
+    data: any;
+}

package/MessageBus/HttpResponse.js

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

package/MessageBus/IMessage.d.ts

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

package/MessageBus/IMessage.js

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

package/MessageBus/ISender.d.ts

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

package/MessageBus/ISender.js

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

package/MessageBus/Message.d.ts

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

package/MessageBus/Message.js

@@ -0,0 +1,8 @@
+export class Message {
+    Name;
+    Body;
+    constructor(Name, Body) {
+        this.Name = Name;
+        this.Body = Body;
+    }
+}

package/MessageBus/MessageBus.d.ts

@@ -0,0 +1,12 @@
+import { IMessage } from './IMessage';
+import { ISender } from './ISender';
+import { MessageBusResponse } from './MessageBusResponse';
+export declare class MessageBus {
+    private serverUrl;
+    private user?;
+    constructor(serverUrl: string, user?: ISender | undefined);
+    SendMessage(message: IMessage): Promise<MessageBusResponse>;
+    private PostJSON;
+    Ping(): Promise<boolean>;
+    private SendMessagePackage;
+}

package/MessageBus/MessageBus.js

@@ -0,0 +1,80 @@
+import { MessageBusResponse } from './MessageBusResponse';
+import { MessagePackage } from './MessagePackage';
+/*
+    SAMPLE POST:
+
+    {
+        "Sender": {
+            "Id": "guid",
+            "AuthToken": "token"
+        },
+        "Message": {
+            "Name": "Update",
+            "Body": {
+                "Id": "number"
+                "Content": { "foo": "bar" },
+                "CreateIfNotExist": false
+            }
+        }
+    }
+*/
+export class MessageBus {
+    serverUrl;
+    user;
+    constructor(serverUrl, user) {
+        this.serverUrl = serverUrl;
+        this.user = user;
+    }
+    async SendMessage(message) {
+        let messagePackage = new MessagePackage();
+        messagePackage.Message = message;
+        messagePackage.Sender = this.user || { Id: "Anonymous" };
+        return await this.SendMessagePackage(messagePackage);
+    }
+    async PostJSON(data) {
+        let httpResponse = { status: 0, data: undefined };
+        const dataAsString = JSON.stringify(data);
+        const response = await fetch(this.serverUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: dataAsString,
+        });
+        httpResponse.status = response.status;
+        const json = await response.json();
+        httpResponse.data = json;
+        return httpResponse;
+    }
+    async Ping() {
+        try {
+            const response = await fetch(this.serverUrl + "/ping", {
+                method: "GET",
+            });
+            if (response.status != 200) {
+                return false;
+            }
+            const body = await response.text();
+            return (body == "pong");
+        }
+        catch (ex) {
+            return false;
+        }
+    }
+    async SendMessagePackage(messagePackage) {
+        try {
+            const response = await this.PostJSON(messagePackage);
+            if (response.status == 200 && response.data.IsSuccess == true) {
+                const result = response.data;
+                return MessageBusResponse.Success(result.Result);
+            }
+            else if (response.status == 200 && response.data.IsSuccess == false) {
+                return MessageBusResponse.Fault(response.status, response.data.ErrorMessage);
+            }
+            return MessageBusResponse.Fault(response.status, "Non-200 status");
+        }
+        catch (ex) {
+            return MessageBusResponse.Fault(ex.response?.status, ex.message);
+        }
+    }
+}

package/MessageBus/MessageBusResponse.d.ts

@@ -0,0 +1,8 @@
+export declare class MessageBusResponse {
+    IsSuccess: boolean;
+    ErrorMessage: string;
+    ErrorCode: number;
+    Result?: any;
+    static Success(result?: any): MessageBusResponse;
+    static Fault(errorCode: number, errorMessage: string): MessageBusResponse;
+}

package/MessageBus/MessageBusResponse.js

@@ -0,0 +1,20 @@
+export class MessageBusResponse {
+    IsSuccess = false;
+    ErrorMessage = "";
+    ErrorCode = (-1);
+    Result = undefined;
+    static Success(result) {
+        const response = new MessageBusResponse();
+        response.IsSuccess = true;
+        response.Result = result;
+        return response;
+    }
+    static Fault(errorCode, errorMessage) {
+        const response = new MessageBusResponse();
+        response.IsSuccess = false;
+        response.Result = undefined;
+        response.ErrorCode = errorCode || (-1);
+        response.ErrorMessage = errorMessage;
+        return response;
+    }
+}

package/MessageBus/MessagePackage.d.ts

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

package/MessageBus/MessagePackage.js

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

package/Messages/DeleteCommand.d.ts

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

package/Messages/DeleteCommand.js

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

package/Messages/DropCommand.d.ts

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

package/Messages/DropCommand.js

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

package/Messages/FindQuery.d.ts

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

package/Messages/FindQuery.js

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

package/Messages/ListQuery.d.ts

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

package/Messages/ListQuery.js

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

package/Messages/MoveCommand.d.ts

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

package/Messages/MoveCommand.js

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

package/Messages/ReadQuery.d.ts

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

package/Messages/ReadQuery.js

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

package/Messages/UpdateCommand.d.ts

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

package/Messages/UpdateCommand.js

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

package/OnlineRepo.d.ts

@@ -0,0 +1,18 @@
+import { IRepo } from "./IRepo";
+import { MessageBus } from "./MessageBus/MessageBus";
+export declare class OnlineRepo<T extends object> implements IRepo<T> {
+    private _bus;
+    private storageFolder;
+    LOG: boolean;
+    constructor(_bus: MessageBus, storageFolder: string);
+    private Log;
+    Ping(): Promise<boolean>;
+    GetOne(folder: string, id: string): Promise<T | null>;
+    FindOne(id: string): Promise<T | null>;
+    GetAll(folder: string): Promise<T[]>;
+    GetAllIds(folder: string): Promise<string[]>;
+    Update(folder: string, id: string, item: T): Promise<void>;
+    Delete(folder: string, id: string): Promise<void>;
+    Drop(): Promise<void>;
+    Move(id: string, sourceFolder: string, targetFolder: string): Promise<void>;
+}

package/OnlineRepo.js

@@ -0,0 +1,103 @@
+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 { UpdateCommand } from "./Messages/UpdateCommand";
+export class OnlineRepo {
+    _bus;
+    storageFolder;
+    LOG = false;
+    constructor(_bus, storageFolder) {
+        this._bus = _bus;
+        this.storageFolder = storageFolder;
+    }
+    Log(...message) {
+        if (this.LOG)
+            console.log('[OnlineRepo]', ...message);
+    }
+    async Ping() {
+        return await this._bus.Ping();
+    }
+    async GetOne(folder, id) {
+        this.Log(`Fetching "${id}"...`);
+        const folderPath = this.storageFolder + "/" + folder;
+        const queryResult = await this._bus.SendMessage(new ReadQuery(id, folderPath));
+        if (queryResult.IsSuccess) {
+            const item = queryResult.Result;
+            this.Log(`Found "${id}" in "${folderPath}".`);
+            return item;
+        }
+        this.Log(`Not found "${id}" in "${folderPath}".`);
+        return null;
+    }
+    async FindOne(id) {
+        this.Log(`Fetching "${id}"...`);
+        const queryResult = await this._bus.SendMessage(new FindQuery(id, this.storageFolder));
+        if (queryResult.IsSuccess) {
+            const item = queryResult.Result;
+            this.Log(`Found "${id}".`);
+            return item;
+        }
+        this.Log(`Not found "${id}".`);
+        return null;
+    }
+    async GetAll(folder) {
+        this.Log(`Fetching all from "${this.storageFolder}"...`);
+        const folderPath = this.storageFolder + "/" + folder;
+        const queryResult = await this._bus.SendMessage(new ListQuery(folderPath, true));
+        if (queryResult.IsSuccess) {
+            const items = queryResult.Result;
+            this.Log(`Fetched ${items.length} items from "${folderPath}".`);
+            return items;
+        }
+        else
+            throw new Error(`Could not fetch all from "${folder}": ${queryResult.ErrorMessage}`);
+    }
+    async GetAllIds(folder) {
+        this.Log(`Fetching all from "${this.storageFolder}"...`);
+        const folderPath = this.storageFolder + "/" + folder;
+        const queryResult = await this._bus.SendMessage(new ListQuery(folderPath, false));
+        if (queryResult.IsSuccess) {
+            const itemsIds = Object.values(queryResult.Result);
+            this.Log(`Fetched ${itemsIds.length} items ids from "${folderPath}".`);
+            return itemsIds;
+        }
+        else
+            throw new Error(`Could not fetch all ids from "${folder}": ${queryResult.ErrorMessage}`);
+    }
+    async Update(folder, id, item) {
+        this.Log(`Updating "${id}"...`);
+        const folderPath = this.storageFolder + "/" + folder;
+        const result = await this._bus.SendMessage(new UpdateCommand(id, folderPath, item));
+        if (!result.IsSuccess)
+            throw new Error(`Could not update "${id}" in "${folderPath}": ${result.ErrorMessage}`);
+        this.Log(`Updated "${id}" in "${folderPath}".`);
+    }
+    ;
+    async Delete(folder, id) {
+        const folderPath = this.storageFolder + "/" + folder;
+        this.Log(`Deleting "${id}" from "${folderPath}"...`);
+        const result = await this._bus.SendMessage(new DeleteCommand(id, folderPath));
+        if (!result.IsSuccess)
+            throw new Error(`Could not delete "${id}" from "${folderPath}": ${result.ErrorMessage}`);
+        this.Log(`Deleted "${id}" from "${folderPath}".`);
+    }
+    async Drop() {
+        this.Log(`Dropping "${this.storageFolder}"...`);
+        const result = await this._bus.SendMessage(new DropCommand(this.storageFolder));
+        if (!result.IsSuccess)
+            throw new Error(`Could not drop "${this.storageFolder}": ${result.ErrorMessage}`);
+        this.Log(`Dropped "${this.storageFolder}".`);
+    }
+    async Move(id, sourceFolder, targetFolder) {
+        const source = this.storageFolder + "/" + sourceFolder;
+        const target = this.storageFolder + "/" + targetFolder;
+        this.Log(`Moving "${id}" from "${source}" to "${target}"...`);
+        const result = await this._bus.SendMessage(new MoveCommand(id, source, target));
+        if (!result.IsSuccess)
+            throw new Error(`Could not move "${id}" from "${source}" to "${target}": ${result.ErrorMessage}`);
+        this.Log(`Moved "${id}" from "${source}" to "${target}".`);
+    }
+}

package/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./IRepo";
+export * from "./OnlineRepo";

package/index.js

@@ -0,0 +1,2 @@
+export * from "./IRepo";
+export * from "./OnlineRepo";

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@tblabs/storage",
+  "version": "1.0.0",
+  "description": "online storage module",
+  "license": "beerware",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "pack": "npm pack",
+    "clean": "rm ./bin -rf",
+    "build": "npm run clean && tsc ./src/index.ts --declaration --outDir ./bin && cp ./package.json ./bin/package.json",
+    "publish": "npm run build && npm run pack && cd ./bin && npm publish --access public"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.2"
+  }
+}