update utils

Author: 0xfantaholic

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heyanon/sdk",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

src/utils/index.ts

@@ -4,3 +4,6 @@ export * from './stringify';
 export * from './is-address';
 export * from './get-timestamp';
 export * from './normalize-address';
+export * from './messages-releaser';
+export * from './try-steps-executor';
+export * from './workflow-retry';

src/utils/messages-releaser.spec.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest';
+
+import { MessagesReleaser } from './messages-releaser';
+
+describe('MessagesReleaser', () => {
+    it('should initialize with default separator', () => {
+        const releaser = new MessagesReleaser();
+        expect(releaser.separator).toBe('\n');
+    });
+
+    it('should initialize with custom separator', () => {
+        const releaser = new MessagesReleaser({ separator: ' ' });
+        expect(releaser.separator).toBe(' ');
+    });
+
+    it('should add messages and release them with default separator', () => {
+        const releaser = new MessagesReleaser();
+        releaser.add('Message 1');
+        releaser.add('Message 2');
+        const result = releaser.release();
+        expect(result).toBe('\nMessage 1\nMessage 2');
+    });
+
+    it('should add messages and release them with custom separator', () => {
+        const releaser = new MessagesReleaser({ separator: ' ' });
+        releaser.add('Message 1');
+        releaser.add('Message 2');
+        const result = releaser.release();
+        expect(result).toBe(' Message 1 Message 2');
+    });
+
+    it('should release messages and reset the internal state', () => {
+        const releaser = new MessagesReleaser();
+        releaser.add('Message 1');
+        releaser.add('Message 2');
+        releaser.release();
+        const result = releaser.release();
+        expect(result).toBe('');
+    });
+
+    it('should add a last message during release', () => {
+        const releaser = new MessagesReleaser();
+        releaser.add('Message 1');
+        const result = releaser.release('Message 2');
+        expect(result).toBe('\nMessage 1\nMessage 2');
+    });
+
+    it('should reset messages after release', () => {
+        const releaser = new MessagesReleaser();
+        releaser.add('Message 1');
+        releaser.release();
+        expect(releaser.messages).toEqual([]);
+    });
+
+    it('should add multiple messages at once', () => {
+        const releaser = new MessagesReleaser();
+        releaser.add('Message 1', 'Message 2', 'Message 3');
+        expect(releaser.messages).toEqual(['Message 1', 'Message 2', 'Message 3']);
+    });
+});

src/utils/messages-releaser.ts

@@ -0,0 +1,39 @@
+export type MessagesReleaserOptions = {
+    separator?: string;
+};
+
+export class MessagesReleaser {
+    private _messages: string[] = [];
+    private _separator = '\n';
+
+    constructor(opts: MessagesReleaserOptions = {}) {
+        if (opts?.separator) {
+            this._separator = opts.separator;
+        }
+    }
+
+    public get separator(): string {
+        return this._separator;
+    }
+
+    public get messages(): string[] {
+        return this._messages;
+    }
+
+    public release(lastMessage?: string): string {
+        if (lastMessage) {
+            this.add(lastMessage);
+        }
+        const message: string = this._messages.length > 0 ? this._separator.concat(this._messages.join(this._separator)) : '';
+        this.reset();
+        return message;
+    }
+
+    public add(...msgs: string[]): void {
+        this._messages.push(...msgs);
+    }
+
+    private reset(): void {
+        this._messages = [];
+    }
+}

src/utils/try-steps-executor.ts

@@ -0,0 +1,32 @@
+import { MessagesReleaser } from './messages-releaser';
+
+export type ExecuteFn<T> = () => Promise<T>;
+export type OnSuccessFn = () => Promise<void>;
+export type OnFailureFn = (message: string) => Promise<void>;
+
+export type StepOpts<R> = {
+    executeFn: ExecuteFn<R>;
+    onSuccessMessage: string;
+    onFailureFn: OnFailureFn;
+};
+
+export class TryStepsExecutor {
+    private msgsReleaser: MessagesReleaser;
+    private onFailureFn: OnFailureFn;
+
+    constructor(initialReleaser: MessagesReleaser, initialOnFailureFn: OnFailureFn) {
+        this.msgsReleaser = initialReleaser || new MessagesReleaser();
+        this.onFailureFn = initialOnFailureFn;
+    }
+
+    public async executeStep<ER, FR>(executeFn: ExecuteFn<ER>, onSuccessMessage: string, onFailureMessage: string): Promise<ER | FR> {
+        try {
+            const result: ER = await executeFn();
+            this.msgsReleaser.add(onSuccessMessage);
+            return result;
+        } catch (error) {
+            await this.onFailureFn(onFailureMessage);
+            throw error;
+        }
+    }
+}