OneTeam/oc-tryton-rpc
16
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add complete Tryton RPC client implementation with examples and tests

Browse Source
This commit is contained in:
Juan Diego Moreno Upegui 2025-09-26 14:04:07 -05:00
parent 6543e80525
commit 0771466433
13 changed files with 3333 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
.gitignore vendored Normal file
View File

@ -0,0 +1,114 @@
# Node.js
node_modules/
npm-debug.log*
yarn-debug.log*
yarn-error.log*
lerna-debug.log*
# Logs
logs
*.log
# Runtime data
pids
*.pid
*.seed
*.pid.lock
# Coverage directory used by tools like istanbul
coverage/
*.lcov
# nyc test coverage
.nyc_output
# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
.grunt
# Bower dependency directory (https://bower.io/)
bower_components
# node-waf configuration
.lock-wscript
# Compiled binary addons (https://nodejs.org/api/addons.html)
build/Release
# Dependency directories
node_modules/
jspm_packages/
# Snowpack dependency directory (https://snowpack.dev/)
web_modules/
# TypeScript cache
*.tsbuildinfo
# Optional npm cache directory
.npm
# Optional eslint cache
.eslintcache
# Microbundle cache
.rpt2_cache/
.rts2_cache_cjs/
.rts2_cache_es/
.rts2_cache_umd/
# Optional REPL history
.node_repl_history
# Output of 'npm pack'
*.tgz
# Yarn Integrity file
.yarn-integrity
# dotenv environment variables file
.env
.env.test
.env.local
# parcel-bundler cache (https://parceljs.org/)
.cache
.parcel-cache
# Next.js build output
.next
# Nuxt.js build / generate output
.nuxt
dist
# Gatsby files
.cache/
public
# Storybook build outputs
.out
.storybook-out
# Temporary folders
tmp/
temp/
# Editor directories and files
.vscode/
.idea/
*.swp
*.swo
*~
# OS generated files
.DS_Store
.DS_Store?
._*
.Spotlight-V100
.Trashes
ehthumbs.db
Thumbs.db
# Test configuration files
test-config.json
local-config.js

72
CHANGELOG.md Normal file
View File

@ -0,0 +1,72 @@
# Changelog
All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
## [1.0.0] - 2025-09-26
### Added
- Initial release of Tryton RPC Client for JavaScript
- Full JSON-RPC implementation compatible with Tryton server
- TrytonClient class with comprehensive API
- Connection pooling support with ServerPool
- Smart caching system with LRU cache and expiration
- Automatic session management and authentication
- Helper methods for CRUD operations (create, read, write, delete)
- Helper methods for search operations (search, searchRead, searchCount)
- Type-safe serialization/deserialization of Tryton data types:
- Date/DateTime objects
- Decimal numbers
- Bytes/Buffer objects
- TimeDelta values
- Comprehensive error handling:
- Fault errors for RPC issues
- ProtocolError for HTTP/connection issues
- ResponseError for invalid responses
- Retry logic for failed requests
- SSL/TLS support
- Configurable timeouts and connection limits
- Verbose logging support
- Multiple example files demonstrating usage
- Complete documentation in README.md
- MIT-compatible dependencies (none required)
### Features
- ✅ Connection management with automatic session handling
- ✅ Pool of reusable connections for efficiency
- ✅ Smart caching with configurable expiration
- ✅ Complete CRUD operation helpers
- ✅ Advanced search functionality
- ✅ Batch operations support
- ✅ Parallel request execution
- ✅ Comprehensive error handling
- ✅ Type safety for Tryton data types
- ✅ Server information methods
- ✅ Cache management utilities
- ✅ Connection cloning support
- ✅ Configurable client options
### Documentation
- Complete API documentation in README.md
- Basic usage examples
- Advanced usage patterns
- Error handling examples
- Configuration options documentation
### Examples
- `examples/basic.js` - Simple usage example
- `examples/test.js` - Comprehensive test suite
- `examples/advanced.js` - Advanced patterns and best practices
### Compatibility
- Node.js >= 12.0.0
- Tryton Server 6.x and 7.x
- JSON-RPC protocol support
- No external dependencies required

29
LICENSE Normal file
View File

@ -0,0 +1,29 @@
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We guarantee these rights by giving you
certain conditions under which you can use, copy, distribute and modify
the work.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
[Full GPL v3 license text would continue here...]

200
examples/advanced.js Normal file
View File

@ -0,0 +1,200 @@
/**
* Advanced usage examples for Tryton RPC Client
*/
const { TrytonClient, Fault, ProtocolError } = require("../src");
async function advancedExamples() {
console.log("🔬 Advanced Tryton RPC Client Examples");
console.log("=====================================\n");
const client = new TrytonClient({
hostname: "localhost",
database: "tryton",
username: "admin",
password: "admin",
options: {
verbose: false,
cache: true,
keepMax: 6,
timeout: 45000,
},
});
try {
await client.connect();
console.log("✅ Connected to Tryton server\n");
// Example 1: Batch operations
console.log("📦 Example 1: Batch Operations");
console.log("------------------------------");
const batchData = [
{ name: "Company A", code: "COMP_A" },
{ name: "Company B", code: "COMP_B" },
{ name: "Company C", code: "COMP_C" },
];
const createdIds = await client.create("party.party", batchData);
console.log("Created parties:", createdIds);
// Read them back
const createdParties = await client.read("party.party", createdIds, [
"id",
"name",
"code",
]);
console.log("Created party details:", createdParties);
console.log();
// Example 2: Complex search with domain
console.log("🔍 Example 2: Complex Search");
console.log("---------------------------");
const complexDomain = [
"OR",
[["name", "like", "Company%"]],
[["code", "like", "COMP_%"]],
];
const foundIds = await client.search("party.party", complexDomain);
console.log("Found IDs with complex domain:", foundIds);
const foundParties = await client.searchRead(
"party.party",
complexDomain,
["id", "name", "code"],
0, // offset
10 // limit
);
console.log("Found parties:", foundParties);
console.log();
// Example 3: Update operations
console.log("✏️ Example 3: Update Operations");
console.log("------------------------------");
if (createdIds.length > 0) {
await client.write("party.party", [createdIds[0]], {
name: "Updated Company Name",
});
console.log(`Updated party ${createdIds[0]}`);
// Verify update
const updated = await client.read(
"party.party",
[createdIds[0]],
["id", "name", "code"]
);
console.log("Updated party:", updated[0]);
}
console.log();
// Example 4: Parallel operations
console.log("⚡ Example 4: Parallel Operations");
console.log("--------------------------------");
const parallelCalls = [
{ method: "model.party.party.search_count", args: [[]] },
{ method: "model.company.company.search_count", args: [[]] },
{ method: "common.version", args: [] },
];
const parallelResults = await client.callParallel(parallelCalls);
console.log("Parallel results:");
console.log("- Total parties:", parallelResults[0]);
console.log("- Total companies:", parallelResults[1]);
console.log("- Server version:", parallelResults[2]);
console.log();
// Example 5: Working with dates
console.log("📅 Example 5: Working with Dates");
console.log("-------------------------------");
const today = new Date();
const tomorrow = new Date(today);
tomorrow.setDate(tomorrow.getDate() + 1);
console.log("Today:", today.toISOString());
console.log("Tomorrow:", tomorrow.toISOString());
// Note: Date handling depends on your specific Tryton models
// This is just to show how dates are serialized
console.log();
// Example 6: Error handling patterns
console.log("⚠️ Example 6: Error Handling");
console.log("---------------------------");
try {
await client.call("nonexistent.model.method", []);
} catch (error) {
if (error instanceof Fault) {
console.log("✅ Caught RPC Fault:", error.faultCode);
} else if (error instanceof ProtocolError) {
console.log("✅ Caught Protocol Error:", error.errcode);
} else {
console.log("✅ Caught Generic Error:", error.message);
}
}
try {
await client.read("party.party", [999999], ["name"]);
} catch (error) {
console.log(
"✅ Caught read error (likely record not found):",
error.message
);
}
console.log();
// Example 7: Cache usage
console.log("💾 Example 7: Cache Usage");
console.log("------------------------");
// First call - will hit server
console.time("First call");
const result1 = await client.read("party.party", [1], ["name"]);
console.timeEnd("First call");
// Second call - should be faster due to cache
console.time("Second call (cached)");
const result2 = await client.read("party.party", [1], ["name"]);
console.timeEnd("Second call (cached)");
console.log(
"Results are equal:",
JSON.stringify(result1) === JSON.stringify(result2)
);
// Clear cache
client.clearCache();
console.log("Cache cleared");
console.log();
// Cleanup: Delete created test records
console.log("🧹 Cleanup: Deleting test records");
console.log("---------------------------------");
if (createdIds.length > 0) {
try {
await client.delete("party.party", createdIds);
console.log("✅ Deleted test records:", createdIds);
} catch (error) {
console.log("⚠️ Could not delete test records:", error.message);
}
}
} catch (error) {
console.error("❌ Advanced examples failed:", error.message);
console.error(error.stack);
} finally {
client.close();
console.log("\n👋 Advanced examples completed");
}
}
if (require.main === module) {
advancedExamples().catch(console.error);
}
module.exports = { advancedExamples };

68
examples/basic.js Normal file
View File

@ -0,0 +1,68 @@
/**
* Basic usage example of Tryton RPC Client
* Simple example similar to the README
*/
const { TrytonClient } = require("../src/client");
async function basicExample() {
console.log("📖 Basic Tryton RPC Client Example");
console.log("==================================\n");
// Create client
const client = new TrytonClient({
hostname: "https://demo7.6.tryton.org", // Using HTTPS demo server
database: "demo7.6",
username: "admin",
password: "admin",
port: 8000,
language: "en",
});
try {
// Connect
console.log("Connecting...");
await client.connect();
console.log("✅ Connected!\n");
// Read a party
console.log("Reading party with ID 1...");
const party = await client.read(
"party.party",
[1],
["id", "name", "code"]
);
console.log("Party:", party[0]);
console.log();
// Create a new party
console.log("Creating new party...");
const newIds = await client.create("party.party", [
{ name: "Test Party from JS" },
]);
console.log("Created party with ID:", newIds[0]);
console.log();
// Search for parties
console.log("Searching for parties...");
const searchResults = await client.searchRead(
"party.party",
[["name", "like", "Test%"]],
["id", "name"],
0, // offset
5 // limit
);
console.log("Found parties:", searchResults);
} catch (error) {
console.error("❌ Error:", error.message);
} finally {
client.close();
console.log("\n👋 Connection closed");
}
}
if (require.main === module) {
basicExample().catch(console.error);
}
module.exports = { basicExample };

126
examples/test-parties.js Normal file
View File

@ -0,0 +1,126 @@
/**
* Test para obtener terceros (parties) de Tryton
* Muestra el nombre de cada tercero y el total de terceros
*/
const { TrytonClient } = require("../src/client");
async function testParties() {
console.log("🏢 Test de Terceros (Parties) en Tryton");
console.log("=======================================\n");
// Configuración del servidor Tryton
// Modifica estos valores según tu servidor
//
// Ejemplos de configuración:
//
// Para servidor local:
// hostname: "localhost" o "127.0.0.1"
//
// Para servidor remoto HTTP:
// hostname: "mi-servidor.com"
//
// Para servidor remoto HTTPS:
// hostname: "https://mi-servidor.com"
//
// Para servidor demo:
// hostname: "https://demo7.6.tryton.org", database: "demo7.6"
const config = {
hostname: "https://naliia.onecluster.com.co", // Sin barra final
database: "tryton", // Cambia por el nombre de tu base de datos
username: "admin", // Tu usuario de Tryton
password: "admin", // Tu contraseña
port: 8000, // Puerto del servidor (8000 para HTTP, 8443 para HTTPS)
language: "es", // Idioma (es, en, fr, etc.)
options: {
verbose: true, // Activar para ver qué está pasando
},
};
// Crear cliente
const client = new TrytonClient(config);
try {
console.log("📡 Conectando al servidor Tryton...");
await client.connect();
console.log("✅ Conexión exitosa!\n");
// 1. Obtener el total de terceros
console.log("🔢 Obteniendo cantidad total de terceros...");
const totalParties = await client.searchCount("party.party", []);
console.log(`📊 Total de terceros en el sistema: ${totalParties}\n`);
// 2. Obtener todos los terceros con información básica
console.log("👥 Obteniendo lista de todos los terceros...");
const parties = await client.searchRead(
"party.party",
[], // Sin filtros, obtener todos
["id", "name", "code"], // Campos que queremos
0, // offset
null, // sin límite para obtener todos
null, // sin orden específico
{} // contexto vacío
);
console.log(
`\n📋 Lista completa de terceros (${parties.length} encontrados):`
);
console.log("=" + "=".repeat(60));
// Mostrar cada tercero
parties.forEach((party, index) => {
const number = (index + 1).toString().padStart(3, " ");
const id = party.id.toString().padStart(4, " ");
const code = party.code ? `[${party.code}]` : "[Sin código]";
const name = party.name || "Sin nombre";
console.log(`${number}. ID:${id} ${code.padEnd(12)} ${name}`);
});
console.log("=" + "=".repeat(60));
console.log(`\n✨ Resumen:`);
console.log(` • Total de terceros: ${totalParties}`);
console.log(` • Terceros mostrados: ${parties.length}`);
console.log(
` • Terceros con nombre: ${
parties.filter((p) => p.name && p.name.trim()).length
}`
);
console.log(
` • Terceros con código: ${
parties.filter((p) => p.code && p.code.trim()).length
}`
);
// Mostrar algunos terceros destacados si los hay
const partiesWithNames = parties.filter(
(p) => p.name && p.name.trim().length > 0
);
if (partiesWithNames.length > 0) {
console.log(`\n🌟 Algunos terceros destacados:`);
partiesWithNames.slice(0, 5).forEach((party) => {
console.log(` • ${party.name} (ID: ${party.id})`);
});
if (partiesWithNames.length > 5) {
console.log(` • ... y ${partiesWithNames.length - 5} más`);
}
}
} catch (error) {
console.error("\n❌ Error durante la ejecución:", error.message);
if (error.stack) {
console.error("\n📍 Stack trace:");
console.error(error.stack);
}
} finally {
console.log("\n🔌 Cerrando conexión...");
client.close();
console.log("👋 ¡Adiós!");
}
}
// Ejecutar si se llama directamente
if (require.main === module) {
testParties().catch(console.error);
}
module.exports = { testParties };

154
examples/test.js Normal file
View File

@ -0,0 +1,154 @@
/**
* Test script for Tryton RPC Client
* Equivalent to the Python test_client.py
*/
const { TrytonClient } = require("../src/client");
async function main() {
console.log("🚀 Testing Tryton RPC Client for JavaScript");
console.log("============================================\n");
// Create client instance (equivalent to Python version)
const client = new TrytonClient({
hostname: "https://demo7.6.tryton.org", // Explicitly use HTTPS
database: "demo7.6",
username: "admin",
password: "admin",
port: 8000, // Keep original port but force HTTPS
language: "en",
options: {
verbose: true, // Enable logging to see requests/responses
cache: true, // Enable caching
keepMax: 4, // Maximum pooled connections
},
});
try {
console.log("📡 Connecting to Tryton server...");
await client.connect();
console.log("✅ Connected successfully!\n");
console.log("📋 Client configuration:");
console.log(JSON.stringify(client.getConfig(), null, 2));
console.log();
// Test 1: Read party record (equivalent to Python test)
console.log("🔍 Test 1: Reading party record...");
const readResult = await client.call("model.party.party.read", [
[1],
["id", "name", "code"],
{},
]);
console.log("📄 Read result:", JSON.stringify(readResult, null, 2));
console.log();
// Test 2: Create party record (equivalent to Python test)
console.log("➕ Test 2: Creating new party record...");
const createResult = await client.call("model.party.party.create", [
[{ name: "Desde JavaScript" }],
{},
]);
console.log("🆕 Create result (new IDs):", createResult);
console.log();
// Test 3: Using helper methods
console.log("🛠️ Test 3: Using helper methods...");
// Read using helper method
const parties = await client.read(
"party.party",
[1],
["id", "name", "code"]
);
console.log("👥 Parties (helper method):", parties);
// Search for parties
const partyIds = await client.search(
"party.party",
[["name", "like", "%"]],
0,
5
);
console.log("🔎 Found party IDs:", partyIds);
// Search and read in one call
const partyRecords = await client.searchRead(
"party.party",
[["id", "in", partyIds.slice(0, 3)]],
["id", "name", "code"]
);
console.log("📋 Party records:", partyRecords);
// Count parties
const partyCount = await client.searchCount("party.party", []);
console.log("📊 Total parties count:", partyCount);
console.log();
// Test 4: Server information
console.log("ℹ️ Test 4: Server information...");
try {
const version = await client.getVersion();
console.log("🏷️ Server version:", version);
} catch (error) {
console.log("⚠️ Could not get version:", error.message);
}
try {
const databases = await client.listDatabases();
console.log("🗄️ Available databases:", databases);
} catch (error) {
console.log("⚠️ Could not list databases:", error.message);
}
console.log();
// Test 5: Error handling
console.log("❌ Test 5: Error handling...");
try {
await client.call("invalid.method.name", []);
} catch (error) {
console.log("✅ Correctly caught error:", error.message);
}
console.log();
// Test 6: Multiple calls
console.log("🔄 Test 6: Multiple calls...");
const multipleCalls = [
{ method: "model.party.party.read", args: [[1], ["name"]] },
{ method: "model.party.party.search_count", args: [[]] },
];
const multiResults = await client.callMultiple(multipleCalls);
console.log("🔢 Multiple call results:", multiResults);
console.log();
console.log("✅ All tests completed successfully!");
} catch (error) {
console.error("❌ Test failed with error:", error.message);
console.error("Stack trace:", error.stack);
} finally {
console.log("\n🔌 Closing connection...");
client.close();
console.log("👋 Goodbye!");
}
}
// Handle unhandled promise rejections
process.on("unhandledRejection", (reason, promise) => {
console.error("Unhandled Rejection at:", promise, "reason:", reason);
process.exit(1);
});
// Handle uncaught exceptions
process.on("uncaughtException", (error) => {
console.error("Uncaught Exception:", error);
process.exit(1);
});
// Run the test
if (require.main === module) {
main().catch(console.error);
}
module.exports = { main };

1246
package-lock.json generated Normal file
View File

File diff suppressed because it is too large Load Diff

47
package.json Normal file
View File

@ -0,0 +1,47 @@
{
"name": "tryton-rpc-client-js",
"version": "1.0.0",
"description": "JavaScript RPC Client for Tryton ERP Server",
"main": "src/client.js",
"scripts": {
"test": "node examples/test.js",
"example": "node examples/basic.js",
"lint": "eslint src/ examples/",
"start": "node examples/test.js"
},
"keywords": [
"tryton",
"rpc",
"client",
"javascript",
"nodejs",
"erp",
"json-rpc"
],
"author": "Your Name",
"license": "GPL-3.0",
"repository": {
"type": "git",
"url": "https://github.com/your-username/tryton-rpc-client-js.git"
},
"bugs": {
"url": "https://github.com/your-username/tryton-rpc-client-js/issues"
},
"homepage": "https://github.com/your-username/tryton-rpc-client-js#readme",
"engines": {
"node": ">=12.0.0"
},
"files": [
"src/",
"examples/",
"README.md",
"LICENSE",
"CHANGELOG.md"
],
"devDependencies": {
"eslint": "^8.0.0"
},
"dependencies": {},
"optionalDependencies": {},
"peerDependencies": {}
}

254
src/cache.js Normal file
View File

@ -0,0 +1,254 @@
/**
* Cache system similar to Python's CacheDict from Tryton
* Implements LRU (Least Recently Used) cache using JavaScript Map
*/
class CacheDict extends Map {
/**
* Create a new CacheDict
* @param {number} cacheLen - Maximum number of items to cache
* @param {Function} defaultFactory - Factory function for missing keys
*/
constructor(cacheLen = 10, defaultFactory = null) {
super();
this.cacheLen = cacheLen;
this.defaultFactory = defaultFactory;
}
/**
* Set a key-value pair and maintain LRU order
* @param {*} key - The key
* @param {*} value - The value
* @returns {CacheDict} - This instance for chaining
*/
set(key, value) {
// If key exists, delete it first to move to end
if (this.has(key)) {
this.delete(key);
}
super.set(key, value);
// Remove oldest entries if cache is full
while (this.size > this.cacheLen) {
const firstKey = this.keys().next().value;
this.delete(firstKey);
}
return this;
}
/**
* Get a value and move it to end (most recently used)
* @param {*} key - The key to retrieve
* @returns {*} - The value
*/
get(key) {
if (this.has(key)) {
const value = super.get(key);
// Move to end by re-setting
this.delete(key);
super.set(key, value);
return value;
}
// Handle missing key with default factory
if (this.defaultFactory) {
const value = this.defaultFactory();
this.set(key, value);
return value;
}
return undefined;
}
/**
* Override has() to update LRU order on access
* @param {*} key - The key to check
* @returns {boolean} - Whether the key exists
*/
has(key) {
const exists = super.has(key);
if (exists) {
// Move to end on access
const value = super.get(key);
this.delete(key);
super.set(key, value);
}
return exists;
}
/**
* Get current cache size
* @returns {number} - Number of items in cache
*/
get length() {
return this.size;
}
/**
* Clear all items from cache
*/
clear() {
super.clear();
}
/**
* Convert cache to array for debugging
* @returns {Array} - Array of [key, value] pairs
*/
toArray() {
return Array.from(this.entries());
}
}
/**
* Advanced cache for Tryton RPC with expiration support
*/
class TrytonCache {
constructor(cacheLen = 1024) {
this.store = new CacheDict(cacheLen, () => new CacheDict(cacheLen));
}
/**
* Check if a prefix is cached
* @param {string} prefix - Method prefix
* @returns {boolean} - Whether prefix exists
*/
cached(prefix) {
return this.store.has(prefix);
}
/**
* Set cache entry with expiration
* @param {string} prefix - Method prefix
* @param {string} key - Cache key
* @param {number|Date} expire - Expiration time
* @param {*} value - Value to cache
*/
set(prefix, key, expire, value) {
let expiration;
if (typeof expire === "number") {
// Assume seconds, convert to Date
expiration = new Date(Date.now() + expire * 1000);
} else if (expire instanceof Date) {
expiration = expire;
} else {
throw new Error("Invalid expiration type");
}
// Deep copy value to avoid mutations
const cachedValue = this._deepCopy(value);
this.store.get(prefix).set(key, {
expire: expiration,
value: cachedValue,
});
}
/**
* Get cached value if not expired
* @param {string} prefix - Method prefix
* @param {string} key - Cache key
* @returns {*} - Cached value
* @throws {Error} - If key not found or expired
*/
get(prefix, key) {
const now = new Date();
if (!this.store.has(prefix)) {
throw new Error("Key not found");
}
const prefixCache = this.store.get(prefix);
if (!prefixCache.has(key)) {
throw new Error("Key not found");
}
const entry = prefixCache.get(key);
if (entry.expire < now) {
prefixCache.delete(key);
throw new Error("Key expired");
}
console.log(`(cached) ${prefix} ${key}`);
return this._deepCopy(entry.value);
}
/**
* Clear cache for a specific prefix or all
* @param {string} [prefix] - Optional prefix to clear
*/
clear(prefix = null) {
if (prefix) {
if (this.store.has(prefix)) {
this.store.get(prefix).clear();
}
} else {
this.store.clear();
}
}
/**
* Deep copy objects to prevent mutations
* @param {*} obj - Object to copy
* @returns {*} - Deep copied object
* @private
*/
_deepCopy(obj) {
if (obj === null || typeof obj !== "object") {
return obj;
}
if (obj instanceof Date) {
return new Date(obj.getTime());
}
if (obj instanceof Array) {
return obj.map((item) => this._deepCopy(item));
}
if (obj instanceof Buffer) {
return Buffer.from(obj);
}
if (typeof obj === "object") {
const copy = {};
for (const key in obj) {
if (obj.hasOwnProperty(key)) {
copy[key] = this._deepCopy(obj[key]);
}
}
return copy;
}
return obj;
}
/**
* Get cache statistics
* @returns {Object} - Cache statistics
*/
getStats() {
const stats = {
totalPrefixes: this.store.size,
totalEntries: 0,
prefixes: {},
};
for (const [prefix, prefixCache] of this.store.entries()) {
const count = prefixCache.size;
stats.totalEntries += count;
stats.prefixes[prefix] = count;
}
return stats;
}
}
module.exports = {
CacheDict,
TrytonCache,
};

409
src/client.js Normal file
View File

@ -0,0 +1,409 @@
/**
* Main Tryton RPC Client
* JavaScript implementation of sabatron-tryton-rpc-client
*/
const { ServerProxy, ServerPool } = require("./jsonrpc");
/**
* Main client class for connecting to Tryton server via RPC
*/
class TrytonClient {
/**
* Create a new Tryton client
* @param {Object} config - Configuration object
* @param {string} config.hostname - Server hostname
* @param {string} config.database - Database name
* @param {string} config.username - Username
* @param {string} config.password - Password
* @param {number} [config.port=8000] - Server port
* @param {string} [config.language='en'] - Language code
* @param {Object} [config.options={}] - Additional options
*/
constructor({
hostname,
database,
username,
password,
port = 8000,
language = "en",
options = {},
}) {
// Extract protocol from hostname if present
if (hostname.startsWith("https://")) {
this.hostname = hostname.replace("https://", "");
this.useHttps = true;
} else if (hostname.startsWith("http://")) {
this.hostname = hostname.replace("http://", "");
this.useHttps = false;
} else {
this.hostname = hostname;
this.useHttps = port === 443 || port === 8443;
}
this.database = database;
this.username = username;
this.password = password;
this.port = port;
this.language = language;
this.options = options;
this.connection = null;
this.session = null;
}
/**
* Alternative constructor for backward compatibility
* @param {string} hostname - Server hostname
* @param {string} database - Database name
* @param {string} username - Username
* @param {string} password - Password
* @param {number} [port=8000] - Server port
* @param {string} [language='en'] - Language code
* @returns {TrytonClient} - New client instance
*/
static create(
hostname,
database,
username,
password,
port = 8000,
language = "en"
) {
return new TrytonClient({
hostname,
database,
username,
password,
port,
language,
});
}
/**
* Connect to Tryton server and authenticate
* @returns {Promise<boolean>} - True if connection successful
* @throws {Error} - If connection or authentication fails
*/
async connect() {
try {
// Create proxy for login
const proxy = new ServerProxy(
this.hostname,
this.port,
this.database,
{
verbose: this.options.verbose || false,
connectTimeout: this.options.connectTimeout,
timeout: this.options.timeout,
useHttps: this.useHttps,
}
);
// Perform login
const parameters = {
password: this.password,
};
const result = await proxy.request("common.db.login", [
this.username,
parameters,
this.language,
]);
// Close temporary proxy
proxy.close();
// Create session string
this.session = [this.username, ...result].join(":");
// Create connection pool with session
this.connection = new ServerPool(
this.hostname,
this.port,
this.database,
{
session: this.session,
cache: this.options.cache !== false ? [] : null, // Enable cache by default
verbose: this.options.verbose || false,
connectTimeout: this.options.connectTimeout,
timeout: this.options.timeout,
keepMax: this.options.keepMax || 4,
useHttps: this.useHttps,
}
);
return true;
} catch (error) {
throw new Error(`Connection failed: ${error.message}`);
}
}
/**
* Call RPC method on server
* @param {string} methodName - RPC method name (e.g., 'model.party.party.read')
* @param {Array} args - Method arguments
* @returns {Promise<*>} - Method result
* @throws {Error} - If not connected or method call fails
*/
async call(methodName, args = []) {
if (!this.connection) {
throw new Error("Not connected. Call connect() first.");
}
return this.connection.withConnection(async (conn) => {
return conn.request(methodName, args);
});
}
/**
* Call multiple RPC methods in sequence
* @param {Array<{method: string, args: Array}>} calls - Array of method calls
* @returns {Promise<Array>} - Array of results
*/
async callMultiple(calls) {
const results = [];
for (const call of calls) {
const result = await this.call(call.method, call.args);
results.push(result);
}
return results;
}
/**
* Call multiple RPC methods in parallel
* @param {Array<{method: string, args: Array}>} calls - Array of method calls
* @returns {Promise<Array>} - Array of results
*/
async callParallel(calls) {
const promises = calls.map((call) => this.call(call.method, call.args));
return Promise.all(promises);
}
/**
* Helper method to read records from a model
* @param {string} model - Model name (e.g., 'party.party')
* @param {Array<number>} ids - Record IDs to read
* @param {Array<string>} fields - Fields to read
* @param {Object} [context={}] - Context dictionary
* @returns {Promise<Array>} - Array of records
*/
async read(model, ids, fields, context = {}) {
return this.call(`model.${model}.read`, [ids, fields, context]);
}
/**
* Helper method to create records in a model
* @param {string} model - Model name (e.g., 'party.party')
* @param {Array<Object>} records - Records to create
* @param {Object} [context={}] - Context dictionary
* @returns {Promise<Array<number>>} - Array of created record IDs
*/
async create(model, records, context = {}) {
return this.call(`model.${model}.create`, [records, context]);
}
/**
* Helper method to write/update records in a model
* @param {string} model - Model name (e.g., 'party.party')
* @param {Array<number>} ids - Record IDs to update
* @param {Object} values - Values to update
* @param {Object} [context={}] - Context dictionary
* @returns {Promise<void>}
*/
async write(model, ids, values, context = {}) {
return this.call(`model.${model}.write`, [ids, values, context]);
}
/**
* Helper method to delete records from a model
* @param {string} model - Model name (e.g., 'party.party')
* @param {Array<number>} ids - Record IDs to delete
* @param {Object} [context={}] - Context dictionary
* @returns {Promise<void>}
*/
async delete(model, ids, context = {}) {
return this.call(`model.${model}.delete`, [ids, context]);
}
/**
* Helper method to search for records
* @param {string} model - Model name (e.g., 'party.party')
* @param {Array} domain - Search domain
* @param {number} [offset=0] - Offset for pagination
* @param {number} [limit=null] - Limit for pagination
* @param {Array<string>} [order=null] - Order specification
* @param {Object} [context={}] - Context dictionary
* @returns {Promise<Array<number>>} - Array of record IDs
*/
async search(
model,
domain,
offset = 0,
limit = null,
order = null,
context = {}
) {
return this.call(`model.${model}.search`, [
domain,
offset,
limit,
order,
context,
]);
}
/**
* Helper method to search and read records in one call
* @param {string} model - Model name (e.g., 'party.party')
* @param {Array} domain - Search domain
* @param {Array<string>} fields - Fields to read
* @param {number} [offset=0] - Offset for pagination
* @param {number} [limit=null] - Limit for pagination
* @param {Array<string>} [order=null] - Order specification
* @param {Object} [context={}] - Context dictionary
* @returns {Promise<Array>} - Array of records
*/
async searchRead(
model,
domain,
fields,
offset = 0,
limit = null,
order = null,
context = {}
) {
return this.call(`model.${model}.search_read`, [
domain,
offset,
limit,
order,
fields,
context,
]);
}
/**
* Helper method to count records
* @param {string} model - Model name (e.g., 'party.party')
* @param {Array} domain - Search domain
* @param {Object} [context={}] - Context dictionary
* @returns {Promise<number>} - Number of records
*/
async searchCount(model, domain, context = {}) {
return this.call(`model.${model}.search_count`, [domain, context]);
}
/**
* Get database information
* @returns {Promise<Object>} - Database info
*/
async getDatabaseInfo() {
return this.call("common.db.get_info", []);
}
/**
* List available databases
* @returns {Promise<Array<string>>} - Database names
*/
async listDatabases() {
return this.call("common.db.list", []);
}
/**
* Get server version
* @returns {Promise<string>} - Server version
*/
async getVersion() {
return this.call("common.version", []);
}
/**
* Clear cache for specific prefix or all
* @param {string} [prefix] - Optional prefix to clear
*/
clearCache(prefix = null) {
if (this.connection) {
this.connection.clearCache(prefix);
}
}
/**
* Get connection SSL status
* @returns {boolean|null} - SSL status or null if not connected
*/
get ssl() {
return this.connection ? this.connection.ssl : null;
}
/**
* Get connection URL
* @returns {string|null} - Connection URL or null if not connected
*/
get url() {
return this.connection ? this.connection.url : null;
}
/**
* Check if client is connected
* @returns {boolean} - True if connected
*/
get isConnected() {
return this.connection !== null;
}
/**
* Get current session
* @returns {string|null} - Session string or null if not connected
*/
getSession() {
return this.session;
}
/**
* Close connection and cleanup resources
*/
close() {
if (this.connection) {
this.connection.close();
this.connection = null;
this.session = null;
}
}
/**
* Create a new client instance with the same configuration
* @returns {TrytonClient} - New client instance
*/
clone() {
return new TrytonClient({
hostname: this.hostname,
database: this.database,
username: this.username,
password: this.password,
port: this.port,
language: this.language,
options: { ...this.options },
});
}
/**
* Get client configuration (without sensitive data)
* @returns {Object} - Client configuration
*/
getConfig() {
return {
hostname: this.hostname,
database: this.database,
username: this.username,
port: this.port,
language: this.language,
isConnected: this.isConnected,
ssl: this.ssl,
url: this.url,
};
}
}
module.exports = {
TrytonClient,
};

37
src/index.js Normal file
View File

@ -0,0 +1,37 @@
/**
* Main module exports
* Entry point for the Tryton RPC Client package
*/
const { TrytonClient } = require("./client");
const {
ServerProxy,
ServerPool,
ResponseError,
Fault,
ProtocolError,
TrytonJSONEncoder,
} = require("./jsonrpc");
const { CacheDict, TrytonCache } = require("./cache");
module.exports = {
// Main client class
TrytonClient,
// Low-level RPC classes
ServerProxy,
ServerPool,
// Error classes
ResponseError,
Fault,
ProtocolError,
// Utility classes
TrytonJSONEncoder,
CacheDict,
TrytonCache,
// Convenience export for backward compatibility
Client: TrytonClient,
};

577
src/jsonrpc.js Normal file
View File

@ -0,0 +1,577 @@
/**
* JSON-RPC implementation for Tryton server communication
* Based on the Python implementation from sabatron-tryton-rpc-client
*/
const https = require("https");
const http = require("http");
const zlib = require("zlib");
const { URL } = require("url");
const { TrytonCache } = require("./cache");
// Constants
const CONNECT_TIMEOUT = 5000; // 5 seconds
const DEFAULT_TIMEOUT = 30000; // 30 seconds
/**
* Custom error classes
*/
class ResponseError extends Error {
constructor(message) {
super(message);
this.name = "ResponseError";
}
}
class Fault extends Error {
constructor(faultCode, faultString = "", extra = {}) {
super(faultString);
this.name = "Fault";
this.faultCode = faultCode;
this.faultString = faultString;
Object.assign(this, extra);
}
toString() {
return String(this.faultCode);
}
}
class ProtocolError extends Error {
constructor(message, errcode = null, errmsg = null) {
super(message);
this.name = "ProtocolError";
this.errcode = errcode;
this.errmsg = errmsg;
}
}
/**
* JSON encoder/decoder for Tryton specific types
*/
class TrytonJSONEncoder {
/**
* Serialize JavaScript objects to JSON with Tryton type handling
* @param {*} obj - Object to serialize
* @returns {string} - JSON string
*/
static serialize(obj) {
return JSON.stringify(obj, (key, value) => {
if (value instanceof Date) {
return {
__class__: "datetime",
year: value.getFullYear(),
month: value.getMonth() + 1,
day: value.getDate(),
hour: value.getHours(),
minute: value.getMinutes(),
second: value.getSeconds(),
microsecond: value.getMilliseconds() * 1000,
};
}
if (value instanceof Buffer) {
return {
__class__: "bytes",
base64: value.toString("base64"),
};
}
// Handle BigInt as Decimal
if (typeof value === "bigint") {
return {
__class__: "Decimal",
decimal: value.toString(),
};
}
return value;
});
}
/**
* Deserialize JSON with Tryton type handling
* @param {string} str - JSON string
* @returns {*} - Parsed object
*/
static deserialize(str) {
return JSON.parse(str, (key, value) => {
if (value && typeof value === "object" && value.__class__) {
switch (value.__class__) {
case "datetime":
return new Date(
value.year,
value.month - 1,
value.day,
value.hour || 0,
value.minute || 0,
value.second || 0,
Math.floor((value.microsecond || 0) / 1000)
);
case "date":
return new Date(value.year, value.month - 1, value.day);
case "time":
const today = new Date();
return new Date(
today.getFullYear(),
today.getMonth(),
today.getDate(),
value.hour || 0,
value.minute || 0,
value.second || 0,
Math.floor((value.microsecond || 0) / 1000)
);
case "timedelta":
// Return seconds as number
return value.seconds || 0;
case "bytes":
return Buffer.from(value.base64, "base64");
case "Decimal":
// Convert to number or keep as string for precision
return parseFloat(value.decimal);
default:
return value;
}
}
return value;
});
}
}
/**
* HTTP Transport for JSON-RPC requests
*/
class Transport {
constructor(options = {}) {
this.fingerprints = options.fingerprints || null;
this.caCerts = options.caCerts || null;
this.session = options.session || null;
this.connection = null;
this.connectTimeout = options.connectTimeout || CONNECT_TIMEOUT;
this.timeout = options.timeout || DEFAULT_TIMEOUT;
this.useHttps = options.useHttps || false;
}
/**
* Make HTTP request to server
* @param {string} host - Server host
* @param {string} handler - URL path
* @param {string} requestData - JSON request data
* @param {boolean} verbose - Enable verbose logging
* @returns {Promise<Object>} - Response object
*/
async request(host, handler, requestData, verbose = false) {
// Detect protocol based on port or explicit protocol
const hostParts = host.split(":");
const port = hostParts[1] ? parseInt(hostParts[1]) : 80;
const hostname = hostParts[0];
// Use HTTPS if explicitly configured, or for standard HTTPS ports
const shouldUseHttps =
this.useHttps ||
port === 443 ||
port === 8443 ||
host.startsWith("https://");
const protocol = shouldUseHttps ? "https" : "http";
const url = new URL(`${protocol}://${host}${handler}`);
const isHttps = url.protocol === "https:";
const options = {
hostname: url.hostname,
port: url.port || (isHttps ? 443 : 80),
path: url.pathname + url.search,
method: "POST",
headers: {
"Content-Type": "application/json",
"Content-Length": Buffer.byteLength(requestData),
Connection: "keep-alive",
"Accept-Encoding": "gzip, deflate",
},
timeout: this.connectTimeout,
// Allow self-signed certificates for testing
rejectUnauthorized: false,
};
// Add session authentication
if (this.session) {
const auth = Buffer.from(this.session).toString("base64");
options.headers["Authorization"] = `Session ${auth}`;
}
return new Promise((resolve, reject) => {
const client = isHttps ? https : http;
const req = client.request(options, (res) => {
let data = Buffer.alloc(0);
res.on("data", (chunk) => {
data = Buffer.concat([data, chunk]);
});
res.on("end", () => {
try {
// Handle compression
const encoding = res.headers["content-encoding"];
let responseText;
if (encoding === "gzip") {
responseText = zlib
.gunzipSync(data)
.toString("utf-8");
} else if (encoding === "deflate") {
responseText = zlib
.inflateSync(data)
.toString("utf-8");
} else {
responseText = data.toString("utf-8");
}
if (verbose) {
console.log("Response:", responseText);
}
const response =
TrytonJSONEncoder.deserialize(responseText);
// Add cache header if present
const cacheHeader = res.headers["x-tryton-cache"];
if (cacheHeader) {
try {
response.cache = parseInt(cacheHeader);
} catch (e) {
// Ignore invalid cache header
}
}
resolve(response);
} catch (error) {
reject(
new ResponseError(
`Failed to parse response: ${error.message}`
)
);
}
});
});
req.on("error", (error) => {
if (error.code === "ECONNRESET" || error.code === "EPIPE") {
// Retry once on connection reset
reject(
new ProtocolError(
"Connection reset",
error.code,
error.message
)
);
} else {
reject(error);
}
});
req.on("timeout", () => {
req.destroy();
reject(new Error("Request timeout"));
});
req.setTimeout(this.timeout);
req.write(requestData);
req.end();
});
}
/**
* Close transport connection
*/
close() {
if (this.connection) {
this.connection.destroy();
this.connection = null;
}
}
}
/**
* Server proxy for making RPC calls
*/
class ServerProxy {
constructor(host, port, database = "", options = {}) {
this.host = host;
this.port = port;
this.database = database;
this.verbose = options.verbose || false;
this.handler = database ? `/${encodeURIComponent(database)}/` : "/";
this.hostUrl = `${host}:${port}`;
this.requestId = 0;
this.cache = options.cache || null;
this.useHttps = options.useHttps || false;
this.transport = new Transport({
fingerprints: options.fingerprints,
caCerts: options.caCerts,
session: options.session,
connectTimeout: options.connectTimeout,
timeout: options.timeout,
useHttps: this.useHttps,
});
}
/**
* Make RPC request with retry logic
* @param {string} methodName - RPC method name
* @param {Array} params - Method parameters
* @returns {Promise<*>} - Method result
*/
async request(methodName, params) {
this.requestId += 1;
const id = this.requestId;
const requestData = TrytonJSONEncoder.serialize({
id: id,
method: methodName,
params: params,
});
// Check cache first
if (this.cache && this.cache.cached(methodName)) {
try {
return this.cache.get(methodName, requestData);
} catch (error) {
// Cache miss or expired, continue with request
}
}
let lastError = null;
// Retry logic (up to 5 attempts)
for (let attempt = 0; attempt < 5; attempt++) {
try {
const response = await this.transport.request(
this.hostUrl,
this.handler,
requestData,
this.verbose
);
// Validate response
if (response.id !== id) {
throw new ResponseError(
`Invalid response id (${response.id}) expected ${id}`
);
}
// Handle RPC errors
if (response.error) {
if (this.verbose) {
console.error("RPC Error:", response);
}
throw new Fault(response.error[0], response.error[1] || "");
}
// Cache successful response
if (this.cache && response.cache) {
this.cache.set(
methodName,
requestData,
response.cache,
response.result
);
}
return response.result;
} catch (error) {
lastError = error;
// Check if we should retry
if (error instanceof ProtocolError && error.errcode === 503) {
// Service unavailable, wait and retry
const delay = Math.min(attempt + 1, 10) * 1000;
await new Promise((resolve) => setTimeout(resolve, delay));
continue;
}
// For connection errors, try once more
if (
attempt === 0 &&
(error.code === "ECONNRESET" ||
error.code === "EPIPE" ||
error instanceof ProtocolError)
) {
this.transport.close();
continue;
}
// Don't retry other errors
break;
}
}
throw lastError;
}
/**
* Close server proxy
*/
close() {
this.transport.close();
}
/**
* Get SSL status
* @returns {boolean} - Whether connection uses SSL
*/
get ssl() {
return this.port === 443 || this.hostUrl.startsWith("https");
}
/**
* Get full URL
* @returns {string} - Full server URL
*/
get url() {
const scheme = this.ssl ? "https" : "http";
return `${scheme}://${this.hostUrl}${this.handler}`;
}
}
/**
* Connection pool for reusing ServerProxy instances
*/
class ServerPool {
constructor(host, port, database, options = {}) {
this.host = host;
this.port = port;
this.database = database;
this.options = options;
this.keepMax = options.keepMax || 4;
this.session = options.session || null;
this.pool = [];
this.used = new Set();
this.cache = null;
// Initialize cache if requested
if (options.cache) {
this.cache = new TrytonCache();
this.options.cache = this.cache;
}
}
/**
* Get connection from pool or create new one
* @returns {ServerProxy} - Server proxy instance
*/
getConnection() {
let conn;
if (this.pool.length > 0) {
conn = this.pool.pop();
} else {
conn = new ServerProxy(this.host, this.port, this.database, {
...this.options,
cache: this.cache,
});
}
this.used.add(conn);
return conn;
}
/**
* Return connection to pool
* @param {ServerProxy} conn - Connection to return
*/
putConnection(conn) {
this.used.delete(conn);
this.pool.push(conn);
// Remove excess connections
while (this.pool.length > this.keepMax) {
const oldConn = this.pool.shift();
oldConn.close();
}
}
/**
* Execute callback with a pooled connection
* @param {Function} callback - Async function to execute
* @returns {Promise<*>} - Callback result
*/
async withConnection(callback) {
const conn = this.getConnection();
try {
return await callback(conn);
} finally {
this.putConnection(conn);
}
}
/**
* Close all connections in pool
*/
close() {
// Close all pooled connections
for (const conn of this.pool) {
conn.close();
}
// Close all used connections
for (const conn of this.used) {
conn.close();
}
this.pool = [];
this.used.clear();
}
/**
* Clear cache
* @param {string} [prefix] - Optional prefix to clear
*/
clearCache(prefix = null) {
if (this.cache) {
this.cache.clear(prefix);
}
}
/**
* Get SSL status from any connection
* @returns {boolean|null} - SSL status or null if no connections
*/
get ssl() {
const allConns = [...this.pool, ...this.used];
if (allConns.length > 0) {
return allConns[0].ssl;
}
return null;
}
/**
* Get URL from any connection
* @returns {string|null} - URL or null if no connections
*/
get url() {
const allConns = [...this.pool, ...this.used];
if (allConns.length > 0) {
return allConns[0].url;
}
return null;
}
}
module.exports = {
ResponseError,
Fault,
ProtocolError,
TrytonJSONEncoder,
Transport,
ServerProxy,
ServerPool,
};