Building a Server-Side Rendered (SSR) App with Vite

Building a Server-Side Rendered (SSR) app involves orchestrating three main components: the frontend app, the SSR render entry, and the server to serve assets and handle backend APIs. In this guide, we'll leverage Vite for the frontend, Node.js and Express for the server, and demonstrate a streamlined development workflow using Nx. Prerequisites * Node.js and npm installed * Basic understanding of JavaScript, React.js (or your preferred frontend framework), and Express.js Project Structur

Post, Code and Quiet Time. Building a Server-Side Rendered (SSR) App with Vite By Errong Leng – 21 Nov 2023 – View online → Photo by Artboard Studio / Unsplash Building a Server-Side Rendered (SSR) app involves orchestrating three main components: the frontend app, the SSR render entry, and the server to serve assets and handle backend APIs. In this guide, we'll leverage Vite for the frontend, Node.js and Express for the server, and demonstrate a streamlined development workflow using Nx. Prerequisites Node.js and npm installed Basic understanding of JavaScript, React.js (or your preferred frontend framework), and Express.js Project Structure Before diving into the setup, let's outline the project structure: frontend app src/main.tsx SSR src/main.server.tsx backend app src/server.ts 3 vite configs: vite.config.ts for frontend vite.config.ssr.ts for SSR vite.config.server.ts for backend project.json: define build targets you can checkout the full example from github. GitHub - lengerrong/nx-vite-ssr-react-app Contribute to lengerrong/nx-vite-ssr-react-app development by creating an account on GitHub. GitHub•lengerrong vite.config.ts fronend app config just a normal Vite default config. export default defineConfig({ plugins: [ react(),  // import your frontend framework plugin nxViteTsPaths(), ], }); vite.config.ssr.ts SSR config export default defineConfig({ plugins: [ react(),  //yes, we need the same plugin here nxViteTsPaths(), ], build: { target: "esnext", rollupOptions: { external: ["fsevents", "esbuild", "vite", "fs", "path", "https", "http", "tls", "net", "zlib", "stream", "tty", "os", "crypto", "util"], output: { dynamicImportInCjs: true } }, copyPublicDir: false, // not copy public assets minify: false }, optimizeDeps: { esbuildOptions: { target: "esnext" }, force: true }, ssr: { // for production standalone deployment. bundle everything except the above external // so that await import main.server.mjs no need any dpes under node_modules noExternal: process.env["NX_TASK_TARGET_CONFIGURATION"] === "production" ? true : undefined } }); vite.config.server.ts backend server config same as vite.config.ssr.ts, but remove frontend plugin. Perhaps more externals need to specify not bundle for production build. Project Build Structure: project.json production build, depends on 3 parts "build": { "dependsOn": ["browser-build", "ssr-build", "server-build"], "executor": "nx:run-commands", "options": { "commands": [{ "command":"echo 'build done'" }] } }, browser build "browser-build": { "executor": "@nx/vite:build", "outputs": ["{options.outputPath}"], "defaultConfiguration": "production", "options": { "outputPath": "dist/apps/activate/browser" }, "configurations": { "development": { "mode": "development" }, "production": { "mode": "production" } } }, SSR build: use ssr and specify configFile "emptyOutDir" needs set to false, since we are using the same output path for backend entry. "ssr-build": { "executor": "@nx/vite:build", "outputs": ["{options.outputPath}"], "defaultConfiguration": "production", "options": { "emptyOutDir": false, "outputPath": "dist/apps/activate/server", "ssr": "src/main.server.tsx", "configFile": "apps/activate/vite.config.ssr.ts" }, "configurations": { "development": { "mode": "development" }, "production": { "mode": "production" } } }, Backend Build similar to SSR, use different configFile. We also need to specify the "outputFileName" as well, otherwise you will get an error while work with @nx/js:node executor. "server-build": { "executor": "@nx/vite:build", "outputs": ["{options.outputPath}"], "defaultConfiguration": "production", "options": { "outputPath": "dist/apps/activate/server", "ssr": "src/server.ts", "configFile": "apps/activate/vite.config.server.ts", "emptyOutDir": false, "outputFileName": "server.mjs" }, "configurations": { "development": { "mode": "development" }, "production": { "mode": "production" } } }, Server.ts Set SSR with Vite, please refer to https://vitejs.dev/guide/ssr. This server.ts is doing exactly same follow the doc. app.use('*', async (req, res) => { let template; if (process.env["NODE_ENV"] === "production") { template = fs.readFileSync(path.resolve(fileURLToPath(import.meta.url), '../../browser/index.html')).toString(); const { ssrRender } = await import(path.resolve(fileURLToPath(import.meta.url), '../main.server.mjs')); ssrRender(template, req, res); res.status(200); } else { const url = req.originalUrl // always read fresh template in dev template = fs.readFileSync(path.resolve(vite.config.root, './index.html'), 'utf-8') template = await vite.transformIndexHtml(url, template) const { ssrRender } = await vite.ssrLoadModule('/src/main.server.tsx'); ssrRender(template, req, res); } }) Serve Let's server our SSR app. "serve": { "executor": "@nx/js:node", "defaultConfiguration": "development", "options": { "buildTarget": "activate:build" }, "configurations": { "development": { "buildTarget": "activate:server-build:development" }, "production": { "buildTarget": "activate:server-build:production", "waitUntilTargets": ["activate:browser-build:production", "activate:ssr-build:production"] } } }, As you can observe, for development, you just need compile one file: server.ts. The server just started in less than 50ms. All the frontend part will be take over by Vite Dev Server and provide fast build, HMR and more. Conclusion Congratulations! You've successfully set up a Server-Side Rendered (SSR) app with Vite and Express, creating a powerful and efficient web application with benefits on both the frontend and backend. By leveraging Vite's capabilities for rapid frontend development, you've harnessed features like Hot Module Replacement (HMR) for instantaneous updates during development. Combining this with an Express server allows you to achieve server-side rendering, providing improved performance and search engine optimization. The use of Nx has streamlined your development workflow, enabling watch mode for both frontend and backend applications. This ensures that any changes made to your code trigger automatic rebuilds, enhancing productivity and reducing development time. As you move forward, consider exploring additional features and optimizations for your SSR app, such as: Optimizing SSR Render Entry: Fine-tune the SSR render entry point for performance improvements and better server-side rendering results. Middleware and API Enhancements: Extend your Express server with middleware for additional functionalities and enhance your backend APIs to meet the requirements of your application. Testing and Deployment Strategies: Implement thorough testing procedures for both the frontend and backend components. Explore deployment options, such as containerization or serverless architectures, based on your application's needs. Remember to refer to official documentation and community resources for ongoing support and updates on the tools and frameworks you've used in this setup. Now, with a robust SSR app in place, you're well-equipped to deliver a seamless user experience while taking advantage of the best features that Vite and Express have to offer. Happy coding! Post, Code and Quiet Time. © 2023 – Unsubscribe

Building an Backend App with Vite: A Comprehensive Guide

Introduction: Leveraging Vite for Express Backend Development Traditionally recognized as a powerful frontend build tool, Vite has become synonymous with rapid development, efficient bundling, and seamless hot module replacement in the world of web development. However, the utility of Vite extends beyond the boundaries of frontend applications, making it a compelling choice for optimizing the development workflow of Express backend applications. In this guide, we'll explore how you can harness

Post, Code and Quiet Time. Building an Backend App with Vite: A Comprehensive Guide By Errong Leng – 20 Nov 2023 – View online → Photo by Monika Borys / Unsplash Introduction: Leveraging Vite for Express Backend Development Traditionally recognized as a powerful frontend build tool, Vite has become synonymous with rapid development, efficient bundling, and seamless hot module replacement in the world of web development. However, the utility of Vite extends beyond the boundaries of frontend applications, making it a compelling choice for optimizing the development workflow of Express backend applications. In this guide, we'll explore how you can harness the speed and configurability of Vite to streamline the development and build processes of your Express backend. By merging the strengths of Vite's build system with the robustness of Express, developers can achieve a harmonious blend of efficiency and performance, ultimately enhancing the overall development experience. This exploration into using Vite with Express opens up new possibilities for developers seeking to unify their stack, providing a cohesive environment that facilitates rapid iteration, code splitting, and a modern development experience for both frontend and backend components. Join us on this journey as we delve into the steps of setting up, configuring, and integrating Vite within an Express application, unlocking a synergistic approach that promises to redefine your backend development workflow. Step 1: Creating an Express App via Nx In this initial step, we'll leverage Nx, a powerful toolkit for monorepo development, to scaffold our Express app. Install Nx CLI: Start by installing Nx globally on your machine: npm install -g create-nx-workspace Create Express App: Use Nx to generate a new Express app within your workspace: npx create-nx-workspace --preset=express Explore Nx Express Capabilities: Take a moment to explore the Nx capabilities for Express development. Nx simplifies monorepo management, making it an ideal choice for projects of any scale. Executing task: npx nx run vite-backend-app:serve nx run vite-backend-app:serve:development chunk (runtime: main) main.js (main) 841 bytes [entry] [rendered] webpack compiled successfully (1ac9127e4c838d67) Debugger listening on ws://localhost:9229/85766bec-fca0-4272-8092-1305151fed78 Debugger listening on ws://localhost:9229/85766bec-fca0-4272-8092-1305151fed78 For help, see: https://nodejs.org/en/docs/inspector Listening at http://localhost:3333/api curl http://localhost:3333/api {"message":"Welcome to vite-backend-app!"}% @nx/webpack:webpack is the default build tool Step 2: Modifying the Express App to Use Vite Integrating Vite for Streamlined Development Now that our Express app is set up, let's seamlessly integrate Vite to supercharge the development process. Install Vite deps and use it as build npm install --save-dev @nx/vite build looks good. First serve error: The "path" argument must be of type string. Received undefined Check this fix, "outputFileName": "main.mjs" @nrwl/js:node can’t work with @nrwl/vite:build · Issue #14760 · nrwl/nx I’d be willing to implement this feature (contributing guide) Description I have a build target build by vite build executor. “build”: { “executor”: ”@nrwl/vite:build”, “outputs”: [”{options.output... GitHub•nrwl Run time error: ReferenceError: __dirname is not defined in ES module scope The __dirname variable is commonly used in CommonJS modules to get the directory name of the current module. However, in ECMAScript (ES) modules, which have a different module syntax (import and export), __dirname is not available by default. To address the ReferenceError: __dirname is not defined issue in an ES module, you can use the following workaround: Use import.meta.url: In an ES module, you can use import.meta.url to get the URL of the current module file and then extract the directory name. Here's an example:javascriptCopy codeimport { fileURLToPath } from 'url'; import { dirname } from 'path'; const __filename = fileURLToPath(import.meta.url); const __dirname = dirname(__filename); // Now you can use __dirname in your code console.log(__dirname); In this example, the fileURLToPath function from the 'url' module is used to convert the import.meta.url to a file path, and then the dirname function from the 'path' module is used to get the directory name. Use Node.js __filename and __dirname global variables: If you are running your code in a Node.js environment, you can use the __filename and __dirname global variables directly without the need for import.meta.url:javascriptCopy code// This check is necessary to avoid issues when using this code in a bundler if(typeof __filename === 'undefined') { global.__filename = import.meta.url;global.__dirname = path.dirname(import.meta.url); } // Now you can use __dirname in your code console.log(__dirname); This code sets __filename and __dirname as global variables if they are not defined, making them accessible throughout the module. Choose the approach that best fits your environment and requirements. If you're working in a modern ES module environment, the first approach is recommended. If you're working in a Node.js environment, the second approach might be more straightforward. Modify main.ts, Save it, HMR works and server restarted automatically for you. The same out come for the api. Conclusion: In this guide, we embarked on a journey to unite Express backend development with the cutting-edge capabilities of Vite. By leveraging Nx for project structuring and seamlessly integrating Vite into our Express app, we've redefined the backend development workflow. This fusion presents a powerful toolkit for developers, offering efficiency, performance, and a unified environment for frontend and backend components. As you experiment with these techniques, you'll discover the endless possibilities that arise from the integration of Vite with Express. The synergy achieved promises to elevate your development experience, providing a modern and efficient foundation for building web applications. Embrace this convergence, explore the nuances, and unlock the full potential of combining Vite with Express in your projects. Checkout the full example from github. Post, Code and Quiet Time. © 2023 – Unsubscribe

Automate Form Filling in PDFs Using iText 5 Library in Java

Have you ever needed to automatically fill out PDF forms with preset data using a Java application? In this post, we'll explore how to achieve this using the iText 5 library. iText is a popular Java library for creating and manipulating PDF documents, including form filling. We'll walk you through the steps to load an existing PDF form, access form fields, set values, and even flatten the form to make it read-only. Let's get started. Step 1: Add iText 5 Library Before we begin, ensure that you

Post, Code and Quiet Time. Automate Form Filling in PDFs Using iText 5 Library in Java By Errong Leng – 23 Oct 2023 – View online → Photo by GoodNotes 5 / Unsplash Have you ever needed to automatically fill out PDF forms with preset data using a Java application? In this post, we'll explore how to achieve this using the iText 5 library. iText is a popular Java library for creating and manipulating PDF documents, including form filling. We'll walk you through the steps to load an existing PDF form, access form fields, set values, and even flatten the form to make it read-only. Let's get started. Step 1: Add iText 5 Library Before we begin, ensure that you have the iText 5 library added to your Java project. You can download the iText 5 JAR files from the official website or use dependency management tools like Maven or Gradle. Step 2: Load the PDF Form Load the existing PDF form that you want to fill. You can do this using the PdfReader class in iText: PdfReader reader = new PdfReader("path/to/your/form.pdf"); PdfStamper stamper = new PdfStamper(reader, new FileOutputStream("path/to/output.pdf")); Step 3: Access Form Fields To access form fields in the PDF, you can use the AcroFields class. Set values in the form fields using the setField method: AcroFields form = stamper.getAcroFields(); form.setField("FieldName1", "Value1"); form.setField("FieldName2", "Value2"); // Set values for other form fields as needed Replace "FieldName1", "FieldName2", and "Value1", "Value2" with the actual field names and values you want to set. Step 4: Flatten the Form (Optional) If you want to make the form read-only after filling it, you can use the setFormFlattening(true) method on the PdfStamper object: stamper.setFormFlattening(true); Step 5: Close and Save the PDF After filling the form fields, close the PdfStamper and save the PDF: stamper.close(); Your filled PDF will be saved as specified in the output path. Here's a complete example: import com.itextpdf.text.pdf.PdfReader; import com.itextpdf.text.pdf.PdfStamper; import com.itextpdf.text.pdf.AcroFields; import java.io.FileOutputStream; public class PdfFormFiller { public static void main(String[] args) { try { PdfReader reader = new PdfReader("path/to/your/form.pdf"); PdfStamper stamper = new PdfStamper(reader, new FileOutputStream("path/to/output.pdf")); AcroFields form = stamper.getAcroFields(); form.setField("FieldName1", "Value1"); form.setField("FieldName2", "Value2"); // Set values for other form fields as needed stamper.setFormFlattening(true); stamper.close(); } catch (Exception e) { e.printStackTrace(); } } } This process allows you to automate form filling in PDFs, making it convenient for applications that require bulk data entry or report generation. Just replace file paths and field names/values as needed, and you're ready to go! Post, Code and Quiet Time. © 2023 – Unsubscribe

Efficient File Transfer: Pushing and Pulling Files Between a Spring Boot App and an sFTP Server

Are you a developer looking to seamlessly exchange files between your Spring Boot application and an sFTP server? Whether it's pushing files from your app to the server or pulling files from the server to your app, this post will guide you through the process. In this tutorial, we'll cover the steps for both operations to make your file transfers smooth and reliable. Pushing Files from Spring Boot to sFTP Server 1. Dependency Setup: First, make sure your Spring Boot project is equipped with t

Post, Code and Quiet Time. Efficient File Transfer: Pushing and Pulling Files Between a Spring Boot App and an sFTP Server By Errong Leng – 23 Oct 2023 – View online → Photo by Marc Kleen / Unsplash Are you a developer looking to seamlessly exchange files between your Spring Boot application and an sFTP server? Whether it's pushing files from your app to the server or pulling files from the server to your app, this post will guide you through the process. In this tutorial, we'll cover the steps for both operations to make your file transfers smooth and reliable. Pushing Files from Spring Boot to sFTP Server Dependency Setup: First, make sure your Spring Boot project is equipped with the necessary dependencies to interact with an sFTP server. You can add the spring-integration-sftp library to your project. Configure sFTP Connection: Create a configuration file to set up the sFTP connection parameters, including the host, port, username, and password. Develop the File Push Logic: Write the Java code to handle file push operations. You can use Spring Integration to create a flow that monitors a local directory for files to be pushed to the sFTP server. Error Handling: Implement error handling mechanisms to deal with potential issues during the file transfer process. This ensures the reliability of your file transfer operations. Testing: Thoroughly test the file push functionality to ensure that files are transferred successfully to the sFTP server. Pulling Files from sFTP Server to Spring Boot Dependency Setup: Similar to the file push operation, ensure you have the necessary dependencies to interact with the sFTP server. Configure sFTP Connection: Create a configuration file with the sFTP connection details, just as you did for the file push operation. Develop the File Pull Logic: Write Java code that monitors the sFTP server for files and pulls them into your Spring Boot application. Again, Spring Integration can be used for this purpose. Error Handling: Implement error handling to manage issues that may occur during the file retrieval process. Testing: Rigorously test the file pull functionality to ensure that files are pulled successfully from the sFTP server and stored in your Spring Boot app. Setting Up a Free sFTP Server For those looking to get started with sFTP, you can set up a free sFTP server for your development needs. Here are a couple of popular options: FileZilla Server: FileZilla is a widely used open-source FTP server that also supports sFTP. You can set up FileZilla Server on your local machine or on a dedicated server. Detailed installation and configuration instructions can be found here. OpenSSH: If you're working on a Unix-based system, you can use OpenSSH as your sFTP server. Most Linux distributions come with OpenSSH pre-installed. You can configure it for sFTP by following instructions specific to your OS. Code in Java Below is a Java code example that demonstrates how to set up an sFTP connection using the JSch library, connect via a username and public key authentication, and perform sFTP operations such as pushing a file, pulling a file, and performing an ls (list directory) lookup. Make sure to add the JSch library to your project's dependencies. import com.jcraft.jsch.*; public class SftpExample { public static void main(String[] args) { String host = "sftp.example.com"; int port = 22; String username = "your_username"; String privateKeyPath = "/path/to/your/private-key"; String passphrase = "your_passphrase"; String remoteDirectory = "/path/to/remote/directory/"; try { JSch jsch = new JSch(); // Load the private key jsch.addIdentity(privateKeyPath, passphrase); // Create an sFTP session Session session = jsch.getSession(username, host, port); session.setConfig("PreferredAuthentications", "publickey,keyboard-interactive,password"); session.setConfig("StrictHostKeyChecking", "no"); // Disable host key checking (for development purposes only) session.connect(); // Push a file to the remote directory ChannelSftp channelSftp = (ChannelSftp) session.openChannel("sftp"); channelSftp.connect(); String localFilePath = "/path/to/local/file.txt"; channelSftp.put(localFilePath, remoteDirectory); channelSftp.disconnect(); // Pull a file from the remote directory channelSftp = (ChannelSftp) session.openChannel("sftp"); channelSftp.connect(); String remoteFileName = "file.txt"; // The name of the file on the remote server String localDownloadPath = "/path/to/local/downloaded/file.txt"; channelSftp.get(remoteDirectory + remoteFileName, localDownloadPath); channelSftp.disconnect(); // List files in the remote directory channelSftp = (ChannelSftp) session.openChannel("sftp"); channelSftp.connect(); @SuppressWarnings("unchecked") Vector<ChannelSftp.LsEntry> fileList = channelSftp.ls(remoteDirectory); for (ChannelSftp.LsEntry entry : fileList) { System.out.println(entry.getFilename()); } channelSftp.disconnect(); // Close the sFTP session session.disconnect(); } catch (JSchException | SftpException e) { e.printStackTrace(); } } } Remember to replace placeholders like sftp.example.com, your_username, your_passphrase, and file paths with your actual information. This code connects to the sFTP server, pushes a file, pulls a file, and lists the files in the remote directory. Be cautious about security and best practices when dealing with sensitive data and private keys. Security Considerations Remember to secure your sFTP operations by using secure, encrypted connections and ensuring that your credentials are stored and managed securely. Consider using environment-specific properties or secret management tools to keep sensitive information safe. In conclusion, efficient file transfer between a Spring Boot application and an sFTP server is a crucial part of many systems. By following these steps and best practices, you can ensure that your file transfer operations are reliable and secure. Whether you're pushing files to the server or pulling files from it, the process can be made seamless with the right tools and techniques. Happy coding! Post, Code and Quiet Time. © 2023 – Unsubscribe