docstron 1.0.0

package/lib/resources/Documents.js

@@ -0,0 +1,173 @@
+class Documents {
+    constructor(httpClient) {
+        this.http = httpClient;
+    }
+
+    /**
+     * Generate a PDF document from a template
+     * @param {string} templateId - The template ID
+     * @param {Object} options - Generation options
+     * @param {Object} options.data - Data to populate template placeholders
+     * @param {string} [options.response_type='document_id'] - Respose format - 'pdf', 'json_with_base64' or 'document_id'
+     * @param {string} [options.password] - Optional password to protect the PDF 
+     * @returns {Promise<Object|Buffer>} Generated document (format depends om response_type)
+     */
+
+    async generate(templateId, options = {}) {
+        if (!templateId) {
+            throw new Error('Template ID is required');
+        }
+
+        if (!options.data) {
+            throw new Error('Data is required to generate document');
+        }
+
+        const payload = {
+            template_id: templateId,
+            data: options.data,
+            response_type: options.response_type || 'document_id',
+            ...(options.password && { password: options.password })
+        };
+
+        // For PDF response_type,
+        if (payload.response_type === 'pdf') {
+            const response = await this.http.post('/v1/documents/generate', payload, {
+                responseType: 'arraybuffer',
+            });
+            return response;
+        }
+
+        const response = await this.http.post('/v1/documents/generate', payload);
+        return response.data;
+    }
+
+    /**
+     * Quick generate a PDF  without creating a template first
+     * @param {Object} options - Quick generation options
+     * @param {string} options.html - HTML content with optional placeholders
+     * @param {Object} options.data - Data to populate HTML placeholders
+     * @param {string} [options.response_type='document_id'] - Response format: 'pdf', 'json_with_base64' or 'document_id'
+     * @param {string} [options.extra_css] - Additional CSS styling
+     * @param {boolean} [options.save_template=false] - Whether to save as reusable template
+     * @param {string} [options.application_id] - Required when save template is true
+     * @param {string} [options.password] - Optional password to protect PDF
+     * @returns {Promise<Object|Buffer>} Generated Document (format based on response_type)
+     */
+
+    async quickGenerate(options = {}) {
+        if (!options.html) {
+            throw new Error('HTML content is required');
+        }
+        if (!options.data) {
+            throw new Error('Data is required to generate document');
+        }
+        if (options.save_template && !options.application_id) {
+            throw new Error('application_id is required when save_template is true');
+        }
+
+        // For PDF generation,
+        const payload = {
+            html: options.html,
+            data: options.data,
+            response_type: options.response_type || 'document_id',
+            ...(options.extra_css && { extra_css: options.extra_css }),
+            ...(options.save_template !== undefined && { save_template: options.save_template }),
+            ...(options.application_id && { application_id: options.application_id }),
+            ...(options.password && { password: options.password })
+        }
+
+        if (payload.response_type === 'pdf') {
+            const response = await this.http.post('/v1/documents/quick/generate', payload, {
+                responseType: 'arraybuffer'
+            });
+            return response;
+        }
+
+        const response = await this.http.post('/v1/documents/quick/generate', payload);
+        return response.data;
+    }
+
+    /**
+     * Get document details by ID
+     * @param {string} documentId - the document id
+     * @returns {Promise<Object>} Document details
+     */
+
+    async get(documentId) {
+        if (!documentId) {
+            throw new Error('Document ID is required');
+        }
+
+        const response = await this.http.get(`/v1/documents/${documentId}`);
+        return response.data;
+    }
+
+    /**
+     * List all documents
+     * @returns {Promise<Array>} List of all documents
+     */
+
+    async list() {
+        const response = await this.http.get('/v1/documents');
+        return response.data;
+    }
+
+    /**
+     * Update a document 
+     * @param {string} documentId - The document ID
+     * @param {Object} data - New data to update the document
+     * @returns {Promise<Object>} Updated document
+     */
+
+    async update(documentId, data) {
+        if (!documentId) {
+            throw new Error('Document ID is required');
+        }
+        if (!data) {
+            throw new Error('Data is required to update the document');
+        }
+
+        const response = await this.http.put(`/v1/documents/${documentId}`, { data });
+        return response.data;
+    }
+
+    /**
+     * Delete a document
+     * @param {string} documentId - The document id
+     * @returns {Promise<Object>} Deletion confirmation
+     */
+
+    async delete(documentId) {
+        if (!documentId) {
+            throw new Error('Document ID is required');
+        }
+        const response = await this.http.delete(`/v1/documents/${documentId}`);
+        return response.data;
+    }
+
+    /**
+     * Download a document as a PDF
+     * @param {string} documentId - The document ID
+     * @param {string} [filepath] - Optional file path to save (Node.js only)
+     * @returns {Promise<Buffer>} PDF file as buffer
+     */
+    async download(documentId, filepath) {
+        if (!documentId) {
+            throw new Error('Document ID is required');
+        }
+        const response = await this.http.get(`/v1/documents/download/${documentId}`, {
+            responseType: 'arraybuffer'
+        });
+
+        // If file path is provided and we're in Node.js, save the file
+        if (filepath && typeof require !== undefined) {
+            const fs = require('fs');
+            fs.writeFileSync(filepath, Buffer.from(response));
+            return Buffer.from(response);
+        }
+
+        return Buffer.from(response);
+    }
+}
+
+module.exports = Documents;

package/lib/resources/Templates.js

@@ -0,0 +1,97 @@
+class Templates {
+    constructor(httpClient) {
+        this.http = httpClient;
+    }
+
+
+    /**
+     * Create a new Template
+     * @param {Object} params - Template Parameters
+     * @param {string} params.application_id - The application ID
+     * @param {string} params.name - Template name
+     * @param {string} params.content - HTML content with placeholder
+     * @param {boolean} [params.is_active=true] - Whether template is active
+     * @param {string} [params.extra_css] - Additiional css styling
+     * @returns {Promise<Object>} Cretaed template
+     */
+
+    async create(params) {
+        this._validateCreateParams(params);
+        const response = await this.http.post('/v1/templates', params);
+        return response.data;
+    }
+
+    /**
+     * Get a template by ID
+     * @param {string} templateId - The template ID
+     * @returns {Promise<Object>} Template Details
+     */
+    async get(templateId) {
+        if (!templateId) {
+            throw new Error('Template ID is required');
+        }
+
+        const response = await this.http.get(`/v1/templates/${templateId}`);
+        return response.data;
+    }
+
+    /**
+     * Update an existing template
+     * @param {string} templateId - The template ID
+     * @param {Object} params - Template parameters to update
+     * @returns {Promise<Object>} U*pdated template
+     */
+    async update(templateId, params) {
+        if (!templateId) {
+            throw new Error('Template ID is required');
+        }
+
+        const response = await this.http.put(`/v1/templates/${templateId}`, params);
+        return response.data;
+    }
+
+    /**
+     * Delete a template
+     * @param {string} templateId - The template ID
+     * @returns {Promise<Object>} Delete Confirmation
+     */
+
+    async delete(templateId) {
+        if (!templateId) {
+            throw new Error('Template ID is required');
+        }
+
+        const response = await this.http.delete(`/v1/templates/${templateId}`);
+        return response.data;
+    }
+
+    /**
+     * List all templates for an application
+     * @param {string} applicationId - The application ID
+     * @returns {Promise<Array>} List of templates
+     */
+    async list(applicationId) {
+        if (!applicationId) {
+            throw new Error('Application ID is required');
+        }
+
+        const response = await this.http.get('/v1/templates', {
+            params: { application_id: applicationId }
+        });
+        return response.data;
+    }
+
+    _validateCreateParams(params){
+        if(!params.application_id){
+            throw new Error('application_id is required');        
+        }
+        if(!params.name){
+            throw new Error('name is required');
+        }
+        if(!params.content){
+            throw new Error('content is required');
+        }
+    }
+}
+
+module.exports = Templates;

package/lib/utils/errors.js

@@ -0,0 +1,38 @@
+class DocstronError extends Error{
+    constructor(message, statusCode, response){
+        super(message);
+        this.name = 'DocstronError';
+        this.statusCode = statusCode;
+        this.response = response;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+
+class ValidationError extends DocstronError{
+    constructor(message, errors){
+        super(message, 422, {errors});
+        this.name = 'ValidationError';
+        this.errors = errors;
+    }
+}
+
+class AuthenticationError extends DocstronError{
+    constructor(message){
+        super(message, 401);
+        this.name = 'AuthenticationError';        
+    }
+}
+
+class NotFoundError extends DocstronError{
+    constructor(message){
+        super(message, 404);
+        this.name = 'NotFoundError';
+    }
+}
+
+module.exports = {
+    DocstronError,
+    ValidationError,
+    AuthenticationError,
+    NotFoundError,    
+}

package/lib/utils/httpClient.js

@@ -0,0 +1,68 @@
+const axios = require('axios');
+const {
+    DocstronError,
+    ValidationError,
+    AuthenticationError,
+    NotFoundError
+} = require('./errors');
+
+class HttpClient {
+    constructor(apiKey, baseURL) {
+        this.client = axios.create({
+            baseURL: baseURL,
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            timeout: 30000
+        });
+
+        this.client.interceptors.response.use(
+            (response) => response,
+            (error) => {
+                if (error.response) {
+                    const { status, data } = error.response;
+                    const message = data.message || error.message;
+
+                    switch (status) {
+                        case 401:
+                            throw new AuthenticationError(message);
+                        case 404:
+                            throw new NotFoundError(message);
+                        case 422:
+                            throw new ValidationError(message, data.errors);
+                        default:
+                            throw new DocstronError(message, status, data);
+                    }
+                } else if (error.request) {
+                    throw new DocstronError("No response from server.", 0, null);
+                } else {
+                    throw new DocstronError(error.message, 0, null);
+                }
+            }
+        );
+    }
+
+    async get(url, config = {}) {
+        const response = await this.client.get(url, config);
+        return response.data;
+    }
+
+    async post(url, data, config = {}) {
+        const response = await this.client.post(url, data, config);
+        return response.data;
+    }
+
+    async put(url, data, config = {}) {
+        const response = await this.client.put(url, data, config);
+        return response.data;
+    }
+
+    async delete(url, config = {}) {
+        const response = await this.client.delete(url, config);
+        return response.data;
+    }
+}
+
+module.exports = HttpClient;
+

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "docstron",
+  "version": "1.0.0",
+  "description": "Node.js SDK for Docstron PDF Generation API - Complete Features",
+  "main": "index.js",
+   "scripts": {
+    "test": "node test/test.js",
+    "example": "node examples/basic-usage.js",
+    "example:invoice": "node examples/invoice-template.js",
+    "example:generate": "node examples/generate-pdf.js",
+    "example:quick": "node examples/quick-generate.js",
+    "example:existing": "node examples/generate-from-existing-template.js",
+    "example:batch": "node examples/batch-generate.js",
+    "example:apps": "node examples/manage-applications.js",
+    "example:workflow": "node examples/complete-workflow-with-apps.js"
+  },
+  "keywords": [
+    "pdf",
+    "pdf-generation",
+    "docstron",
+    "api-client",
+    "document",
+    "templates",
+    "applications"
+  ],
+  "author": "CM_Soyza cmsoyza@gmail.com",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ChamithSoyza/doctron-node-sdk"
+  },
+  "dependencies": {
+    "axios": "^1.13.2",
+    "dotenv": "^17.2.3"
+  },
+  "devDependencies": {
+    "eslint": "^8.50.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/test/test.js

@@ -0,0 +1,213 @@
+const Docstron = require('../index');
+
+async function runTests() {
+  console.log('🧪 Docstron SDK v0.1.0 - Test Suite\n');
+
+  // Test 1: SDK Version
+  console.log('Test 1: Check SDK version');
+  try {
+    const version = Docstron.getVersion();
+    console.log(`✅ Version: ${version}\n`);
+  } catch (error) {
+    console.log('❌ Failed:', error.message, '\n');
+  }
+
+  // Test 2: Client initialization with API key
+  console.log('Test 2: Initialize client with API key');
+  try {
+    const client = new Docstron('test-api-key');
+    console.log('✅ Client initialized successfully');
+    console.log('   - Has templates:', typeof client.templates === 'object');
+    console.log('');
+  } catch (error) {
+    console.log('❌ Failed:', error.message, '\n');
+  }
+
+  // Test 3: Client without API key should fail
+  console.log('Test 3: Initialize client without API key (should fail)');
+  try {
+    const client = new Docstron();
+    console.log('❌ Should have thrown an error\n');
+  } catch (error) {
+    console.log('✅ Correctly threw error:', error.message, '\n');
+  }
+
+  // Test 4: Template validation
+  console.log('Test 4: Template create validation');
+  const client = new Docstron('test-key');
+  try {
+    await client.templates.create({});
+    console.log('❌ Should have thrown validation error\n');
+  } catch (error) {
+    console.log('✅ Correctly validated required fields:', error.message, '\n');
+  }
+
+  // Test 5: Custom base URL
+  console.log('Test 5: Initialize with custom base URL');
+  try {
+    const customClient = new Docstron('test-key', {
+      baseURL: 'https://custom.api.com'
+    });
+    console.log('✅ Client accepts custom configuration');
+    console.log('   - Base URL:', customClient.baseURL, '\n');
+  } catch (error) {
+    console.log('❌ Failed:', error.message, '\n');
+  }
+
+  // Test 6: Error exports
+  console.log('Test 6: Error classes are exported');
+  try {
+    const {
+      DocstronError,
+      ValidationError,
+      AuthenticationError,
+      NotFoundError
+    } = require('../index');
+
+    console.log('✅ All error classes exported:');
+    console.log('   - DocstronError:', typeof DocstronError === 'function');
+    console.log('   - ValidationError:', typeof ValidationError === 'function');
+    console.log('   - AuthenticationError:', typeof AuthenticationError === 'function');
+    console.log('   - NotFoundError:', typeof NotFoundError === 'function');
+    console.log('');
+  } catch (error) {
+    console.log('❌ Failed:', error.message, '\n');
+  }
+
+  // Test 7: Documents resource exists
+  console.log('Test 7: Documents resource exists');
+  try {
+    const client = new Docstron('test-key');
+    console.log('✅ Documents resource available:', typeof client.documents === 'object');
+    console.log('   - Has generate:', typeof client.documents.generate === 'function');
+    console.log('   - Has quickGenerate:', typeof client.documents.quickGenerate === 'function');
+    console.log('   - Has download:', typeof client.documents.download === 'function');
+    console.log('');
+  } catch (error) {
+    console.log('❌ Failed:', error.message, '\n');
+  }
+
+  // Test 8: Features check
+  console.log('Test 8: Check available features');
+  try {
+    const features = Docstron.getFeatures();
+    console.log('✅ Features:', JSON.stringify(features, null, 2));
+    console.log('');
+  } catch (error) {
+    console.log('❌ Failed:', error.message, '\n');
+  }
+
+  // Test 9: Applications resource exists
+  console.log('Test 9: Applications resource exists');
+  try {
+    const client = new Docstron('test-key');
+    console.log('✅ Applications resource available:', typeof client.applications === 'object');
+    console.log('   - Has create:', typeof client.applications.create === 'function');
+    console.log('   - Has get:', typeof client.applications.get === 'function');
+    console.log('   - Has list:', typeof client.applications.list === 'function');
+    console.log('   - Has update:', typeof client.applications.update === 'function');
+    console.log('   - Has delete:', typeof client.applications.delete === 'function');
+    console.log('');
+  } catch (error) {
+    console.log('❌ Failed:', error.message, '\n');
+  }
+
+  console.log('🏁 Test suite completed!\n');
+  console.log('⚠️  Note: To test with real API, set DOCSTRON_API_KEY environment variable');
+  console.log('   Example: DOCSTRON_API_KEY=your-key node test/test.js\n');
+}
+
+// Run the test suite
+runTests().catch(error => {
+  console.error('Test suite failed:', error);
+  process.exit(1);
+});
+
+/*
+const Docstron = require('../index');
+
+async function runTests() {
+  console.log('🧪 Docstron SDK v0.1.0 - Test Suite\n');
+
+  // Test 1: SDK Version
+  console.log('Test 1: Check SDK version');
+  try {
+    const version = Docstron.getVersion();
+    console.log(`✅ Version: ${version}\n`);
+  } catch (error) {
+    console.log('❌ Failed:', error.message, '\n');
+  }
+
+  // Test 2: Client initialization with API key
+  console.log('Test 2: Initialize client with API key');
+  try {
+    const client = new Docstron('test-api-key');
+    console.log('✅ Client initialized successfully');
+    console.log('   - Has templates:', typeof client.templates === 'object');
+    console.log('');
+  } catch (error) {
+    console.log('❌ Failed:', error.message, '\n');
+  }
+
+  // Test 3: Client without API key should fail
+  console.log('Test 3: Initialize client without API key (should fail)');
+  try {
+    const client = new Docstron();
+    console.log('❌ Should have thrown an error\n');
+  } catch (error) {
+    console.log('✅ Correctly threw error:', error.message, '\n');
+  }
+
+  // Test 4: Template validation
+  console.log('Test 4: Template create validation');
+  const client = new Docstron('test-key');
+  try {
+    await client.templates.create({});
+    console.log('❌ Should have thrown validation error\n');
+  } catch (error) {
+    console.log('✅ Correctly validated required fields:', error.message, '\n');
+  }
+
+  // Test 5: Custom base URL
+  console.log('Test 5: Initialize with custom base URL');
+  try {
+    const customClient = new Docstron('test-key', {
+      baseURL: 'https://custom.api.com'
+    });
+    console.log('✅ Client accepts custom configuration');
+    console.log('   - Base URL:', customClient.baseURL, '\n');
+  } catch (error) {
+    console.log('❌ Failed:', error.message, '\n');
+  }
+
+  // Test 6: Error exports
+  console.log('Test 6: Error classes are exported');
+  try {
+    const {
+      DocstronError,
+      ValidationError,
+      AuthenticationError,
+      NotFoundError
+    } = require('../index');
+    
+    console.log('✅ All error classes exported:');
+    console.log('   - DocstronError:', typeof DocstronError === 'function');
+    console.log('   - ValidationError:', typeof ValidationError === 'function');
+    console.log('   - AuthenticationError:', typeof AuthenticationError === 'function');
+    console.log('   - NotFoundError:', typeof NotFoundError === 'function');
+    console.log('');
+  } catch (error) {
+    console.log('❌ Failed:', error.message, '\n');
+  }
+
+  console.log('🏁 Test suite completed!\n');
+  console.log('⚠️  Note: To test with real API, set DOCSTRON_API_KEY environment variable');
+  console.log('   Example: DOCSTRON_API_KEY=your-key node test/test.js\n');
+}
+
+// Run the test suite
+runTests().catch(error => {
+  console.error('Test suite failed:', error);
+  process.exit(1);
+});
+*/