Migration Guide

-import { createFetchHandler } from '@wolfstar/http-framework/fetch';
-import { Client } from '@wolfstar/http-framework';
+import { Client } from '@wolfstar/http-framework';

 const client = new Client({ discordToken, discordPublicKey });
 await client.load();

-const handler = createFetchHandler(client, { postPath: '/interactions' });
 export default {
-	fetch: handler
+	fetch: (request: Request) => client.fetch(request, { postPath: '/interactions' })
 };

export default defineConfig({
	experimental: {
		enableVite: true,
		enableNitro: true,
		nitro: {
			// 'node-server' by default; deployable to anything Nitro targets — 'cloudflare-module', 'aws-lambda',
			// 'vercel', 'netlify', 'bun', 'deno-deploy', and more.
			preset: 'node-server'
		}
	}
});

import { Client } from '@wolfstar/http-framework';

const client = new Client({
	discordToken: process.env.DISCORD_TOKEN,
	discordPublicKey: process.env.DISCORD_PUBLIC_KEY
});
await client.load();

export default client;

-import { ConfigError } from '@wolfstar/http-framework/config';
+import { Diagnostic } from 'nostics';
 import { loadStarsConfig } from '@wolfstar/http-framework/config';

 try {
  await loadStarsConfig({ cwd: process.cwd() });
 } catch (error) {
-	if (error instanceof ConfigError) {
-		console.error(error.code, error.path, error.file, error.hint);
+	if (error instanceof Diagnostic) {
+		console.error(error.code, error.message, error.sources);
  }
 }

// stars.config.ts
import { defineConfig } from '@wolfstar/http-framework/config';

export default defineConfig({
	// Entry, build output, tsdown, auto imports, env files and src/locales are conventional.
});

import { loadStarsConfig } from '@wolfstar/http-framework/config';

const config = await loadStarsConfig({ cwd: process.cwd() });
console.log(config.entry, config.build.output);

 {
	"scripts": {
-		"build": "tsdown",
-		"dev": "pnpm run build --onSuccess \"pnpm run start\"",
-		"watch": "pnpm run build --watch",
-		"watch:start": "pnpm run build --watch --onSuccess \"pnpm run start\"",
+		"build": "stars build",
+		"dev": "stars dev",
 		"start": "node dist/main.js",
-		"generate:i18n": "i18next-type-generator ./src/locales/en-US/ ./src/@types/i18next.d.ts"
+		"generate:i18n": "stars codegen"
	}
 }

export default defineConfig({
	tsdown: {
		alias: { '#shared': './src/shared' },
		dts: true
	}
});

stars commands list                 # global commands
stars commands list --guild 1234    # a guild's commands
stars commands clean                # checklist wizard, then a confirmation
stars commands clean --name ping    # delete one, asking first

export default defineConfig({
	entry: 'src/main.ts',
	build: { tool: 'tsdown' },
	dev: {
		// A type checker next to the bot, reported on the UI's `tsc` channel. Never blocks a build.
		typecheck: { checker: 'golar' },
		// A cloudflared quick tunnel so Discord can reach the interactions endpoint.
		tunnel: true,
		// Where the session's logs are mirrored; `false` disables it.
		logFile: '.stars/dev.log'
	}
});

export default defineConfig({
	entry: 'src/main.ts',
	build: { tool: 'tsdown' },
	imports: {
		dirs: ['src/lib/**', 'src/utils/**'],
		presets: ['@wolfstar/http-framework', '@wolfstar/env-utilities'],
		exclude: [],
		dts: '.stars/imports.d.ts'
	}
});

{
	"extends": "./.stars/tsconfig.json"
}

-import '@wolfstar/plugin-i18next/register';

import { Client, LogLevel } from '@wolfstar/http-framework';

const client = new Client({ logger: { level: LogLevel.Debug } });

.stars/

// Before
import { addFormatters, init, load } from '@wolfstar/http-framework-i18n';
import { Client } from '@wolfstar/http-framework';

await load(new URL('locales', import.meta.url));

addFormatters(
	{ name: 'uppercase', format: (value) => value.toUpperCase() }, //
	{ name: 'lowercase', format: (value) => value.toLowerCase() }
);

await init();

const client = new Client();
await client.load();

// After
import '@wolfstar/plugin-i18next/register';
import { Client } from '@wolfstar/http-framework';

const client = new Client({
	i18n: {
		// Optional, defaults to `<root>/languages`:
		defaultLanguageDirectory: new URL('languages', import.meta.url).pathname,
		defaultName: 'en-US',
		formatters: [
			{ name: 'uppercase', format: (value) => value.toUpperCase() }, //
			{ name: 'lowercase', format: (value) => value.toLowerCase() }
		]
	}
});
await client.load();

languages/
├── en-US/
│   ├── default.json
│   └── commands/
│       └── ping.json
└── es-ES/
    ├── default.json
    └── commands/
        └── ping.json

-import { FT, T, resolveKey } from '@wolfstar/http-framework-i18n';
+import { FT, T, resolveKey } from '@wolfstar/plugin-i18next';

-import { getT, loadedLocales } from '@wolfstar/http-framework-i18n';
+import { container } from '@wolfstar/http-framework';

-const t = getT('en-US');
-const isLoaded = loadedLocales.has('es-ES');
+const t = container.i18n.getT('en-US');
+const isLoaded = container.i18n.languages.has('es-ES');

import '@wolfstar/plugin-i18next/register';
import { Client } from '@wolfstar/http-framework';

const client = new Client({
	i18n: {
		fetchLanguage: async (context) => {
			if (!context.guildId) return null;
			const guild = await database.getGuild(context.guildId);
			return guild?.language ?? null;
		}
	}
});
await client.load();

import { container } from '@wolfstar/http-framework';

container.i18n.fetchLanguage = async (context) => {
	if (!context.guildId) return null;
	const guild = await database.getGuild(context.guildId);
	return guild?.language ?? null;
};

import { fetchKey, fetchT } from '@wolfstar/plugin-i18next';

const t = await fetchT(interaction);
const content = await fetchKey(interaction, 'commands/ping:success');

const client = new Client({
	i18n: {
		hmr: { enabled: true }
	}
});

-import { Logger, LogLevel } from '@wolfstar/logger';
-import { Client } from '@wolfstar/http-framework';
+import '@wolfstar/plugin-logger/register';
+import { Client, LogLevel, container } from '@wolfstar/http-framework';

-const logger = new Logger({ level: LogLevel.Debug });
-const client = new Client();
+const client = new Client({
+  logger: { level: LogLevel.Debug }
+});

-logger.info('Bot starting');
+container.logger.info('Bot starting');

const client = new Client({
	logger: {
		level: LogLevel.Info,
		instance: myLogger
	}
});

import '@wolfstar/plugin-logger/register';

import * as Sentry from '@sentry/node';
import { Client, LogLevel } from '@wolfstar/http-framework';
import { ConsoleTransport, SentryTransport } from '@wolfstar/plugin-logger';

Sentry.init({ dsn: process.env.SENTRY_DSN });

const client = new Client({
	logger: {
		level: LogLevel.Debug,
		transports: [new ConsoleTransport(), new SentryTransport({ client: Sentry, level: LogLevel.Error })]
	}
});

import { createLogger, format, transports as winstonTransports } from 'winston';
import { WinstonTransport } from '@wolfstar/plugin-logger/winston';

const winston = createLogger({
	format: format.json(),
	transports: [new winstonTransports.Console()]
});

const client = new Client({
	logger: {
		transports: [new WinstonTransport({ instance: winston })]
	}
});

-import { bold, red } from '@wolfstar/logger';
+import { bold, red } from 'colorette';