@jsm-mit/rabbit-motoko-package 0.1.37 → 0.2.1

package/declarations/rabbit-motoko-backend/rabbit-motoko-backend.did

@@ -1,6 +1,7 @@
 type Task = 
  record {
    channel: text;
+   commonId: text;
    completedAt: int;
    createdAt: int;
    expiresAt: int;
@@ -12,6 +13,39 @@ type Task =
    timesOutAt: int;
    worker: principal;
  };
+type Result_4 = 
+ variant {
+   err: Error;
+   ok: bool;
+ };
+type Result_3 = 
+ variant {
+   err: Error;
+   ok: vec nat;
+ };
+type Result_2 = 
+ variant {
+   err: Error;
+   ok: Task;
+ };
+type Result_1 = 
+ variant {
+   err: Error;
+   ok: vec Task;
+ };
+type Result = 
+ variant {
+   err: Error;
+   ok: nat;
+ };
+type Error = 
+ variant {
+   AlreadyExists;
+   InvalidData: text;
+   NotAuthorized: text;
+   NotFound;
+   ReturnsNull;
+ };
 type CompleteTaskArgs = 
  record {
    id: nat;
@@ -25,16 +59,23 @@ type ClaimTaskArgs =
 type AddTaskArgs = 
  record {
    channel: text;
+   commonId: text;
    parentIds: opt vec nat;
    payload: text;
  };
 service : {
-  addTask: (args: AddTaskArgs) -> (nat);
-  claimTask: (args: ClaimTaskArgs) -> (opt Task);
-  completeTask: (args: CompleteTaskArgs) -> (bool);
-  getAvailableTaskIds: (channel: text) -> (vec nat) query;
-  getTask: (id: nat) -> (opt Task) query;
-  getTasks: () -> (vec Task) query;
-  getTasksLast24h: () -> (vec Task) query;
+  addTask: (args: AddTaskArgs) -> (Result);
+  claimTask: (args: ClaimTaskArgs) -> (Result_2);
+  completeTask: (args: CompleteTaskArgs) -> (Result_4);
+  getAvailableTaskIds: (channel: text) -> (Result_3) query;
+  getTask: (id: nat) -> (Result_2) query;
+  getTasks: () -> (Result_1) query;
+  getTasksByChannelAndCommonId: (channel: text, commonId: text) ->
+   (Result_1) query;
+  getTasksByCommonId: (commonId: text) -> (Result_1) query;
+  getTasksLast24h: () -> (Result_1) query;
+  testErrWithText: () -> (Result) query;
+  testErrWithText2: () -> (Result) query;
+  testError: () -> (Result) query;
   whoAmI: () -> (principal) query;
 }

package/declarations/rabbit-motoko-backend/rabbit-motoko-backend.did.d.ts

@@ -4,11 +4,27 @@ import type { IDL } from '@icp-sdk/core/candid';
 
 export interface AddTaskArgs {
   'parentIds' : [] | [Array<bigint>],
+  'commonId' : string,
   'channel' : string,
   'payload' : string,
 }
 export interface ClaimTaskArgs { 'id' : bigint, 'timeoutNanos' : bigint }
 export interface CompleteTaskArgs { 'id' : bigint, 'message' : string }
+export type Error = { 'NotFound' : null } |
+  { 'NotAuthorized' : string } |
+  { 'InvalidData' : string } |
+  { 'AlreadyExists' : null } |
+  { 'ReturnsNull' : null };
+export type Result = { 'ok' : bigint } |
+  { 'err' : Error };
+export type Result_1 = { 'ok' : Array<Task> } |
+  { 'err' : Error };
+export type Result_2 = { 'ok' : Task } |
+  { 'err' : Error };
+export type Result_3 = { 'ok' : Array<bigint> } |
+  { 'err' : Error };
+export type Result_4 = { 'ok' : boolean } |
+  { 'err' : Error };
 export interface Task {
   'id' : bigint,
   'status' : bigint,
@@ -18,18 +34,24 @@ export interface Task {
   'timesOutAt' : bigint,
   'createdAt' : bigint,
   'parentIds' : [] | [Array<bigint>],
+  'commonId' : string,
   'worker' : Principal,
   'channel' : string,
   'payload' : string,
 }
 export interface _SERVICE {
-  'addTask' : ActorMethod<[AddTaskArgs], bigint>,
-  'claimTask' : ActorMethod<[ClaimTaskArgs], [] | [Task]>,
-  'completeTask' : ActorMethod<[CompleteTaskArgs], boolean>,
-  'getAvailableTaskIds' : ActorMethod<[string], Array<bigint>>,
-  'getTask' : ActorMethod<[bigint], [] | [Task]>,
-  'getTasks' : ActorMethod<[], Array<Task>>,
-  'getTasksLast24h' : ActorMethod<[], Array<Task>>,
+  'addTask' : ActorMethod<[AddTaskArgs], Result>,
+  'claimTask' : ActorMethod<[ClaimTaskArgs], Result_2>,
+  'completeTask' : ActorMethod<[CompleteTaskArgs], Result_4>,
+  'getAvailableTaskIds' : ActorMethod<[string], Result_3>,
+  'getTask' : ActorMethod<[bigint], Result_2>,
+  'getTasks' : ActorMethod<[], Result_1>,
+  'getTasksByChannelAndCommonId' : ActorMethod<[string, string], Result_1>,
+  'getTasksByCommonId' : ActorMethod<[string], Result_1>,
+  'getTasksLast24h' : ActorMethod<[], Result_1>,
+  'testErrWithText' : ActorMethod<[], Result>,
+  'testErrWithText2' : ActorMethod<[], Result>,
+  'testError' : ActorMethod<[], Result>,
   'whoAmI' : ActorMethod<[], Principal>,
 }
 export declare const idlFactory: IDL.InterfaceFactory;

package/declarations/rabbit-motoko-backend/rabbit-motoko-backend.did.js

@@ -1,9 +1,18 @@
 export const idlFactory = ({ IDL }) => {
   const AddTaskArgs = IDL.Record({
     'parentIds' : IDL.Opt(IDL.Vec(IDL.Nat)),
+    'commonId' : IDL.Text,
     'channel' : IDL.Text,
     'payload' : IDL.Text,
   });
+  const Error = IDL.Variant({
+    'NotFound' : IDL.Null,
+    'NotAuthorized' : IDL.Text,
+    'InvalidData' : IDL.Text,
+    'AlreadyExists' : IDL.Null,
+    'ReturnsNull' : IDL.Null,
+  });
+  const Result = IDL.Variant({ 'ok' : IDL.Nat, 'err' : Error });
   const ClaimTaskArgs = IDL.Record({
     'id' : IDL.Nat,
     'timeoutNanos' : IDL.Int,
@@ -17,19 +26,33 @@ export const idlFactory = ({ IDL }) => {
     'timesOutAt' : IDL.Int,
     'createdAt' : IDL.Int,
     'parentIds' : IDL.Opt(IDL.Vec(IDL.Nat)),
+    'commonId' : IDL.Text,
     'worker' : IDL.Principal,
     'channel' : IDL.Text,
     'payload' : IDL.Text,
   });
+  const Result_2 = IDL.Variant({ 'ok' : Task, 'err' : Error });
   const CompleteTaskArgs = IDL.Record({ 'id' : IDL.Nat, 'message' : IDL.Text });
+  const Result_4 = IDL.Variant({ 'ok' : IDL.Bool, 'err' : Error });
+  const Result_3 = IDL.Variant({ 'ok' : IDL.Vec(IDL.Nat), 'err' : Error });
+  const Result_1 = IDL.Variant({ 'ok' : IDL.Vec(Task), 'err' : Error });
   return IDL.Service({
-    'addTask' : IDL.Func([AddTaskArgs], [IDL.Nat], []),
-    'claimTask' : IDL.Func([ClaimTaskArgs], [IDL.Opt(Task)], []),
-    'completeTask' : IDL.Func([CompleteTaskArgs], [IDL.Bool], []),
-    'getAvailableTaskIds' : IDL.Func([IDL.Text], [IDL.Vec(IDL.Nat)], ['query']),
-    'getTask' : IDL.Func([IDL.Nat], [IDL.Opt(Task)], ['query']),
-    'getTasks' : IDL.Func([], [IDL.Vec(Task)], ['query']),
-    'getTasksLast24h' : IDL.Func([], [IDL.Vec(Task)], ['query']),
+    'addTask' : IDL.Func([AddTaskArgs], [Result], []),
+    'claimTask' : IDL.Func([ClaimTaskArgs], [Result_2], []),
+    'completeTask' : IDL.Func([CompleteTaskArgs], [Result_4], []),
+    'getAvailableTaskIds' : IDL.Func([IDL.Text], [Result_3], ['query']),
+    'getTask' : IDL.Func([IDL.Nat], [Result_2], ['query']),
+    'getTasks' : IDL.Func([], [Result_1], ['query']),
+    'getTasksByChannelAndCommonId' : IDL.Func(
+        [IDL.Text, IDL.Text],
+        [Result_1],
+        ['query'],
+      ),
+    'getTasksByCommonId' : IDL.Func([IDL.Text], [Result_1], ['query']),
+    'getTasksLast24h' : IDL.Func([], [Result_1], ['query']),
+    'testErrWithText' : IDL.Func([], [Result], ['query']),
+    'testErrWithText2' : IDL.Func([], [Result], ['query']),
+    'testError' : IDL.Func([], [Result], ['query']),
     'whoAmI' : IDL.Func([], [IDL.Principal], ['query']),
   });
 };

package/dist/rabbit-motoko-actor.d.ts

@@ -5,32 +5,29 @@ export declare class RabbitMotokoActor {
     private readonly host;
     private actor;
     private agent;
-    private lastSyncTime;
     constructor(canisterId: string, identity?: Secp256k1KeyIdentity);
     private initActor;
     private setupAgent;
-    private runFunctionSafely;
+    private runFunctionAndSyncTimeIfNecessaryAsyncUnsafe;
+    private handleResultErrors;
     syncTimeAsync(throwError: boolean): Promise<void>;
+    testErrWithText(): Promise<import("../declarations/rabbit-motoko-backend/rabbit-motoko-backend.did.js").Result>;
+    testError(): Promise<import("../declarations/rabbit-motoko-backend/rabbit-motoko-backend.did.js").Result>;
     /**
      * Adds a new task to the queue.
      */
-    addTaskAsync(args: AddTaskArgs, throwError: boolean): Promise<bigint>;
+    addTaskAsync(args: AddTaskArgs, throwException: boolean): Promise<bigint | null>;
     /**
      * Claims a task for a specific worker.
      */
-    claimTaskAsync(args: ClaimTaskArgs, throwError: boolean): Promise<[] | [Task]>;
+    claimTaskAsync(args: ClaimTaskArgs, throwException: boolean): Promise<Task | null>;
     /**
      * Completes a previously claimed task.
      */
-    completeTaskAsync(args: CompleteTaskArgs, throwError: boolean): Promise<boolean>;
+    completeTaskAsync(args: CompleteTaskArgs, throwException: boolean): Promise<boolean>;
     /**
      * Fetches IDs of tasks available in a specific channel.
      */
-    getAvailableTaskIdsAsync(channel: string, throwError: boolean): Promise<bigint[]>;
-    /**
-     * Returns a list of all tasks.
-     */
-    getTasksAsync(throwError: boolean): Promise<Task[]>;
-    whoAmIAsync(throwError: boolean): Promise<string>;
+    getAvailableTaskIdsAsync(channel: string, throwException: boolean): Promise<bigint[]>;
 }
 //# sourceMappingURL=rabbit-motoko-actor.d.ts.map

package/dist/rabbit-motoko-actor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rabbit-motoko-actor.d.ts","sourceRoot":"","sources":["../src/rabbit-motoko-actor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAExE,OAAO,KAAK,EAAY,WAAW,EAAE,aAAa,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,oEAAoE,CAAC;AAGvJ,qBAAa,iBAAiB;IAMd,OAAO,CAAC,QAAQ,CAAC,UAAU;IALvC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA6B;IAClD,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,KAAK,CAAY;IACzB,OAAO,CAAC,YAAY,CAAa;gBAEJ,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,oBAAoB;IAehF,OAAO,CAAC,SAAS;YAOH,UAAU;YAYV,iBAAiB;IAiClB,aAAa,CAAC,UAAU,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAc9D;;OAEG;IACU,YAAY,CAAC,IAAI,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IASlF;;OAEG;IACU,cAAc,CAAC,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,OAAO,GAAG,OAAO,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;IAS3F;;OAEG;IACU,iBAAiB,CAAC,IAAI,EAAE,gBAAgB,EAAE,UAAU,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAS7F;;OAEG;IACU,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAQ9F;;OAEG;IACU,aAAa,CAAC,UAAU,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAQnD,WAAW,CAAC,UAAU,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;CAUjE"}
+{"version":3,"file":"rabbit-motoko-actor.d.ts","sourceRoot":"","sources":["../src/rabbit-motoko-actor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAExE,OAAO,KAAK,EAAY,WAAW,EAAE,aAAa,EAAE,gBAAgB,EAAS,IAAI,EAAE,MAAM,oEAAoE,CAAC;AAI9J,qBAAa,iBAAiB;IAKd,OAAO,CAAC,QAAQ,CAAC,UAAU;IAJvC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA6B;IAClD,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,KAAK,CAAY;gBAEI,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,oBAAoB;IAehF,OAAO,CAAC,SAAS;YAOH,UAAU;YAWV,4CAA4C;IAwB1D,OAAO,CAAC,kBAAkB;IAWb,aAAa,CAAC,UAAU,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAajD,eAAe;IAIf,SAAS;IAItB;;OAEG;IACU,YAAY,CAAC,IAAI,EAAE,WAAW,EAAE,cAAc,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAwB7F;;OAEG;IACU,cAAc,CAAC,IAAI,EAAE,aAAa,EAAE,cAAc,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;IAwB/F;;OAEG;IACU,iBAAiB,CAAC,IAAI,EAAE,gBAAgB,EAAE,cAAc,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAwBjG;;OAEG;IACU,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CAuBrG"}

package/dist/rabbit-motoko-actor.js

@@ -1,12 +1,12 @@
 import { Actor, HttpAgent } from "@icp-sdk/core/agent";
 import { Secp256k1KeyIdentity } from "@icp-sdk/core/identity/secp256k1";
 import { idlFactory } from "../declarations/rabbit-motoko-backend/index.js";
-import { BetterJSON } from "@jsm-mit/utils-package";
+import { BetterJSON, logErrorLocallyAndPublishOnErrorSubject } from "@jsm-mit/utils-package";
+import { pigeon } from "@jsm-mit/pigeon-package";
 export class RabbitMotokoActor {
     constructor(canisterId, identity) {
         this.canisterId = canisterId;
         this.host = "https://icp0.io";
-        this.lastSyncTime = 0;
         // 1. Tworzymy agenta
         this.agent = HttpAgent.createSync({
             host: this.host,
@@ -28,14 +28,13 @@ export class RabbitMotokoActor {
         try {
             // Synchronizacja czasu z siecią IC - rozwiązuje błąd "certificate is still too far in the future"
             await this.agent.syncTime();
-            this.lastSyncTime = Date.now();
             console.log("✅ Agent IC zsynchronizowany pomyślnie.");
         }
         catch (err) {
             console.error("❌ Błąd podczas konfiguracji Agenta:", err);
         }
     }
-    async runFunctionSafely(fn, throwError) {
+    async runFunctionAndSyncTimeIfNecessaryAsyncUnsafe(fn) {
         try {
             return fn();
         }
@@ -49,27 +48,25 @@ export class RabbitMotokoActor {
                 }
                 catch (err) {
                     console.error(BetterJSON.stringify(err));
-                    if (throwError) {
-                        throw err;
-                    }
-                    else {
-                        return {};
-                    }
+                    throw err;
                 }
             }
             console.error(BetterJSON.stringify(error));
-            if (throwError) {
-                throw error;
-            }
-            else {
-                return {};
-            }
+            throw error;
         }
     }
+    handleResultErrors(functionName, params, error) {
+        pigeon.debugEmailAsyncSafe("debug", functionName, params, BetterJSON.stringify(error));
+        const errorKey = Object.keys(error)[0];
+        const errorMessage = error[errorKey];
+        return {
+            errorKey,
+            errorMessage
+        };
+    }
     async syncTimeAsync(throwError) {
         try {
             await this.agent.syncTime();
-            this.lastSyncTime = Date.now();
             console.log("🔄 Czas agenta został zsynchronizowany ponownie.");
         }
         catch (err) {
@@ -79,70 +76,110 @@ export class RabbitMotokoActor {
             }
         }
     }
+    async testErrWithText() {
+        return this.actor.testErrWithText();
+    }
+    async testError() {
+        return this.actor.testError();
+    }
     /**
      * Adds a new task to the queue.
      */
-    async addTaskAsync(args, throwError) {
+    async addTaskAsync(args, throwException) {
+        const errorMessage = "Network error: add task failed";
         try {
-            return this.runFunctionSafely(() => this.actor.addTask(args), throwError);
+            const result = await this.runFunctionAndSyncTimeIfNecessaryAsyncUnsafe(() => this.actor.addTask(args));
+            if ('ok' in result) {
+                return result.ok;
+            }
+            else {
+                this.handleResultErrors("addTaskAsync", [args, throwException], result.err);
+                return null;
+            }
         }
-        catch {
-            throw new Error("Failed to add task");
+        catch (err) {
+            logErrorLocallyAndPublishOnErrorSubject(errorMessage, err);
+            if (throwException) {
+                throw err;
+            }
+            else {
+                return null;
+            }
         }
     }
     /**
      * Claims a task for a specific worker.
      */
-    async claimTaskAsync(args, throwError) {
+    async claimTaskAsync(args, throwException) {
+        const errorMessage = "Network error: claim task failed";
         try {
-            return this.runFunctionSafely(() => this.actor.claimTask(args), throwError);
+            const result = await this.runFunctionAndSyncTimeIfNecessaryAsyncUnsafe(() => this.actor.claimTask(args));
+            if ('ok' in result) {
+                return result.ok;
+            }
+            else {
+                this.handleResultErrors("claimTaskAsync", [args, throwException], result.err);
+                return null;
+            }
         }
-        catch {
-            throw new Error("Failed to claim task");
+        catch (err) {
+            logErrorLocallyAndPublishOnErrorSubject(errorMessage, err);
+            if (throwException) {
+                throw err;
+            }
+            else {
+                return null;
+            }
         }
     }
     /**
      * Completes a previously claimed task.
      */
-    async completeTaskAsync(args, throwError) {
+    async completeTaskAsync(args, throwException) {
+        const errorMessage = "Network error: complete task failed";
         try {
-            return this.runFunctionSafely(() => this.actor.completeTask(args), throwError);
+            const result = await this.runFunctionAndSyncTimeIfNecessaryAsyncUnsafe(() => this.actor.completeTask(args));
+            if ('ok' in result) {
+                return result.ok;
+            }
+            else {
+                this.handleResultErrors("completeTaskAsync", [args, throwException], result.err);
+                return false;
+            }
         }
-        catch {
-            throw new Error("Failed to complete task");
+        catch (err) {
+            logErrorLocallyAndPublishOnErrorSubject(errorMessage, err);
+            if (throwException) {
+                throw err;
+            }
+            else {
+                return false;
+            }
         }
     }
     /**
      * Fetches IDs of tasks available in a specific channel.
      */
-    async getAvailableTaskIdsAsync(channel, throwError) {
-        try {
-            return this.runFunctionSafely(() => this.actor.getAvailableTaskIds(channel), throwError);
-        }
-        catch {
-            throw new Error("Failed to get available task IDs");
-        }
-    }
-    /**
-     * Returns a list of all tasks.
-     */
-    async getTasksAsync(throwError) {
+    async getAvailableTaskIdsAsync(channel, throwException) {
+        const errorMessage = "Network error: get available task IDs failed";
         try {
-            return this.runFunctionSafely(() => this.actor.getTasks(), throwError);
-        }
-        catch {
-            throw new Error("Failed to get tasks");
-        }
-    }
-    async whoAmIAsync(throwError) {
-        try {
-            return this.runFunctionSafely(() => {
-                const result = this.actor.whoAmI();
-                return Promise.resolve(result.toString());
-            }, throwError);
+            const result = await this.runFunctionAndSyncTimeIfNecessaryAsyncUnsafe(() => this.actor.getAvailableTaskIds(channel));
+            if ('ok' in result) {
+                return result.ok;
+            }
+            else {
+                this.handleResultErrors("getAvailableTaskIdsAsync", [channel, throwException], result.err);
+                return [];
+            }
         }
-        catch {
-            throw new Error("Failed to get who I am");
+        catch (err) {
+            logErrorLocallyAndPublishOnErrorSubject(errorMessage, err);
+            if (throwException) {
+                throw err;
+            }
+            else {
+                return [];
+            }
         }
     }
 }

package/dist/rabbit-task-worker.d.ts

@@ -1,20 +1,15 @@
 import { Observable } from 'rxjs';
 import { RabbitMotokoActor, type Task } from '@jsm-mit/rabbit-motoko-package';
-import { Pigeon } from '@jsm-mit/pigeon-package';
 export declare class RabbitTaskWorker {
     private channel;
     private intervalMiliseconds;
     private actor;
-    private pigeon;
     private intervalId;
     private isProcessing;
     private readonly taskSubject;
     get tasks$(): Observable<Task>;
-    constructor(channel: string, intervalMiliseconds: number, actor: RabbitMotokoActor, pigeon: Pigeon);
-    private claimAndProcessTask;
+    constructor(channel: string, intervalMiliseconds: number, actor: RabbitMotokoActor);
     private processQueue;
-    completeTaskAsyncSafe(taskId: bigint): Promise<void>;
-    addTaskAsyncSafe(channel: string, payload: string): Promise<void>;
     run(): void;
     stop(): void;
 }

package/dist/rabbit-task-worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rabbit-task-worker.d.ts","sourceRoot":"","sources":["../src/rabbit-task-worker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAW,MAAM,MAAM,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAsB,KAAK,IAAI,EAAE,MAAM,gCAAgC,CAAC;AAClG,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAGjD,qBAAa,gBAAgB;IAUrB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,MAAM;IAZlB,OAAO,CAAC,UAAU,CAA+C;IACjE,OAAO,CAAC,YAAY,CAAkB;IACtC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAuB;IAEnD,IAAW,MAAM,IAAI,UAAU,CAAC,IAAI,CAAC,CAEpC;gBAGW,OAAO,EAAE,MAAM,EACf,mBAAmB,EAAE,MAAM,EAC3B,KAAK,EAAE,iBAAiB,EACxB,MAAM,EAAE,MAAM;YAIZ,mBAAmB;YAWnB,YAAY;IAyCb,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASpD,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASvE,GAAG,IAAI,IAAI;IAWX,IAAI,IAAI,IAAI;CAQtB"}
+{"version":3,"file":"rabbit-task-worker.d.ts","sourceRoot":"","sources":["../src/rabbit-task-worker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAW,MAAM,MAAM,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAsB,KAAK,IAAI,EAAE,MAAM,gCAAgC,CAAC;AAGlG,qBAAa,gBAAgB;IAUrB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,KAAK;IAXjB,OAAO,CAAC,UAAU,CAA+C;IACjE,OAAO,CAAC,YAAY,CAAkB;IACtC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAuB;IAEnD,IAAW,MAAM,IAAI,UAAU,CAAC,IAAI,CAAC,CAEpC;gBAGW,OAAO,EAAE,MAAM,EACf,mBAAmB,EAAE,MAAM,EAC3B,KAAK,EAAE,iBAAiB;YAItB,YAAY;IAyCnB,GAAG,IAAI,IAAI;IAWX,IAAI,IAAI,IAAI;CAQtB"}

package/dist/rabbit-task-worker.js

@@ -1,84 +1,52 @@
 import { Observable, Subject } from 'rxjs';
 import { RabbitMotokoActor } from '@jsm-mit/rabbit-motoko-package';
-import { Pigeon } from '@jsm-mit/pigeon-package';
-import { BetterJSON, handleErrorProperly } from '@jsm-mit/utils-package';
+import { BetterJSON, logErrorLocallyAndPublishOnErrorSubject } from '@jsm-mit/utils-package';
 export class RabbitTaskWorker {
     get tasks$() {
         return this.taskSubject.asObservable();
     }
-    constructor(channel, intervalMiliseconds, actor, pigeon) {
+    constructor(channel, intervalMiliseconds, actor) {
         this.channel = channel;
         this.intervalMiliseconds = intervalMiliseconds;
         this.actor = actor;
-        this.pigeon = pigeon;
         this.intervalId = null;
         this.isProcessing = false;
         this.taskSubject = new Subject();
     }
-    async claimAndProcessTask(args) {
-        const claimResult = await this.actor.claimTaskAsync(args, true);
-        if (claimResult.length > 0) {
-            const task = claimResult[0] || {};
-            console.log(`✅ Przejęto zadanie ${task.id}`);
-            this.taskSubject.next(task);
-        }
-    }
     async processQueue() {
         if (this.isProcessing)
             return; // Zapobiega nakładaniu się wywołań
         this.isProcessing = true;
-        try {
-            const availableIds = await this.actor.getAvailableTaskIdsAsync(this.channel, true);
-            if (!availableIds || availableIds.length === 0) {
-                return;
-            }
-            const timeoutNanos = BigInt(5 * 60 * 1000000000);
-            for (const taskId of availableIds) {
-                const args = {
-                    id: taskId,
-                    timeoutNanos: timeoutNanos
-                };
-                try {
-                    await this.claimAndProcessTask(args);
-                }
-                catch (err) {
-                    // second attempt to claim after short delay, in case that time sync fixed the issue
-                    setTimeout(async () => {
-                        try {
-                            await this.claimAndProcessTask(args);
-                        }
-                        catch (claimErr) {
-                            this.pigeon.reportUrgentAsyncSafe('Error at claiming task', BetterJSON.stringify(claimErr));
-                            handleErrorProperly(`Error processing task ${taskId}`, claimErr);
-                        }
-                    }, 10 * 1000);
-                }
-            }
-        }
-        catch (error) {
-            handleErrorProperly("Fatal error in TaskWorker", error);
-        }
-        finally {
-            this.isProcessing = false;
-        }
-    }
-    async completeTaskAsyncSafe(taskId) {
-        try {
-            await this.actor.completeTaskAsync({ id: taskId, message: "Zadanie ukończone przez RabbitTaskWorker" }, true);
-            console.log(`✅ Zadanie ${taskId} oznaczone jako ukończone.`);
-        }
-        catch (err) {
-            handleErrorProperly(`Błąd podczas completeTask (ID: ${taskId})`, err);
-        }
-    }
-    async addTaskAsyncSafe(channel, payload) {
-        try {
-            await this.actor.addTaskAsync({ channel, payload, parentIds: [] }, true);
-            console.log(`✅ Dodano nowe zadanie do kanału ${channel}.`);
-        }
-        catch (err) {
-            handleErrorProperly(`Błąd podczas addTask (Kanał: ${channel})`, err);
-        }
+        // try {
+        //     const availableIds = await this.actor.getAvailableTaskIdsAsync(this.channel, true);
+        //     if (!availableIds || availableIds.length === 0) {
+        //         return;
+        //     }
+        //     const timeoutNanos = BigInt(5 * 60 * 1_000_000_000);
+        //     for (const taskId of availableIds) {
+        //         const args: ClaimTaskArgs = {
+        //             id: taskId,
+        //             timeoutNanos: timeoutNanos
+        //         };
+        //         try {
+        //             await this.claimAndProcessTask(args);
+        //         } catch (err) {
+        //             // second attempt to claim after short delay, in case that time sync fixed the issue
+        //             setTimeout(async () => {
+        //                 try {
+        //                     await this.claimAndProcessTask(args);
+        //                 } catch (claimErr) {
+        //                     this.pigeon.reportUrgentAsyncSafe('Error at claiming task', BetterJSON.stringify(claimErr));
+        //                     handleErrorProperly(`Error processing task ${taskId}`, claimErr);
+        //                 }
+        //             }, 10 * 1000);
+        //         }
+        //     }
+        // } catch (error: any) {
+        //     logErrorLocallyAndPublishOnErrorSubject("Error in processQueue", error);
+        // } finally {
+        //     this.isProcessing = false;
+        // }
     }
     run() {
         if (this.intervalId)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jsm-mit/rabbit-motoko-package",
-    "version": "0.1.37",
+    "version": "0.2.1",
     "description": "Wrapper TypeScript package for Rabbit Motoko Canister.",
     "license": "ISC",
     "author": "",
@@ -22,11 +22,18 @@
         "clean": "rm -rf dist",
         "prepare": "npm run build",
         "publish-public": "npm login && npm publish --access public",
-        "test": "echo \"Error: no test specified\" && exit 1"
+        "test": "vitest",
+        "sandbox": "npx tsx sandbox/main.ts"
     },
     "peerDependencies": {
-        "@jsm-mit/pigeon-package": "^0.1.0",
-        "@jsm-mit/utils-package": "^0.1.0",
-        "@icp-sdk/core": "^5.2.0"
+        "@icp-sdk/core": "^5.2.0",
+        "@jsm-mit/pigeon-package": "^0.5.0",
+        "@jsm-mit/utils-package": "^0.2.2"
+    },
+    "devDependencies": {
+        "@types/node": "^25.5.2",
+        "dotenv": "^16.3.1",
+        "tsx": "^4.18.0",
+        "vitest": "^1.0.0"
     }
-}
+}