lotus-tree-types 2.0.1

package/.github/ci-publish.yml

@@ -0,0 +1,25 @@
+name: Publish pipeline
+
+on:
+  push:
+  workflow_dispatch:
+
+jobs:
+  build-types:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
+        with:
+          node-version: latest
+          caceh: yarn
+      - name: 'Create .npmrc'
+        run: |
+          echo "registry.npmjs.org/:_authToken=${NPM_TOKEN}" >> .npmrc
+      - name: Prepare build-types
+        run: |
+          yarn -y 
+          yarn build
+          cp package-types.json dist/types/
+          cd dist/types/
+          npm publish

package/.prettierignore

@@ -0,0 +1,3 @@
+# Ignore artifacts:
+build
+coverage

package/.prettierrc

@@ -0,0 +1 @@
+"prettier-config-standard"

package/.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Launch dev",
+      "runtimeExecutable": "yarn",
+      "runtimeArgs": ["dev"],
+      "cwd": "${workspaceFolder}/src",
+      "console": "integratedTerminal",
+      "internalConsoleOptions": "neverOpen"
+    }
+  ]
+}

package/README.md

@@ -0,0 +1 @@
+# lotus-core

package/dist/lotus/app.js

@@ -0,0 +1,84 @@
+import { Sequelize } from 'sequelize';
+import { Client, Events, GatewayIntentBits, Partials } from 'discord.js';
+import { loadModule } from "./loadPackage.js";
+import lotusConfig from './config/lotus.json' with { type: 'json' };
+const { sequelize: sequelizeConfig, discord: discordConfig, packages: packageList } = lotusConfig;
+const sequelize = new Sequelize(sequelizeConfig);
+const events = new Map();
+const commands = new Map();
+const modules = new Map();
+const intents = new Set();
+const partials = new Set();
+const defaultConfig = { guild: {}, global: {} };
+const config = {};
+const localConfig = {};
+const packages = (await Promise.all(packageList.map((p) => loadModule(p, sequelize)))).filter((p) => p !== null);
+packages.forEach((pkg) => {
+    const { name, intents: packageIntents, partials: packagePartials, events: packageEvents, commands: packageCommands, config, localConfig: pkgLocalConfig } = pkg;
+    const commandNames = [];
+    localConfig[name] = {};
+    packageIntents?.forEach((intent) => intents.add(intent));
+    packagePartials?.forEach((partial) => partials.add(partial));
+    if (packageEvents) {
+        for (const [name, fn] of Object.entries(packageEvents)) {
+            if (!events.has(name))
+                events.set(name, [fn]);
+            else
+                events.set(name, [...(events.get(name) || []), fn]);
+        }
+    }
+    if (packageCommands) {
+        for (const [name, command] of Object.entries(packageCommands)) {
+            command.name = name;
+            command.moduleName = pkg.name;
+            command.enabled = {};
+            commands.set(name, command);
+            commandNames.push(name);
+        }
+    }
+    if (config?.global) {
+        for (const [name, value] of Object.entries(config.global || {})) {
+            defaultConfig.global[name] = value;
+        }
+    }
+    if (config?.guild) {
+        for (const [name, value] of Object.entries(config.guild || {})) {
+            defaultConfig.guild[name] = value;
+        }
+    }
+    if (pkgLocalConfig) {
+        for (const [configName, value] of Object.entries(pkgLocalConfig)) {
+            localConfig[name][configName] = value;
+        }
+    }
+    const module = { name, commandNames, enabled: {} };
+    modules.set(name, module);
+});
+const client = new Client({
+    intents: Array.from(intents),
+    partials: Array.from(partials)
+});
+const globals = {
+    sequelize,
+    client,
+    commands,
+    defaultConfig,
+    config,
+    localConfig,
+    modules,
+    lotusConfig
+};
+for (const [eventName, eventList] of events.entries()) {
+    client.on(eventName, (...args) => eventList.forEach((item) => {
+        try {
+            item(globals, ...args);
+        }
+        catch (err) {
+            console.log(err);
+        }
+    }));
+}
+client.once(Events.ClientReady, () => {
+    console.log(`Discord bot started! Logged in as ${client.user?.tag}`);
+});
+client.login(discordConfig.token);

package/dist/lotus/index.js

@@ -0,0 +1,2 @@
+import { Client, Events, GatewayIntentBits, Partials } from 'discord.js';
+import { Sequelize } from 'sequelize';

package/dist/lotus/loadPackage.js

@@ -0,0 +1,46 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import fs from 'fs-extra';
+import path from 'path';
+import { Sequelize } from 'sequelize';
+export async function loadModule(packagePath, sequelize) {
+    const { default: packageObj } = (await import(__rewriteRelativeImportExtension(packagePath)));
+    const { name } = packageObj;
+    try {
+        const { preload, localConfig, commands = {}, events = {} } = packageObj;
+        if (localConfig) {
+            const configPath = path.join('./config/', `${name}.json`);
+            const configExists = await fs.pathExists(configPath);
+            if (!configExists) {
+                await fs.writeJson(configPath, localConfig);
+                throw new Error(`${configPath} has been created. Edit the file then restart the bot`);
+            }
+            else {
+                packageObj.localConfig = await fs.readJSON(configPath);
+            }
+        }
+        if (preload)
+            await preload(sequelize);
+        const commandSize = Object.values(commands).length;
+        const eventSize = Object.values(events).length;
+        const loadedText = commandSize > 0 && eventSize > 0
+            ? ` with ${commandSize} commands and ${eventSize} events`
+            : commandSize > 0
+                ? ` with ${commandSize} commands`
+                : eventSize > 0
+                    ? ` with ${eventSize} events`
+                    : '';
+        console.log(`Loaded ${name}${loadedText}`);
+        return packageObj;
+    }
+    catch (err) {
+        console.error(err, `Failed to load ${name}`);
+        return null;
+    }
+}

package/dist/lotus/types.js

@@ -0,0 +1,2 @@
+import { Client, Events, GatewayIntentBits, Partials } from 'discord.js';
+import { Sequelize } from 'sequelize';

package/dist/types/app.d.ts

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

package/dist/types/index.d.ts

@@ -0,0 +1,35 @@
+import { Client, Events, GatewayIntentBits, Partials } from 'discord.js';
+import { type Options, Sequelize } from 'sequelize';
+export interface Config {
+    guild: Record<string, any>;
+    global: Record<string, any>;
+}
+export type LocalConfig = Record<string, Record<string, any>>;
+export type EventFunction = (globals: Globals, ...args: any[]) => void;
+export interface Package {
+    name: string;
+    intents?: GatewayIntentBits[];
+    partials?: Partials[];
+    events?: Record<Events, EventFunction>;
+    commands?: Record<string, any>;
+    config?: Config;
+    localConfig?: LocalConfig;
+    preload?: (sequelize: Sequelize) => Promise<void>;
+}
+export interface LotusConfig {
+    sequelize: Options;
+    discord: {
+        token: string;
+    };
+    packages: string[];
+}
+export interface Globals {
+    sequelize: Sequelize;
+    client: Client<boolean>;
+    commands: Map<any, any>;
+    defaultConfig: Config;
+    config: {};
+    localConfig: LocalConfig;
+    modules: Map<any, any>;
+    lotusConfig: LotusConfig;
+}

package/dist/types/loadPackage.d.ts

@@ -0,0 +1,3 @@
+import { Sequelize } from 'sequelize';
+import type { Package } from './index.ts';
+export declare function loadModule(packagePath: string, sequelize: Sequelize): Promise<Package | null>;

package/dist/types/types.d.ts

@@ -0,0 +1,35 @@
+import { Client, Events, GatewayIntentBits, Partials } from 'discord.js';
+import { type Options, Sequelize } from 'sequelize';
+export interface Config {
+    guild: Record<string, any>;
+    global: Record<string, any>;
+}
+export type LocalConfig = Record<string, Record<string, any>>;
+export type EventFunction = (globals: Globals, ...args: any[]) => void;
+export interface Package {
+    name: string;
+    intents?: GatewayIntentBits[];
+    partials?: Partials[];
+    events?: Record<Events, EventFunction>;
+    commands?: Record<string, any>;
+    config?: Config;
+    localConfig?: LocalConfig;
+    preload?: (sequelize: Sequelize) => Promise<void>;
+}
+export interface LotusConfig {
+    sequelize: Options;
+    discord: {
+        token: string;
+    };
+    packages: string[];
+}
+export interface Globals {
+    sequelize: Sequelize;
+    client: Client<boolean>;
+    commands: Map<any, any>;
+    defaultConfig: Config;
+    config: {};
+    localConfig: LocalConfig;
+    modules: Map<any, any>;
+    lotusConfig: LotusConfig;
+}

package/eslint.config.mjs

@@ -0,0 +1,16 @@
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+import { defineConfig } from '@eslint/config-helpers'
+import { FlatCompat } from '@eslint/eslintrc'
+
+import config from 'eslint-config-standard'
+import eslintConfigPrettier from 'eslint-config-prettier/flat'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+const compat = new FlatCompat({
+  baseDirectory: __dirname
+})
+
+export default defineConfig([...compat.config(config), eslintConfigPrettier])

package/nodemon.json

@@ -0,0 +1,8 @@
+{
+    "watch": [
+        "../Lotus-Tree-packages/**",
+        "./src/**",
+        "./config/**"
+    ],
+    "exec": "yarn start"
+}

package/package-types.json

@@ -0,0 +1,27 @@
+{
+  "name": "@rikumax/lotus-tree-types",
+  "version": "2.0.2",
+  "private": false,
+  "description": "",
+  "homepage": "https://github.com/jorgev259/Lotus-Tree#readme",
+  "bugs": {
+    "url": "https://github.com/jorgev259/Lotus-Tree/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jorgev259/Lotus-Tree.git"
+  },
+  "type": "module",
+  "main": "index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx --watch src/index.ts"
+  },
+  "dependencies": {
+    "discord.js": "^14.14.1",
+    "sequelize": "^6.35.2"
+  },
+  "engines": {
+    "node": "24.x"
+  }
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "lotus-tree-types",
+  "version": "2.0.1",
+  "private": false,
+  "description": "",
+  "homepage": "https://github.com/jorgev259/Lotus-Tree#readme",
+  "bugs": {
+    "url": "https://github.com/jorgev259/Lotus-Tree/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jorgev259/Lotus-Tree.git"
+  },
+  "license": "ISC",
+  "author": "",
+  "type": "module",
+  "main": "dist/types/types.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx --watch src/index.ts"
+  },
+  "dependencies": {
+    "discord.js": "^14.14.1",
+    "fs-extra": "^11.2.0",
+    "sequelize": "^6.35.2"
+  },
+  "devDependencies": {
+    "@eslint/config-helpers": "^0.5.0",
+    "@eslint/eslintrc": "^3.3.3",
+    "@eslint/js": "^9.39.2",
+    "@tsconfig/node-lts": "^24.0.0",
+    "@tsconfig/node-ts": "^23.6.2",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.0.3",
+    "eslint": "^8.0.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-import": "^2.25.2",
+    "eslint-plugin-n": "^15.0.0 || ^16.0.0 ",
+    "eslint-plugin-promise": "^6.0.0",
+    "globals": "^17.0.0",
+    "prettier": "^3.7.4",
+    "prettier-config-standard": "^7.0.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.51.0"
+  },
+  "peerDependencies": {
+    "sqlite3": "^5.1.7"
+  },
+  "engines": {
+    "node": "24.x"
+  }
+}

package/src/app.ts

@@ -0,0 +1,126 @@
+import { Sequelize } from 'sequelize'
+import { Client, Events, GatewayIntentBits, Partials } from 'discord.js'
+
+import { loadModule } from './loadPackage.ts'
+import type {
+  LocalConfig,
+  Package,
+  Config,
+  LotusConfig,
+  EventFunction,
+  Globals
+} from './index.ts'
+
+import lotusConfig from './config/lotus.json' with { type: 'json' }
+
+const {
+  sequelize: sequelizeConfig,
+  discord: discordConfig,
+  packages: packageList
+} = lotusConfig as LotusConfig
+const sequelize = new Sequelize(sequelizeConfig)
+
+const events = new Map<string, EventFunction[]>()
+const commands = new Map()
+const modules = new Map()
+
+const intents = new Set<GatewayIntentBits>()
+const partials = new Set<Partials>()
+
+const defaultConfig: Config = { guild: {}, global: {} }
+const config = {}
+const localConfig = {} as LocalConfig
+
+const packages = (
+  await Promise.all(packageList.map((p) => loadModule(p, sequelize)))
+).filter((p: Package | null) => p !== null) as Package[]
+
+packages.forEach((pkg) => {
+  const {
+    name,
+    intents: packageIntents,
+    partials: packagePartials,
+    events: packageEvents,
+    commands: packageCommands,
+    config,
+    localConfig: pkgLocalConfig
+  } = pkg
+
+  const commandNames = []
+  localConfig[name] = {}
+
+  packageIntents?.forEach((intent) => intents.add(intent))
+  packagePartials?.forEach((partial) => partials.add(partial))
+
+  if (packageEvents) {
+    for (const [name, fn] of Object.entries(packageEvents)) {
+      if (!events.has(name)) events.set(name, [fn])
+      else events.set(name, [...(events.get(name) || []), fn])
+    }
+  }
+
+  if (packageCommands) {
+    for (const [name, command] of Object.entries(packageCommands)) {
+      command.name = name
+      command.moduleName = pkg.name
+      command.enabled = {}
+      commands.set(name, command)
+      commandNames.push(name)
+    }
+  }
+
+  if (config?.global) {
+    for (const [name, value] of Object.entries(config.global || {})) {
+      defaultConfig.global[name] = value
+    }
+  }
+
+  if (config?.guild) {
+    for (const [name, value] of Object.entries(config.guild || {})) {
+      defaultConfig.guild[name] = value
+    }
+  }
+
+  if (pkgLocalConfig) {
+    for (const [configName, value] of Object.entries(pkgLocalConfig)) {
+      localConfig[name][configName] = value
+    }
+  }
+
+  const module = { name, commandNames, enabled: {} }
+  modules.set(name, module)
+})
+
+const client = new Client({
+  intents: Array.from(intents),
+  partials: Array.from(partials)
+})
+
+const globals = {
+  sequelize,
+  client,
+  commands,
+  defaultConfig,
+  config,
+  localConfig,
+  modules,
+  lotusConfig
+} as Globals
+
+for (const [eventName, eventList] of events.entries()) {
+  client.on(eventName, (...args) =>
+    eventList.forEach((item) => {
+      try {
+        item(globals, ...args)
+      } catch (err) {
+        console.log(err)
+      }
+    })
+  )
+}
+
+client.once(Events.ClientReady, () => {
+  console.log(`Discord bot started! Logged in as ${client.user?.tag}`)
+})
+
+client.login(discordConfig.token)

package/src/config/lotus.example.json

@@ -0,0 +1,11 @@
+{
+  "sequelize": {
+    "dialect": "sqlite",
+    "storage": "./db.sqlite"
+  },
+  "discord": {
+    "token": ""
+  },
+  "owners": [],
+  "packages": []
+}

package/src/index.ts

@@ -0,0 +1,41 @@
+import { Client, Events, GatewayIntentBits, Partials } from 'discord.js'
+import { type Options, Sequelize } from 'sequelize'
+
+export interface Config {
+  guild: Record<string, any>
+  global: Record<string, any>
+}
+
+export type LocalConfig = Record<string, Record<string, any>>
+
+export type EventFunction = (globals: Globals, ...args: any[]) => void
+
+export interface Package {
+  name: string
+  intents?: GatewayIntentBits[]
+  partials?: Partials[]
+  events?: Record<Events, EventFunction>
+  commands?: Record<string, any>
+  config?: Config
+  localConfig?: LocalConfig
+  preload?: (sequelize: Sequelize) => Promise<void>
+}
+
+export interface LotusConfig {
+  sequelize: Options
+  discord: {
+    token: string
+  }
+  packages: string[]
+}
+
+export interface Globals {
+  sequelize: Sequelize
+  client: Client<boolean>
+  commands: Map<any, any>
+  defaultConfig: Config
+  config: {}
+  localConfig: LocalConfig
+  modules: Map<any, any>
+  lotusConfig: LotusConfig
+}

package/src/loadPackage.ts

@@ -0,0 +1,49 @@
+import fs from 'fs-extra'
+import path from 'path'
+import { Sequelize } from 'sequelize'
+import type { Package } from './index.ts'
+
+export async function loadModule(packagePath: string, sequelize: Sequelize) {
+  const { default: packageObj } = (await import(packagePath)) as {
+    default: Package
+  }
+  const { name } = packageObj
+
+  try {
+    const { preload, localConfig, commands = {}, events = {} } = packageObj
+
+    if (localConfig) {
+      const configPath = path.join('./config/', `${name}.json`)
+      const configExists = await fs.pathExists(configPath)
+
+      if (!configExists) {
+        await fs.writeJson(configPath, localConfig)
+        throw new Error(
+          `${configPath} has been created. Edit the file then restart the bot`
+        )
+      } else {
+        packageObj.localConfig = await fs.readJSON(configPath)
+      }
+    }
+    if (preload) await preload(sequelize)
+
+    const commandSize = Object.values(commands).length
+    const eventSize = Object.values(events).length
+
+    const loadedText =
+      commandSize > 0 && eventSize > 0
+        ? ` with ${commandSize} commands and ${eventSize} events`
+        : commandSize > 0
+          ? ` with ${commandSize} commands`
+          : eventSize > 0
+            ? ` with ${eventSize} events`
+            : ''
+
+    console.log(`Loaded ${name}${loadedText}`)
+    return packageObj
+  } catch (err) {
+    console.error(err, `Failed to load ${name}`)
+
+    return null
+  }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": [
+    "@tsconfig/node-lts/tsconfig.json",
+    "@tsconfig/node-ts/tsconfig.json"
+  ],
+  "compilerOptions": {
+    "baseUrl": "./",
+    "declaration": true,
+    "declarationDir": "./dist/types/",
+    "outDir": "./dist/lotus/",
+    "rootDir": "./src/",
+    "resolveJsonModule": true
+  }
+}