teidesu/mtcute
1
0
Fork 0
Code Issues 15 Pull requests 1 Projects Releases Packages Wiki Activity Actions

refactor!: renamed MaybeAsync -> MaybePromise

Browse source
This commit is contained in:
alina 🌸 2024-02-03 20:14:03 +03:00
parent 20a46c54a8
commit ac3b5df9a0
Signed by: teidesu
SSH key fingerprint: SHA256:uNeCpw6aTSU4aIObXLvHfLkDa82HWH9EiOj9AXOIRpI
30 changed files with 127 additions and 125 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
e2e/ts/utils.ts
View file

@ -1,7 +1,7 @@
// eslint-disable-next-line no-restricted-imports
import { join } from 'path'
import { MaybeAsync, MemoryStorage } from '@mtcute/core'
import { MaybePromise, MemoryStorage } from '@mtcute/core'
import { LogManager, sleep } from '@mtcute/core/utils.js'
import { SqliteStorage } from '@mtcute/sqlite'
@ -19,7 +19,7 @@ export const getApiParams = (storage?: string) => {
}
}
export async function waitFor(condition: () => MaybeAsync<void>, timeout = 5000): Promise<void> {
export async function waitFor(condition: () => MaybePromise<void>, timeout = 5000): Promise<void> {
const start = Date.now()
let lastError

8
packages/core/src/highlevel/client.ts
View file

@ -8,7 +8,7 @@ import { tdFileId } from '@mtcute/file-id'
import { tl } from '@mtcute/tl'
import { MemoryStorage } from '../storage/providers/memory/index.js'
import { MaybeArray, MaybeAsync, PartialExcept, PartialOnly } from '../types/index.js'
import { MaybeArray, MaybePromise, PartialExcept, PartialOnly } from '../types/index.js'
import { StringSessionData } from '../utils/string-session.js'
import { BaseTelegramClient, BaseTelegramClientOptions } from './base.js'
import { ITelegramClient } from './client.types.js'
@ -672,7 +672,7 @@ export interface TelegramClient extends ITelegramClient {
* This method handles both login and sign up, and also handles 2FV
*
* All parameters are `MaybeDynamic<T>`, meaning you
* can either supply `T`, or a function that returns `MaybeAsync<T>`
* can either supply `T`, or a function that returns `MaybePromise<T>`
*
* This method is intended for simple and fast use in automated
* scripts and bots. If you are developing a custom client,
@ -725,7 +725,7 @@ export interface TelegramClient extends ITelegramClient {
* If provided `code`/`password` is a constant string, providing an
* invalid one will interrupt authorization flow.
*/
invalidCodeCallback?: (type: 'code' | 'password') => MaybeAsync<void>
invalidCodeCallback?: (type: 'code' | 'password') => MaybePromise<void>
/**
* Whether to force code delivery through SMS
@ -741,7 +741,7 @@ export interface TelegramClient extends ITelegramClient {
* @param code
* @default `console.log`.
*/
codeSentCallback?: (code: SentCode) => MaybeAsync<void>
codeSentCallback?: (code: SentCode) => MaybePromise<void>
}): Promise<User>
/**
* Check if the given peer/input peer is referring to the current user

2
packages/core/src/highlevel/methods/_imports.ts
View file

@ -6,7 +6,7 @@ import { tdFileId } from '@mtcute/file-id'
import { tl } from '@mtcute/tl'
// @copy
import { MaybeArray, MaybeAsync, PartialExcept, PartialOnly } from '../../types/index.js'
import { MaybeArray, MaybePromise, PartialExcept, PartialOnly } from '../../types/index.js'
// @copy
import { StringSessionData } from '../../utils/string-session.js'
// @copy

8
packages/core/src/highlevel/methods/auth/start.ts
View file

@ -2,7 +2,7 @@
import { tl } from '@mtcute/tl'
import { MtArgumentError } from '../../../types/errors.js'
import { MaybeAsync } from '../../../types/utils.js'
import { MaybePromise } from '../../../types/utils.js'
import { StringSessionData } from '../../../utils/string-session.js'
import { ITelegramClient } from '../../client.types.js'
import { SentCode } from '../../types/auth/sent-code.js'
@ -24,7 +24,7 @@ import { signInBot } from './sign-in-bot.js'
* This method handles both login and sign up, and also handles 2FV
*
* All parameters are `MaybeDynamic<T>`, meaning you
* can either supply `T`, or a function that returns `MaybeAsync<T>`
* can either supply `T`, or a function that returns `MaybePromise<T>`
*
* This method is intended for simple and fast use in automated
* scripts and bots. If you are developing a custom client,
@ -77,7 +77,7 @@ export async function start(
* If provided `code`/`password` is a constant string, providing an
* invalid one will interrupt authorization flow.
*/
invalidCodeCallback?: (type: 'code' | 'password') => MaybeAsync<void>
invalidCodeCallback?: (type: 'code' | 'password') => MaybePromise<void>
/**
* Whether to force code delivery through SMS
@ -93,7 +93,7 @@ export async function start(
* @param code
* @default `console.log`.
*/
codeSentCallback?: (code: SentCode) => MaybeAsync<void>
codeSentCallback?: (code: SentCode) => MaybePromise<void>
},
): Promise<User> {
if (params.session) {

12
packages/core/src/highlevel/storage/repository/peers.ts
View file

@ -1,4 +1,4 @@
import { MaybeAsync } from '../../../types/utils.js'
import { MaybePromise } from '../../../types/utils.js'
// eslint-disable-next-line @typescript-eslint/no-namespace
export namespace IPeersRepository {
@ -25,13 +25,13 @@ export namespace IPeersRepository {
export interface IPeersRepository {
/** Store the given peer*/
store(peer: IPeersRepository.PeerInfo): MaybeAsync<void>
store(peer: IPeersRepository.PeerInfo): MaybePromise<void>
/** Find a peer by their `id` */
getById(id: number): MaybeAsync<IPeersRepository.PeerInfo | null>
getById(id: number): MaybePromise<IPeersRepository.PeerInfo | null>
/** Find a peer by their username (where `usernames` includes `username`) */
getByUsername(username: string): MaybeAsync<IPeersRepository.PeerInfo | null>
getByUsername(username: string): MaybePromise<IPeersRepository.PeerInfo | null>
/** Find a peer by their `phone` */
getByPhone(phone: string): MaybeAsync<IPeersRepository.PeerInfo | null>
getByPhone(phone: string): MaybePromise<IPeersRepository.PeerInfo | null>
deleteAll(): MaybeAsync<void>
deleteAll(): MaybePromise<void>
}

12
packages/core/src/highlevel/storage/repository/ref-messages.ts
View file

@ -1,8 +1,8 @@
import { MaybeAsync } from '../../../types/utils.js'
import { MaybePromise } from '../../../types/utils.js'
export interface IReferenceMessagesRepository {
/** Store a reference message */
store(peerId: number, chatId: number, msgId: number): MaybeAsync<void>
store(peerId: number, chatId: number, msgId: number): MaybePromise<void>
/**
* Get the reference message for the given `peerId`.
*
@ -10,13 +10,13 @@ export interface IReferenceMessagesRepository {
* the one with the highest `msgId` should be returned, but this is not
* really important.
*/
getByPeer(peerId: number): MaybeAsync<[number, number] | null>
getByPeer(peerId: number): MaybePromise<[number, number] | null>
/**
* Delete reference messages given the `chatId`
* where `msgId` is one of `msgIds`
*/
delete(chatId: number, msgIds: number[]): MaybeAsync<void>
deleteByPeer(peerId: number): MaybeAsync<void>
deleteAll(): MaybeAsync<void>
delete(chatId: number, msgIds: number[]): MaybePromise<void>
deleteByPeer(peerId: number): MaybePromise<void>
deleteAll(): MaybePromise<void>
}

14
packages/core/src/highlevel/types/conversation.ts
View file

@ -1,7 +1,7 @@
import { tl } from '@mtcute/tl'
import { MtArgumentError, MtTimeoutError } from '../../types/errors.js'
import { MaybeAsync } from '../../types/utils.js'
import { MaybePromise } from '../../types/utils.js'
import { AsyncLock } from '../../utils/async-lock.js'
import { ControllablePromise, createControllablePromise } from '../../utils/controllable-promise.js'
import { Deque } from '../../utils/deque.js'
@ -20,7 +20,7 @@ import { ParametersSkip2 } from './utils.js'
interface QueuedHandler<T> {
promise: ControllablePromise<T>
check?: (update: T) => MaybeAsync<boolean>
check?: (update: T) => MaybePromise<boolean>
timeout?: NodeJS.Timeout
}
@ -304,7 +304,7 @@ export class Conversation {
*
* @param handler
*/
async with<T>(handler: () => MaybeAsync<T>): Promise<T> {
async with<T>(handler: () => MaybePromise<T>): Promise<T> {
await this.start()
let err: unknown
@ -332,7 +332,7 @@ export class Conversation {
* When the timeout is reached, `MtTimeoutError` is thrown.
*/
waitForNewMessage(
filter?: (msg: Message) => MaybeAsync<boolean>,
filter?: (msg: Message) => MaybePromise<boolean>,
timeout: number | null = 15000,
): Promise<Message> {
if (!this._started) {
@ -372,7 +372,7 @@ export class Conversation {
* @param params
*/
waitForResponse(
filter?: (msg: Message) => MaybeAsync<boolean>,
filter?: (msg: Message) => MaybePromise<boolean>,
params?: {
/**
* Message for which to wait for response for.
@ -408,7 +408,7 @@ export class Conversation {
* @param params
*/
waitForReply(
filter?: (msg: Message) => MaybeAsync<boolean>,
filter?: (msg: Message) => MaybePromise<boolean>,
params?: {
/**
* Message for which to wait for reply for.
@ -451,7 +451,7 @@ export class Conversation {
* @param params
*/
async waitForEdit(
filter?: (msg: Message) => MaybeAsync<boolean>,
filter?: (msg: Message) => MaybePromise<boolean>,
params?: {
/**
* Message for which to wait for reply for.

4
packages/core/src/highlevel/types/utils.ts
View file

@ -1,7 +1,7 @@
/* eslint-disable @typescript-eslint/no-explicit-any */
import { MaybeAsync } from '../../types/utils.js'
import { MaybePromise } from '../../types/utils.js'
export type MaybeDynamic<T> = MaybeAsync<T> | (() => MaybeAsync<T>)
export type MaybeDynamic<T> = MaybePromise<T> | (() => MaybePromise<T>)
export type ArrayWithTotal<T> = T[] & { total: number }
export type ArrayPaginated<T, Offset> = T[] & { total: number; next?: Offset }

4
packages/core/src/highlevel/updates/manager.ts
View file

@ -2,7 +2,7 @@
import { tl } from '@mtcute/tl'
import { MtArgumentError } from '../../types/errors.js'
import { assertNever, MaybeAsync } from '../../types/utils.js'
import { assertNever, MaybePromise } from '../../types/utils.js'
import {
AsyncLock,
ConditionVariable,
@ -680,7 +680,7 @@ export class UpdatesManager {
const channelId = toggleChannelIdMark(peerId.channelId)
const promises: MaybeAsync<void>[] = []
const promises: MaybePromise<void>[] = []
function store(peer?: tl.TypePeer | number | number[]): void {
if (!peer) return

6
packages/core/src/network/transports/abstract.ts
View file

@ -2,7 +2,7 @@ import EventEmitter from 'events'
import { tl } from '@mtcute/tl'
import { MaybeAsync } from '../../types/index.js'
import { MaybePromise } from '../../types/index.js'
import { BasicDcOption, ICryptoProvider, Logger } from '../../utils/index.js'
/** Current state of the transport */
@ -73,10 +73,10 @@ export type TransportFactory = () => ITelegramTransport
*/
export interface IPacketCodec {
/** Initial tag of the codec. Will be sent immediately once connected. */
tag(): MaybeAsync<Uint8Array>
tag(): MaybePromise<Uint8Array>
/** Encodes and frames a single packet */
encode(packet: Uint8Array): MaybeAsync<Uint8Array>
encode(packet: Uint8Array): MaybePromise<Uint8Array>
/** Feed packet to the codec. Once packet is processed, codec is supposed to emit `packet` or `error` */
feed(data: Uint8Array): void

16
packages/core/src/storage/driver.ts
View file

@ -1,4 +1,4 @@
import { MaybeAsync } from '../types/utils.js'
import { MaybePromise } from '../types/utils.js'
import { Logger } from '../utils/logger.js'
/**
@ -14,7 +14,7 @@ export interface IStorageDriver {
* May be called more than once, handle this with care
* (or use {@link BaseStorageDriver} that handles this for you)
*/
load?(): MaybeAsync<void>
load?(): MaybePromise<void>
/**
* Save session to some external storage.
* Should be used to commit pending changes in the session.
@ -24,14 +24,14 @@ export interface IStorageDriver {
* It is safe to batch all changes and only commit them here,
* unless stated otherwise in the method description
*/
save?(): MaybeAsync<void>
save?(): MaybePromise<void>
/**
* Cleanup session and release all used resources.
*
* May be called more than once, handle this with care
* (or use {@link BaseStorageDriver} that handles this for you)
*/
destroy?(): MaybeAsync<void>
destroy?(): MaybePromise<void>
/**
* Setup the driver, passing the logger instance,
@ -45,9 +45,9 @@ export interface IStorageDriver {
* and handling the lifecycle for you
*/
export abstract class BaseStorageDriver implements IStorageDriver {
abstract _load(): MaybeAsync<void>
abstract _destroy(): MaybeAsync<void>
abstract _save?(): MaybeAsync<void>
abstract _load(): MaybePromise<void>
abstract _destroy(): MaybePromise<void>
abstract _save?(): MaybePromise<void>
private _loadedTimes = 0
private _destroyed = false
@ -84,7 +84,7 @@ export abstract class BaseStorageDriver implements IStorageDriver {
}
}
save(): MaybeAsync<void> {
save(): MaybePromise<void> {
return this._save?.()
}
}

14
packages/core/src/storage/repository/auth-keys.ts
View file

@ -1,4 +1,4 @@
import { MaybeAsync } from '../../types/utils.js'
import { MaybePromise } from '../../types/utils.js'
export interface IAuthKeysRepository {
/**
@ -8,9 +8,9 @@ export interface IAuthKeysRepository {
*
* **MUST** be applied immediately, without batching
*/
set(dc: number, key: Uint8Array | null): MaybeAsync<void>
set(dc: number, key: Uint8Array | null): MaybePromise<void>
/** Get auth_key for the given DC */
get(dc: number): MaybeAsync<Uint8Array | null>
get(dc: number): MaybePromise<Uint8Array | null>
/**
* Store temp_auth_key for the given DC and idx,
@ -20,13 +20,13 @@ export interface IAuthKeysRepository {
*
* **MUST** be applied immediately, without batching
*/
setTemp(dc: number, idx: number, key: Uint8Array | null, expires: number): MaybeAsync<void>
setTemp(dc: number, idx: number, key: Uint8Array | null, expires: number): MaybePromise<void>
/**
* Given the DC id, idx and point in time (in seconds),
* return the temp_auth_key that should be used for the next request
* (such that `now < key.expires`), or `null` if no such key exists
*/
getTemp(dc: number, idx: number, now: number): MaybeAsync<Uint8Array | null>
getTemp(dc: number, idx: number, now: number): MaybePromise<Uint8Array | null>
/**
* Delete all stored auth keys for the given DC, including
@ -34,12 +34,12 @@ export interface IAuthKeysRepository {
*
* **MUST** be applied immediately, without batching
*/
deleteByDc(dc: number): MaybeAsync<void>
deleteByDc(dc: number): MaybePromise<void>
/**
* Delete all stored auth keys, including both permanent and temp keys
*
* **MUST** be applied immediately, without batching
*/
deleteAll(): MaybeAsync<void>
deleteAll(): MaybePromise<void>
}

10
packages/core/src/storage/repository/key-value.ts
View file

@ -1,12 +1,12 @@
import { MaybeAsync } from '../../types/utils.js'
import { MaybePromise } from '../../types/utils.js'
export interface IKeyValueRepository {
/** Set a key-value pair */
set(key: string, value: Uint8Array): MaybeAsync<void>
set(key: string, value: Uint8Array): MaybePromise<void>
/** Get a key-value pair */
get(key: string): MaybeAsync<Uint8Array | null>
get(key: string): MaybePromise<Uint8Array | null>
/** Delete a key-value pair */
delete(key: string): MaybeAsync<void>
delete(key: string): MaybePromise<void>
deleteAll(): MaybeAsync<void>
deleteAll(): MaybePromise<void>
}

2
packages/core/src/types/utils.ts
View file

@ -1,4 +1,4 @@
export type MaybeAsync<T> = T | Promise<T>
export type MaybePromise<T> = T | Promise<T>
export type PartialExcept<T, K extends keyof T> = Partial<Omit<T, K>> & Pick<T, K>
export type PartialOnly<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>

10
packages/core/src/utils/crypto/abstract.ts
View file

@ -1,4 +1,4 @@
import { MaybeAsync } from '../../types/index.js'
import { MaybePromise } from '../../types/index.js'
import { factorizePQSync } from './factorization.js'
export interface IEncryptionScheme {
@ -12,7 +12,7 @@ export interface IAesCtr {
}
export interface ICryptoProvider {
initialize?(): MaybeAsync<void>
initialize?(): MaybePromise<void>
sha1(data: Uint8Array): Uint8Array
@ -24,15 +24,15 @@ export interface ICryptoProvider {
iterations: number,
keylen?: number, // = 64
algo?: string, // sha1 or sha512 (default sha512)
): MaybeAsync<Uint8Array>
): MaybePromise<Uint8Array>
hmacSha256(data: Uint8Array, key: Uint8Array): MaybeAsync<Uint8Array>
hmacSha256(data: Uint8Array, key: Uint8Array): MaybePromise<Uint8Array>
createAesCtr(key: Uint8Array, iv: Uint8Array, encrypt: boolean): IAesCtr
createAesIge(key: Uint8Array, iv: Uint8Array): IEncryptionScheme
factorizePQ(pq: Uint8Array): MaybeAsync<[Uint8Array, Uint8Array]>
factorizePQ(pq: Uint8Array): MaybePromise<[Uint8Array, Uint8Array]>
gzip(data: Uint8Array, maxSize: number): Uint8Array | null
gunzip(data: Uint8Array): Uint8Array

4
packages/core/src/utils/crypto/node.ts
View file

@ -4,7 +4,7 @@ import { deflateSync, gunzipSync } from 'zlib'
import { ige256Decrypt, ige256Encrypt, initAsync, InitInput } from '@mtcute/wasm'
import { MaybeAsync } from '../../types/index.js'
import { MaybePromise } from '../../types/index.js'
import { BaseCryptoProvider, IAesCtr, ICryptoProvider, IEncryptionScheme } from './abstract.js'
export abstract class BaseNodeCryptoProvider extends BaseCryptoProvider {
@ -24,7 +24,7 @@ export abstract class BaseNodeCryptoProvider extends BaseCryptoProvider {
iterations: number,
keylen = 64,
algo = 'sha512',
): MaybeAsync<Uint8Array> {
): MaybePromise<Uint8Array> {
return new Promise((resolve, reject) =>
pbkdf2(password, salt, iterations, keylen, algo, (err: Error | null, buf: Uint8Array) =>
err !== null ? reject(err) : resolve(buf),

4
packages/dispatcher/src/context/callback-query.ts
View file

@ -1,4 +1,4 @@
import { CallbackQuery, InlineCallbackQuery, MaybeAsync, Message, TelegramClient } from '@mtcute/core'
import { CallbackQuery, InlineCallbackQuery, MaybePromise, Message, TelegramClient } from '@mtcute/core'
import { UpdateContext } from './base.js'
@ -46,7 +46,7 @@ export class CallbackQueryContext extends CallbackQuery implements UpdateContext
/**
* Shortcut for getting the message and editing it.
*/
async editMessageWith(handler: (msg: Message) => MaybeAsync<Parameters<CallbackQueryContext['editMessage']>[0]>) {
async editMessageWith(handler: (msg: Message) => MaybePromise<Parameters<CallbackQueryContext['editMessage']>[0]>) {
const msg = await this.getMessage()
if (!msg) return

29
packages/dispatcher/src/dispatcher.ts
View file

@ -12,7 +12,7 @@ import {
DeleteMessageUpdate,
DeleteStoryUpdate,
HistoryReadUpdate,
MaybeAsync,
MaybePromise,
MtArgumentError,
ParsedUpdate,
PeersIndex,
@ -66,12 +66,7 @@ import {
} from './handler.js'
// end-codegen-imports
import { PropagationAction } from './propagation.js'
import {
defaultStateKeyDelegate,
IStateStorageProvider,
StateKeyDelegate,
UpdateState,
} from './state/index.js'
import { defaultStateKeyDelegate, IStateStorageProvider, StateKeyDelegate, UpdateState } from './state/index.js'
import { StateService } from './state/service.js'
export interface DispatcherParams {
@ -121,18 +116,18 @@ export class Dispatcher<State extends object = never> {
err: Error,
update: ParsedUpdate & T,
state?: UpdateState<State>,
) => MaybeAsync<boolean>
) => MaybePromise<boolean>
private _preUpdateHandler?: <T = {}>(
update: ParsedUpdate & T,
state?: UpdateState<State>,
) => MaybeAsync<PropagationAction | void>
) => MaybePromise<PropagationAction | void>
private _postUpdateHandler?: <T = {}>(
handled: boolean,
update: ParsedUpdate & T,
state?: UpdateState<State>,
) => MaybeAsync<void>
) => MaybePromise<void>
protected constructor(client?: TelegramClient, params?: DispatcherParams) {
this.dispatchRawUpdate = this.dispatchRawUpdate.bind(this)
@ -146,7 +141,7 @@ export class Dispatcher<State extends object = never> {
if (storage) {
this._storage = new StateService(storage)
this._stateKeyDelegate = (key ?? defaultStateKeyDelegate)
this._stateKeyDelegate = key ?? defaultStateKeyDelegate
}
} else {
// child dispatcher without client
@ -597,7 +592,7 @@ export class Dispatcher<State extends object = never> {
* @param handler Error handler
*/
onError<T = {}>(
handler: ((err: Error, update: ParsedUpdate & T, state?: UpdateState<State>) => MaybeAsync<boolean>) | null,
handler: ((err: Error, update: ParsedUpdate & T, state?: UpdateState<State>) => MaybePromise<boolean>) | null,
): void {
if (handler) this._errorHandler = handler
else this._errorHandler = undefined
@ -617,7 +612,7 @@ export class Dispatcher<State extends object = never> {
*/
onPreUpdate<T = {}>(
handler:
| ((update: ParsedUpdate & T, state?: UpdateState<State>) => MaybeAsync<PropagationAction | void>)
| ((update: ParsedUpdate & T, state?: UpdateState<State>) => MaybePromise<PropagationAction | void>)
| null,
): void {
if (handler) this._preUpdateHandler = handler
@ -637,7 +632,9 @@ export class Dispatcher<State extends object = never> {
* @param handler Pre-update middleware
*/
onPostUpdate<T = {}>(
handler: ((handled: boolean, update: ParsedUpdate & T, state?: UpdateState<State>) => MaybeAsync<void>) | null,
handler:
| ((handled: boolean, update: ParsedUpdate & T, state?: UpdateState<State>) => MaybePromise<void>)
| null,
): void {
if (handler) this._postUpdateHandler = handler
else this._postUpdateHandler = undefined
@ -647,7 +644,7 @@ export class Dispatcher<State extends object = never> {
* Set error handler that will propagate
* the error to the parent dispatcher
*/
propagateErrorToParent(err: Error, update: ParsedUpdate, state?: UpdateState<State>): MaybeAsync<boolean> {
propagateErrorToParent(err: Error, update: ParsedUpdate, state?: UpdateState<State>): MaybePromise<boolean> {
if (!this.parent) {
throw new MtArgumentError('This dispatcher is not a child')
}
@ -912,7 +909,7 @@ export class Dispatcher<State extends object = never> {
* @template S State type, defaults to dispatcher's state type. Only checked at compile-time
*/
getState<S extends object = State>(object: Parameters<StateKeyDelegate>[0]): Promise<UpdateState<S>>
getState<S extends object = State>(object: string | Parameters<StateKeyDelegate>[0]): MaybeAsync<UpdateState<S>> {
getState<S extends object = State>(object: string | Parameters<StateKeyDelegate>[0]): MaybePromise<UpdateState<S>> {
if (!this._storage) {
throw new MtArgumentError('Cannot use getUpdateState() filter without state storage')
}

4
packages/dispatcher/src/filters/bots.ts
View file

@ -1,4 +1,4 @@
import { MaybeArray, MaybeAsync, Message } from '@mtcute/core'
import { MaybeArray, MaybePromise, Message } from '@mtcute/core'
import { MessageContext } from '../context/message.js'
import { chat } from './chat.js'
@ -51,7 +51,7 @@ export const command = (
const _prefixes = prefixes
const check = (msg: MessageContext): MaybeAsync<boolean> => {
const check = (msg: MessageContext): MaybePromise<boolean> => {
if (msg.isMessageGroup) return check(msg.messages[0])
for (const pref of _prefixes) {

6
packages/dispatcher/src/filters/group.ts
View file

@ -1,4 +1,4 @@
import { MaybeAsync, Message } from '@mtcute/core'
import { MaybePromise, Message } from '@mtcute/core'
import { MessageContext } from '../context/message.js'
import { Modify, UpdateFilter } from './types.js'
@ -26,7 +26,7 @@ export function every<Mod, State extends object>(
const upds = ctx.messages
const max = upds.length
const next = (): MaybeAsync<boolean> => {
const next = (): MaybePromise<boolean> => {
if (i === max) return true
const res = filter(upds[i++], state)
@ -67,7 +67,7 @@ export function some<State extends object>(
const upds = ctx.messages
const max = upds.length
const next = (): MaybeAsync<boolean> => {
const next = (): MaybePromise<boolean> => {
if (i === max) return false
const res = filter(upds[i++], state)

6
packages/dispatcher/src/filters/logic.ts
View file

@ -1,7 +1,7 @@
/* eslint-disable @typescript-eslint/no-explicit-any */
// ^^ will be looked into in MTQ-29
import { MaybeAsync } from '@mtcute/core'
import { MaybePromise } from '@mtcute/core'
import { ExtractBaseMany, ExtractMod, Invert, UnionToIntersection, UpdateFilter } from './types.js'
@ -160,7 +160,7 @@ export function and(...fns: UpdateFilter<any, any, any>[]): UpdateFilter<any, an
let i = 0
const max = fns.length
const next = (): MaybeAsync<boolean> => {
const next = (): MaybePromise<boolean> => {
if (i === max) return true
const res = fns[i++](upd, state)
@ -306,7 +306,7 @@ export function or(...fns: UpdateFilter<any, any, any>[]): UpdateFilter<any, any
let i = 0
const max = fns.length
const next = (): MaybeAsync<boolean> => {
const next = (): MaybePromise<boolean> => {
if (i === max) return false
const res = fns[i++](upd, state)

4
packages/dispatcher/src/filters/state.ts
View file

@ -1,5 +1,5 @@
/* eslint-disable @typescript-eslint/no-explicit-any */
import { MaybeAsync } from '@mtcute/core'
import { MaybePromise } from '@mtcute/core'
import { UpdateFilter } from './types.js'
@ -21,7 +21,7 @@ export const stateEmpty: UpdateFilter<any> = async (upd, state) => {
* @param predicate State predicate
*/
export const state = <T extends object>(
predicate: (state: T) => MaybeAsync<boolean>,
predicate: (state: T) => MaybePromise<boolean>,
// eslint-disable-next-line @typescript-eslint/ban-types
): UpdateFilter<any, {}, T> => {
return async (upd, state) => {

4
packages/dispatcher/src/filters/types.ts
View file

@ -2,7 +2,7 @@
/* eslint-disable @typescript-eslint/no-explicit-any */
// ^^ will be looked into in MTQ-29
import { MaybeAsync } from '@mtcute/core'
import { MaybePromise } from '@mtcute/core'
import { UpdateState } from '../state/update-state.js'
/**
@ -78,7 +78,7 @@ import { UpdateState } from '../state/update-state.js'
export type UpdateFilter<Base, Mod = {}, State extends object = never> = (
update: Base,
state?: UpdateState<State>,
) => MaybeAsync<boolean>
) => MaybePromise<boolean>
export type Modify<Base, Mod> = Omit<Base, keyof Mod> & Mod
export type Invert<Base, Mod> = {

10
packages/dispatcher/src/handler.ts
View file

@ -7,7 +7,7 @@ import {
DeleteMessageUpdate,
DeleteStoryUpdate,
HistoryReadUpdate,
MaybeAsync,
MaybePromise,
PeersIndex,
PollUpdate,
PollVoteUpdate,
@ -39,8 +39,8 @@ export interface BaseUpdateHandler<Name, Handler, Checker> {
export type ParsedUpdateHandler<Name, Update, State = never> = BaseUpdateHandler<
Name,
(update: Update, state: State) => MaybeAsync<void | PropagationAction>,
(update: Update, state: State) => MaybeAsync<boolean>
(update: Update, state: State) => MaybePromise<void | PropagationAction>,
(update: Update, state: State) => MaybePromise<boolean>
>
export type RawUpdateHandler = BaseUpdateHandler<
@ -49,8 +49,8 @@ export type RawUpdateHandler = BaseUpdateHandler<
client: TelegramClient,
update: tl.TypeUpdate | tl.TypeMessage,
peers: PeersIndex,
) => MaybeAsync<void | PropagationAction>,
(client: TelegramClient, update: tl.TypeUpdate | tl.TypeMessage, peers: PeersIndex) => MaybeAsync<boolean>
) => MaybePromise<void | PropagationAction>,
(client: TelegramClient, update: tl.TypeUpdate | tl.TypeMessage, peers: PeersIndex) => MaybePromise<boolean>
>
// begin-codegen

4
packages/dispatcher/src/state/key.ts
View file

@ -1,4 +1,4 @@
import { assertNever, MaybeAsync, Peer } from '@mtcute/core'
import { assertNever, MaybePromise, Peer } from '@mtcute/core'
import { CallbackQueryContext, MessageContext } from '../context/index.js'
@ -10,7 +10,7 @@ import { CallbackQueryContext, MessageContext } from '../context/index.js'
* @param msg Message or callback from which to derive the key
* @param scene Current scene UID, or `null` if none
*/
export type StateKeyDelegate = (upd: MessageContext | CallbackQueryContext | Peer) => MaybeAsync<string | null>
export type StateKeyDelegate = (upd: MessageContext | CallbackQueryContext | Peer) => MaybePromise<string | null>
/**
* Default state key delegate.

8
packages/dispatcher/src/state/providers/memory.ts
View file

@ -1,4 +1,4 @@
import { MaybeAsync, MemoryStorageDriver } from '@mtcute/core'
import { MaybePromise, MemoryStorageDriver } from '@mtcute/core'
import { IStateStorageProvider } from '../provider.js'
import { IStateRepository } from '../repository.js'
@ -91,15 +91,13 @@ class MemoryStateRepository implements IStateRepository {
return [item.remaining, item.reset]
}
resetRateLimit(key: string): MaybeAsync<void> {
resetRateLimit(key: string): MaybePromise<void> {
this.rl.delete(key)
}
}
export class MemoryStateStorage implements IStateStorageProvider {
constructor(
readonly driver: MemoryStorageDriver = new MemoryStorageDriver(),
) {}
constructor(readonly driver: MemoryStorageDriver = new MemoryStorageDriver()) {}
readonly state = new MemoryStateRepository(this.driver)
}

12
packages/dispatcher/src/state/providers/sqlite.ts
View file

@ -1,4 +1,4 @@
import { MaybeAsync } from '@mtcute/core'
import { MaybePromise } from '@mtcute/core'
import type { SqliteStorage, SqliteStorageDriver, Statement } from '@mtcute/sqlite'
import { IStateStorageProvider } from '../provider.js'
@ -46,12 +46,12 @@ class SqliteStateRepository implements IStateRepository {
}
private _setState!: Statement
setState(key: string, state: string, ttl?: number | undefined): MaybeAsync<void> {
setState(key: string, state: string, ttl?: number | undefined): MaybePromise<void> {
this._setState.run(key, state, ttl ? Date.now() + ttl * 1000 : undefined)
}
private _getState!: Statement
getState(key: string, now: number): MaybeAsync<string | null> {
getState(key: string, now: number): MaybePromise<string | null> {
const res_ = this._getState.get(key)
if (!res_) return null
const res = res_ as StateDto
@ -66,13 +66,13 @@ class SqliteStateRepository implements IStateRepository {
}
private _deleteState!: Statement
deleteState(key: string): MaybeAsync<void> {
deleteState(key: string): MaybePromise<void> {
this._deleteState.run(key)
}
private _deleteOldState!: Statement
private _deleteOldRl!: Statement
vacuum(now: number): MaybeAsync<void> {
vacuum(now: number): MaybePromise<void> {
this._deleteOldState.run(now)
this._deleteOldRl.run(now)
}
@ -107,7 +107,7 @@ class SqliteStateRepository implements IStateRepository {
return [val.remaining, val.reset]
}
resetRateLimit(key: string): MaybeAsync<void> {
resetRateLimit(key: string): MaybePromise<void> {
this._deleteRl.run(key)
}
}

14
packages/dispatcher/src/state/repository.ts
View file

@ -1,4 +1,4 @@
import { MaybeAsync } from '@mtcute/core'
import { MaybePromise } from '@mtcute/core'
/**
* Interface for FSM storage for the dispatcher.
@ -19,7 +19,7 @@ export interface IStateRepository {
*
* @param key Key of the state, as defined by {@link StateKeyDelegate}
*/
getState(key: string, now: number): MaybeAsync<string | null>
getState(key: string, now: number): MaybePromise<string | null>
/**
* Save state to the storage
@ -28,21 +28,21 @@ export interface IStateRepository {
* @param state String representing the state
* @param ttl TTL for the state, in seconds
*/
setState(key: string, state: string, ttl?: number): MaybeAsync<void>
setState(key: string, state: string, ttl?: number): MaybePromise<void>
/**
* Delete state from the storage
*
* @param key Key of the state, as defined by {@link StateKeyDelegate}
*/
deleteState(key: string): MaybeAsync<void>
deleteState(key: string): MaybePromise<void>
/**
* Clean up expired states and rate limits.
*
* @param now Current unix time in ms
*/
vacuum(now: number): MaybeAsync<void>
vacuum(now: number): MaybePromise<void>
/**
* Get information about a rate limit.
@ -57,12 +57,12 @@ export interface IStateRepository {
* @returns Tuple containing the number of remaining and
* unix time in ms when the user can try again
*/
getRateLimit(key: string, now: number, limit: number, window: number): MaybeAsync<[number, number]>
getRateLimit(key: string, now: number, limit: number, window: number): MaybePromise<[number, number]>
/**
* Reset a rate limit.
*
* @param key Key of the rate limit
*/
resetRateLimit(key: string): MaybeAsync<void>
resetRateLimit(key: string): MaybePromise<void>
}

4
packages/dispatcher/src/wizard.ts
View file

@ -1,4 +1,4 @@
import { MaybeAsync } from '@mtcute/core'
import { MaybePromise } from '@mtcute/core'
import { MessageContext } from './context/message.js'
import { Dispatcher } from './dispatcher.js'
@ -94,7 +94,7 @@ export class WizardScene<State extends object> extends Dispatcher<State & Wizard
handler: (
msg: MessageContext,
state: UpdateState<State & WizardInternalState>,
) => MaybeAsync<WizardSceneAction | number>,
) => MaybePromise<WizardSceneAction | number>,
): void {
const step = this._steps++

13
packages/test/src/client.ts
View file

@ -1,4 +1,11 @@
import { BaseTelegramClient, BaseTelegramClientOptions, MaybeAsync, MustEqual, RpcCallOptions, tl } from '@mtcute/core'
import {
BaseTelegramClient,
BaseTelegramClientOptions,
MaybePromise,
MustEqual,
RpcCallOptions,
tl,
} from '@mtcute/core'
import { StubMemoryTelegramStorage } from './storage.js'
import { StubTelegramTransport } from './transport.js'
@ -174,7 +181,7 @@ export class StubTelegramClient extends BaseTelegramClient {
respondWith<
T extends tl.RpcMethod['_'],
Fn extends(data: tl.FindByName<tl.RpcMethod, T>) => MaybeAsync<tl.RpcCallReturn[T]>,
Fn extends(data: tl.FindByName<tl.RpcMethod, T>) => MaybePromise<tl.RpcCallReturn[T]>,
>(method: T, response: Fn): Fn {
// eslint-disable-next-line
this._responders.set(method, response as any)
@ -280,7 +287,7 @@ export class StubTelegramClient extends BaseTelegramClient {
// helpers //
async with(fn: () => MaybeAsync<void>): Promise<void> {
async with(fn: () => MaybePromise<void>): Promise<void> {
await this.connect()
let error: unknown