gramstax 0.0.1

package/src/cache/external.ts

@@ -0,0 +1,15 @@
+import { Keyv } from "keyv"
+import KeyvRedis from "@keyv/redis"
+
+type IMore = Omit<Required<ConstructorParameters<typeof Keyv>>[0], `store` | `namespace` | `ttl`> & { forceStore?: any }
+
+export class CacheExternal extends Keyv {
+  constructor(public url: string | `memory` = `memory`, namespace?: string, ttl?: number, more?: IMore) {
+    let store: any
+    if (url.startsWith(`redis`)) store = new KeyvRedis(url)
+    if (url === `memory`) store = new Map()
+    if (more?.forceStore) store = more.forceStore
+
+    super({ store, namespace, ttl })
+  }
+}

package/src/cache/index.ts

@@ -0,0 +1 @@
+export * from "./external"

package/src/core/bot.ts

@@ -0,0 +1,535 @@
+import { Ctx } from "./ctx"
+import { serve } from "bun"
+import { readdirSync } from "node:fs"
+import { join, parse } from "node:path"
+import { CacheExternal } from "../cache"
+import { LoggingPretty } from "logging-pretty"
+import { TemplateManager } from "../template"
+import { Bot, webhookCallback, type BotError, type Context } from "grammy"
+import type { UserFromGetMe } from "grammy/types"
+import type { IPageBase } from "../types/page"
+
+export class Gramstax {
+  public templateManager: TemplateManager
+  public cacheKeyboard: Map<any, any>
+  public cacheSession: CacheExternal
+  public pages = this.pageLoads()
+  public log: LoggingPretty
+  public bot: Bot
+
+  public constructor(params: { token: string; deploy: string; log?: LoggingPretty; cacheSession?: CacheExternal; cacheKeyboard?: Map<any, any>; templateManager?: TemplateManager }) {
+    this.log = params.log || new LoggingPretty()
+    this.cacheSession = params.cacheSession || new CacheExternal(`memory`, `session`)
+    this.cacheKeyboard = params.cacheKeyboard || new Map()
+    this.templateManager = params.templateManager || new TemplateManager({ path: null })
+
+    this.bot = new Bot(params.token)
+    this.bot.catch(this.onCatch)
+    this.bot.on(`callback_query:data`, this.onCallbackQueryData.bind(this)) // Handle callback queries from inline keyboards
+    this.bot.on(`message:text`, this.onMessageText.bind(this)) // Handle global text messages
+    this.bot.on(`message:photo`, this.onMessagePhoto.bind(this)) // Handle global photo messages
+    this.bot.on(`message:video`, this.onMessageVideo.bind(this)) // Handle global video messages
+    this.bot.on(`message:audio`, this.onMessageAudio.bind(this)) // Handle global audio messages
+    this.bot.on(`message:document`, this.onMessageDocument.bind(this)) // Handle global document messages
+    this.bot.on(`message:animation`, this.onMessageAnimation.bind(this)) // Handle global animation messages
+    this.bot.on(`message:voice`, this.onMessageVoice.bind(this)) // Handle global voice messages
+    this.bot.on(`message:video_note`, this.onMessageVideoNote.bind(this)) // Handle global video note messages
+    this.bot.on(`message:sticker`, this.onMessageSticker.bind(this)) // Handle global sticker messages
+    this.bot.on(`message:location`, this.onMessageLocation.bind(this)) // Handle global location messages
+    this.bot.on(`message:contact`, this.onMessageContact.bind(this)) // Handle global contact messages
+
+    // Graceful shutdown
+    process.once(`SIGINT`, () => this.bot.stop())
+    process.once(`SIGTERM`, () => this.bot.stop())
+
+    if (params.deploy.startsWith(`polling`)) {
+      this.runPolling()
+    } else if (params.deploy.startsWith(`webhook`)) {
+      this.runWebhook(params.deploy.split(`webhook:`)[1] as string)
+    }
+  }
+
+  public onCatch(error: BotError<Context>) {
+    this.log.error(`[Bot.catch]: ${String(error)}`)
+  }
+
+  public onStart(botInfo: UserFromGetMe, method: `polling` | `webhook`, data: string | null) {
+    const { username } = botInfo
+    if (method == `polling`) {
+      this.log.success(`Telegram bot polling started: ${username}`)
+    } else {
+      this.log.success(`Telegram bot webhook started: ${username} (${data})`)
+    }
+  }
+
+  public initCtx(ct: Context) {
+    return new Ctx(ct, this.templateManager, this.cacheSession, this.cacheKeyboard)
+  }
+
+  public async runPolling() {
+    this.bot.start({
+      onStart: async (botInfo) => {
+        this.onStart(botInfo, `polling`, null)
+      }
+    })
+  }
+
+  public async runWebhook(baseUrl: string) {
+    const handleUpdate = webhookCallback(this.bot, `bun`)
+    const pathWebhook = `/telegram-webhook`
+    serve({
+      fetch(req) {
+        const { pathname } = new URL(req.url)
+        if (pathname === pathWebhook) {
+          if (req.method === `POST`) {
+            return handleUpdate(req as any)
+          }
+          return new Response(`OK`, { status: 200 })
+        }
+
+        if (pathname === `/` && req.method === `GET`) {
+          const timestamp = new Date().toISOString()
+          return new Response(JSON.stringify({ timestamp }), {
+            status: 200,
+            headers: { "Content-Type": `application/json` }
+          })
+        }
+
+        // Jika tidak cocok
+        return new Response(`Not found`, { status: 404 })
+      }
+    })
+
+    const data = await this.bot.api.getWebhookInfo()
+    const webhookUrl = baseUrl.endsWith(`/`) ? baseUrl.slice(0, -1) + pathWebhook : baseUrl + pathWebhook
+    if (data.url != webhookUrl) {
+      await this.bot.api.setWebhook(webhookUrl)
+    }
+
+    const botInfo = await this.bot.api.getMe()
+    this.onStart(botInfo, `webhook`, webhookUrl)
+  }
+
+  public pageCompile(Page: IPageBase, redacted = true) {
+    if (Page?.template !== undefined) {
+      this.templateManager.compile(Page.data.name, Page.template)
+      if (redacted) {
+        Page.template = undefined // redacted to reduce memory
+      }
+    } else {
+      Page.template = undefined
+    }
+  }
+
+  public pageBuildData(Page: IPageBase, filePath: string) {
+    if (Page?.data === undefined) {
+      Page.data = Page.buildData()
+    }
+    Page.data.name = parse(filePath).name
+  }
+
+  public pageSorts(Page: IPageBase, pages: typeof this.pages) {
+    const name = Page.data.name
+    const proto = Page.prototype
+
+    const partPayload = `Payload`
+    const partCommand = `Command`
+    const partCaption = `Caption`
+    const partFree = `Free`
+
+    const pd = pages.dynamic
+    const pds = pages.dynamicSpesific
+
+    const upFirst = (s: string) => s.charAt(0).toUpperCase() + s.slice(1)
+    const getPureFuncName = (func: string) => func.replace(partPayload, ``).replace(partCommand, ``).replace(partCaption, ``).replace(partFree, ``)
+    const buildSessionMethod = (func: string, name: any) => (proto as any)[`buildSessionMethod${upFirst(func)}`](name)
+
+    // all
+    pages.all[name] = Page
+
+    for (let index = 0; index < pages.lenListFuncStaticSession; index++) {
+      const func = pages.listFuncStaticSession[index] as string
+
+      const ps = pages.static[func as keyof typeof pages.static]
+      const psi = pages.staticIntent[func as keyof typeof pages.staticIntent]
+      const pss = pages.staticSession[func as keyof typeof pages.staticSession]
+
+      const value = { name, func } as any
+      const p = ps || psi
+      if (p !== undefined) {
+        const _name = func.includes(partCommand) ? `/${name}` : name
+        p[proto.buildIntent(_name, func.startsWith(`callback`))] = value
+      }
+
+      // staticSession
+      if (pss !== undefined) {
+        pss[buildSessionMethod(func, name)] = value
+      }
+
+      // dynamicStatic
+      if (func.toLowerCase().endsWith(`free`)) {
+        pds[getPureFuncName(func) as keyof typeof pds].push(value)
+      }
+    }
+
+    // all
+    if (proto.free) {
+      pd.push(name)
+    }
+  }
+
+  public pageLoads() {
+    this.log.info(`Load pages..`)
+
+    const path = join(process.cwd(), `src`, `pages`)
+    const files = readdirSync(path)
+    const initStatic = {} as Record<string, { name: string; func: string }> // { [page.data.name]: { name: Page.data.name, func: routeFunctionName } }
+    const initStaticIntent = initStatic // { [intent]: { name: page.data.name, func: routeFunctionName } }
+    const initStaticSession = initStatic // { [session.method]: { name: page.data.name, func: routeFunctionName } }
+    const initDynamicSpesific = [] as { name: string; func: string }[] //
+
+    const listFuncStatic = [
+      // callback
+      `callback`,
+      // text
+      `text`,
+      `textCommand`,
+      // photo
+      `photoCaption`,
+      `photoCaptionCommand`,
+      // video
+      `videoCaption`,
+      `videoCaptionCommand`,
+      // audio
+      `audioCaption`,
+      `audioCaptionCommand`,
+      // document
+      `documentCaption`,
+      `documentCaptionCommand`,
+      // animation
+      `animationCaption`,
+      `animationCaptionCommand`,
+      // voice
+      `voiceCaption`,
+      `voiceCaptionCommand`,
+      // videoNote
+      `videoNoteCaption`,
+      `videoNoteCaptionCommand`
+    ] as const
+    const listFuncStaticIntent = [
+      // callback
+      `callbackPayload`,
+      // text
+      `textPayload`,
+      `textCommandPayload`,
+      // photo
+      `photoCaptionPayload`,
+      `photoCaptionCommandPayload`,
+      // video
+      `videoCaptionPayload`,
+      `videoCaptionCommandPayload`,
+      // audio
+      `audioCaptionPayload`,
+      `audioCaptionCommandPayload`,
+      // document
+      `documentCaptionPayload`,
+      `documentCaptionCommandPayload`,
+      // animation
+      `animationCaptionPayload`,
+      `animationCaptionCommandPayload`,
+      // voice
+      `voiceCaptionPayload`,
+      `voiceCaptionCommandPayload`,
+      // video note
+      `videoNoteCaptionPayload`,
+      `videoNoteCaptionCommandPayload`
+    ] as const
+    const listFuncStaticSession = [
+      ...listFuncStatic,
+      ...listFuncStaticIntent,
+      // text
+      `textFree`,
+      // photo
+      `photoFree`,
+      // video
+      `videoFree`,
+      // audio
+      `audioFree`,
+      // document
+      `documentFree`,
+      // animation
+      `animationFree`,
+      // voice
+      `voiceFree`,
+      // videoNote
+      `videoNoteFree`,
+      // sticker
+      `stickerFree`,
+      // location
+      `locationFree`,
+      // contact
+      `contactFree`
+    ] as const
+
+    const makeObject = <const T extends readonly string[], V>(keys: T, val: V): { [K in T[number]]: V } => Object.fromEntries(keys.map((k) => [k, { ...val }])) as { [K in T[number]]: V }
+
+    const pages = {
+      all: {} as Record<string, IPageBase>, // (classes) all Page
+      dynamic: [] as string[], // (dynamic) all Page function free
+      dynamicSpesific: {
+        text: initDynamicSpesific,
+        photo: initDynamicSpesific,
+        video: initDynamicSpesific,
+        audio: initDynamicSpesific,
+        document: initDynamicSpesific,
+        animation: initDynamicSpesific,
+        voice: initDynamicSpesific,
+        videoNote: initDynamicSpesific,
+        sticker: initDynamicSpesific,
+        location: initDynamicSpesific,
+        contact: initDynamicSpesific
+      },
+      static: makeObject(listFuncStatic, initStatic),
+      staticIntent: makeObject(listFuncStaticIntent, initStaticIntent),
+      staticSession: makeObject(listFuncStaticSession, initStaticSession),
+      listFuncStatic,
+      listFuncStaticIntent,
+      listFuncStaticSession,
+      lenListFuncStatic: listFuncStatic.length,
+      lenListFuncStaticIntent: listFuncStaticIntent.length,
+      lenListFuncStaticSession: listFuncStaticSession.length
+    }
+
+    for (const file of files) {
+      const filePath = join(path, file)
+      const module = require(filePath) // eslint-disable-line
+      const exports = Object.values(module)
+      const Page = exports[0] as IPageBase // like StartPage. not have default export
+      if (Page === undefined) {
+        throw `file ${parse(filePath).name} must have export (not default) class page`
+      }
+
+      // create if not exist and set name (without ext) according filePath
+      this.pageBuildData(Page, filePath)
+
+      // if the raw template writes directly to the Page class, do a compile
+      this.pageCompile(Page)
+
+      // sort route method
+      this.pageSorts(Page, pages)
+    }
+
+    this.log.info(`Finish load pages with total (${Object.keys(pages.all).length})`)
+    return pages
+  }
+
+  public async pageRoutes(ctx: Ctx, fromListener: `callback` | keyof typeof this.pages.dynamicSpesific): Promise<any | null> {
+    // to be reassigned
+    let Page: IPageBase | undefined
+    let res: { name: string; func: string } | undefined
+
+    // (static) priority O(1)
+    if (Page === undefined) {
+      const cd = ctx.callbackData
+      const mt = ctx.msgText
+      const mc = ctx.msgCaption
+      const ps = this.pages.static
+
+      for (let index = 0; index < this.pages.lenListFuncStatic; index++) {
+        const funcName = this.pages.listFuncStatic[index] as `animationCaption`
+        res = ps[funcName][cd || mt || mc]
+        if (res) {
+          break
+        }
+      }
+
+      if (res !== undefined) {
+        Page = this.pages.all[res.name]
+      }
+    }
+
+    // (staticSession) x = method; O(x)
+    if (Page === undefined) {
+      const session = await ctx.sessionGet()
+      if (session) {
+        const mtd = session.method
+        const pss = this.pages.staticSession
+
+        for (let index = 0; index < this.pages.lenListFuncStaticSession; index++) {
+          const funcName = this.pages.listFuncStaticSession[index] as `animationCaption`
+          res = pss[funcName][mtd]
+          if (res) {
+            break
+          }
+        }
+
+        if (res !== undefined) {
+          Page = this.pages.all[res.name]
+        }
+      }
+    }
+
+    // (staticIntent) x = startsWith; O(x)
+    if (Page === undefined) {
+      const cdi = ctx.callbackDataIntent
+      const mti = ctx.msgTextIntent
+      const mci = ctx.msgCaptionIntent
+      const psi = this.pages.staticIntent
+
+      for (let index = 0; index < this.pages.lenListFuncStaticIntent; index++) {
+        const funcName = this.pages.listFuncStaticIntent[index] as `animationCaptionCommandPayload`
+        res = psi[funcName][cdi || mti || mci]
+        if (res) {
+          break
+        }
+      }
+
+      if (res !== undefined) {
+        Page = this.pages.all[res.name]
+      }
+    }
+
+    // run
+    if (Page !== undefined && res !== undefined) {
+      const initPage = new Page(ctx)
+      const initRoute = await initPage[res.func as keyof typeof initPage]?.()
+      return initRoute
+    }
+
+    // (dynamicSpesific) O(n)
+    const arrFree = this.pages.dynamicSpesific[fromListener as keyof typeof this.pages.dynamicSpesific] || []
+    for (let index = 0; index < arrFree.length; index++) {
+      const value = arrFree[index]
+      if (value === undefined) {
+        continue
+      }
+
+      const Page = this.pages.all[value.func]
+      if (Page === undefined) {
+        continue
+      }
+
+      const initPage = new Page(ctx)
+      const initRoute = await initPage[value.name as keyof typeof initPage]?.()
+      // const initRoute = await initPage.route(value.name)
+      if (initRoute !== null) {
+        return initRoute // stop when return not null
+      }
+    }
+
+    // (dynamic) O(n)
+    for (let index = 0; index < this.pages.dynamic.length; index++) {
+      const value = this.pages.dynamic[index]
+      if (value === undefined) {
+        continue
+      }
+
+      const Page = this.pages.all[value]
+      if (Page === undefined) {
+        continue
+      }
+
+      const initPage = new Page(ctx)
+      const initRoute = await initPage.free?.()
+      // const initRoute = await initPage.route(`free`)
+      if (initRoute !== null) {
+        return initRoute // stop when return not null
+      }
+    }
+
+    return null
+  }
+
+  public async hookBeforeRoute(ctx: Ctx, listenerName: string) {
+    // must be override
+    return true
+  }
+
+  public async hookErrorPage(ctx: Ctx, listenerName: string, error: any, isEdit: boolean) {
+    // must be override
+    return
+  }
+
+  public async hookErrorInputNotFoundPage(ctx: Ctx) {
+    // must be override
+    return
+  }
+
+  public async onMessage(ct: Context, listenerName: string): Promise<void> {
+    const ctx = this.initCtx(ct)
+    try {
+      const before = await this.hookBeforeRoute(ctx, listenerName)
+      if (before === false) {
+        return
+      }
+
+      const route = await this.pageRoutes(ctx, listenerName as any)
+      if (route === null) {
+        await this.hookErrorInputNotFoundPage(ctx)
+      }
+    } catch (error) {
+      await this.hookErrorPage(ctx, listenerName, error, false)
+    }
+  }
+
+  public async onCallbackQueryData(ct: Context): Promise<void> {
+    const ctx = this.initCtx(ct)
+    try {
+      // answer callback query first for fast response
+      await ctx.callbackQueryAnswer()
+      const before = await this.hookBeforeRoute(ctx, `onCallbackQueryData`)
+      if (before === false) {
+        return
+      }
+
+      // Check all route
+      await this.pageRoutes(ctx, `callback`)
+    } catch (error) {
+      await this.hookErrorPage(ctx, `onCallbackQueryData`, error, true)
+    }
+  }
+
+  public async onMessageText(ct: Context): Promise<void> {
+    await this.onMessage(ct, `onMessageText`)
+  }
+
+  public async onMessagePhoto(ct: Context): Promise<void> {
+    await this.onMessage(ct, `onMessagePhoto`)
+  }
+
+  public async onMessageVideo(ct: Context): Promise<void> {
+    await this.onMessage(ct, `onMessageVideo`)
+  }
+
+  public async onMessageAudio(ct: Context): Promise<void> {
+    await this.onMessage(ct, `onMessageAudio`)
+  }
+
+  public async onMessageDocument(ct: Context): Promise<void> {
+    await this.onMessage(ct, `onMessageDocument`)
+  }
+
+  public async onMessageAnimation(ct: Context): Promise<void> {
+    await this.onMessage(ct, `onMessageAnimation`)
+  }
+
+  public async onMessageVoice(ct: Context): Promise<void> {
+    await this.onMessage(ct, `onMessageVoice`)
+  }
+
+  public async onMessageVideoNote(ct: Context): Promise<void> {
+    await this.onMessage(ct, `onMessageVideoNote`)
+  }
+
+  public async onMessageSticker(ct: Context): Promise<void> {
+    await this.onMessage(ct, `onMessageSticker`)
+  }
+
+  public async onMessageLocation(ct: Context): Promise<void> {
+    await this.onMessage(ct, `onMessageLocation`)
+  }
+
+  public async onMessageContact(ct: Context): Promise<void> {
+    await this.onMessage(ct, `onMessageContact`)
+  }
+}