feat(cli): ♻️ Begin new CLI rewrite with oclif

Author: CPlusPatch

.gitignore

@@ -179,4 +179,5 @@ glitch-old
 glitch
 glitch.tar.gz
 glitch-dev
-*.pem
+*.pem
+oclif.manifest.json

bun.lockb

@@ -1,4 +1,4 @@
-import { config } from "config-manager";
+import { config } from "~/packages/config-manager";
 import { drizzle } from "drizzle-orm/node-postgres";
 import { migrate } from "drizzle-orm/postgres-js/migrator";
 import { LogLevel, type LogManager, type MultiLogManager } from "log-manager";
@@ -13,7 +13,10 @@ export const client = new Client({
     database: config.database.database,
 });
 
-export const setupDatabase = async (logger: LogManager | MultiLogManager) => {
+export const setupDatabase = async (
+    logger: LogManager | MultiLogManager,
+    info = true,
+) => {
     try {
         await client.connect();
     } catch (e) {
@@ -28,7 +31,8 @@ export const setupDatabase = async (logger: LogManager | MultiLogManager) => {
     }
 
     // Migrate the database
-    await logger.log(LogLevel.INFO, "Database", "Migrating database...");
+    info &&
+        (await logger.log(LogLevel.INFO, "Database", "Migrating database..."));
 
     try {
         await migrate(db, {
@@ -44,7 +48,7 @@ export const setupDatabase = async (logger: LogManager | MultiLogManager) => {
         process.exit(1);
     }
 
-    await logger.log(LogLevel.INFO, "Database", "Database migrated");
+    info && (await logger.log(LogLevel.INFO, "Database", "Database migrated"));
 };
 
 export const db = drizzle(client, { schema });

drizzle/db.ts

@@ -35,7 +35,7 @@
         "build": "bun run build.ts",
         "cloc": "cloc . --exclude-dir node_modules,dist,.output,.nuxt,meta,logs,glitch,glitch-dev --exclude-ext sql,log,pem",
         "wc": "find server database *.ts docs packages types utils drizzle tests -type f -print0 | wc -m --files0-from=-",
-        "cli": "bun run cli.ts",
+        "cli": "bun run packages/cli/bin/run.ts",
         "prune": "ts-prune | grep -v server/ | grep -v dist/ | grep -v '(used in module)'"
     },
     "trustedDependencies": [

package.json

@@ -0,0 +1,14 @@
+import { Command } from "@oclif/core";
+
+export abstract class BaseCommand<T extends typeof Command> extends Command {
+    protected async init(): Promise<void> {
+        await super.init();
+
+        const { setupDatabase } = await import("~drizzle/db");
+        const { consoleLogger } = await import("@loggers");
+
+        (async () => {
+            await setupDatabase(consoleLogger, false);
+        })();
+    }
+}

packages/cli/base.ts

@@ -0,0 +1,3 @@
+@echo off
+
+bun "%~dp0\dev" %*

packages/cli/bin/dev.cmd

@@ -0,0 +1,5 @@
+#!/usr/bin/env -S bun
+
+import { execute } from "@oclif/core";
+
+await execute({ development: true, dir: import.meta.url });

packages/cli/bin/dev.ts

@@ -0,0 +1,3 @@
+@echo off
+
+bun "%~dp0\run" %*

packages/cli/bin/run.cmd

@@ -0,0 +1,5 @@
+#!/usr/bin/env bun
+
+import { execute } from "@oclif/core";
+
+await execute({ dir: import.meta.url });

packages/cli/bin/run.ts

@@ -0,0 +1,96 @@
+import { and, eq, like } from "drizzle-orm";
+import { Users } from "~drizzle/schema";
+import type { User } from "~packages/database-interface/user";
+import { BaseCommand } from "./base";
+import { Args, Flags, type Command, type Interfaces } from "@oclif/core";
+
+export type FlagsType<T extends typeof Command> = Interfaces.InferredFlags<
+    (typeof BaseCommand)["baseFlags"] & T["flags"]
+>;
+export type ArgsType<T extends typeof Command> = Interfaces.InferredArgs<
+    T["args"]
+>;
+
+export abstract class UserFinderCommand<
+    T extends typeof BaseCommand,
+> extends BaseCommand<typeof UserFinderCommand> {
+    static baseFlags = {
+        pattern: Flags.boolean({
+            char: "p",
+            description:
+                "Process as a wildcard pattern (don't forget to escape)",
+        }),
+        type: Flags.string({
+            char: "t",
+            description: "Type of identifier",
+            options: ["id", "username", "note", "display-name", "email"],
+            default: "id",
+        }),
+        limit: Flags.integer({
+            char: "n",
+            description: "Limit the number of users",
+            default: 100,
+        }),
+        print: Flags.boolean({
+            allowNo: true,
+            default: true,
+            char: "P",
+            description: "Print user(s) found before processing",
+        }),
+    };
+
+    static baseArgs = {
+        identifier: Args.string({
+            description:
+                "Identifier of the user (by default this must be an ID)",
+            required: true,
+        }),
+    };
+
+    protected flags!: FlagsType<T>;
+    protected args!: ArgsType<T>;
+
+    public async init(): Promise<void> {
+        await super.init();
+        const { args, flags } = await this.parse({
+            flags: this.ctor.flags,
+            baseFlags: (super.ctor as typeof BaseCommand).baseFlags,
+            args: this.ctor.args,
+            strict: this.ctor.strict,
+        });
+        this.flags = flags as FlagsType<T>;
+        this.args = args as ArgsType<T>;
+    }
+
+    public async findUsers(): Promise<User[]> {
+        const operator = this.flags.pattern ? like : eq;
+        // Replace wildcards with an SQL LIKE pattern
+        const identifier = this.flags.pattern
+            ? this.args.identifier.replace(/\*/g, "%")
+            : this.args.identifier;
+
+        const { User } = await import("~packages/database-interface/user");
+
+        return await User.manyFromSql(
+            and(
+                this.flags.type === "id"
+                    ? operator(Users.id, identifier)
+                    : undefined,
+                this.flags.type === "username"
+                    ? operator(Users.username, identifier)
+                    : undefined,
+                this.flags.type === "note"
+                    ? operator(Users.note, identifier)
+                    : undefined,
+                this.flags.type === "display-name"
+                    ? operator(Users.displayName, identifier)
+                    : undefined,
+                this.flags.type === "email"
+                    ? operator(Users.email, identifier)
+                    : undefined,
+            ),
+            undefined,
+            this.flags.limit,
+        );
+    }
+}