refactor: better define the api bounderies of the module

.gitignore

@@ -15,3 +15,4 @@ coverage
 #$ git update-index --no-assume-unchanged <file-to-ignore>
 # Credit: https://web.archive.org/web/20240726013834/https://practicalgit.com/blog/make-git-ignore-local-changes-to-tracked-files.html
 nx.json
+.env

apps/server/.env.example

@@ -0,0 +1,2 @@
+NX_CLOUD_AUTH_TOKEN=
+SENTRY_DSN=

apps/server/package.json

@@ -8,7 +8,8 @@
     "build": "tsc --build  --verbose",
     "check-types": "tsc --noEmit",
     "lint": "eslint src",
-    "start": "node dist/src/index.js",
+    "prestart": "nx run @rusty/server:build",
+    "start": "node --env-file .env dist/src/index.js",
     "test": "vitest",
     "dev": "node --import 'data:text/javascript,import { register } from \"node:module\"; import { pathToFileURL } from \"node:url\"; register(\"ts-node/esm\", pathToFileURL(\"./\"));' --watch src/index.ts"
   },
@@ -30,6 +31,8 @@
   },
   "dependencies": {
     "@rusty/util": "workspace:*",
-    "@rusty/web": "workspace:*"
+    "@rusty/web": "workspace:*",
+    "@sentry/node": "^8.20.0",
+    "@sentry/profiling-node": "^8.20.0"
   }
 }

apps/server/src/ServerController.ts

@@ -4,7 +4,7 @@
 import { WrappedServer } from "./WrappedServer.js";
 import { exit } from "node:process";
 import { log } from "@rusty/util";
-import { handleWebRequests } from "@rusty/web";
+import { processWebRequests } from "@rusty/web";
 import { headersToRecords } from "./headersToRecords.js";
 
 /**
@@ -16,7 +16,7 @@
   req: import("node:http").IncomingMessage,
   res: import("node:http").ServerResponse
 ) {
-  const response = await handleWebRequests({
+  const response = await processWebRequests({
     headers: headersToRecords(req.headers),
     remoteAddress: req.socket.remoteAddress || "",
     method: req.method || "",

apps/server/src/index.ts

@@ -1,4 +1,27 @@
+// IMPORTANT: Make sure to import `instrument.js` at the top of your file.
+// If you're using ECMAScript Modules (ESM) syntax, use `import "./instrument.js";`
+void import ("./instrument.js");
+
+// All other imports below
+import * as Sentry from "@sentry/node";
 import { ServerController } from "./ServerController.js";
 
-const serverController = new ServerController();
-void serverController.start();
+process.on("unhandledRejection", (reason, promise) => {
+    console.error("Unhandled Rejection at:", promise, "reason:", reason);
+    Sentry.captureException(reason as Error);
+    process.exit(1);
+    })
+
+process.on("uncaughtException", (error) => {
+    console.error("Uncaught Exception thrown", error);
+    Sentry.captureException(error);
+    process.exit(1);
+    })  
+
+function main() {
+    const serverController = new ServerController();
+    void serverController.start();
+}
+
+main();
+

apps/server/src/instrument.ts

@@ -0,0 +1,18 @@
+// Import with `import * as Sentry from "@sentry/node"` if you are using ESM
+import * as Sentry from "@sentry/node";
+import { nodeProfilingIntegration } from "@sentry/profiling-node";
+
+if (typeof process.env.SENTRY_DSN === "undefined" || process.env.SENTRY_DSN === "") {
+  console.error("No SENTRY_DSN provided");
+  process.exit(1);
+}
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  integrations: [nodeProfilingIntegration()],
+  // Performance Monitoring
+  tracesSampleRate: 1.0, //  Capture 100% of the transactions
+
+  // Set sampling rate for profiling - this is relative to tracesSampleRate
+  profilesSampleRate: 1.0,
+});

libs/util/package.json

@@ -31,6 +31,8 @@
     "vitest": "^2.0.4"
   },
   "dependencies": {
+    "@sentry/node": "^8.20.0",
+    "@sentry/profiling-node": "^8.20.0",
     "pino": "9.3.1"
   }
 }

libs/web/index.ts

@@ -1 +1,9 @@
-export { handleWebRequests } from "./src/index.js";
+export { processWebRequests } from "./src/index.js";
+export { RouteHandlers } from "./src/processors/index.js";
+export {
+  ErrorUserNotFound,
+  handleCreateUserError,
+  ErrorMissingCredentials,
+  ErrorUserExists,
+} from "./src/errors.js";
+export { createUser, userLogin, deleteUser } from "./src/services/AuthLogin.js";

libs/web/package.json

@@ -3,6 +3,9 @@
   "version": "1.0.0",
   "private": true,
   "type": "module",
+  "imports": {
+    "#internal": "./dist/src/index.js"
+  },
   "exports": {
     ".": "./dist/index.js"
   },
@@ -32,6 +35,8 @@
   },
   "dependencies": {
     "@rusty/util": "workspace:*",
+    "@sentry/node": "^8.20.0",
+    "@sentry/profiling-node": "^8.20.0",
     "pino": "9.3.1",
     "sequelize": "6.37.3",
     "sqlite3": "5.1.7"

libs/web/src/db.ts

@@ -5,8 +5,8 @@
 export const db = new Sequelize({
   dialect: "sqlite",
   storage: DATABASE_URL,
-  logging: console.log, // Enable logging
+  logging: false,
 });
 
 db.authenticate()
   .then(() => db.sync())

libs/web/src/helpers.ts

@@ -0,0 +1,32 @@
+import { ErrorMissingCredentials } from "./errors.js";
+import type { parsedHttpRequestData } from "./types.js";
+
+/**
+ * Extracts the username and password from the parsed HTTP request data.
+ * @param info - The parsed HTTP request data.
+ * @returns An object containing the extracted username and password.
+ */
+export function extractCredentials(info: parsedHttpRequestData): {
+    username: string;
+    password: string;
+  } {
+    const username = (info.searchParams.get("username") as string) || "";
+    const password = (info.searchParams.get("password") as string) || "";
+    return { username, password };
+  }
+
+/**
+ * Validates the provided username and password.
+ * @param {string} username - The username to validate.
+ * @param {string} password - The password to validate.
+ * @throws {ErrorMissingCredentials} If either the username or password is empty.
+ */
+  export function validateCredentials(username: string, password: string): void {
+    if (username === "") {
+      throw new ErrorMissingCredentials("Username is required");
+    }
+
+    if (password === "") {
+      throw new ErrorMissingCredentials("Password is required");
+    }
+  }

libs/web/src/index.ts

@@ -1,19 +1,10 @@
 import { log } from "@rusty/util";
-import type { parsedHttpRequestData, rawHttpRequestData, RequestResponse } from "./types.js";
-import { handleAuthLogin } from "./services/AuthLogin.js";
+import type { rawHttpRequestData, RequestResponse } from "./types.js";
+import { RouteHandlers } from "./processors/index.js";
+export { User } from "./models/User.js";
+export type { UserAttributes } from "./models/User.js";
 
-const RouteHandlers: Record<
-  string,
-  (info: parsedHttpRequestData) => Promise<{
-    statusCode: number;
-    body: string;
-    headers: Record<string, string>;
-  }>
-> = {
-  "/AuthLogin": handleAuthLogin,
-};
-
-export async function handleWebRequests({
+export async function processWebRequests({
   headers,
   remoteAddress,
   method,

libs/web/src/models/User.ts

@@ -5,6 +5,7 @@
   id: number;
   username: string;
   password: string;
+  customerId: number;
 }
 
 export interface UserCreationAttributes
@@ -17,6 +18,7 @@
   declare id: number;
   declare username: string;
   declare password: string;
+  declare customerId: number;
 }
 
 User.init(
@@ -35,6 +37,10 @@
       type: DataTypes.STRING,
       allowNull: false,
     },
+    customerId: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+    },
   },
   {
     sequelize: db,

libs/web/src/processors/index.ts

@@ -0,0 +1,13 @@
+import type { parsedHttpRequestData } from "../types.js";
+import { authenticateUser } from "./processLogin.js";
+
+export const RouteHandlers: Record<
+  string,
+  (info: parsedHttpRequestData) => Promise<{
+    statusCode: number;
+    body: string;
+    headers: Record<string, string>;
+  }>
+> = {
+  "/AuthLogin": authenticateUser,
+};

libs/web/src/processors/processLogin.ts

@@ -0,0 +1,66 @@
+import { log } from "@rusty/util";
+import { extractCredentials, validateCredentials } from "../helpers.js";
+import { userLogin } from "../services/AuthLogin.js";
+import type { parsedHttpRequestData, RequestResponse } from "../types.js";
+
+/**
+ * Handles the authentication login process.
+ *
+ * @param info - The parsed HTTP request data.
+ * @returns A promise that resolves to the request response.
+ */
+export async function authenticateUser(
+  info: parsedHttpRequestData
+): Promise<RequestResponse> {
+  const { username, password } = extractCredentials(info);
+
+  try {
+    validateCredentials(username, password);
+
+    await userLogin(username, password);
+
+    const token = "abc123";
+
+    return constructLoginResponse(`Valid=TRUE\nTicket=${token}`);
+  } catch (error: unknown) {
+    log.error(`Error validating credentials: ${(error as Error).message}`);
+    return generateLoginError(
+      "INV-200",
+      "Unable to login",
+      "https://rusty-motors.com"
+    );
+  }
+}
+
+/**
+ * Constructs a login response object.
+ * @param body - The response body.
+ * @returns The constructed login response object.
+ */
+function constructLoginResponse(body = ""): RequestResponse {
+  return {
+    statusCode: 200,
+    body,
+    headers: { "Content-Type": "text/plain" },
+  };
+}
+
+/**
+ * Generates a login error response.
+ *
+ * @param errorCode - The error code. Default is "INV-200".
+ * @param errorText - The error text. Default is "Unable to login".
+ * @param errorUrl - The error URL. Default is "https://rusty-motors.com".
+ * @returns The login error response.
+ */
+function generateLoginError(
+  errorCode = "INV-200",
+  errorText = "Unable to login",
+  errorUrl = "https://rusty-motors.com"
+): RequestResponse | PromiseLike<RequestResponse> {
+  return {
+    statusCode: 200,
+    body: `reasoncode=${errorCode}\nreasontext=${errorText}\nreasonurl=${errorUrl}`,
+    headers: { "Content-Type": "text/plain" },
+  };
+}