@mtcute/core 0.28.2 → 0.29.0

package/highlevel/worker/port.js

@@ -1,27 +1,40 @@
-import { unknownToError, Emitter } from "@fuman/utils";
+import { Emitter } from "@fuman/utils";
 import { LogManager } from "../../utils/logger.js";
-import { TimersManager } from "../managers/timers.js";
 import { PeersIndex } from "../types/peers/peers-index.js";
 import { AppConfigManagerProxy } from "./app-config.js";
 import { deserializeError } from "./errors.js";
 import { WorkerInvoker } from "./invoker.js";
 import { DEFAULT_WORKER_ID, deserializeResult } from "./protocol.js";
 import { TelegramStorageProxy } from "./storage.js";
+import { WorkerTimersManager } from "./timers.js";
+const WORKER_HEARTBEAT_INTERVAL = 1e4;
+let _nextConnectionId = 0;
+function makeConnectionId() {
+  return `${Date.now().toString(36)}-${(_nextConnectionId++).toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
 class TelegramWorkerPort {
   constructor(options) {
     this.options = options;
     this.log = new LogManager("worker", options.platform);
     this.platform = options.platform;
     this.workerId = options.workerId ?? DEFAULT_WORKER_ID;
+    this.connectionId = makeConnectionId();
     this._connection = this.connectToWorker(this.options.worker, this._onMessage);
-    this._invoker = new WorkerInvoker(this._connection[0], this.workerId);
+    this._invoker = new WorkerInvoker(this._connection[0], this.workerId, this.connectionId);
+    this._invoker.connect();
+    this._heartbeatTimer = setInterval(() => {
+      this._invoker.heartbeat();
+    }, WORKER_HEARTBEAT_INTERVAL);
+    this._cancelBeforeExit = this.platform.beforeExit(() => {
+      void this.destroy();
+    });
     this.storage = new TelegramStorageProxy(this._invoker);
     this.appConfig = new AppConfigManagerProxy(this._invoker);
     const bind = this._invoker.makeBinder("client");
     this.prepare = bind("prepare");
     this._connect = bind("connect");
     this.disconnect = bind("disconnect");
-    this.destroy_ = bind("destroy");
+    this.unsafeForceDestroy = bind("destroy");
     this.notifyLoggedIn = bind("notifyLoggedIn");
     this.notifyLoggedOut = bind("notifyLoggedOut");
     this.notifyChannelOpened = bind("notifyChannelOpened");
@@ -39,8 +52,7 @@ class TelegramWorkerPort {
     this.stopUpdatesLoop = bind("stopUpdatesLoop");
     this.getMtprotoMessageId = bind("getMtprotoMessageId");
     this.recreateDc = bind("recreateDc");
-    this.timers = new TimersManager();
-    this.timers.onError((err) => this.onError.emit(unknownToError(err)));
+    this.timers = new WorkerTimersManager(this._invoker);
   }
   log;
   platform;
@@ -48,15 +60,12 @@ class TelegramWorkerPort {
   _invoker;
   storage;
   appConfig;
-  // todo: ideally timers should be handled on the worker side,
-  // but i'm not sure yet of the best way to handle multiple clients (e.g. in SharedWorker-s)
-  // (with one worker client it's not that big of a deal)
   timers;
   // bound methods
   prepare;
   _connect;
   disconnect;
-  destroy_;
+  unsafeForceDestroy;
   notifyLoggedIn;
   notifyLoggedOut;
   notifyChannelOpened;
@@ -77,6 +86,9 @@ class TelegramWorkerPort {
   _abortController = new AbortController();
   stopSignal = this._abortController.signal;
   workerId;
+  connectionId;
+  _cancelBeforeExit;
+  _heartbeatTimer;
   call(message, params) {
     if (params?.abortSignal) {
       const { abortSignal, ...rest } = params;
@@ -89,7 +101,9 @@ class TelegramWorkerPort {
   onConnectionState = new Emitter();
   onError = new Emitter();
   _onMessage = (message) => {
+    if (this._closed) return;
     if (message._mtcuteWorkerId !== this.workerId) return;
+    if ("connectionId" in message && message.connectionId !== this.connectionId) return;
     switch (message.type) {
       case "log":
         this.log.handler(message.color, message.level, message.tag, message.fmt, message.args);
@@ -97,6 +111,15 @@ class TelegramWorkerPort {
       case "server_update":
         this.onServerUpdate.emit(deserializeResult(message.update));
         break;
+      case "self_sync":
+        this.storage.self.setCached(deserializeResult(message.self));
+        break;
+      case "connection_expired": {
+        const error = new Error("Worker connection expired");
+        this.onError.emit(error);
+        this._close(false);
+        break;
+      }
       case "conn_state":
         this.onConnectionState.emit(message.state);
         break;
@@ -113,17 +136,28 @@ class TelegramWorkerPort {
         this.onError.emit(deserializeError(message.error));
         break;
       case "stop":
-        this._abortController.abort();
+        this._close(false);
         break;
     }
   };
-  _destroyed = false;
+  _closed = false;
+  _close(sendRelease) {
+    if (this._closed) return;
+    this._closed = true;
+    if (this._heartbeatTimer !== void 0) {
+      clearInterval(this._heartbeatTimer);
+    }
+    this._cancelBeforeExit?.();
+    if (sendRelease) {
+      this._invoker.release();
+    } else {
+      this._invoker.expire();
+    }
+    this._abortController.abort();
+    queueMicrotask(() => this._connection[1]());
+  }
   async destroy(terminate = false) {
-    if (this._destroyed) return;
-    await this.destroy_();
-    this.timers.destroy();
-    this._connection[1]();
-    this._destroyed = true;
+    this._close(true);
     if (terminate && "terminate" in this.options.worker) {
       await Promise.resolve(this.options.worker.terminate());
     }

package/highlevel/worker/protocol.cjs

@@ -7,7 +7,21 @@ if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WAR
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const Long = require("long");
 const DEFAULT_WORKER_ID = "default";
+function serializeLong(value) {
+  return {
+    __type: "long",
+    low: value.low,
+    high: value.high,
+    unsigned: value.unsigned
+  };
+}
+function isSerializedLong(value) {
+  return Boolean(value && typeof value === "object" && value.__type === "long");
+}
 function serializeResult(result) {
+  if (Long.isLong(result)) {
+    return serializeLong(result);
+  }
   if (ArrayBuffer.isView(result)) return result;
   if (Array.isArray(result)) {
     return result.map(serializeResult);
@@ -22,12 +36,7 @@ function serializeResult(result) {
     const newResult = {};
     for (const [key, value] of Object.entries(result)) {
       if (Long.isLong(value)) {
-        newResult[key] = {
-          __type: "long",
-          low: value.low,
-          high: value.high,
-          unsigned: value.unsigned
-        };
+        newResult[key] = serializeLong(value);
       } else if (typeof value === "object") {
         newResult[key] = serializeResult(value);
       } else {
@@ -39,6 +48,9 @@ function serializeResult(result) {
   return result;
 }
 function deserializeResult(result) {
+  if (isSerializedLong(result)) {
+    return Long.fromValue(result);
+  }
   if (ArrayBuffer.isView(result)) return result;
   if (Array.isArray(result)) {
     return result.map(deserializeResult);
@@ -51,7 +63,7 @@ function deserializeResult(result) {
   }
   if (result && typeof result === "object") {
     for (const [key, value] of Object.entries(result)) {
-      if (value && typeof value === "object" && value.__type === "long") {
+      if (isSerializedLong(value)) {
         result[key] = Long.fromValue(value);
       } else if (typeof value === "object") {
         result[key] = deserializeResult(value);

package/highlevel/worker/protocol.d.cts

@@ -1,18 +1,33 @@
-import { tl } from '@mtcute/tl';
-import { Worker as NodeWorker } from 'node:worker_threads';
+import { MessagePort as NodeMessagePort, Worker as NodeWorker } from 'node:worker_threads';
+import { tl } from '../../tl/index.js';
 import { ConnectionState } from '../client.types.js';
+import { CurrentUserInfo } from '../storage/service/current-user.js';
 import { SerializedError } from './errors.js';
 export type WorkerInboundMessage = {
     _mtcuteWorkerId: string;
+    connectionId: string;
+    type: 'connect';
+} | {
+    _mtcuteWorkerId: string;
+    connectionId: string;
+    type: 'release';
+} | {
+    _mtcuteWorkerId: string;
+    connectionId: string;
+    type: 'heartbeat';
+} | {
+    _mtcuteWorkerId: string;
+    connectionId: string;
     type: 'invoke';
     id: number;
-    target: 'custom' | 'client' | 'storage' | 'storage-self' | 'storage-peers' | 'app-config';
+    target: 'custom' | 'client' | 'storage' | 'storage-self' | 'storage-peers' | 'app-config' | 'timers';
     method: string;
     args: SerializedResult<unknown[]>;
     void: boolean;
     withAbort: boolean;
 } | {
     _mtcuteWorkerId: string;
+    connectionId: string;
     type: 'abort';
     id: number;
 };
@@ -48,13 +63,22 @@ export type WorkerOutboundMessage = {
     args: unknown[];
 } | {
     _mtcuteWorkerId: string;
+    type: 'self_sync';
+    self: SerializedResult<CurrentUserInfo | null>;
+} | {
+    _mtcuteWorkerId: string;
+    connectionId: string;
+    type: 'connection_expired';
+} | {
+    _mtcuteWorkerId: string;
+    connectionId: string;
     type: 'result';
     id: number;
     result?: SerializedResult<unknown>;
     error?: SerializedError;
 };
 export declare const DEFAULT_WORKER_ID = "default";
-export type SomeWorker = NodeWorker | Worker | SharedWorker;
+export type SomeWorker = NodeWorker | NodeMessagePort | Worker | SharedWorker | MessagePort;
 export type SendFn = (message: WorkerInboundMessage) => void;
 export type ClientMessageHandler = (message: WorkerOutboundMessage) => void;
 export type RespondFn = (message: WorkerOutboundMessage) => void;

package/highlevel/worker/protocol.d.ts

@@ -1,18 +1,33 @@
-import { tl } from '@mtcute/tl';
-import { Worker as NodeWorker } from 'node:worker_threads';
+import { MessagePort as NodeMessagePort, Worker as NodeWorker } from 'node:worker_threads';
+import { tl } from '../../tl/index.js';
 import { ConnectionState } from '../client.types.js';
+import { CurrentUserInfo } from '../storage/service/current-user.js';
 import { SerializedError } from './errors.js';
 export type WorkerInboundMessage = {
     _mtcuteWorkerId: string;
+    connectionId: string;
+    type: 'connect';
+} | {
+    _mtcuteWorkerId: string;
+    connectionId: string;
+    type: 'release';
+} | {
+    _mtcuteWorkerId: string;
+    connectionId: string;
+    type: 'heartbeat';
+} | {
+    _mtcuteWorkerId: string;
+    connectionId: string;
     type: 'invoke';
     id: number;
-    target: 'custom' | 'client' | 'storage' | 'storage-self' | 'storage-peers' | 'app-config';
+    target: 'custom' | 'client' | 'storage' | 'storage-self' | 'storage-peers' | 'app-config' | 'timers';
     method: string;
     args: SerializedResult<unknown[]>;
     void: boolean;
     withAbort: boolean;
 } | {
     _mtcuteWorkerId: string;
+    connectionId: string;
     type: 'abort';
     id: number;
 };
@@ -48,13 +63,22 @@ export type WorkerOutboundMessage = {
     args: unknown[];
 } | {
     _mtcuteWorkerId: string;
+    type: 'self_sync';
+    self: SerializedResult<CurrentUserInfo | null>;
+} | {
+    _mtcuteWorkerId: string;
+    connectionId: string;
+    type: 'connection_expired';
+} | {
+    _mtcuteWorkerId: string;
+    connectionId: string;
     type: 'result';
     id: number;
     result?: SerializedResult<unknown>;
     error?: SerializedError;
 };
 export declare const DEFAULT_WORKER_ID = "default";
-export type SomeWorker = NodeWorker | Worker | SharedWorker;
+export type SomeWorker = NodeWorker | NodeMessagePort | Worker | SharedWorker | MessagePort;
 export type SendFn = (message: WorkerInboundMessage) => void;
 export type ClientMessageHandler = (message: WorkerOutboundMessage) => void;
 export type RespondFn = (message: WorkerOutboundMessage) => void;

package/highlevel/worker/protocol.js

@@ -1,6 +1,20 @@
 import Long from "long";
 const DEFAULT_WORKER_ID = "default";
+function serializeLong(value) {
+  return {
+    __type: "long",
+    low: value.low,
+    high: value.high,
+    unsigned: value.unsigned
+  };
+}
+function isSerializedLong(value) {
+  return Boolean(value && typeof value === "object" && value.__type === "long");
+}
 function serializeResult(result) {
+  if (Long.isLong(result)) {
+    return serializeLong(result);
+  }
   if (ArrayBuffer.isView(result)) return result;
   if (Array.isArray(result)) {
     return result.map(serializeResult);
@@ -15,12 +29,7 @@ function serializeResult(result) {
     const newResult = {};
     for (const [key, value] of Object.entries(result)) {
       if (Long.isLong(value)) {
-        newResult[key] = {
-          __type: "long",
-          low: value.low,
-          high: value.high,
-          unsigned: value.unsigned
-        };
+        newResult[key] = serializeLong(value);
       } else if (typeof value === "object") {
         newResult[key] = serializeResult(value);
       } else {
@@ -32,6 +41,9 @@ function serializeResult(result) {
   return result;
 }
 function deserializeResult(result) {
+  if (isSerializedLong(result)) {
+    return Long.fromValue(result);
+  }
   if (ArrayBuffer.isView(result)) return result;
   if (Array.isArray(result)) {
     return result.map(deserializeResult);
@@ -44,7 +56,7 @@ function deserializeResult(result) {
   }
   if (result && typeof result === "object") {
     for (const [key, value] of Object.entries(result)) {
-      if (value && typeof value === "object" && value.__type === "long") {
+      if (isSerializedLong(value)) {
         result[key] = Long.fromValue(value);
       } else if (typeof value === "object") {
         result[key] = deserializeResult(value);

package/highlevel/worker/protocol.test.d.cts

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

package/highlevel/worker/protocol.test.d.ts

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

package/highlevel/worker/storage.cjs

@@ -28,7 +28,7 @@ class CurrentUserServiceProxy {
     return this._cached;
   }
   async fetch() {
-    if (this._cached) return this._cached;
+    if (this._cached !== void 0) return this._cached;
     this._cached = await this._fetch();
     return this._cached;
   }
@@ -43,6 +43,9 @@ class CurrentUserServiceProxy {
     await this._update(params);
     this._cached = await this._fetch();
   }
+  setCached(info) {
+    this._cached = info;
+  }
 }
 class PeersServiceProxy {
   constructor(_invoker) {

package/highlevel/worker/storage.d.cts

@@ -1,4 +1,4 @@
-import { tl } from '@mtcute/tl';
+import { tl } from '../../tl/index.js';
 import { PublicPart } from '../../types/utils.js';
 import { CurrentUserInfo, CurrentUserService } from '../storage/service/current-user.js';
 import { PeersService } from '../storage/service/peers.js';
@@ -16,6 +16,7 @@ declare class CurrentUserServiceProxy implements PublicPart<CurrentUserService>
     fetch(): Promise<CurrentUserInfo | null>;
     getCached(safe?: boolean): CurrentUserInfo | null;
     update(params: Parameters<CurrentUserService['update']>[0]): Promise<void>;
+    setCached(info: CurrentUserInfo | null): void;
 }
 declare class PeersServiceProxy implements PublicPart<PeersService> {
     private _invoker;

package/highlevel/worker/storage.d.ts

@@ -1,4 +1,4 @@
-import { tl } from '@mtcute/tl';
+import { tl } from '../../tl/index.js';
 import { PublicPart } from '../../types/utils.js';
 import { CurrentUserInfo, CurrentUserService } from '../storage/service/current-user.js';
 import { PeersService } from '../storage/service/peers.js';
@@ -16,6 +16,7 @@ declare class CurrentUserServiceProxy implements PublicPart<CurrentUserService>
     fetch(): Promise<CurrentUserInfo | null>;
     getCached(safe?: boolean): CurrentUserInfo | null;
     update(params: Parameters<CurrentUserService['update']>[0]): Promise<void>;
+    setCached(info: CurrentUserInfo | null): void;
 }
 declare class PeersServiceProxy implements PublicPart<PeersService> {
     private _invoker;

package/highlevel/worker/storage.js

@@ -21,7 +21,7 @@ class CurrentUserServiceProxy {
     return this._cached;
   }
   async fetch() {
-    if (this._cached) return this._cached;
+    if (this._cached !== void 0) return this._cached;
     this._cached = await this._fetch();
     return this._cached;
   }
@@ -36,6 +36,9 @@ class CurrentUserServiceProxy {
     await this._update(params);
     this._cached = await this._fetch();
   }
+  setCached(info) {
+    this._cached = info;
+  }
 }
 class PeersServiceProxy {
   constructor(_invoker) {

package/highlevel/worker/timers.cjs

@@ -0,0 +1,19 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/core] CommonJS bundles are deprecated. They will be removed completely in one of the upcoming releases. No support is provided for CommonJS users. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/core] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class WorkerTimersManager {
+  upsert;
+  cancel;
+  exists;
+  constructor(invoker) {
+    const bind = invoker.makeBinder("timers");
+    this.upsert = bind("upsert");
+    this.cancel = bind("cancel");
+    this.exists = bind("exists");
+  }
+}
+exports.WorkerTimersManager = WorkerTimersManager;

package/highlevel/worker/timers.d.cts

@@ -0,0 +1,11 @@
+import { TimersManager } from '../managers/timers.js';
+import { WorkerInvoker } from './invoker.js';
+interface WorkerTimersTarget extends Pick<TimersManager, 'upsert' | 'cancel' | 'exists'> {
+}
+export declare class WorkerTimersManager implements WorkerTimersTarget {
+    readonly upsert: TimersManager['upsert'];
+    readonly cancel: TimersManager['cancel'];
+    readonly exists: TimersManager['exists'];
+    constructor(invoker: WorkerInvoker);
+}
+export {};

package/highlevel/worker/timers.d.ts

@@ -0,0 +1,11 @@
+import { TimersManager } from '../managers/timers.js';
+import { WorkerInvoker } from './invoker.js';
+interface WorkerTimersTarget extends Pick<TimersManager, 'upsert' | 'cancel' | 'exists'> {
+}
+export declare class WorkerTimersManager implements WorkerTimersTarget {
+    readonly upsert: TimersManager['upsert'];
+    readonly cancel: TimersManager['cancel'];
+    readonly exists: TimersManager['exists'];
+    constructor(invoker: WorkerInvoker);
+}
+export {};

package/highlevel/worker/timers.js

@@ -0,0 +1,14 @@
+class WorkerTimersManager {
+  upsert;
+  cancel;
+  exists;
+  constructor(invoker) {
+    const bind = invoker.makeBinder("timers");
+    this.upsert = bind("upsert");
+    this.cancel = bind("cancel");
+    this.exists = bind("exists");
+  }
+}
+export {
+  WorkerTimersManager
+};

package/highlevel/worker/timers.test.d.cts

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

package/highlevel/worker/timers.test.d.ts

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