@relazio/plugin-sdk 0.1.0

package/dist/server/express.js

@@ -0,0 +1,279 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressServer = void 0;
+const express_1 = __importDefault(require("express"));
+const https_1 = __importDefault(require("https"));
+const fs_1 = __importDefault(require("fs"));
+/**
+ * Server Express per il plugin
+ */
+class ExpressServer {
+    constructor(plugin, options) {
+        this.plugin = plugin;
+        this.options = options;
+        this.app = (0, express_1.default)();
+        this.setupMiddleware();
+        this.setupRoutes();
+    }
+    /**
+     * Setup middleware
+     */
+    setupMiddleware() {
+        // Body parser
+        this.app.use(express_1.default.json({ limit: '10mb' }));
+        // CORS
+        this.app.use((req, res, next) => {
+            res.header('Access-Control-Allow-Origin', '*');
+            res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+            res.header('Access-Control-Allow-Headers', 'Content-Type, X-Organization-Id');
+            if (req.method === 'OPTIONS') {
+                res.sendStatus(200);
+            }
+            else {
+                next();
+            }
+        });
+        // Request logging
+        this.app.use((req, res, next) => {
+            console.log(`[${new Date().toISOString()}] ${req.method} ${req.path}`);
+            next();
+        });
+        // Error handling
+        this.app.use((err, req, res, next) => {
+            console.error('Error:', err);
+            res.status(500).json({
+                error: 'Internal server error',
+                message: err.message,
+            });
+        });
+    }
+    /**
+     * Setup routes
+     */
+    setupRoutes() {
+        // Health check
+        this.app.get('/health', (req, res) => {
+            const config = this.plugin.getConfig();
+            res.json({
+                status: 'ok',
+                plugin: config.id,
+                version: config.version,
+                uptime: process.uptime(),
+                transforms: {
+                    sync: this.plugin.getTransforms().length,
+                    async: this.plugin.getAsyncTransforms().length,
+                },
+            });
+        });
+        // Registration endpoint (multi-tenant)
+        if (this.options.multiTenant) {
+            this.app.post('/register', async (req, res) => {
+                try {
+                    const registry = this.plugin.getRegistry();
+                    if (!registry) {
+                        res.status(501).json({ error: 'Multi-tenant not enabled' });
+                        return;
+                    }
+                    const result = await registry.register(req.body);
+                    res.json(result);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : 'Unknown error';
+                    console.error('Registration error:', error);
+                    res.status(500).json({ error: 'Registration failed', message });
+                }
+            });
+            // Unregister endpoint
+            this.app.post('/unregister', async (req, res) => {
+                try {
+                    const registry = this.plugin.getRegistry();
+                    if (!registry) {
+                        res.status(501).json({ error: 'Multi-tenant not enabled' });
+                        return;
+                    }
+                    const { organizationId } = req.body;
+                    if (!organizationId) {
+                        res.status(400).json({ error: 'Missing organizationId' });
+                        return;
+                    }
+                    const success = await registry.unregister(organizationId);
+                    res.json({ success, message: success ? 'Unregistered successfully' : 'Organization not found' });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : 'Unknown error';
+                    console.error('Unregister error:', error);
+                    res.status(500).json({ error: 'Unregister failed', message });
+                }
+            });
+            // Stats endpoint (admin)
+            this.app.get('/stats', async (req, res) => {
+                try {
+                    const registry = this.plugin.getRegistry();
+                    if (!registry) {
+                        res.status(501).json({ error: 'Multi-tenant not enabled' });
+                        return;
+                    }
+                    const stats = await registry.getStats();
+                    res.json(stats);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : 'Unknown error';
+                    res.status(500).json({ error: message });
+                }
+            });
+        }
+        // Manifest endpoint
+        this.app.get('/manifest.json', (req, res) => {
+            try {
+                const endpoint = this.getBaseUrl();
+                const manifest = this.plugin.generateManifest({ endpoint });
+                res.json(manifest);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                res.status(500).json({ error: message });
+            }
+        });
+        // Transform endpoints
+        const allTransforms = this.plugin.getAllTransforms();
+        for (const transform of allTransforms) {
+            this.app.post(`/${transform.id}`, async (req, res) => {
+                try {
+                    await this.handleTransform(transform.id, req, res);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : 'Unknown error';
+                    console.error(`Transform ${transform.id} error:`, error);
+                    res.status(500).json({
+                        error: 'Transform execution failed',
+                        message,
+                    });
+                }
+            });
+        }
+        // 404 handler
+        this.app.use((req, res) => {
+            res.status(404).json({
+                error: 'Not found',
+                path: req.path,
+            });
+        });
+    }
+    /**
+     * Handler per transform
+     */
+    async handleTransform(transformId, req, res) {
+        const body = req.body;
+        if (!body.input) {
+            res.status(400).json({ error: 'Missing input' });
+            return;
+        }
+        // Estrai organization ID dall'header (per multi-tenancy)
+        const organizationId = req.headers['x-organization-id'];
+        // Se il plugin è multi-tenant, organizationId è obbligatorio
+        if (this.plugin.isMultiTenant() && !organizationId) {
+            res.status(400).json({ error: 'Missing X-Organization-Id header for multi-tenant plugin' });
+            return;
+        }
+        // Aggiungi organizationId all'input
+        if (organizationId) {
+            body.input.organizationId = organizationId;
+        }
+        const isAsync = this.plugin.isAsyncTransform(transformId);
+        if (isAsync) {
+            // Transform asincrona
+            if (!body.callbackUrl) {
+                res.status(400).json({ error: 'Missing callbackUrl for async transform' });
+                return;
+            }
+            const result = await this.plugin.executeAsyncTransform(transformId, body.input, body.callbackUrl, organizationId);
+            const response = {
+                async: true,
+                jobId: result.jobId,
+                estimatedTime: result.estimatedTime,
+                message: 'Job queued for processing',
+            };
+            res.json(response);
+        }
+        else {
+            // Transform sincrona
+            const result = await this.plugin.executeTransform(transformId, body.input);
+            const response = {
+                async: false,
+                result,
+            };
+            res.json(response);
+        }
+    }
+    /**
+     * Ottieni base URL del server
+     */
+    getBaseUrl() {
+        const protocol = this.options.https ? 'https' : 'http';
+        const host = this.options.host || 'localhost';
+        const port = this.options.port;
+        return `${protocol}://${host}:${port}`;
+    }
+    /**
+     * Avvia il server
+     */
+    async start() {
+        return new Promise((resolve, reject) => {
+            try {
+                if (this.options.https) {
+                    // HTTPS server
+                    const httpsOptions = {
+                        key: fs_1.default.readFileSync(this.options.https.key),
+                        cert: fs_1.default.readFileSync(this.options.https.cert),
+                    };
+                    this.server = https_1.default.createServer(httpsOptions, this.app);
+                }
+                else {
+                    // HTTP server
+                    this.server = this.app.listen(this.options.port, this.options.host || '0.0.0.0');
+                }
+                this.server.listen(this.options.port, this.options.host || '0.0.0.0', () => {
+                    console.log(`🚀 Server listening on ${this.getBaseUrl()}`);
+                    resolve();
+                });
+                this.server.on('error', (error) => {
+                    console.error('Server error:', error);
+                    reject(error);
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Ferma il server
+     */
+    async stop() {
+        return new Promise((resolve, reject) => {
+            if (!this.server) {
+                resolve();
+                return;
+            }
+            this.server.close((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    console.log('✅ Server stopped');
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * Ottieni Express app (per customizzazione)
+     */
+    getApp() {
+        return this.app;
+    }
+}
+exports.ExpressServer = ExpressServer;

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@relazio/plugin-sdk",
+  "version": "0.1.0",
+  "description": "Official SDK for building external plugins for Relazio",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build",
+    "test": "vitest",
+    "lint": "eslint src --ext .ts"
+  },
+  "keywords": [
+    "relazio",
+    "osint",
+    "plugin",
+    "sdk",
+    "external-plugin"
+  ],
+  "author": "Relazio Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/relazio/plugin-sdk.git"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.10.6",
+    "@typescript-eslint/eslint-plugin": "^6.17.0",
+    "@typescript-eslint/parser": "^6.17.0",
+    "eslint": "^8.56.0",
+    "typescript": "^5.3.3",
+    "vitest": "^1.1.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}
+