Ultimate Nuxt. js for Full-Stack Web Applications : Build Production-Grade Server-Side Rendering (SSR) and Static-Site Generated (SSG) Vue. js Applications Using Nuxt. js, Node. js, and Composition API (English Edition) / Lau Tiam Kok.

Format:

Book

Author/Creator:

Kok, Lau Tiam, author.

Language:

English

Subjects (All):

Computers.

Internet programming.

Physical Description:

1 online resource (195 pages)

Edition:

First edition.

Place of Publication:

Delhi : Orange Education Pvt Ltd, [2024]

Summary:

Unlock the true potential of Nuxt.js with this comprehensive guide. The book explores the intricacies of Nuxt.js, with a primary focus on addressing scalability challenges inherent in web applications. Readers will acquire the expertise to efficiently separate APIs and data management from Nuxt projects, thereby significantly enhancing maintainability. This journey is complemented by harnessing the potent Nitro Server Engine, enabling the seamless construction of full-stack web applications using Nuxt alone, ensuring a harmonious blend of efficiency and scalability.The book will help navigate the complexities of large-scale Nuxt projects, uncovering the integration of remote Node.js and PHP applications to streamline API and data management processes. Practical insights abound, offering a deep understanding of effective data handling and API management using prominent technologies such as MongoDB, MariaDB, RethinkDB, and GraphQL tailored specifically for Nuxt applications. By the end of the book you will create static site generation (SSG) Nuxt applications paired with WordPress to optimize production performance.

Contents:

Intro

Cover Page

Title Page

Copyright Page

Dedication Page

About the Author

About the Technical Reviewer

Acknowledgements

Preface

Errata

Table of Contents

1. Introducing Advanced Nuxt Web Development

Introduction

Structure

Knowing Nuxt and Starting Nuxt Projects

Types of Apps

Nuxt as Universal SSR Apps and SSG Apps

Starting Nuxt Projects

Exploring the Nuxt Project Directory Structure

Exploring the Project Structure

Discovering the Reserved Directories and Files

Making Custom Configurations in Nuxt Projects

Discovering Configuration Options in `nuxt.config.ts`

Conclusion

2. Creating Pages, Layouts, Composables, Plugins, Utilities, and Middleware

Creating Static and Dynamic Routes

Creating Simple Routes and Pages

Creating Dynamic Routes and Pages

Creating Nested Routes and Pages

Validating Route Params

Catching All Unknown Routes

Creating Static and Dynamic Layouts

Creating Static Layouts with definePageMeta

Creating Dynamic Layouts with `setPageLayout` and Middleware

Creating Dynamic Per-page Layouts with Named `NuxtLayout`

Creating Plugins and Middleware

Creating Plugins with defineNuxtPlugin and provide

Creating Plugins with `defineNuxtPlugin`, `provide`, and `nuxt.config.ts`

Creating Middleware with `defineNuxtRouteMiddleware`

Creating Middleware with `defineNuxtPlugin` and `addRouteMiddleware`

Creating Composables and Utilities

Creating Composables with `export` and `export default`

Using Composables in Plugins

Creating Utilities with export default

3. Managing Assets and Adding UI Frameworks

Adding UI Frameworks: Windi CSS

Adding Windi CSS as Your UI Framework

Creating Responsive Layouts with Windi CSS.

Adding CSS Preprocessors: Less

Adding Less as a CSS Preprocessor

Writing Global Styles with Less

Serving Static Assets

Serving `asset` and `public` Images

Serving Custom Fonts from the `assets` Directory

Serving Dynamic Assets

Requiring `public` Images Dynamically

Requiring assets Images Dynamically

4. Fetching Data and Handling Errors

Fetching Data with `useFetch`

Fetching Remote Data with the `useFetch` API

Creating and Handling HTTP Errors

Handling HTTP Errors with the Nuxt Default Error Page

Handling JavaScript Errors with the Nuxt Default Error Page

Customizing the Error Page for HTTP Errors

Handling HTTP and JavaScript Errors with `error.vue`

Abstracting Error Logic with `&lt

slot&gt

` and `if-else` Blocks

5. Managing States and Stores

Creating Global States with `useState`

Using Custom Composables

Using provide and inject APIs

Using The `useState` API

Creating Data-Persistent Stores with Pinia and Cookies: A Counter

Creating Global States with Pinia

Creating Data-Persistent Stores with Cookies

Creating Stores with Pinia: A Shopping Cart

Creating the Shopping Cart

Creating the Cart Page

Handling Shopping Cart Statuses

Creating Data-Persistent Stores with Pinia, `localStorage`, Cookies, and Redis

Creating Data-Persistent Stores with `localStorage`

Creating a Custom Cookie Composable

Creating Data-Persistent Stores with Cookies, Nitro Web Server, Middleware, and Redis

6. Managing Data with Nitro Server Engine in Nuxt

Creating Server Routes, Server Middleware, Server Plugins, and Server Utilities

Creating Server Routes and Middleware

Creating Server Plugins and Utilities.

Managing Data with In-Memory Data Storage

Using Nitro's In-Memory Data Storage

Managing Data with MongoDB Database

Using MongoDB as Data Storage: MongoDB Server and MongoDB Shell

Fetching Data from MongoDB: MongoDB Drivers and MongoDB GUI

Managing Data with the Nuxt Content Module

Using Nuxt Content as Data Storage

7. Managing Data with Node.js Apps for Nuxt

Creating HMR Node.js HTTP Servers with Vite and the Node.js HTTP Module

Creating a Node.js HTTP Web Server: HMR, Routers, and CORS

Adding and Auto-Importing Composables and Utilities

Serving Assets with the Node.js File System Module

Managing Data with MariaDB

Using MariaDB as Data Storage: MariaDB Server and MariaDB Client

Fetching Data from MariaDB: MariaDB Drivers and MariaDB GUI

Injecting Data with UUID and Timestamp

Managing Data with MongoDB

Fetching Data from MongoDB: Cross-origin Resource Sharing (CORS)

Managing Real-time Data with RethinkDB

Creating Real-time Nuxt Apps with RethinkDB and Socket.IO: Cross-origin Resource Sharing (CORS)

8. Managing Database with PHP Apps for Nuxt

Managing Data with WordPress

Creating Headless WordPress REST APIs

Connecting Nuxt Apps with WordPress REST APIs

Managing Data with PHP PSR Apps

Scaffolding PHP PSR Apps: PSR-4, PSR-7, PSR-15, and CORS

Managing Data with the PSR App and MySQL: MySQL driver, UUID, and Timestamp

Managing Metadata with WordPress for SEO and Open Graph

Managing SEO and Open Graph Metadata with WordPress and Carbon Fields

9. Building GraphQL Layers with MongoDB, WordPress, and GraphQL Tools for Nuxt

Introducing GraphQL and Understanding GraphQL Schema.

Understanding GraphQL Schema and Resolvers by Creating Low-level GraphQL APIs with GraphQL.js Only

Understanding GraphQL Default Resolvers by Creating GraphQL APIs with GraphQL.js and GraphQL Tools

Creating GraphQL Servers with MongoDB and Node.js HTTP API

Creating a GraphQL Server for Nuxt: Node.js HTTP API, GraphQL Tools, MongoDB

Creating GraphQL Servers with WordPress and Node.js HTTP API

Creating a GraphQL Server for Nuxt: Node.js HTTP API, GraphQL Tools, WordPress

10. Creating SSG Sites with Nuxt and WordPress and Going Further

Fetching Data from WordPress for Static Sites

Fetching Data and Generating SSG Sites

Streaming Assets from WordPress for Static Sites

Streaming Assets and Generating SSG Sites

Going Further and Knowing Your Options

Testing Your Nuxt Apps

Deploying Your Nuxt Apps

Knowing Other Nuxt Modules and APIs

Knowing Other SSR and SSG Options

Index.

Notes:

Description based on publisher supplied metadata and other sources.

Description based on print version record.

Includes index.

ISBN:

9788196815141

819681514X

OCLC:

1419870911