A Biblioteca PDF do Node.js

Name: IronPDF
Brand: Iron Software
Availability: InStock
Rating: 4.87 (307 reviews)

Explore IronPDF for Node.js Comece seu teste gratuito

HTML para PDF

Online Demo Veja todos os exemplos de código %s

import {PdfDocument} from "@ironsoftware/ironpdf";

(async () => {
    // Create a PDF from an HTML string
    const pdf = await PdfDocument.fromHtml("<h1>Hello World</h1>");

    // Export the PDF to a file
    await pdf.saveAs("output.pdf");

    // Advanced Example with HTML Assets
    // Load external HTML assets: Images, CSS, and JavaScript.
    const htmlContentWithAssets = "<img src='icons/iron.png'>";
    const advancedPdf = await PdfDocument.fromHtml(htmlContentWithAssets);

    // Save the PDF with loaded assets
    await advancedPdf.saveAs("html-with-assets.pdf");
})();

import {PdfDocument} from "@ironsoftware/ironpdf";

(async () => {
    // Create a PDF from an HTML string
    const pdf = await PdfDocument.fromHtml("<h1>Hello World</h1>");

    // Export the PDF to a file
    await pdf.saveAs("output.pdf");

    // Advanced Example with HTML Assets
    // Load external HTML assets: Images, CSS, and JavaScript.
    const htmlContentWithAssets = "<img src='icons/iron.png'>";
    const advancedPdf = await PdfDocument.fromHtml(htmlContentWithAssets);

    // Save the PDF with loaded assets
    await advancedPdf.saveAs("html-with-assets.pdf");
})();

AJUDA DO NODE

oauth2orize NPM (Como funciona para desenvolvedores)

Curtis Chau

Updated: 20 de junho de 2026

A criação de conteúdo dinâmico e a segurança robusta são essenciais para os aplicativos web atuais. Ao permitir que os aplicativos forneçam acesso restrito ou limitado a recursos em nome de um usuário sem revelar suas credenciais, o OAuth 2.0 se tornou a estrutura padrão para autorização segura. O módulo adaptável para Node.js, OAuth2orize, fornece uma estrutura robusta para gerenciar a autenticação segura baseada em tokens de acesso, facilitando a configuração de servidores de autorização OAuth 2.0.

Ao mesmo tempo, uma demanda típica em diversas áreas, incluindo a produção de relatórios e sistemas de faturamento, é a capacidade de gerar e manipular documentos PDF programaticamente. A geração, edição e renderização de documentos PDF simples tornam-se mais fáceis com o IronPDF, um utilitário poderoso no ambiente Node.js

Este tutorial ensina como criar uma aplicação Node.js dinâmica e segura, combinando os melhores recursos do IronPDF e do OAuth2orize. Você descobrirá como lidar com a autenticação e autorização de usuários configurando um servidor OAuth 2.0 com o OAuth2orize. Você também aprenderá a usar o IronPDF para criar documentos PDF acessíveis por meio de endpoints de API que exigem autenticação.

O que é OAuth2orize?

Um framework Node.js chamado OAuth2orize fornece aos desenvolvedores os recursos necessários para criar servidores de autorização OAuth 2.0. Auxilia no manuseio e gerenciamento do complexo fluxo de trabalho do OAuth 2.0, que inclui a criação, validação e administração de tokens de atualização. Como esta biblioteca foi projetada para interagir com o framework Express, desenvolvedores que já estão familiarizados com o Express acharão que ela se encaixa perfeitamente.

oauth2orize NPM (Como Funciona para Desenvolvedores): Figura 1 - OAuth2orize

Características e componentes detalhados do OAuth2orize

Tipos de Subvenções Apoio

A atribuição de um código de autorização é mais adequada para aplicações do lado do servidor, nas quais o código de autorização pode ser armazenado com segurança pelo cliente e, posteriormente, trocado por um token de acesso.

Concessão implícita: Adequada para programas do lado do cliente, como aplicativos de página única, nos quais o cliente recebe o token de acesso imediatamente.
Concessão de credenciais de senha do proprietário do recurso: geralmente aplicada a clientes de primeira parte, essa opção é útil quando o proprietário do recurso e o cliente têm um relacionamento de confiança.
Concessão de credenciais do cliente: Utilizada em interações entre máquinas (servidores e clientes) nas quais o cliente precisa se autenticar usando solicitações de API para receber um token de acesso.

Integração de middleware

Middleware do Express: O OAuth2orize se integra facilmente à arquitetura de roteamento e middleware do Express, funcionando como middleware dentro de uma aplicação Express.
Integração com Passport.js: O OAuth2orize integra-se perfeitamente com o Passport.js, um middleware de autenticação rico em recursos para Node.js, permitindo que os desenvolvedores usem uma variedade de técnicas de autenticação além do OAuth 2.0.

Gerenciamento de Tokens

Tokens de acesso: Tokens transitórios que concedem acesso a recursos são restritos.
Tokens de atualização: São tokens de longa duração que permitem aos usuários obter novos tokens de acesso sem precisar se autenticar novamente.

Subvenções e Prorrogações Personalizadas

Graças à grande adaptabilidade do OAuth2orize, os desenvolvedores podem criar tipos de concessão e tipos de resposta personalizados para atender aos requisitos de aplicativos específicos.

Pontos de segurança importantes a lembrar

O OAuth2orize gerencia a emissão, validação e revogação de tokens de forma segura, promovendo aplicações OAuth 2.0 seguras. Recomenda-se que os desenvolvedores sigam as melhores práticas do OAuth 2.0, que incluem a utilização de HTTPS, a validação de URIs de redirecionamento e o armazenamento de tokens em um local seguro.

Criar e configurar o OAuth2orize

Siga estas instruções para configurar e estabelecer um servidor de autorização OAuth 2.0 em Node.js usando o OAuth2orize. Definiremos os tipos de concessão, criaremos APIs para autorização e troca de tokens e colocaremos um servidor de autorização em funcionamento. Para autenticação de usuários nesta configuração, serão utilizados Passport.js, OAuth2orize e Express.

Instalar dependências

Primeiro, inicialize seu projeto Node.js e instale as dependências necessárias.

npm install express 
npm install oauth2orize  
npm install passport 
npm install passport-local 
npm install passport-http  
npm install body-parser
npm install passport-http-bearer
npm install express-session uuid
npm install connect-ensure-login

npm install express 
npm install oauth2orize  
npm install passport 
npm install passport-local 
npm install passport-http  
npm install body-parser
npm install passport-http-bearer
npm install express-session uuid
npm install connect-ensure-login

SHELL

Criar o servidor de autorização

Para configurar o servidor, crie um arquivo chamado server.js e adicione o seguinte código a ele:

const express = require('express');
const oauth2orize = require('oauth2orize');
const passport = require('passport');
const LocalStrategy = require('passport-local').Strategy;
const BasicStrategy = require('passport-http').BasicStrategy;
const BearerStrategy = require('passport-http-bearer').Strategy;
const bodyParser = require('body-parser');
const session = require('express-session');
const { v4: uuidv4 } = require('uuid');

// In-memory data storage (use a database in production)
const users = [{ id: '1', username: 'user', password: 'pass' }];
const clients = [{ id: 'client', secret: 'secret', redirectUris: ['http://localhost:3000/cb'] }];
const tokens = [];

// Passport configuration for session management
passport.serializeUser((user, done) => done(null, user.id));
passport.deserializeUser((id, done) => {
    const user = users.find(user => user.id === id);
    done(null, user);
});

// Local strategy for username and password login
passport.use(new LocalStrategy((username, password, done) => {
    const user = users.find(user => user.username === username && user.password === password);
    if (user) return done(null, user);
    return done(null, false);
}));

// Basic strategy for client ID and secret authentication
passport.use(new BasicStrategy((clientId, clientSecret, done) => {
    const client = clients.find(client => client.id === clientId && client.secret === clientSecret);
    if (client) return done(null, client);
    return done(null, false);
}));

// Bearer strategy for access token authentication
passport.use(new BearerStrategy((token, done) => {
    const accessToken = tokens.find(t => t.accessToken === token);
    if (accessToken) {
        const user = users.find(user => user.id === accessToken.userId);
        if (user) return done(null, user);
    }
    return done(null, false);
}));

// Create OAuth 2.0 server
const server = oauth2orize.createServer();

// Grant authorization codes
server.grant(oauth2orize.grant.code((client, redirectUri, user, ares, done) => {
    const code = uuidv4();
    tokens.push({ code, clientId: client.id, redirectUri, userId: user.id });
    done(null, code);
}));

// Exchange authorization codes for access tokens
server.exchange(oauth2orize.exchange.code((client, code, redirectUri, done) => {
    const token = tokens.find(t => t.code === code && t.clientId === client.id && t.redirectUri === redirectUri);
    if (!token) return done(null, false);
    const accessToken = uuidv4();
    tokens.push({ accessToken, userId: token.userId, clientId: client.id });
    done(null, accessToken);
}));

// Express application setup
const app = express();
app.use(bodyParser.urlencoded({ extended: true }));
app.use(session({ secret: 'secret', resave: false, saveUninitialized: false }));
app.use(passport.initialize());
app.use(passport.session());

// Authorization endpoint
app.get('/authorize', (req, res) => {
    res.send('<form action="/authorize/decision" method="post"><button type="submit">Allow</button></form>');
});

// Decision endpoint for authorization
app.post('/authorize/decision', (req, res, next) => {
    server.decision()(req, res, next);
});

// Token endpoint for exchanging authorization codes for access tokens
app.post('/token', 
    passport.authenticate('basic', { session: false }),
    server.token(),
    server.errorHandler()
);

// Protected resource endpoint
app.get('/resource', passport.authenticate('bearer', { session: false }), (req, res) => {
    res.json({ message: 'Access granted to protected resource!' });
});

// Start the server
const port = 3000;
app.listen(port, () => {
    console.log(`OAuth2orize server is running on http://localhost:${port}`);
});

const express = require('express');
const oauth2orize = require('oauth2orize');
const passport = require('passport');
const LocalStrategy = require('passport-local').Strategy;
const BasicStrategy = require('passport-http').BasicStrategy;
const BearerStrategy = require('passport-http-bearer').Strategy;
const bodyParser = require('body-parser');
const session = require('express-session');
const { v4: uuidv4 } = require('uuid');

// In-memory data storage (use a database in production)
const users = [{ id: '1', username: 'user', password: 'pass' }];
const clients = [{ id: 'client', secret: 'secret', redirectUris: ['http://localhost:3000/cb'] }];
const tokens = [];

// Passport configuration for session management
passport.serializeUser((user, done) => done(null, user.id));
passport.deserializeUser((id, done) => {
    const user = users.find(user => user.id === id);
    done(null, user);
});

// Local strategy for username and password login
passport.use(new LocalStrategy((username, password, done) => {
    const user = users.find(user => user.username === username && user.password === password);
    if (user) return done(null, user);
    return done(null, false);
}));

// Basic strategy for client ID and secret authentication
passport.use(new BasicStrategy((clientId, clientSecret, done) => {
    const client = clients.find(client => client.id === clientId && client.secret === clientSecret);
    if (client) return done(null, client);
    return done(null, false);
}));

// Bearer strategy for access token authentication
passport.use(new BearerStrategy((token, done) => {
    const accessToken = tokens.find(t => t.accessToken === token);
    if (accessToken) {
        const user = users.find(user => user.id === accessToken.userId);
        if (user) return done(null, user);
    }
    return done(null, false);
}));

// Create OAuth 2.0 server
const server = oauth2orize.createServer();

// Grant authorization codes
server.grant(oauth2orize.grant.code((client, redirectUri, user, ares, done) => {
    const code = uuidv4();
    tokens.push({ code, clientId: client.id, redirectUri, userId: user.id });
    done(null, code);
}));

// Exchange authorization codes for access tokens
server.exchange(oauth2orize.exchange.code((client, code, redirectUri, done) => {
    const token = tokens.find(t => t.code === code && t.clientId === client.id && t.redirectUri === redirectUri);
    if (!token) return done(null, false);
    const accessToken = uuidv4();
    tokens.push({ accessToken, userId: token.userId, clientId: client.id });
    done(null, accessToken);
}));

// Express application setup
const app = express();
app.use(bodyParser.urlencoded({ extended: true }));
app.use(session({ secret: 'secret', resave: false, saveUninitialized: false }));
app.use(passport.initialize());
app.use(passport.session());

// Authorization endpoint
app.get('/authorize', (req, res) => {
    res.send('<form action="/authorize/decision" method="post"><button type="submit">Allow</button></form>');
});

// Decision endpoint for authorization
app.post('/authorize/decision', (req, res, next) => {
    server.decision()(req, res, next);
});

// Token endpoint for exchanging authorization codes for access tokens
app.post('/token', 
    passport.authenticate('basic', { session: false }),
    server.token(),
    server.errorHandler()
);

// Protected resource endpoint
app.get('/resource', passport.authenticate('bearer', { session: false }), (req, res) => {
    res.json({ message: 'Access granted to protected resource!' });
});

// Start the server
const port = 3000;
app.listen(port, () => {
    console.log(`OAuth2orize server is running on http://localhost:${port}`);
});

JavaScript

Seguindo estes passos, você utilizou com sucesso o OAuth2orize no Node.js para estabelecer e configurar um servidor de autorização OAuth 2.0. Esta configuração mostra como gerenciar concessões de códigos de autorização, convertê-los em tokens de acesso e usar tokens de portador para proteger os endpoints da API. Considere implementar um tratamento de erros adequado, proteger dados sensíveis e armazenar usuários, clientes e tokens em um banco de dados robusto para um ambiente de produção.

oauth2orize NPM (Como Funciona para Desenvolvedores): Figura 2 - Saída de Autorização

Começando

Para começar a integrar o OAuth2orize e o IronPDF em uma aplicação Node.js , você deve primeiro usar o OAuth2orize para criar um servidor de autorização OAuth 2.0 e o IronPDF para implementar a geração de PDFs. Um tutorial detalhado para ajudá-lo(a) a alcançar esse objetivo pode ser encontrado abaixo.

O que é o IronPDF for Node.js ?

IronPDF for Node.js é um pacote NPM que facilita a criação e modificação de arquivos PDF. Com essa ferramenta, os desenvolvedores podem adicionar cabeçalhos e marcas d'água, combinar várias páginas de PDF, extrair texto e imagens de documentos HTML e realizar diversas outras tarefas. A API intuitiva e a extensa documentação do IronPDF facilitam a criação automática de documentos PDF de alta qualidade pelos desenvolvedores. O IronPDF possui todos os recursos e funcionalidades necessários para aprimorar os fluxos de trabalho de documentos e proporcionar excelentes experiências de usuário em diversos contextos, incluindo a criação de faturas, relatórios e documentação.

oauth2orize NPM (Como Funciona para Desenvolvedores): Figura 3 - IronPDF

Funcionalidades do IronPDF

Converter HTML para PDF: Uma maneira rápida e fácil de lidar com qualquer tipo de texto HTML, incluindo CSS e JavaScript.
Fusão de arquivos PDF: Combine vários documentos PDF em um único arquivo PDF para simplificar as tarefas de gerenciamento de documentos.
Extração de texto e imagem: Remova texto e imagens de arquivos PDF para que você possa utilizá-los em análises posteriores ou processamento de dados.
Marca d'água: Você pode aplicar marcas d'água de texto ou imagem às páginas de PDF para fins de identidade visual ou segurança.
Incluir cabeçalho e rodapé: Você pode adicionar uma mensagem personalizada ou números de página aos cabeçalhos e rodapés de documentos PDF.

Instale o IronPDF

Para habilitar a funcionalidade IronPDF , instale os pacotes Node.js necessários usando o gerenciador de pacotes do Node.

> npm i @ironsoftware/ironpdf

npm i @ironsoftware/ironpdf

Integre o OAuth2orize Node.js com o IronPDF

Adicione o seguinte código ao código do servidor de autorização OAuth 2.0 para integrar o IronPDF para geração de PDFs.

const IronPdf = require("@ironsoftware/ironpdf");
const document = IronPdf.PdfDocument;

// Protected resource endpoint to generate PDF
app.get('/generate-pdf', passport.authenticate('bearer', { session: false }), async (req, res) => {
    // Example HTML content for PDF generation
    const htmlContent = `
    <html>
    <head>
        <title>PDF Report</title>
    </head>
    <body>
        <h1>Secure PDF Report</h1>
        <p>This PDF was generated by IronPDF.</p>
    </body>
    </html>
    `;
    try {
        // Convert HTML content to a PDF document
        const pdf = await document.fromHtml(htmlContent);
        const pdfBuffer = await pdf.saveAsBuffer();
        // Send the PDF as a response
        res.writeHead(200, {
            'Content-Type': 'application/pdf',
            'Content-Disposition': 'attachment; filename=report.pdf',
            'Content-Length': pdfBuffer.length
        });
        res.end(pdfBuffer);
    } catch (error) {
        res.status(500).send('Error generating PDF');
    }
});

const IronPdf = require("@ironsoftware/ironpdf");
const document = IronPdf.PdfDocument;

// Protected resource endpoint to generate PDF
app.get('/generate-pdf', passport.authenticate('bearer', { session: false }), async (req, res) => {
    // Example HTML content for PDF generation
    const htmlContent = `
    <html>
    <head>
        <title>PDF Report</title>
    </head>
    <body>
        <h1>Secure PDF Report</h1>
        <p>This PDF was generated by IronPDF.</p>
    </body>
    </html>
    `;
    try {
        // Convert HTML content to a PDF document
        const pdf = await document.fromHtml(htmlContent);
        const pdfBuffer = await pdf.saveAsBuffer();
        // Send the PDF as a response
        res.writeHead(200, {
            'Content-Type': 'application/pdf',
            'Content-Disposition': 'attachment; filename=report.pdf',
            'Content-Length': pdfBuffer.length
        });
        res.end(pdfBuffer);
    } catch (error) {
        res.status(500).send('Error generating PDF');
    }
});

JavaScript

O código fornecido mostra como integrar o IronPDF para geração dinâmica de PDFs e construir um servidor de autorização OAuth 2.0 usando o OAuth2orize em Node.js Dependências essenciais como Express, Passport e UUID estão incluídas na configuração. Para simplificar, usuários e clientes são salvos em arrays na memória; No entanto, um banco de dados deve ser usado em um ambiente de produção.

O código lida com a validação do cliente e a autenticação do usuário definindo várias técnicas do Passport. A concessão de códigos de autorização, na qual os usuários permitem que os clientes acessem recursos em seu nome, é gerenciada pelo OAuth2orize. O cliente pode trocar um código de autorização por um token de acesso após obtê-lo. Somente solicitações autenticadas têm permissão para criar PDFs graças à técnica de token Bearer usada para proteger o endpoint /generate-pdf.

O conteúdo HTML é convertido pelo endpoint usando o IronPDF em um documento PDF , que é posteriormente retornado ao cliente. Esta integração fornece um exemplo de como usar o OAuth 2.0 para proteger endpoints de API e fornecer conteúdo dinâmico de forma escalável e segura.

oauth2orize NPM (Como Funciona para Desenvolvedores): Figura 4 - OAuth2orize com Saída IronPDF

Conclusão

Em conclusão, o uso do OAuth2orize e do IronPDF em uma aplicação Node.js resulta na geração de PDFs de alta qualidade, de forma robusta e segura. Os dados sensíveis são protegidos, uma vez que o OAuth2orize oferece uma forte autenticação OAuth 2.0, garantindo que apenas usuários autorizados e autenticados possam usar os serviços de criação de PDFs. O IronPDF, por outro lado, torna simples e eficaz a conversão de informações HTML em arquivos PDF de qualidade profissional.

Essa integração oferece aos desenvolvedores uma solução escalável e fácil de implementar, além de melhorar a segurança, a flexibilidade e a experiência do usuário. Com o auxílio dessas tecnologias, os desenvolvedores podem produzir aplicativos que sejam fáceis de usar, confiáveis, seguros e compatíveis com os padrões contemporâneos de segurança e funcionalidade.

Ao adicionar as tecnologias IronPDF e Iron Software à sua pilha de desenvolvimento de aplicativos corporativos, a IronPDF pode garantir soluções de software de alta qualidade e ricas em recursos para clientes e usuários finais. Além disso, iniciativas, sistemas de back-end e otimização de processos serão facilitados por essa base sólida. IronPDF está disponível para $999. Essas tecnologias são uma excelente opção para projetos modernos de desenvolvimento de software devido à sua extensa documentação, comunidade ativa de desenvolvedores online e atualizações regulares.

Curtis Chau

Converse agora mesmo com a equipe de engenharia.

Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.

...