chore: migrate to pnpm workspaces monorepo with Turborepo

- Restructure directories: apps/api, apps/admin, apps/website
- Add root pnpm-workspace.yaml, turbo.json, .prettierrc, .gitignore
- Rename packages to @inkreach/api, @inkreach/admin, @inkreach/website
- Add shared packages: packages/tsconfig, packages/shared-types
- Add pnpm.onlyBuiltDependencies for native builds
- Update docs: README.md, structs.md
- All three projects build successfully

apps/api/src/common/decorators/current-user.decorator.ts

@@ -0,0 +1,13 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+
+/**
+ * Pulls the authenticated user out of the request, as populated by
+ * the JWT strategy.
+ */
+export const CurrentUser = createParamDecorator(
+  (data: keyof { id: bigint; username: string } | undefined, ctx: ExecutionContext) => {
+    const request = ctx.switchToHttp().getRequest<{ user?: { id: bigint; username: string } }>();
+    const user = request.user;
+    return data ? user?.[data] : user;
+  },
+);

apps/api/src/common/filters/http-exception.filter.ts

@@ -0,0 +1,73 @@
+import {
+  ArgumentsHost,
+  Catch,
+  ExceptionFilter,
+  HttpException,
+  HttpStatus,
+  Logger,
+} from '@nestjs/common';
+import { Request, Response } from 'express';
+
+/**
+ * Global HTTP exception filter.
+ *
+ * Normalizes the error envelope to:
+ * ```json
+ * {
+ *   "statusCode": 400,
+ *   "message": "...",
+ *   "error": "...",
+ *   "timestamp": "ISO-8601",
+ *   "path": "..."
+ * }
+ * ```
+ */
+@Catch()
+export class HttpExceptionFilter implements ExceptionFilter {
+  private readonly logger = new Logger(HttpExceptionFilter.name);
+
+  catch(exception: unknown, host: ArgumentsHost): void {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+    const request = ctx.getRequest<Request>();
+
+    const status =
+      exception instanceof HttpException
+        ? exception.getStatus()
+        : HttpStatus.INTERNAL_SERVER_ERROR;
+
+    let message: string | string[] = 'Internal server error';
+    let error = 'InternalServerError';
+
+    if (exception instanceof HttpException) {
+      const resp = exception.getResponse();
+      if (typeof resp === 'string') {
+        message = resp;
+      } else if (typeof resp === 'object' && resp !== null) {
+        const obj = resp as Record<string, unknown>;
+        message = (obj.message as string | string[]) ?? exception.message;
+        error = (obj.error as string) ?? exception.name;
+      } else {
+        message = exception.message;
+      }
+    } else if (exception instanceof Error) {
+      message = exception.message;
+      error = exception.name;
+    }
+
+    if (status >= 500) {
+      this.logger.error(
+        `${request.method} ${request.url} -> ${status} ${message}`,
+        exception instanceof Error ? exception.stack : undefined,
+      );
+    }
+
+    response.status(status).json({
+      statusCode: status,
+      message,
+      error,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+    });
+  }
+}

apps/api/src/common/interceptors/transform.interceptor.ts

@@ -0,0 +1,19 @@
+import {
+  CallHandler,
+  ExecutionContext,
+  Injectable,
+  NestInterceptor,
+} from '@nestjs/common';
+import { Observable, map } from 'rxjs';
+
+/**
+ * Wraps every successful response into `{ data, success: true }`.
+ *
+ * Exceptions still flow through the global filter and are not wrapped.
+ */
+@Injectable()
+export class TransformInterceptor implements NestInterceptor {
+  intercept(_context: ExecutionContext, next: CallHandler): Observable<unknown> {
+    return next.handle().pipe(map((data) => ({ data, success: true })));
+  }
+}