refactor: remove DTOs

apps/admin/.env.example

@@ -0,0 +1,12 @@
+NODE_ENV=development
+ADMIN_APP_HOST=0.0.0.0
+ADMIN_APP_PORT=4010
+
+MONGO_URL=mongodb://localhost:27017/noteblockworld
+
+S3_ENDPOINT=http://localhost:9000
+S3_BUCKET_SONGS=noteblockworld-songs
+S3_BUCKET_THUMBS=noteblockworld-thumbs
+S3_KEY=minioadmin
+S3_SECRET=minioadmin
+S3_REGION=us-east-1

apps/admin/components.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "new-york",
+  "tsx": true,
+  "tailwind": {
+    "css": "src/web/styles.css",
+    "baseColor": "zinc",
+    "cssVariables": false
+  },
+  "aliases": {
+    "components": "@admin-web/components",
+    "utils": "@admin-web/lib"
+  }
+}

apps/admin/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@nbw/admin",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "NODE_ENV=production bun run scripts/build.ts",
+    "dev": "bun run build && bun --watch run src/index.ts",
+    "start": "bun run dist/server/index.js",
+    "lint": "eslint \"src/**/*.{ts,tsx}\" --fix",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.946.0",
+    "@aws-sdk/s3-request-presigner": "^3.946.0",
+    "@nbw/config": "workspace:*",
+    "@nbw/database": "workspace:*",
+    "@nbw/validation": "workspace:*",
+    "@radix-ui/react-slot": "^1.2.4",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "lucide-react": "^0.556.0",
+    "mongoose": "^9.0.1",
+    "react": "^19.2.1",
+    "react-dom": "^19.2.1",
+    "tailwind-merge": "^3.4.0",
+    "zod": "^4.1.13"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4.1.18",
+    "@types/bun": "^1.3.4",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "postcss": "^8.5.6",
+    "tailwindcss": "^4.1.18",
+    "typescript": "^5.9.3"
+  }
+}

apps/admin/postcss.config.mjs

@@ -0,0 +1,7 @@
+const config = {
+  plugins: {
+    '@tailwindcss/postcss': {},
+  },
+};
+
+export default config;

apps/admin/scripts/build.ts

@@ -0,0 +1,84 @@
+import { $ } from 'bun';
+
+import tailwindcss from '@tailwindcss/postcss';
+import postcss from 'postcss';
+
+const DIST_DIR = './dist';
+const PUBLIC_DIR = `${DIST_DIR}/public`;
+const SERVER_DIR = `${DIST_DIR}/server`;
+
+async function buildStyles() {
+  const sourceCss = await Bun.file('./src/web/styles.css').text();
+  const output = await postcss([tailwindcss()]).process(sourceCss, {
+    from: './src/web/styles.css',
+    to: `${PUBLIC_DIR}/styles.css`,
+  });
+
+  await Bun.write(`${PUBLIC_DIR}/styles.css`, output.css);
+}
+
+async function buildSpa() {
+  const result = await Bun.build({
+    entrypoints: ['./src/web/main.tsx'],
+    outdir: PUBLIC_DIR,
+    target: 'browser',
+    format: 'esm',
+    splitting: false,
+    minify: false,
+    sourcemap: 'linked',
+  });
+
+  if (!result.success) {
+    throw new Error(
+      `SPA build failed: ${result.logs.map((log) => log.message).join('\n')}`,
+    );
+  }
+
+  await Bun.write(
+    `${PUBLIC_DIR}/index.html`,
+    await Bun.file('./src/web/index.html').text(),
+  );
+}
+
+async function buildServer() {
+  const result = await Bun.build({
+    entrypoints: ['./src/index.ts'],
+    outdir: SERVER_DIR,
+    target: 'bun',
+    format: 'esm',
+    splitting: false,
+    minify: false,
+    sourcemap: 'linked',
+    external: ['@nbw/database', '@nbw/config', '@nbw/validation'],
+  });
+
+  if (!result.success) {
+    throw new Error(
+      `Server build failed: ${result.logs
+        .map((log) => log.message)
+        .join('\n')}`,
+    );
+  }
+}
+
+async function buildAll() {
+  await $`rm -rf ${DIST_DIR}`;
+  await $`mkdir -p ${PUBLIC_DIR} ${SERVER_DIR}`;
+
+  await Promise.all([buildStyles(), buildSpa(), buildServer()]);
+}
+
+if (process.argv.includes('--watch')) {
+  throw new Error(
+    'Watch mode is handled by `bun --watch run src/index.ts` in `bun run dev`.',
+  );
+}
+
+buildAll()
+  .then(() => {
+    process.stdout.write('Built admin app successfully.\n');
+  })
+  .catch((error) => {
+    process.stderr.write(`${String(error)}\n`);
+    process.exit(1);
+  });

apps/admin/src/index.ts

@@ -0,0 +1,91 @@
+import path from 'path';
+
+import { connectDatabase } from '@admin/db/connect';
+import { createDatabaseModels } from '@admin/db/models';
+import { parseEnvironment } from '@admin/env';
+import { routeApiRequest } from '@admin/http/router';
+import { type ServiceContext } from '@admin/services/context';
+import { createS3StorageClient } from '@admin/storage/s3-client';
+
+const env = parseEnvironment(process.env);
+
+await connectDatabase(env.MONGO_URL);
+
+const models = createDatabaseModels();
+const storage = createS3StorageClient(env);
+await storage.verifyBuckets();
+
+const context: ServiceContext = {
+  env,
+  models,
+  storage,
+  startedAt: Date.now(),
+};
+
+async function resolvePublicRoot() {
+  const candidates = [
+    path.resolve(import.meta.dir, '../public'),
+    path.resolve(import.meta.dir, '../dist/public'),
+  ];
+
+  for (const candidate of candidates) {
+    if (await Bun.file(path.join(candidate, 'index.html')).exists()) {
+      return candidate;
+    }
+  }
+
+  return candidates[0];
+}
+
+const publicRoot = await resolvePublicRoot();
+
+function safeResolvePublicPath(urlPath: string) {
+  const normalized = path.normalize(urlPath).replace(/^(\.\.(\/|\\|$))+/, '');
+  const fullPath = path.resolve(publicRoot, `.${normalized}`);
+
+  if (!fullPath.startsWith(publicRoot)) {
+    return null;
+  }
+
+  return fullPath;
+}
+
+async function serveStatic(request: Request) {
+  const url = new URL(request.url);
+  const pathname = url.pathname === '/' ? '/index.html' : url.pathname;
+  const filePath = safeResolvePublicPath(pathname);
+
+  if (filePath) {
+    const file = Bun.file(filePath);
+    if (await file.exists()) {
+      return new Response(file);
+    }
+  }
+
+  const spaFallback = Bun.file(path.join(publicRoot, 'index.html'));
+  if (await spaFallback.exists()) {
+    return new Response(spaFallback);
+  }
+
+  return new Response('index.html was not found. Run `bun run build` first.', {
+    status: 500,
+  });
+}
+
+Bun.serve({
+  hostname: env.ADMIN_APP_HOST,
+  port: env.ADMIN_APP_PORT,
+  async fetch(request) {
+    const url = new URL(request.url);
+
+    if (url.pathname.startsWith('/api/')) {
+      return routeApiRequest(request, context);
+    }
+
+    return serveStatic(request);
+  },
+});
+
+process.stdout.write(
+  `@nbw/admin listening on http://${env.ADMIN_APP_HOST}:${env.ADMIN_APP_PORT}\n`,
+);

apps/admin/src/server/db/connect.ts

@@ -0,0 +1,5 @@
+import mongoose from 'mongoose';
+
+export async function connectDatabase(mongoUrl: string) {
+  await mongoose.connect(mongoUrl);
+}

apps/admin/src/server/db/models.ts

@@ -0,0 +1,15 @@
+import mongoose from 'mongoose';
+
+import { Song, SongSchema, User, UserSchema } from '@nbw/database';
+
+export function createDatabaseModels() {
+  const songs =
+    mongoose.models[Song.name] ?? mongoose.model(Song.name, SongSchema);
+
+  const users =
+    mongoose.models[User.name] ?? mongoose.model(User.name, UserSchema);
+
+  return { songs, users };
+}
+
+export type DatabaseModels = ReturnType<typeof createDatabaseModels>;

apps/admin/src/server/env.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+
+const envSchema = z.object({
+  NODE_ENV: z.enum(['development', 'production']).default('development'),
+  ADMIN_APP_HOST: z.string().default('0.0.0.0'),
+  ADMIN_APP_PORT: z.coerce.number().int().positive().default(4010),
+  MONGO_URL: z.string().min(1),
+  S3_ENDPOINT: z.string().min(1),
+  S3_BUCKET_SONGS: z.string().min(1),
+  S3_BUCKET_THUMBS: z.string().min(1),
+  S3_KEY: z.string().min(1),
+  S3_SECRET: z.string().min(1),
+  S3_REGION: z.string().min(1),
+});
+
+export type AdminEnvironment = z.output<typeof envSchema>;
+
+export function parseEnvironment(source: Record<string, string | undefined>) {
+  const result = envSchema.safeParse(source);
+
+  if (!result.success) {
+    const messages = result.error.issues
+      .map((issue) => `${issue.path.join('.')}: ${issue.message}`)
+      .join('\n');
+    throw new Error(`Admin environment validation failed:\n${messages}`);
+  }
+
+  return result.data;
+}

apps/admin/src/server/http/json.ts

@@ -0,0 +1,23 @@
+export function json(
+  payload: unknown,
+  init: Omit<ResponseInit, 'headers'> & {
+    headers?: HeadersInit;
+  } = {},
+) {
+  return new Response(JSON.stringify(payload), {
+    ...init,
+    headers: {
+      'content-type': 'application/json; charset=utf-8',
+      ...init.headers,
+    },
+  });
+}
+
+export function notFound() {
+  return json(
+    {
+      error: 'Not Found',
+    },
+    { status: 404 },
+  );
+}

apps/admin/src/server/http/router.ts

@@ -0,0 +1,34 @@
+import { notFound } from '@admin/http/json';
+import { handleHealthRequest } from '@admin/routes/health.route';
+import {
+  handleDashboardStatsRequest,
+  handleSongsRequest,
+} from '@admin/routes/songs.route';
+import { handleUsersRequest } from '@admin/routes/users.route';
+import type { ServiceContext } from '@admin/services/context';
+
+type RouteHandler = (
+  request: Request,
+  context: ServiceContext,
+) => Promise<Response>;
+
+const routeTable = new Map<string, RouteHandler>([
+  ['/api/health', async (_request, context) => handleHealthRequest(context)],
+  ['/api/users', handleUsersRequest],
+  ['/api/songs', handleSongsRequest],
+  ['/api/dashboard/stats', handleDashboardStatsRequest],
+]);
+
+export async function routeApiRequest(
+  request: Request,
+  context: ServiceContext,
+): Promise<Response> {
+  const url = new URL(request.url);
+  const handler = routeTable.get(url.pathname);
+
+  if (!handler) {
+    return notFound();
+  }
+
+  return handler(request, context);
+}

apps/admin/src/server/routes/health.route.ts

@@ -0,0 +1,10 @@
+import { json } from '@admin/http/json';
+import type { ServiceContext } from '@admin/services/context';
+
+export async function handleHealthRequest(context: ServiceContext) {
+  return json({
+    ok: true,
+    uptimeMs: Date.now() - context.startedAt,
+    env: context.env.NODE_ENV,
+  });
+}