PornX_Cash/matrix-appservice-kakaotalk
1
0
Fork 0
forked from fair/matrix-appservice-kakaotalk
Code Pull Requests Activity

Clean up Long

Browse Source 
Keep it as an int in Python, and do all fancy conversions in Node
This commit is contained in:
Andrew Ferrazzutti 2022-03-11 03:43:00 -05:00
parent 2a91a7b43e
commit 4158788496
10 changed files with 102 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
matrix_appservice_kakaotalk/db/message.py
View File

@ -18,12 +18,12 @@ from __future__ import annotations
from typing import TYPE_CHECKING, ClassVar
from asyncpg import Record
from attr import dataclass
from attr import dataclass, field
from mautrix.types import EventID, RoomID
from mautrix.util.async_db import Database
from ..kt.types.bson import Long, StrLong
from ..kt.types.bson import Long
fake_db = Database.create("") if TYPE_CHECKING else None
@ -32,27 +32,17 @@ fake_db = Database.create("") if TYPE_CHECKING else None
class Message:
db: ClassVar[Database] = fake_db
# TODO Store all Long values as the same type
mxid: EventID
mx_room: RoomID
ktid: Long
ktid: Long = field(converter=Long)
index: int
kt_chat: Long
kt_receiver: Long
kt_chat: Long = field(converter=Long)
kt_receiver: Long = field(converter=Long)
timestamp: int
@classmethod
def _from_row(cls, row: Record) -> Message | None:
data = {**row}
ktid = data.pop("ktid")
kt_chat = data.pop("kt_chat")
kt_receiver = data.pop("kt_receiver")
return cls(
**data,
ktid=StrLong(ktid),
kt_chat=Long.from_bytes(kt_chat),
kt_receiver=Long.from_bytes(kt_receiver)
)
def _from_row(cls, row: Record) -> Message:
return cls(**row)
@classmethod
def _from_optional_row(cls, row: Record | None) -> Message | None:
@ -61,15 +51,15 @@ class Message:
columns = 'mxid, mx_room, ktid, "index", kt_chat, kt_receiver, timestamp'
@classmethod
async def get_all_by_ktid(cls, ktid: Long, kt_receiver: Long) -> list[Message]:
async def get_all_by_ktid(cls, ktid: int, kt_receiver: int) -> list[Message]:
q = f"SELECT {cls.columns} FROM message WHERE ktid=$1 AND kt_receiver=$2"
rows = await cls.db.fetch(q, str(ktid), bytes(kt_receiver))
rows = await cls.db.fetch(q, ktid, kt_receiver)
return [cls._from_row(row) for row in rows if row]
@classmethod
async def get_by_ktid(cls, ktid: Long, kt_receiver: Long, index: int = 0) -> Message | None:
async def get_by_ktid(cls, ktid: int, kt_receiver: int, index: int = 0) -> Message | None:
q = f'SELECT {cls.columns} FROM message WHERE ktid=$1 AND kt_receiver=$2 AND "index"=$3'
row = await cls.db.fetchrow(q, str(ktid), bytes(kt_receiver), index)
row = await cls.db.fetchrow(q, ktid, kt_receiver, index)
return cls._from_optional_row(row)
@classmethod
@ -83,18 +73,18 @@ class Message:
return cls._from_optional_row(row)
@classmethod
async def get_most_recent(cls, kt_chat: Long, kt_receiver: Long) -> Message | None:
async def get_most_recent(cls, kt_chat: int, kt_receiver: int) -> Message | None:
q = (
f"SELECT {cls.columns} "
"FROM message WHERE kt_chat=$1 AND kt_receiver=$2 AND ktid IS NOT NULL "
"ORDER BY timestamp DESC LIMIT 1"
)
row = await cls.db.fetchrow(q, bytes(kt_chat), bytes(kt_receiver))
row = await cls.db.fetchrow(q, kt_chat, kt_receiver)
return cls._from_optional_row(row)
@classmethod
async def get_closest_before(
cls, kt_chat: Long, kt_receiver: Long, timestamp: int
cls, kt_chat: int, kt_receiver: int, timestamp: int
) -> Message | None:
q = (
f"SELECT {cls.columns} "
@ -102,7 +92,7 @@ class Message:
" ktid IS NOT NULL "
"ORDER BY timestamp DESC LIMIT 1"
)
row = await cls.db.fetchrow(q, bytes(kt_chat), bytes(kt_receiver), timestamp)
row = await cls.db.fetchrow(q, kt_chat, kt_receiver, timestamp)
return cls._from_optional_row(row)
_insert_query = (
@ -111,46 +101,23 @@ class Message:
"VALUES ($1, $2, $3, $4, $5, $6, $7)"
)
@classmethod
async def bulk_create(
cls,
ktid: Long,
kt_chat: Long,
kt_receiver: Long,
event_ids: list[EventID],
timestamp: int,
mx_room: RoomID,
) -> None:
if not event_ids:
return
columns = [col.strip('"') for col in cls.columns.split(", ")]
records = [
(mxid, mx_room, str(ktid), index, bytes(kt_chat), bytes(kt_receiver), timestamp)
for index, mxid in enumerate(event_ids)
]
async with cls.db.acquire() as conn, conn.transaction():
if cls.db.scheme == "postgres":
await conn.copy_records_to_table("message", records=records, columns=columns)
else:
await conn.executemany(cls._insert_query, records)
async def insert(self) -> None:
q = self._insert_query
await self.db.execute(
q,
self.mxid,
self.mx_room,
str(self.ktid),
self.ktid,
self.index,
bytes(self.kt_chat),
bytes(self.kt_receiver),
self.kt_chat,
self.kt_receiver,
self.timestamp,
)
async def delete(self) -> None:
q = 'DELETE FROM message WHERE ktid=$1 AND kt_receiver=$2 AND "index"=$3'
await self.db.execute(q, str(self.ktid), bytes(self.kt_receiver), self.index)
await self.db.execute(q, self.ktid, self.kt_receiver, self.index)
async def update(self) -> None:
q = "UPDATE message SET ktid=$1, timestamp=$2 WHERE mxid=$3 AND mx_room=$4"
await self.db.execute(q, str(self.ktid), self.timestamp, self.mxid, self.mx_room)
await self.db.execute(q, self.ktid, self.timestamp, self.mxid, self.mx_room)

25
matrix_appservice_kakaotalk/db/portal.py
View File

@ -18,7 +18,7 @@ from __future__ import annotations
from typing import TYPE_CHECKING, ClassVar
from asyncpg import Record
from attr import dataclass
from attr import dataclass, field
from mautrix.types import ContentURI, RoomID, UserID
from mautrix.util.async_db import Database
@ -33,8 +33,8 @@ fake_db = Database.create("") if TYPE_CHECKING else None
class Portal:
db: ClassVar[Database] = fake_db
ktid: Long
kt_receiver: Long
ktid: Long = field(converter=Long)
kt_receiver: Long = field(converter=Long)
kt_type: ChannelType
mxid: RoomID | None
name: str | None
@ -47,23 +47,20 @@ class Portal:
@classmethod
def _from_row(cls, row: Record) -> Portal:
data = {**row}
ktid = data.pop("ktid")
kt_receiver = data.pop("kt_receiver")
return cls(**data, ktid=Long.from_bytes(ktid), kt_receiver=Long.from_bytes(kt_receiver))
return cls(**row)
@classmethod
def _from_optional_row(cls, row: Record | None) -> Portal | None:
return cls._from_row(row) if row is not None else None
@classmethod
async def get_by_ktid(cls, ktid: Long, kt_receiver: Long) -> Portal | None:
async def get_by_ktid(cls, ktid: int, kt_receiver: int) -> Portal | None:
q = """
SELECT ktid, kt_receiver, kt_type, mxid, name, photo_id, avatar_url, encrypted,
name_set, avatar_set, relay_user_id
FROM portal WHERE ktid=$1 AND kt_receiver=$2
"""
row = await cls.db.fetchrow(q, bytes(ktid), bytes(kt_receiver))
row = await cls.db.fetchrow(q, ktid, kt_receiver)
return cls._from_optional_row(row)
@classmethod
@ -77,13 +74,13 @@ class Portal:
return cls._from_optional_row(row)
@classmethod
async def get_all_by_receiver(cls, kt_receiver: Long) -> list[Portal]:
async def get_all_by_receiver(cls, kt_receiver: int) -> list[Portal]:
q = """
SELECT ktid, kt_receiver, kt_type, mxid, name, photo_id, avatar_url, encrypted,
name_set, avatar_set, relay_user_id
FROM portal WHERE kt_receiver=$1
"""
rows = await cls.db.fetch(q, bytes(kt_receiver))
rows = await cls.db.fetch(q, kt_receiver)
return [cls._from_row(row) for row in rows if row]
@classmethod
@ -99,8 +96,8 @@ class Portal:
@property
def _values(self):
return (
Long.to_optional_bytes(self.ktid),
Long.to_optional_bytes(self.kt_receiver),
self.ktid,
self.kt_receiver,
self.kt_type,
self.mxid,
self.name,
@ -122,7 +119,7 @@ class Portal:
async def delete(self) -> None:
q = "DELETE FROM portal WHERE ktid=$1 AND kt_receiver=$2"
await self.db.execute(q, Long.to_optional_bytes(self.ktid), Long.to_optional_bytes(self.kt_receiver))
await self.db.execute(q, self.ktid, self.kt_receiver)
async def save(self) -> None:
q = """

15
matrix_appservice_kakaotalk/db/puppet.py
View File

@ -18,7 +18,7 @@ from __future__ import annotations
from typing import TYPE_CHECKING, ClassVar
from asyncpg import Record
from attr import dataclass
from attr import dataclass, field
from yarl import URL
from mautrix.types import ContentURI, SyncToken, UserID
@ -33,7 +33,7 @@ fake_db = Database.create("") if TYPE_CHECKING else None
class Puppet:
db: ClassVar[Database] = fake_db
ktid: Long
ktid: Long = field(converter=Long)
name: str | None
photo_id: str | None
photo_mxc: ContentURI | None
@ -49,22 +49,21 @@ class Puppet:
@classmethod
def _from_row(cls, row: Record) -> Puppet:
data = {**row}
ktid = data.pop("ktid")
base_url = data.pop("base_url", None)
return cls(**data, ktid=Long.from_optional_bytes(ktid), base_url=URL(base_url) if base_url else None)
return cls(**data, base_url=URL(base_url) if base_url else None)
@classmethod
def _from_optional_row(cls, row: Record | None) -> Puppet | None:
return cls._from_row(row) if row is not None else None
@classmethod
async def get_by_ktid(cls, ktid: Long) -> Puppet | None:
async def get_by_ktid(cls, ktid: int) -> Puppet | None:
q = (
"SELECT ktid, name, photo_id, photo_mxc, name_set, avatar_set, is_registered, "
" custom_mxid, access_token, next_batch, base_url "
"FROM puppet WHERE ktid=$1"
)
row = await cls.db.fetchrow(q, bytes(ktid))
row = await cls.db.fetchrow(q, ktid)
return cls._from_optional_row(row)
@classmethod
@ -100,7 +99,7 @@ class Puppet:
@property
def _values(self):
return (
bytes(self.ktid),
self.ktid,
self.name,
self.photo_id,
self.photo_mxc,
@ -123,7 +122,7 @@ class Puppet:
async def delete(self) -> None:
q = "DELETE FROM puppet WHERE ktid=$1"
await self.db.execute(q, bytes(self.ktid))
await self.db.execute(q, self.ktid)
async def save(self) -> None:
q = """

18
matrix_appservice_kakaotalk/db/upgrade/v01_initial_revision.py
View File

@ -30,7 +30,7 @@ async def create_v1_tables(conn: Connection) -> None:
await conn.execute(
"""CREATE TABLE "user" (
mxid TEXT PRIMARY KEY,
ktid BYTES UNIQUE,
ktid BIGINT UNIQUE,
uuid TEXT,
access_token TEXT,
refresh_token TEXT,
@ -39,8 +39,8 @@ async def create_v1_tables(conn: Connection) -> None:
)
await conn.execute(
"""CREATE TABLE portal (
ktid BYTES,
kt_receiver BYTES,
ktid BIGINT,
kt_receiver BIGINT,
kt_type TEXT,
mxid TEXT UNIQUE,
name TEXT,
@ -55,7 +55,7 @@ async def create_v1_tables(conn: Connection) -> None:
)
await conn.execute(
"""CREATE TABLE puppet (
ktid BYTES PRIMARY KEY,
ktid BIGINT PRIMARY KEY,
name TEXT,
photo_id TEXT,
photo_mxc TEXT,
@ -74,10 +74,10 @@ async def create_v1_tables(conn: Connection) -> None:
"""CREATE TABLE message (
mxid TEXT,
mx_room TEXT,
ktid TEXT,
kt_receiver BYTES,
ktid BIGINT,
kt_receiver BIGINT,
"index" SMALLINT,
kt_chat BYTES,
kt_chat BIGINT,
timestamp BIGINT,
PRIMARY KEY (ktid, kt_receiver, "index"),
FOREIGN KEY (kt_chat, kt_receiver) REFERENCES portal(ktid, kt_receiver)
@ -90,8 +90,8 @@ async def create_v1_tables(conn: Connection) -> None:
mxid TEXT,
mx_room TEXT,
kt_msgid TEXT,
kt_receiver BYTES,
kt_sender BYTES,
kt_receiver BIGINT,
kt_sender BIGINT,
reaction TEXT,
PRIMARY KEY (kt_msgid, kt_receiver, kt_sender),
UNIQUE (mxid, mx_room)

16
matrix_appservice_kakaotalk/db/user.py
View File

@ -18,7 +18,7 @@ from __future__ import annotations
from typing import TYPE_CHECKING, ClassVar, List, Set
from asyncpg import Record
from attr import dataclass
from attr import dataclass, field
from mautrix.types import RoomID, UserID
from mautrix.util.async_db import Database
@ -33,7 +33,7 @@ class User:
db: ClassVar[Database] = fake_db
mxid: UserID
ktid: Long | None
ktid: Long | None = field(converter=lambda x: Long(x) if x is not None else None)
uuid: str | None
access_token: str | None
refresh_token: str | None
@ -41,9 +41,7 @@ class User:
@classmethod
def _from_row(cls, row: Record) -> User:
data = {**row}
ktid = data.pop("ktid", None)
return cls(**data, ktid=Long.from_optional_bytes(ktid))
return cls(**row)
@classmethod
def _from_optional_row(cls, row: Record | None) -> User | None:
@ -59,9 +57,9 @@ class User:
return [cls._from_row(row) for row in rows if row]
@classmethod
async def get_by_ktid(cls, ktid: Long) -> User | None:
async def get_by_ktid(cls, ktid: int) -> User | None:
q = 'SELECT mxid, ktid, uuid, access_token, refresh_token, notice_room FROM "user" WHERE ktid=$1'
row = await cls.db.fetchrow(q, bytes(ktid))
row = await cls.db.fetchrow(q, ktid)
return cls._from_optional_row(row)
@classmethod
@ -81,7 +79,7 @@ class User:
VALUES ($1, $2, $3, $4, $5, $6)
"""
await self.db.execute(
q, self.mxid, Long.to_optional_bytes(self.ktid), self.uuid, self.access_token, self.refresh_token, self.notice_room
q, self.mxid, self.ktid, self.uuid, self.access_token, self.refresh_token, self.notice_room
)
async def delete(self) -> None:
@ -93,5 +91,5 @@ class User:
WHERE mxid=$6
"""
await self.db.execute(
q, Long.to_optional_bytes(self.ktid), self.uuid, self.access_token, self.refresh_token, self.notice_room, self.mxid
q, self.ktid, self.uuid, self.access_token, self.refresh_token, self.notice_room, self.mxid
)

69
matrix_appservice_kakaotalk/kt/types/bson.py
View File

@ -13,69 +13,14 @@
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
from typing import ClassVar, Optional
from attr import dataclass, asdict
import bson
from mautrix.types import SerializableAttrs, JSON
from mautrix.types import Serializable, JSON
@dataclass(frozen=True)
class Long(SerializableAttrs):
high: int
low: int
unsigned: bool
@classmethod
def from_bytes(cls, raw: bytes) -> "Long":
return cls(**bson.loads(raw))
@classmethod
def from_optional_bytes(cls, raw: Optional[bytes]) -> Optional["Long"]:
return cls(**bson.loads(raw)) if raw is not None else None
@classmethod
def to_optional_bytes(cls, value: Optional["Long"]) -> Optional[bytes]:
return bytes(value) if value is not None else None
class Long(int, Serializable):
def serialize(self) -> JSON:
data = super().serialize()
data["__type__"] = "Long"
return data
return {"__type__": "Long", "str": str(self)}
def __bytes__(self) -> bytes:
return bson.dumps(asdict(self))
def __int__(self) -> int:
if self.unsigned:
pass
result = \
((self.high + (1 << 32 if self.high < 0 else 0)) << 32) + \
( self.low + (1 << 32 if self.low < 0 else 0))
return result + (1 << 32 if self.unsigned and result < 0 else 0)
def __str__(self) -> str:
return str(int(self))
ZERO: ClassVar["Long"]
Long.ZERO = Long(0, 0, False)
class IntLong(Long):
"""Helper class for constructing a Long from an int."""
def __init__(self, val: int):
if val < 0:
pass
super().__init__(
high=(val & 0xffffffff00000000) >> 32,
low = val & 0x00000000ffffffff,
unsigned=val < 0,
)
class StrLong(IntLong):
"""Helper class for constructing a Long from the string representation of an int."""
def __init__(self, val: str):
super().__init__(int(val))
@classmethod
def deserialize(cls, raw: JSON) -> "Long":
assert isinstance(raw, str), f"Long deserialization expected a string, but got non-string value {raw}"
return cls(raw)

26
matrix_appservice_kakaotalk/portal.py
View File

@ -48,7 +48,7 @@ from .db import (
)
from .formatter import kakaotalk_to_matrix, matrix_to_kakaotalk
from .kt.types.bson import Long, IntLong
from .kt.types.bson import Long
from .kt.types.channel.channel_info import ChannelInfo
from .kt.types.channel.channel_type import KnownChannelType, ChannelType
from .kt.types.chat.chat import Chatlog
@ -87,7 +87,7 @@ StateHalfShotBridge = EventType.find("uk.half-shot.bridge", EventType.Class.STAT
class Portal(DBPortal, BasePortal):
invite_own_puppet_to_pm: bool = False
by_mxid: dict[RoomID, Portal] = {}
by_ktid: dict[tuple[Long, Long], Portal] = {}
by_ktid: dict[tuple[int, int], Portal] = {}
matrix: m.MatrixHandler
config: Config
@ -162,7 +162,7 @@ class Portal(DBPortal, BasePortal):
async def delete(self) -> None:
if self.mxid:
await DBMessage.delete_all_by_room(self.mxid)
self.by_ktid.pop(self.ktid_full, None)
self.by_ktid.pop(self._ktid_full, None)
self.by_mxid.pop(self.mxid, None)
await super().delete()
@ -170,7 +170,7 @@ class Portal(DBPortal, BasePortal):
# region Properties
@property
def ktid_full(self) -> tuple[Long, Long]:
def _ktid_full(self) -> tuple[int, int]:
return self.ktid, self.kt_receiver
@property
@ -617,7 +617,7 @@ class Portal(DBPortal, BasePortal):
# endregion
# region Matrix event handling
def require_send_lock(self, user_id: Long) -> asyncio.Lock:
def require_send_lock(self, user_id: int) -> asyncio.Lock:
try:
lock = self._send_locks[user_id]
except KeyError:
@ -625,7 +625,7 @@ class Portal(DBPortal, BasePortal):
self._send_locks[user_id] = lock
return lock
def optional_send_lock(self, user_id: Long) -> asyncio.Lock | FakeLock:
def optional_send_lock(self, user_id: int) -> asyncio.Lock | FakeLock:
try:
return self._send_locks[user_id]
except KeyError:
@ -937,8 +937,8 @@ class Portal(DBPortal, BasePortal):
after_log_id: Long | None,
channel_info: ChannelInfo,
) -> None:
self.log.debug("Backfilling history through %s", source.mxid)
self.log.debug("Fetching %s messages through %s", f"up to {limit}" if limit else "all", str(source.ktid))
self.log.debug(f"Backfilling history through {source.mxid}")
self.log.debug(f"Fetching {f'up to {limit}' if limit else 'all'} messages through {source.ktid}")
messages = await source.client.get_chats(
channel_info.channelId,
limit,
@ -961,7 +961,7 @@ class Portal(DBPortal, BasePortal):
# region Database getters
async def postinit(self) -> None:
self.by_ktid[self.ktid_full] = self
self.by_ktid[self._ktid_full] = self
if self.mxid:
self.by_mxid[self.mxid] = self
self._main_intent = (
@ -989,14 +989,14 @@ class Portal(DBPortal, BasePortal):
@async_getter_lock
async def get_by_ktid(
cls,
ktid: Long,
ktid: int,
*,
kt_receiver: Long = Long.ZERO,
kt_receiver: int = 0,
create: bool = True,
kt_type: ChannelType | None = None,
) -> Portal | None:
if kt_type:
kt_receiver = kt_receiver if KnownChannelType.is_direct(kt_type) else Long.ZERO
kt_receiver = kt_receiver if KnownChannelType.is_direct(kt_type) else 0
ktid_full = (ktid, kt_receiver)
try:
return cls.by_ktid[ktid_full]
@ -1017,7 +1017,7 @@ class Portal(DBPortal, BasePortal):
return None
@classmethod
async def get_all_by_receiver(cls, kt_receiver: Long) -> AsyncGenerator[Portal, None]:
async def get_all_by_receiver(cls, kt_receiver: int) -> AsyncGenerator[Portal, None]:
portals = await super().get_all_by_receiver(kt_receiver)
portal: Portal
for portal in portals:

16
matrix_appservice_kakaotalk/puppet.py
View File

@ -31,7 +31,7 @@ from . import matrix as m, portal as p, user as u
from .config import Config
from .db import Puppet as DBPuppet
from .kt.types.bson import Long, StrLong
from .kt.types.bson import Long
from .kt.client.types import UserInfoUnion
@ -43,9 +43,9 @@ class Puppet(DBPuppet, BasePuppet):
mx: m.MatrixHandler
config: Config
hs_domain: str
mxid_template: SimpleTemplate[StrLong]
mxid_template: SimpleTemplate[int]
by_ktid: dict[Long, Puppet] = {}
by_ktid: dict[int, Puppet] = {}
by_custom_mxid: dict[UserID, Puppet] = {}
_last_info_sync: datetime | None
@ -127,7 +127,7 @@ class Puppet(DBPuppet, BasePuppet):
keyword="userid",
prefix="@",
suffix=f":{Puppet.hs_domain}",
type=StrLong,
type=int,
)
cls.sync_with_custom_puppets = cls.config["bridge.sync_with_custom_puppets"]
cls.homeserver_url_map = {
@ -218,9 +218,9 @@ class Puppet(DBPuppet, BasePuppet):
@classmethod
@async_getter_lock
async def get_by_ktid(cls, ktid: Long, *, create: bool = True) -> Puppet | None:
async def get_by_ktid(cls, ktid: int, *, create: bool = True) -> Puppet | None:
try:
return cls.by_ktid[ktid]
return cls.by_ktid[int]
except KeyError:
pass
@ -260,11 +260,11 @@ class Puppet(DBPuppet, BasePuppet):
return None
@classmethod
def get_id_from_mxid(cls, mxid: UserID) -> Long | None:
def get_id_from_mxid(cls, mxid: UserID) -> int | None:
return cls.mxid_template.parse(mxid)
@classmethod
def get_mxid_from_id(cls, ktid: Long) -> UserID:
def get_mxid_from_id(cls, ktid: int) -> UserID:
return UserID(cls.mxid_template.format_full(ktid))
@classmethod

4
matrix_appservice_kakaotalk/user.py
View File

@ -84,7 +84,7 @@ class User(DBUser, BaseUser):
config: Config
by_mxid: dict[UserID, User] = {}
by_ktid: dict[Long, User] = {}
by_ktid: dict[int, User] = {}
client: Client | None
@ -217,7 +217,7 @@ class User(DBUser, BaseUser):
@classmethod
@async_getter_lock
async def get_by_ktid(cls, ktid: Long) -> User | None:
async def get_by_ktid(cls, ktid: int) -> User | None:
try:
return cls.by_ktid[ktid]
except KeyError:

45
node/src/client.js
View File

@ -168,10 +168,9 @@ export default class PeerClient {
* @returns {Promise<void>}
*/
#write(data) {
return promisify(cb => this.socket.write(JSON.stringify(data) + "\n", cb))
return promisify(cb => this.socket.write(JSON.stringify(data, this.#writeReplacer) + "\n", cb))
}
/**
* @param {Object} req
* @param {string} req.passcode
@ -414,7 +413,7 @@ export default class PeerClient {
}
let req
try {
req = JSON.parse(line)
req = JSON.parse(line, this.#readReviver)
} catch (err) {
this.log("Non-JSON request:", line)
return
@ -465,7 +464,6 @@ export default class PeerClient {
const resp = { id: req.id }
delete req.id
delete req.command
req = typeify(req)
resp.command = "response"
try {
resp.response = await handler(req)
@ -483,29 +481,22 @@ export default class PeerClient {
}
await this.#write(resp)
}
}
/**
* Recursively scan an object to check if any of its sub-objects
* should be converted into instances of a specified class.
* @param obj The object to be scanned & updated.
* @returns The converted object.
*/
function typeify(obj) {
if (!(obj instanceof Object)) {
return obj
#writeReplacer = function(key, value) {
if (value instanceof Long) {
return value.toString()
} else {
return value
}
}
const converterFunc = TYPE_MAP.get(obj.__type__)
if (converterFunc !== undefined) {
return converterFunc(obj)
}
for (const key in obj) {
obj[key] = typeify(obj[key])
}
return obj
}
// TODO Add more if needed
const TYPE_MAP = new Map([
["Long", (obj) => new Long(obj.low, obj.high, obj.unsigned)],
])
#readReviver = function(key, value) {
if (value instanceof Object) {
// TODO Use a type map if there will be many possible types
if (value.__type__ == "Long") {
return Long.fromString(value.str)
}
}
return value
}
}