Merge pull request #47 from mongodb-developer/add-java-code

Add java code

Author: sis0k0

docs/50-demo-app/2-start-app.mdx

@@ -58,6 +58,8 @@ Right now, you should see a big error message in the console, as we haven't conf
 ```
 :::
 
+<Tabs groupId="server">
+<TabItem value="node" label="🚀 NodeJS/Express">
 
 ### Expose the server port
 
@@ -75,6 +77,24 @@ You'll see the text in the *Visibility* column change to `Public`.
 
 That's it! You're now ready to move to the next section.
 
+</TabItem>
+<TabItem value="java" label="☕️ Java Spring Boot">
+### Set the MongoDB connection
+To run the application in GitHub Codespaces, you now need to set the MongoDB connection string before starting the server.
+In the terminal of your Codespace, run:
+```Java
+export MONGODB_URI="<YOUR_CONNECTION_STRING>"
+```
+After setting the environment variable, start the application again with:
+```Java
+mvn spring-boot:run
+```
+<Screenshot url="https://github.com/mongodb-developer/library-management-system" src="img/screenshots/50-demo-app/2-start-app/5-set-environments.png" alt="The Port Visibility menu" />
+Once the command finishes, the application will be up and running on port 5000.
+<Screenshot url="https://github.com/mongodb-developer/library-management-system" src="img/screenshots/50-demo-app/2-start-app/6-app-started.png" alt="The Port Visibility menu" />
+
+</TabItem>
+</Tabs>
 ## 🦸 Option 2: Run locally
 
 If you prefer to run the application locally, you can do so by following these steps. Keep in mind that the following steps of this lab will be using the codespace, so you might need to adapt some of the commands.
@@ -126,26 +146,33 @@ npm start
 
 <TabItem value="java" label="☕️ Java Spring Boot">
 
-You need to have a local JDK 17+ and Maven installed.
-
-```bash
-cd client
-npm install
-```
-
-Start the server application.
-
-```bash
-cd java-server
-mvn spring-boot:start
+1. Before starting the backend, switch to the java-server project.
 ```
-
-And, in another terminal window, start the client application.
-
-```bash
-cd client
-npm start
+    git checkout java-server
 ```
+This command moves you into the correct project folder that contains the Java backend code.
+
+2. Set the MongoDB connection string as an environment variable:
+   - On Linux / macOS:
+   ```bash
+    export MONGODB_URI="<YOUR_CONNECTION_STRING>"
+    ````
+
+    - On Windows:
+    ```
+    $env:MONGODB_URI="<YOUR_CONNECTION_STRING>"
+    ```
+
+3. Run the Java server:
+    ```
+    cd java-server
+    mvn spring-boot:run
+    ```
+
+4. Run the client:
+    ```bash    
+    (cd ../client && npm install && npm start)
+    ```
 
 </TabItem>
 </Tabs>

docs/50-demo-app/3-configure.mdx

@@ -5,7 +5,6 @@ import TabItem from '@theme/TabItem';
 # 👐 Configure the Application
 
 Now that your environment is set up, you can configure the application.
-
 There should already be a file open in the IDE. If not, look in the file explorer on the left, and open the file below. This file contains the configuration for the application.
 
 <Tabs groupId="server">
@@ -19,20 +18,6 @@ DATABASE_URI="mongodb+srv://user:password@serverurl"
 DATABASE_NAME="library"
 SECRET="secret"
 ```
-</TabItem>
-
-<TabItem value="java" label="☕️ Java Spring Boot">
-
-File: `/java-server/src/main/resources/application.properties`
-
-```
-spring.data.mongodb.uri=mongodb+srv://user:password@serverurl
-spring.data.mongodb.database=library
-```
-</TabItem>
-</Tabs>
-
-
 
 
 You'll need to change the `DATABASE_URI` parameter to match your connection string. That's the same one you used to import the data.
@@ -43,38 +28,23 @@ Don't remember how to get your connection string? Check out the [Import Data](/d
 
 Copy and paste your connection string into the `DATABASE_URI` parameter. 
 
-<Tabs groupId="server">
-<TabItem value="node" label="🚀 NodeJS/Express">
 The file will automatically save, and the server will restart.
-</TabItem>
-
-<TabItem value="java" label="☕️ Java Spring Boot">
-You need to start the server. Click on the terminal window and type:
 
-```shell
-mvn spring-boot:run
-```
-
-</TabItem>
-</Tabs>
 
 
 In the *Terminal* tab at the bottom, look for the `Server is running on port: 5000` line. If you see it, you're good to go!
 
-<Tabs groupId="server">
-<TabItem value="node" label="🚀 NodeJS/Express">
-
 <Screenshot url="https://github.com/mongodb-developer/library-management-system" src="img/screenshots/50-demo-app/3-configure/1-running.png" alt="The terminal panel" />
 
 </TabItem>
 
 <TabItem value="java" label="☕️ Java Spring Boot">
+Everything is set up correctly. You can proceed to the next step.
 
 <Screenshot url="https://github.com/mongodb-developer/library-management-system" src="img/screenshots/50-demo-app/3-configure/1-running-java.png" alt="The terminal panel" />
-
 </TabItem>
-</Tabs>
 
+</Tabs>
 
 ## Reload the client
 

docs/60-schema-validation/2-validate-users.mdx

@@ -1,3 +1,4 @@
+import Screenshot from "@site/src/components/Screenshot";
 import Tabs from '@theme/Tabs';
 import TabItem from '@theme/TabItem';
 
@@ -60,7 +61,6 @@ The schema defines the following constraints:
 
 ## Explore the script to apply the schema
 
-
 <Tabs groupId="server">
 <TabItem value="node" label="🚀 NodeJS/Express">
 
@@ -91,39 +91,36 @@ The function uses the `db.command()` method to apply the schema to the `users` c
 </TabItem>
 
 <TabItem value="java" label="☕️ Java Spring Boot">
+In this step, we’ll review the code that applies schema validation to the users collection.
+It’s already implemented in `SchemaValidationConfig.java` no changes needed. We’ll look at two methods:
+```java title='src/main/java/com/mongodb/devrel/library/infrastructure/config/SchemaValidationConfig.java'
+@Configuration
+public class SchemaValidationConfig {
 
-```java
-public void applySchemaValidation() {
-    try (MongoClient mongoClient = MongoClients.create(mongoDBURI)) {
-        MongoDatabase database = mongoClient.getDatabase("library");
-        
-        Document userSchema = new Document("$jsonSchema", new Document()
-            .append("bsonType", "object")
-            .append("required", List.of("name", "isAdmin"))
-            .append("properties", new Document()
-                .append("name", new Document("bsonType", "string").append("minLength", 5)
-                    .append("description", "must be a string and is required"))
-                .append("isAdmin", new Document("bsonType", "bool")
-                    .append("description", "must be a boolean and is required"))
-            )
-        );
-
-        Document command = new Document("collMod", "users")
-            .append("validator", userSchema)
-            .append("validationLevel", "strict")
-            .append("validationAction", "error");
-        
-        Document result = database.runCommand(command);
-        
-        if (result.getDouble("ok") != 1.0) {
-            System.err.println("Failed to enable schema validation!");
-            System.exit(1);
-        } else {
-            System.out.println("Schema validation enabled!");
-        }
+    // fields ..
+
+    private void applyUserSchema(MongoDatabase db)  {
+       // implementation
+    }
+
+    private void runCollMod(MongoDatabase db, String collection, Document schema) {
+       // implementation
     }
+
 }
 ```
+- `applyUserSchema(MongoDatabase db)`
+  - Ensures the users collection exists.
+  - Builds a $jsonSchema requiring name (string, minLength: 5) and isAdmin (boolean).
+  - Calls runCollMod(...) to attach the validator to the collection.
+
+- `runCollMod(MongoDatabase db, String collection, Document schema)`
+  - Executes collMod with validator, validationLevel=strict, and validationAction=error.
+
+
+
+For readability, only the class structure is shown above. 
+You can open the [SchemaValidationConfig](https://github.com/mongodb-developer/library-management-system/blob/java-server/java-server/src/main/java/com/mongodb/devrel/library/infrastructure/config/SchemaValidationConfig.java) in your project to review the complete implementation.
 
 </TabItem>
 </Tabs>
@@ -164,24 +161,18 @@ You need to run the script to apply the schema to the `users` collection.
 
 <TabItem value="java" label="☕️ Java Spring Boot">
 
-1. Stop the running app.
-    1. Locate the bottom panel and click on the `TERMINAL` tab.
-    1. Press Ctrl+C to interrup the running app
-
-1. Copy above code for `applySchemaValidation` as a method in the `LibraryApplication.java` class.
-1. Modify the `run` method to call `applySchemaValidation`
-    ```java
-    @Override
-    public void run(String... args) {
-        log.info("🚀 App Started");
-        applySchemaValidation();
-    }
-    ```
-1. Restart the app typing in the Terminal:
+The `applyUserSchema` method is triggered by the [execute](https://github.com/mongodb-developer/library-management-system/blob/java-server/java-server/src/main/java/com/mongodb/devrel/library/infrastructure/config/SchemaValidationConfig.java#L44) method, which runs only if the property `lab.schema-mode` is set.
+To apply the schema, you must set this property to **apply**.
+
+Stop the application if it’s running and restart it with:
+
+```java
+mvn spring-boot:run -Dspring-boot.run.jvmArguments="-Dlab.schema-mode=apply"
+```
+
+When the application starts, you should see a message confirming that the validator was successfully applied to the users collection:
+<Screenshot url="https://github.com/mongodb-developer/library-management-system" src="img/screenshots/60-schema-validation/1-schema-applied.png" alt="The schema validation applied" />
 
-    ```bash
-    mvn spring-boot:start
-    ```
 
 </TabItem>
 </Tabs>
@@ -214,17 +205,18 @@ Modify the script to insert a document again with the `name` and `isAdmin` field
 </TabItem>
 
 <TabItem value="java" label="☕️ Java Spring Boot">
+In this step, the schema is already created, and it’s time to test it.
+The [validateUserSchema](https://github.com/mongodb-developer/library-management-system/blob/java-server/java-server/src/main/java/com/mongodb/devrel/library/infrastructure/config/SchemaValidationConfig.java#L97) method, already implemented, tries to insert a new user without the isAdmin field.
 
-Now that the schema validation is enabled for the `users` collection, you can test it by inserting a document that does not match the schema, or you can check the Validation tab in Compass to check for the new validation rules.
-
-You can also check it in the mongosh typing:
+To trigger it, stop the application if it’s running and start it again with the property set to **test**:
 
-```
-db.getCollectionInfos({ name: "users" })
+```java
+mvn spring-boot:run -Dspring-boot.run.jvmArguments="-Dlab.schema-mode=test"
 ```
 
-If schema validation is not enabled, the "validator" field will be missing or empty.
+In the logs, you should see an error indicating that the insert was rejected by the validator:
 
+<Screenshot url="https://github.com/mongodb-developer/library-management-system" src="img/screenshots/60-schema-validation/2-schema-validated.png" alt="The schema validation applied" />
 
 </TabItem>
 </Tabs>

docs/60-schema-validation/3-validate-authors.mdx

@@ -1,9 +1,15 @@
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
 # 🦸‍♀️ Enable Validation for the Authors Collection
 
 In this exercise, you will define a JSON schema for the authors collection, apply the schema to the collection, and test the schema validation by inserting a document that does not match the schema.
 
 This is an advanced exercise that requires you to write code. If you get stuck and you're doing this during a live workshop, you can flag down an instructor in the room for help.
 
+<Tabs groupId="server">
+<TabItem value="node" label="🚀 NodeJS/Express">
+
 1. Start by opening the `server/src/schema-validation/apply-schema.ts` file in your GitHub codespace and uncomment lines 41-61.
 1. Complete the tasks marked with `// TODO` comments.
 1. Execute the script again to apply the schema to the `authors` collection.
@@ -13,3 +19,35 @@ This is an advanced exercise that requires you to write code. If you get stuck a
 
     ```
 1. Finally, test the schema validation by modifying the `server/src/schema-validation/test-validation.ts` script. Inserting a document in the `authors` collection.
+</TabItem>
+
+<TabItem value="java" label="☕️ Java Spring Boot">
+In this advanced exercise, you will extend the [SchemaValidationConfig](https://github.com/mongodb-developer/library-management-system/blob/java-server/java-server/src/main/java/com/mongodb/devrel/library/infrastructure/config/SchemaValidationConfig.java) class to support the authors collection.
+Two methods are already defined in the class, but both are left with `// TODO` markers for you to implement:
+```java title='src/main/java/com/mongodb/devrel/library/infrastructure/config/SchemaValidationConfig.java'
+private void applyAuthorSchema(MongoDatabase db) {
+    // TODO: Implement the schema for authors ($jsonSchema with required 'name', 'bio', etc.)
+}
+
+private void validateAuthorsSchema(MongoDatabase db) {
+    // TODO: Insert an invalid document to assert rejection (e.g., missing or short 'name')
+}
+```
+
+Once implemented, you can run the application with the right target and mode:
+
+- Apply the schema to authors
+```java
+mvn spring-boot:run -Dspring-boot.run.jvmArguments="-Dlab.schema-mode=apply -Dlab.schema-target=authors"
+```
+- Test the schema validation for authors
+```java
+mvn spring-boot:run -Dspring-boot.run.jvmArguments="-Dlab.schema-mode=test -Dlab.schema-target=authors"
+```
+
+When you run in apply mode, you should see logs confirming the schema was applied.
+When you run in test mode, the invalid insert should fail, proving the validation works.
+</TabItem>
+
+
+</Tabs>