@funbrew/pdf 1.0.0

package/README.ja.md

@@ -0,0 +1,59 @@
+# @funbrew/pdf
+
+FUNBREW PDF APIのNode.jsクライアントライブラリです。TypeScript型定義付き。
+
+## インストール
+
+```bash
+npm install @funbrew/pdf
+```
+
+## 使い方
+
+```js
+const { FunbrewPdf } = require('@funbrew/pdf');
+
+const pdf = new FunbrewPdf('sk-your-api-key');
+
+// HTML → PDF
+const result = await pdf.fromHtml('<h1>Hello World</h1>');
+console.log(result.data.download_url);
+
+// URL → PDF
+const result = await pdf.fromUrl('https://example.com');
+
+// テンプレート → PDF
+const result = await pdf.fromTemplate('invoice', {
+  company_name: 'FUNBREW Inc.',
+  amount: '100,000',
+});
+
+// PDF生成 + メール送信
+const result = await pdf.fromHtmlWithEmail(
+  '<h1>請求書</h1>',
+  'customer@example.com',
+  '請求書をお送りします',
+);
+
+// テストモード
+const result = await pdf.test('<h1>Test</h1>');
+
+// ダウンロード
+const buffer = await pdf.download('uuid.pdf');
+require('fs').writeFileSync('output.pdf', buffer);
+
+// 利用状況
+const usage = await pdf.usage();
+```
+
+## オプション
+
+```js
+const result = await pdf.fromHtml('<h1>Hello</h1>', {
+  options: { 'page-size': 'A3' },
+  expiration_hours: 168,
+  max_downloads: 5,
+  password: 'secret',
+  watermark: 'CONFIDENTIAL',
+});
+```

package/README.md

@@ -0,0 +1,106 @@
+# @funbrew/pdf
+
+Official Node.js client library for the [FUNBREW PDF API](https://pdf.funbrew.cloud). Includes TypeScript type definitions.
+
+[日本語ドキュメント](README.ja.md)
+
+## Installation
+
+```bash
+npm install @funbrew/pdf
+```
+
+## Quick Start
+
+```js
+const { FunbrewPdf } = require('@funbrew/pdf');
+
+const pdf = new FunbrewPdf('sk-your-api-key');
+
+// HTML to PDF
+const result = await pdf.fromHtml('<h1>Hello World</h1>');
+console.log(result.data.download_url);
+
+// URL to PDF
+const result = await pdf.fromUrl('https://example.com');
+
+// Template to PDF
+const result = await pdf.fromTemplate('invoice', {
+  company_name: 'Acme Inc.',
+  amount: '1,000',
+});
+```
+
+## Features
+
+```js
+// Generate PDF and send via email
+const result = await pdf.fromHtmlWithEmail(
+  '<h1>Invoice</h1>',
+  'customer@example.com',
+  'Your invoice is ready',
+);
+
+// Test mode (no count, TEST watermark)
+const result = await pdf.test('<h1>Test</h1>');
+
+// File operations
+const info = await pdf.info('uuid.pdf');
+const buffer = await pdf.download('uuid.pdf');
+require('fs').writeFileSync('output.pdf', buffer);
+await pdf.delete('uuid.pdf');
+
+// Batch generate
+const batch = await pdf.batch([
+  { type: 'html', html: '<h1>Doc 1</h1>' },
+  { type: 'html', html: '<h1>Doc 2</h1>' },
+]);
+
+// Merge PDFs
+const merged = await pdf.merge(['file1.pdf', 'file2.pdf']);
+
+// Usage stats
+const usage = await pdf.usage();
+```
+
+## Options
+
+```js
+const result = await pdf.fromHtml('<h1>Hello</h1>', {
+  options: { 'page-size': 'A3', engine: 'quality' },
+  expiration_hours: 168,
+  max_downloads: 5,
+  password: 'secret',
+  watermark: 'CONFIDENTIAL',
+});
+```
+
+## TypeScript
+
+Full type definitions are included. No need for `@types` packages.
+
+```ts
+import { FunbrewPdf, PdfResult } from '@funbrew/pdf';
+
+const pdf = new FunbrewPdf('sk-your-api-key');
+const result: PdfResult = await pdf.fromHtml('<h1>Hello</h1>');
+```
+
+## Error Handling
+
+```js
+const { FunbrewPdf, FunbrewError } = require('@funbrew/pdf');
+
+try {
+  const result = await pdf.fromHtml('<h1>Hello</h1>');
+} catch (e) {
+  if (e instanceof FunbrewError) {
+    console.error(e.message);     // Error message
+    console.error(e.statusCode);  // HTTP status code
+  }
+}
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@funbrew/pdf",
+  "version": "1.0.0",
+  "description": "FUNBREW PDF API client for Node.js",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": ["pdf", "api", "html-to-pdf", "funbrew"]
+}

package/src/index.d.ts

@@ -0,0 +1,54 @@
+export interface PdfResult {
+  success: boolean;
+  data: {
+    filename: string;
+    download_url: string;
+    public_url: string | null;
+    file_size: number;
+    expires_at: string;
+    max_downloads: number;
+    remaining_downloads: number;
+    s3_url?: string;
+    test_mode?: boolean;
+  };
+}
+
+export interface PdfOptions {
+  options?: { 'page-size'?: 'A3' | 'A4' | 'A5' | 'Letter' | 'Legal'; engine?: 'fast' | 'quality' };
+  expiration_hours?: number;
+  max_downloads?: number;
+  password?: string;
+  watermark?: string;
+  filename?: string;
+  test?: boolean;
+  email?: { to: string; subject?: string; body?: string };
+}
+
+export interface UsageResult {
+  success: boolean;
+  data: {
+    plan: { name: string; slug: string; monthly_limit: number };
+    usage: { current_month: string; generated: number; remaining: number | null; is_unlimited: boolean };
+    features: Record<string, boolean | { enabled: boolean; limit: number }>;
+  };
+}
+
+export class FunbrewPdf {
+  constructor(apiKey: string, options?: { baseUrl?: string });
+  fromHtml(html: string, options?: PdfOptions): Promise<PdfResult>;
+  fromUrl(url: string, options?: PdfOptions): Promise<PdfResult>;
+  fromTemplate(slug: string, variables?: Record<string, string>, options?: PdfOptions): Promise<PdfResult>;
+  fromHtmlWithEmail(html: string, to: string, subject?: string, body?: string, options?: PdfOptions): Promise<PdfResult>;
+  batch(items: Array<Record<string, any>>): Promise<any>;
+  batchStatus(batchUuid: string): Promise<any>;
+  merge(filenames: string[], options?: Record<string, any>): Promise<PdfResult>;
+  info(filename: string): Promise<any>;
+  download(filename: string): Promise<Buffer>;
+  delete(filename: string): Promise<any>;
+  usage(): Promise<UsageResult>;
+  test(html: string, options?: PdfOptions): Promise<PdfResult>;
+}
+
+export class FunbrewError extends Error {
+  statusCode: number;
+}

package/src/index.js

@@ -0,0 +1,124 @@
+class FunbrewPdf {
+  /**
+   * @param {string} apiKey
+   * @param {object} [options]
+   * @param {string} [options.baseUrl]
+   */
+  constructor(apiKey, { baseUrl = 'https://pdf.funbrew.cloud' } = {}) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl.replace(/\/$/, '');
+  }
+
+  /** Generate PDF from HTML */
+  async fromHtml(html, options = {}) {
+    return this._post('/api/pdf/generate-from-html', { html, ...options });
+  }
+
+  /** Generate PDF from URL */
+  async fromUrl(url, options = {}) {
+    return this._post('/api/pdf/generate-from-url', { url, ...options });
+  }
+
+  /** Generate PDF from template */
+  async fromTemplate(slug, variables = {}, options = {}) {
+    return this._post('/api/pdf/generate-from-template', {
+      template: slug,
+      variables,
+      ...options,
+    });
+  }
+
+  /** Generate PDF and send via email */
+  async fromHtmlWithEmail(html, to, subject = '', body = '', options = {}) {
+    const email = { to };
+    if (subject) email.subject = subject;
+    if (body) email.body = body;
+    return this.fromHtml(html, { ...options, email });
+  }
+
+  /** Get PDF file info */
+  async info(filename) {
+    return this._get(`/api/pdf/info/${filename}`);
+  }
+
+  /** Download PDF file as Buffer */
+  async download(filename) {
+    const res = await fetch(`${this.baseUrl}/api/pdf/download/${filename}`, {
+      headers: { Authorization: `Bearer ${this.apiKey}` },
+    });
+    if (!res.ok) throw new FunbrewError('Download failed', res.status);
+    return Buffer.from(await res.arrayBuffer());
+  }
+
+  /** Delete PDF file */
+  async delete(filename) {
+    return this._request('DELETE', `/api/pdf/delete/${filename}`);
+  }
+
+  /** Batch generate multiple PDFs */
+  async batch(items) {
+    return this._post('/api/pdf/batch', { items });
+  }
+
+  /** Get batch status */
+  async batchStatus(batchUuid) {
+    return this._get(`/api/pdf/batch/${batchUuid}`);
+  }
+
+  /** Merge multiple PDFs into one */
+  async merge(filenames, options = {}) {
+    return this._post('/api/pdf/merge', { filenames, ...options });
+  }
+
+  /** Get usage information */
+  async usage() {
+    return this._get('/api/usage');
+  }
+
+  /** Generate PDF in test mode */
+  async test(html, options = {}) {
+    return this.fromHtml(html, { ...options, test: true });
+  }
+
+  async _get(path) {
+    return this._request('GET', path);
+  }
+
+  async _post(path, data) {
+    return this._request('POST', path, data);
+  }
+
+  async _request(method, path, data) {
+    const options = {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+      },
+    };
+
+    if (data && method !== 'GET') {
+      options.body = JSON.stringify(data);
+    }
+
+    const res = await fetch(`${this.baseUrl}${path}`, options);
+    const json = await res.json();
+
+    if (!res.ok) {
+      throw new FunbrewError(json.message || 'API request failed', res.status);
+    }
+
+    return json;
+  }
+}
+
+class FunbrewError extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.name = 'FunbrewError';
+    this.statusCode = statusCode;
+  }
+}
+
+module.exports = { FunbrewPdf, FunbrewError };