updated bot.ts

.eslintrc.json

@@ -1,13 +1,7 @@
 {
   "parser": "@typescript-eslint/parser",
-  "extends": [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/recommended"
-  ],
-  "plugins": [
-    "@typescript-eslint",
-    "import"
-  ],
+  "extends": ["eslint:recommended", "plugin:@typescript-eslint/recommended"],
+  "plugins": ["@typescript-eslint", "import"],
   "rules": {
     "import/extensions": [
       "error",
@@ -28,13 +22,14 @@
           "^#config$",
           "^#env$",
           "^#client$",
-          "^#logger$"
+          "^#logger$",
+          "^#database$"
         ]
       }
     ],
     "@typescript-eslint/no-unused-vars": "warn",
     "@typescript-eslint/no-explicit-any": "off",
-    "no-prototype-builtins":  "off",
+    "no-prototype-builtins": "off",
     "no-control-regex": "off",
     "no-misleading-character-class": "off",
     "no-empty": "off"
@@ -43,7 +38,8 @@
     "import/resolver": {
       "alias": {
         "map": [
-          ["#tables", "./src/tables"]
+          ["#tables", "./src/tables"],
+          ["#src", "./src"]
         ],
         "extensions": [".ts", ".js", ".jsx", ".tsx"]
       },
@@ -53,4 +49,4 @@
       }
     }
   }
-}
+}

Gulpfile.js

@@ -1,31 +1,76 @@
-import discord from "discord.js"
-import gulp from "gulp"
-import esbuild from "gulp-esbuild"
-import filter from "gulp-filter"
-import vinyl from "vinyl-paths"
-import rename from "gulp-rename"
-import replace from "gulp-replace"
-import del from "del"
-import log from "fancy-log"
-import chalk from "chalk"
-import git from "git-commit-info"
 import cp from "child_process"
 import path from "path"
-import util from "util"
 import fs from "fs"
 
 import "dotenv/config"
 
-import { Handler } from "@ghom/handler"
-import { dirname } from "dirname-filename-esm"
+import chalk from "chalk"
+import dayjs from "dayjs"
+
+const discord = await __importOrInstall("discord.js@14")
+const gulp = await __importOrInstall("gulp", true)
+const esbuild = await __importOrInstall("gulp-esbuild", true)
+const filter = await __importOrInstall("gulp-filter", true)
+const vinyl = await __importOrInstall("vinyl-paths", true)
+const rename = await __importOrInstall("gulp-rename", true)
+const replace = await __importOrInstall("gulp-replace", true)
+const del = await __importOrInstall("[email protected]", true)
+const log = await __importOrInstall("fancy-log", true)
+const git = await __importOrInstall("git-commit-info", true)
+
+const { Handler } = await __importOrInstall("@ghom/handler")
+const { dirname } = await __importOrInstall("dirname-filename-esm")
 
 const __dirname = dirname(import.meta)
 
+async function __importOrInstall(packageName, importDefault = false) {
+  let namespace = null
+
+  try {
+    namespace = await import(packageName.split(/\b@/)[0])
+  } catch (e) {
+    // eslint-disable-next-line no-undef
+    console.log(
+      `[${dayjs().format("HH:mm:ss")}] Package  '${chalk.cyan(packageName)}' not found. Installing...`,
+    )
+    try {
+      await __install(packageName)
+      // eslint-disable-next-line no-undef
+      console.log(
+        `[${dayjs().format("HH:mm:ss")}] Package  '${chalk.cyan(packageName)}' installed successfully.`,
+      )
+      namespace = await import(packageName.split(/\b@/)[0])
+    } catch (installError) {
+      throw new Error(
+        `Failed to install "${packageName}": ${installError.message}`,
+      )
+    }
+  }
+
+  console.log(`[${dayjs().format("HH:mm:ss")}] Imported '${chalk.cyan(packageName)}'`)
+
+  return importDefault ? namespace.default : namespace
+}
+
+function __install(packageName = "") {
+  return new Promise((resolve, reject) => {
+    // eslint-disable-next-line import/no-unresolved
+    import("@esbuild/linux-x64")
+      .then(() =>
+        cp.exec(`npm i ${packageName}`, (err) =>
+          err ? reject(err) : resolve(),
+        ),
+      )
+      .catch(() =>
+        cp.exec(`npm i ${packageName} --force`, (err) =>
+          err ? reject(err) : resolve(),
+        ),
+      )
+  })
+}
+
 function _npmInstall(cb) {
-  // eslint-disable-next-line import/no-unresolved
-  import("@esbuild/linux-x64")
-    .then(() => cp.exec("npm i", cb))
-    .catch(() => cp.exec("npm i --force", cb))
+  __install().then(cb).catch(cb)
 }
 
 function _gitLog(cb) {
@@ -135,10 +180,8 @@ function _build() {
       esbuild({
         sourcemap: "inline",
         format: "esm",
-        target: "node16",
-        loader: {
-          ".ts": "ts",
-        },
+        target: "node20",
+        loader: { ".ts": "ts" },
       }),
     )
     .pipe(

package.json

@@ -15,7 +15,8 @@
     "deploy": "git reset --hard && git pull && npm run build && pm2 restart tool",
     "start.test": "npm run build && node tests/index.test.js",
     "readme": "gulp readme",
-    "lint": "eslint src/**/*.ts --fix"
+    "lint": "eslint src/**/*.ts --fix",
+    "bot": "npx @ghom/bot.ts-cli"
   },
   "prettier": {
     "semi": false,
@@ -60,7 +61,8 @@
     "tims": "^2.1.0",
     "types-package-json": "^2.0.39",
     "yargs-parser": "^21.0.1",
-    "zod": "^3.23.8"
+    "zod": "^3.23.8",
+    "del": "^6.1.1"
   },
   "devDependencies": {
     "@esbuild/linux-x64": "^0.20.1",
@@ -111,6 +113,8 @@
     "#app/*": "./dist/*",
     "#tables/*": "./dist/tables/*",
     "#client": "./dist/app/client.js",
-    "#logger": "./dist/app/logger.js"
+    "#logger": "./dist/app/logger.js",
+    "#database": "./dist/app/database.js",
+    "#src/*": "./dist/*"
   }
 }

src/app.native.ts

@@ -11,12 +11,12 @@ export * from "./config.ts"
 
 export * as pagination from "./app/pagination.ts"
 export * as argument from "./app/argument.ts"
-export * as database from "./app/database.ts"
 export * as listener from "./app/listener.ts"
 export * as command from "./app/command.ts"
 export * as slash from "./app/slash.ts"
 export * as util from "./app/util.ts"
 
-export { default as env } from "./app/env.ts"
-export { default as client } from "./app/client.ts"
-export { default as logger } from "./app/logger.ts"
+export { default as env } from "#env"
+export { default as client } from "#client"
+export { default as logger } from "#logger"
+export { default as database } from "#database"

src/app/database.ts

@@ -5,7 +5,7 @@ import * as logger from "./logger.ts"
 import env from "./env.ts"
 import path from "path"
 
-export const orm = new ORM({
+const orm = new ORM({
   location: path.join(process.cwd(), "dist", "tables"),
   database: {
     client: "pg",
@@ -23,3 +23,5 @@ export const orm = new ORM({
 })
 
 export * from "@ghom/orm"
+
+export default orm

src/commands/database.native.ts

@@ -22,7 +22,7 @@ export default new app.Command({
       .replace(/<(?:[#@][&!]?|a?:\w+:)(\d+)>/g, "'$1'")
       .replace(/from ([a-z]+)/gi, 'from "$1"')
 
-    const result = await app.orm.raw(query)
+    const result = await app.database.raw(query)
 
     const systemMessage = await app.getSystemMessage("success", {
       title: `Result of SQL query ${
@@ -52,34 +52,36 @@ export default new app.Command({
       aliases: ["tables", "schema", "list", "view"],
       async run(message) {
         const fields = await Promise.all(
-          app.orm.cachedTables.map(async (table): Promise<app.EmbedField> => {
-            const columns: {
-              defaultValue: unknown
-              type: string
-              name: string
-            }[] = await table.getColumns().then((cols) => {
-              return Object.entries(cols).map(
-                ([name, { defaultValue, type }]) => {
-                  return { name, type, defaultValue }
-                },
-              )
-            })
+          app.database.cachedTables.map(
+            async (table): Promise<app.EmbedField> => {
+              const columns: {
+                defaultValue: unknown
+                type: string
+                name: string
+              }[] = await table.getColumns().then((cols) => {
+                return Object.entries(cols).map(
+                  ([name, { defaultValue, type }]) => {
+                    return { name, type, defaultValue }
+                  },
+                )
+              })
 
-            const rowCount = await table.count()
+              const rowCount = await table.count()
 
-            return {
-              name: `${table.options.name} x${rowCount}`,
-              value: columns
-                .map(
-                  ({ name, type, defaultValue }) =>
-                    `[\`${type.slice(0, 5)}\`] \`${name}${
-                      defaultValue ? `?` : ""
-                    }\``,
-                )
-                .join("\n"),
-              inline: true,
-            }
-          }),
+              return {
+                name: `${table.options.name} x${rowCount}`,
+                value: columns
+                  .map(
+                    ({ name, type, defaultValue }) =>
+                      `[\`${type.slice(0, 5)}\`] \`${name}${
+                        defaultValue ? `?` : ""
+                      }\``,
+                  )
+                  .join("\n"),
+                inline: true,
+              }
+            },
+          ),
         )
 
         return message.channel.send(

src/commands/point.ts

@@ -11,7 +11,7 @@ export default new app.Command({
     const user = await app.getUser(message.member, true)
 
     const data = (await points.query
-      .select(app.orm.raw("sum(amount) as total"))
+      .select(app.database.raw("sum(amount) as total"))
       .where("to_id", user._id)
       .first()) as { total: number } | undefined
 

src/config.ts

@@ -1,5 +1,6 @@
-import type { Config } from "#app/app/config.ts"
-import { Emotes } from "./namespaces/emotes.ts"
+import type { Config } from "#app"
+
+import { Emotes } from "#src/namespaces/emotes.ts"
 
 const config: Config = {
   ignoreBots: true,

src/index.ts

@@ -6,7 +6,7 @@ import env from "./app/env.ts"
 const app = await import("#app")
 
 try {
-  await app.orm.init()
+  await app.database.init()
   await app.commandHandler.init()
   await app.slashCommandHandler.init()
   await app.listenerHandler.init()

src/namespaces/active.ts

@@ -27,7 +27,7 @@ export async function fetchActiveMembers(
     .and.where(
       "created_at",
       ">",
-      app.orm.raw(`now() - interval '1 hour' * ${period}`),
+      app.database.raw(`now() - interval '1 hour' * ${period}`),
     )
     .groupBy("author_id")
     .havingRaw(`count(*) >= ${messageCount}`)
@@ -197,7 +197,7 @@ export async function hasActivity(
         .where("message.guild_id", guild_id)
         .andWhere("user.is_bot", false)
         .andWhere(
-          app.orm.raw(
+          app.database.raw(
             `extract(epoch from now()) - extract(epoch from message.created_at) < ${period} * 3600`,
           ),
         ),
@@ -217,15 +217,15 @@ export const activeLadder = (guild_id: number) =>
     fetchLines(options) {
       return message.query
         .select(
-          app.orm.raw(
+          app.database.raw(
             `rank() over (order by count(*) desc) as "rank", "user"."id" as "target", count(*) as "messageCount"`,
           ),
         )
         .leftJoin("user", "message.author_id", "user._id")
         .where("guild_id", guild_id)
         .andWhere("user.is_bot", false)
         .groupBy("user.id")
-        .having(app.orm.raw("count(*) > 0"))
+        .having(app.database.raw("count(*) > 0"))
         .orderBy("rank", "asc")
         .limit(options.pageLineCount)
         .offset(options.pageIndex * options.pageLineCount)
@@ -237,7 +237,7 @@ export const activeLadder = (guild_id: number) =>
           .where("guild_id", guild_id)
           .andWhere("user.is_bot", false)
           .groupBy("user.id")
-          .having(app.orm.raw("count(*) > 0")),
+          .having(app.database.raw("count(*) > 0")),
       )
     },
     formatLine(line, index, lines) {

src/namespaces/backup.ts

@@ -15,7 +15,7 @@ export async function restoreBackup(onSuccess: () => unknown) {
   // disable error handling
   console.error = () => {}
 
-  await app.orm.database.destroy()
+  await app.database.database.destroy()
 
   await fs.cp(
     app.util.rootPath("data", "sqlite3.db.backup"),

src/namespaces/date.ts

@@ -6,5 +6,5 @@ export function addCreatedAt(table: Knex.CreateTableBuilder) {
     .datetime("created_at", {
       useTz: true,
     })
-    .defaultTo(app.orm.database.fn.now())
+    .defaultTo(app.database.database.fn.now())
 }