@opengis/fastify-table 1.4.7 → 1.4.9

package/server/plugins/grpc/file2json.js

@@ -0,0 +1,54 @@
+import path from 'node:path';
+
+import downloadFile from '../file/downloadFile.js';
+
+import getGRPC from './grpc.js';
+
+const grpc = getGRPC();
+
+const file2json = async ({
+  buffer: buffer1, ext: ext1, filepath, encoding: encoding1 = 'UTF-8', debug,
+}) => {
+  if (!filepath && !(buffer1?.length && ext1)) return null;
+
+  const ext = ext1 || path.extname(filepath);
+
+  const encoding = { CP1251: 'windows-1251' }[encoding1] || encoding1;
+  const buffer = buffer1 || await downloadFile(filepath, { provider: 'fs', buffer: true, debug }) || '{}';
+
+  if (debug) return { filepath, buffer };
+
+  if (['.xls', '.xlsx'].includes(ext)) {
+    const { result } = await grpc.excelToJson({ base64: buffer.toString('base64'), type: 'xls' });
+    const json = typeof result === 'object' ? result : JSON.parse(result || {});
+    return json;
+  }
+
+  if (['.csv', '.txt'].includes(ext)) {
+    const { result } = await grpc.excelToJson({ base64: buffer.toString('base64'), type: 'csv', encoding });
+    const json = typeof result === 'object' ? result : JSON.parse(result || {});
+    return json;
+  }
+
+  if (['.zip'].includes(ext)) {
+    const { result } = await grpc.shpToGeojson({
+      base64: buffer.toString('base64'), encoding,
+    });
+    const json = typeof result === 'object' ? result : JSON.parse(result);
+    return json;
+  }
+
+  if (['.xml'].includes(ext)) {
+    const { result } = await grpc.xmlToJson({ xml: buffer.toString('utf-8') });
+    const json = typeof result === 'object' ? result : JSON.parse(result);
+    return json;
+  }
+
+  if (['.geojson', '.json'].includes(ext)) {
+    return JSON.parse(buffer.toString('utf-8'));
+  }
+
+  return filepath.replace(/"/g, '');
+};
+
+export default file2json;

package/server/plugins/grpc/grpc.js

@@ -0,0 +1,295 @@
+/* eslint-disable consistent-return */
+import grpc from '@grpc/grpc-js';
+import protoLoader from '@grpc/proto-loader';
+
+import { config, logger } from '../../../utils.js';
+
+config.ready = config.ready || {};
+
+// const { convertServerAddress = '193.239.152.181:44003' } = config;
+
+// external ip not-accessible from internal network
+const defaultConvertServerAddress = config.pg?.host?.startsWith('192.168.3') ? '192.168.1.96:4003' : '193.239.152.181:44003';
+
+const convertServerAddress = config.convertServerAddress || defaultConvertServerAddress;
+
+console.log('convertServerAddress: ', convertServerAddress, !!config.convertServerAddress);
+
+const relpath = 'server/plugins/grpc/utils/convertp.proto';
+const protoLocation = process.cwd().includes('fastify-table') ? relpath : `node_modules/@opengis/fastify-table/${relpath}`;
+
+const proto = grpc.loadPackageDefinition(
+  protoLoader.loadSync(protoLocation, {
+    keepCase: true,
+    longs: String,
+    enums: String,
+    defaults: true,
+    oneofs: true,
+  }),
+);
+
+const convertClient = new proto.Convert(
+  convertServerAddress,
+  grpc.credentials.createInsecure(),
+  {
+    'grpc.max_send_message_length': 512 * 1024 * 1024,
+    'grpc.max_receive_message_length': 512 * 1024 * 1024,
+  },
+);
+
+convertClient.waitForReady(Date.now() + 5000, (err) => {
+  if (err) {
+    config.ready.convert = false;
+    console.error('Client connection timeout or failure:', err);
+  }
+  else {
+    config.ready.convert = true;
+    console.log('Client connected successfully.');
+    // You can now make RPC calls safely
+  }
+});
+
+// rewrite, merge??
+const pdfMerge = async (data) => new Promise((res, rej) => {
+  convertClient.pdfMerge(data, (err, data1) => {
+    if (err) {
+      logger.file('grpc/convert', { error: err.toString(), stack: err.stack, ready: config.ready.convert });
+      if (!config.ready.convert) {
+        return rej(new Error('no grpc convert connection'));
+      }
+      return rej(err);
+    }
+    res(data1);
+  });
+});
+
+const htmlToPdf = async (data) => new Promise((res, rej) => {
+  convertClient.htmlToPdf(data, (err, data1) => {
+    if (err) {
+      logger.file('grpc/convert', { error: err.toString(), stack: err.stack, ready: config.ready.convert });
+      if (!config.ready.convert) {
+        return rej(new Error('no grpc convert connection'));
+      }
+      return rej(err);
+    }
+    res(data1);
+  });
+});
+
+const csvToXls = async (data) => new Promise((res, rej) => {
+  convertClient.csvToXls(data, (err, data1) => {
+    if (err) {
+      logger.file('grpc/convert', { error: err.toString(), stack: err.stack, ready: config.ready.convert });
+      if (!config.ready.convert) {
+        return rej(new Error('no grpc convert connection'));
+      }
+      return rej(err);
+    }
+    res(data1);
+  });
+});
+
+const jsonToXls = async (data) => new Promise((res, rej) => {
+  convertClient.jsonToXls(data, (err, data1) => {
+    if (err) {
+      logger.file('grpc/convert', { error: err.toString(), stack: err.stack, ready: config.ready.convert });
+      if (!config.ready.convert) {
+        return rej(new Error('no grpc convert connection'));
+      }
+      return rej(err);
+    }
+    res(data1);
+  });
+});
+
+const excelToJson = async (data) => new Promise((res, rej) => {
+  convertClient.excelToJson(data, (err, data1) => {
+    if (err) {
+      logger.file('grpc/convert', { error: err.toString(), stack: err.stack, ready: config.ready.convert });
+      if (!config.ready.convert) {
+        return rej(new Error('no grpc convert connection'));
+      }
+      return rej(err);
+    }
+    res(data1);
+  });
+});
+
+const xmlToJson = async (data) => new Promise((res, rej) => {
+  convertClient.xmlToJson(data, (err, data1) => {
+    if (err) {
+      logger.file('grpc/convert', { error: err.toString(), stack: err.stack, ready: config.ready.convert });
+      if (!config.ready.convert) {
+        return rej(new Error('no grpc convert connection'));
+      }
+      return rej(err);
+    }
+    res(data1);
+  });
+});
+
+const html2Doc = async (data) => new Promise((res, rej) => {
+  convertClient.htmlToDoc(data, (err, data1) => {
+    if (err) {
+      logger.file('grpc/convert', { error: err.toString(), stack: err.stack, ready: config.ready.convert });
+      if (!config.ready.convert) {
+        return rej(new Error('no grpc convert connection'));
+      }
+      return rej(err);
+    }
+    res(data1);
+  });
+});
+
+const htmlToImg = async (data) => new Promise((res, rej) => {
+  convertClient.htmlToImage(data, (err, data1) => {
+    if (err) {
+      logger.file('grpc/convert', { error: err.toString(), stack: err.stack, ready: config.ready.convert });
+      if (!config.ready.convert) {
+        return rej(new Error('no grpc convert connection'));
+      }
+      return rej(err);
+    }
+    res(data1);
+  });
+});
+
+const shpToGeojson = async (data) => new Promise((res, rej) => {
+  convertClient.shpToGeojson(data, (err, data1) => {
+    if (err) {
+      logger.file('grpc/convert', { error: err.toString(), stack: err.stack, ready: config.ready.convert });
+      if (!config.ready.convert) {
+        return rej(new Error('no grpc convert connection'));
+      }
+      return rej(err);
+    }
+    res(data1);
+  });
+});
+
+const geojsonToShp = async (data) => new Promise((res, rej) => {
+  convertClient.geojsonToShp(data, (err, data1) => {
+    if (err) {
+      logger.file('grpc/convert', { error: err.toString(), stack: err.stack, ready: config.ready.convert });
+      if (!config.ready.convert) {
+        return rej(new Error('no grpc convert connection'));
+      }
+      return rej(err);
+    }
+    res(data1);
+  });
+});
+
+const geojsonToGpkg = async (data) => new Promise((res, rej) => {
+  convertClient.geojsonToGpkg(data, (err, data1) => {
+    if (err) {
+      logger.file('grpc/convert', { error: err.toString(), stack: err.stack, ready: config.ready.convert });
+      if (!config.ready.convert) {
+        return rej(new Error('no grpc convert connection'));
+      }
+      return rej(err);
+    }
+    res(data1);
+  });
+});
+
+const docToPDF = async (data) => new Promise((res, rej) => {
+  convertClient.docToPDF(data, (err, data1) => {
+    if (err) {
+      logger.file('grpc/convert', { error: err.toString(), stack: err.stack, ready: config.ready.convert });
+      if (!config.ready.convert) {
+        return rej(new Error('no grpc convert connection'));
+      }
+      return rej(err);
+    }
+    res(data1);
+  });
+});
+
+const mergeImages = async (data) => new Promise((res, rej) => {
+  convertClient.mergeImages(data, (err, data1) => {
+    if (err) {
+      logger.file('grpc/convert', { error: err.toString(), stack: err.stack, ready: config.ready.convert });
+      if (!config.ready.convert) {
+        return rej(new Error('no grpc convert connection'));
+      }
+      return rej(err);
+    }
+    res(data1);
+  });
+});
+
+const resizeImage = async (data) => new Promise((res, rej) => {
+  convertClient.resizeImage(data, (err, data1) => {
+    if (err) {
+      logger.file('grpc/convert', { error: err.toString(), stack: err.stack, ready: config.ready.convert });
+      if (!config.ready.convert) {
+        return rej(new Error('no grpc convert connection'));
+      }
+      return rej(err);
+    }
+    res(data1);
+  });
+});
+
+const jsonToYaml = async (data) => new Promise((res, rej) => {
+  convertClient.jsonToYaml(data, (err, data1) => {
+    if (err) {
+      logger.file('grpc/convert', { error: err.toString(), stack: err.stack, ready: config.ready.convert });
+      if (!config.ready.convert) {
+        return rej(new Error('no grpc convert connection'));
+      }
+      return rej(err);
+    }
+    res(data1);
+  });
+});
+
+const yamlToJson = async (data) => new Promise((res, rej) => {
+  convertClient.yamlToJson(data, (err, data1) => {
+    if (err) {
+      logger.file('grpc/convert', { error: err.toString(), stack: err.stack, ready: config.ready.convert });
+      if (!config.ready.convert) {
+        return rej(new Error('no grpc convert connection'));
+      }
+      return rej(err);
+    }
+    res(data1);
+  });
+});
+
+const log = async (data) => new Promise((res, rej) => {
+  convertClient.log(data, (err, data1) => {
+    if (err) {
+      logger.file('grpc/convert', { error: err.toString(), stack: err.stack, ready: config.ready.convert });
+      if (!config.ready.convert) {
+        return rej(new Error('no grpc convert connection'));
+      }
+      return rej(err);
+    }
+    res(data1);
+  });
+});
+
+const getGRPC = () => ({
+  pdfMerge,
+  htmlToPdf,
+  csvToXls,
+  jsonToXls,
+  excelToJson,
+  xmlToJson,
+  html2Doc,
+  htmlToImg,
+  shpToGeojson,
+  geojsonToShp,
+  geojsonToGpkg,
+  docToPDF,
+  mergeImages,
+  resizeImage,
+  jsonToYaml,
+  yamlToJson,
+  log,
+  convertServerAddress,
+});
+
+export default getGRPC;

package/server/plugins/grpc/office2pdf.js

@@ -0,0 +1,68 @@
+/* eslint-disable consistent-return */
+import grpc from '@grpc/grpc-js';
+import protoLoader from '@grpc/proto-loader';
+
+import { config, logger } from '../../../utils.js';
+
+config.ready = config.ready || {};
+
+// external ip not-accessible from internal network
+const defaultOfficeConverterServerAddress = config.pg?.host?.startsWith('192.168.3') ? '192.168.1.96:4011' : '193.239.152.181:44011';
+
+const officeConverterServerAddress = config.officeConverterServerAddress || defaultOfficeConverterServerAddress;
+
+console.log('officeConverterServerAddress: ', officeConverterServerAddress, !!config.officeConverterServerAddress);
+
+const relpath = 'server/plugins/grpc/utils/office2pdf.proto';
+const protoLocation = process.cwd().includes('fastify-table') ? relpath : `node_modules/@opengis/fastify-table/${relpath}`;
+
+const proto = grpc.loadPackageDefinition(
+  protoLoader.loadSync(protoLocation, {
+    keepCase: true,
+    longs: String,
+    enums: String,
+    defaults: true,
+    oneofs: true,
+  }),
+);
+
+const officeClient = new proto.OfficeConverterService(
+  officeConverterServerAddress,
+  grpc.credentials.createInsecure(),
+  {
+    'grpc.max_send_message_length': 512 * 1024 * 1024,
+    'grpc.max_receive_message_length': 512 * 1024 * 1024,
+  },
+);
+
+officeClient.waitForReady(Date.now() + 5000, (err) => {
+  if (err) {
+    config.ready.office2pdf = false;
+    console.error('Client connection timeout or failure:', err);
+  }
+  else {
+    config.ready.office2pdf = true;
+    console.log('Client connected successfully.');
+    // You can now make RPC calls safely
+  }
+});
+
+const officeToPdf = async (data) => new Promise((res, rej) => {
+  officeClient.OfficeToPdf(data, (err, data1) => {
+    if (err) {
+      logger.file('grpc/office2pdf', { error: err.toString(), stack: err.stack, ready: config.ready.office2pdf });
+      if (!config.ready.office2pdf) {
+        return rej(new Error('no grpc office2pdf connection'));
+      }
+      return rej(err);
+    }
+    res(data1);
+  });
+});
+
+const getOffice = () => ({
+  officeToPdf,
+  officeConverterServerAddress,
+});
+
+export default getOffice;

package/server/plugins/grpc/utils/convertp.proto

@@ -0,0 +1,137 @@
+syntax = "proto3";
+
+service Convert {
+  rpc csvToXls(csvToXlsParams) returns (FileBase64) {}
+  rpc jsonToXls(jsonToXlsParams) returns (FileBase64) {}
+  rpc pdfMerge(pdfMergeParams) returns (FileBase64) {}
+  rpc htmlToPdf(htmlToPdfParams) returns (FileBase64) {}
+  rpc excelToJson(excelToJsonParams) returns (FileBase64) {}
+  rpc xmlToJson(xmlToJsonParams) returns (FileBase64) {}
+  rpc htmlToDoc(htmlToDocParams) returns (FileBase64) {}
+  rpc htmlToImage(htmlToImageParams) returns (FileBase64) {}
+  rpc geojsonToShp(geojsonToShpParams) returns (FileBase64) {}
+  rpc shpToGeojson(shpToGeojsonParams) returns (FileBase64) {}
+  rpc docToPDF(docToPDFParams) returns (FileBase64) {}
+  rpc mergeImages(mergeImagesIn) returns (FileBase64) {}
+  rpc resizeImage(resizeImageIn) returns (FileBase64) {}
+  rpc jsonToYaml(jsonToYamlIn) returns (FileBase64) {}
+  rpc yamlToJson(yamlToJsonIn) returns (FileBase64) {}
+  rpc log(log_in) returns (log_out) {}
+  rpc geojsonToGpkg(geojsonToShpParams) returns (FileBase64) {}
+}
+
+message jsonToYamlIn {
+  string json = 1;
+}
+
+message yamlToJsonIn {
+  string yaml = 1;
+}
+
+message resizeImageIn {
+  string base64 = 1;
+  uint64 width = 2;
+  uint64 height = 3;
+  uint32 quality = 4;
+  uint32 subsampling = 5;
+}
+
+message pdfToImgIn {
+  string pdfPath = 1;
+  string imgPath = 2;
+}
+
+message pdfToImgOut {
+  string imgPath = 1;
+}
+
+message log_in {
+	uint32 rows = 1;
+	string level = 2;
+}
+
+message log_out {
+	repeated string logs = 1;
+}
+
+enum mergeImageFormat {
+  VERTICAL = 0;
+  HORIZONTAL = 1;
+  OVERLAY = 2;
+}
+
+message imageMeta {
+  string base64 = 1;
+  mergeImageFormat mergeFormat = 2;
+}
+
+message mergeImagesIn {
+  repeated string images = 1;
+  repeated imageMeta imagesMeta = 2;
+  string background = 3;
+  string mergeFormat = 4;
+}
+
+message docToPDFParams {
+  string base64 = 1;
+  string to = 2;
+  string ext = 3;
+}
+
+message shpToGeojsonParams {
+  string base64 = 1;
+}
+
+message geojsonToShpParams {
+  string geojson = 1;
+  string proj = 2;
+}
+
+message xmlToJsonParams {
+  string xml = 1;
+}
+
+message jsonToXlsParams {
+  string json = 1;
+  string header = 2;
+  string subheader = 3;
+  string colmodel = 4;
+}
+
+message csvToXlsParams {
+  string csv = 1;
+  string header = 2;
+  string subheader = 3;
+  string separator = 4;
+}
+
+message excelToJsonParams {
+  string base64 = 1;
+  string type = 2;
+  string delimiter = 3;
+  string encoding = 4;
+}
+
+message htmlToPdfParams {
+  string html = 1;
+  string pdfPageConfig = 2;
+}
+
+message pdfMergeParams {
+  repeated string mergeFiles = 1;
+}
+
+message htmlToImageParams {
+  string html = 1;
+  string format = 2;
+  uint64 width = 3;
+  uint64 height = 4;
+}
+
+message htmlToDocParams {
+  string html = 1;
+}
+
+message FileBase64 {
+  string result = 1;
+}

package/server/plugins/grpc/utils/csv2xls.js

@@ -0,0 +1,8 @@
+import grpc from '../grpc.js';
+
+export default async function csv2xls({
+  csvBuffer,
+}) {
+  const result = await grpc.csvToXls({ buffer: csvBuffer.toString('base64') });
+  return { resultBuffer: result.result };
+}

package/server/plugins/grpc/utils/excel2Json.js

@@ -0,0 +1,8 @@
+import grpc from '../grpc.js';
+
+export default async function excel2Json({
+  buffer, type, delimiter,
+}) {
+  const { result } = await grpc.excelToJson({ buffer: buffer.toString('base64'), type, delimiter });
+  return { resultBuffer: result };
+}

package/server/plugins/grpc/utils/html2doc.js

@@ -0,0 +1,19 @@
+import { mkdir, writeFile } from 'fs/promises';
+import path from 'path';
+
+import grpc from '../grpc.js';
+
+export default async function html2doc({
+  html, filepath,
+}) {
+  const result = await grpc.html2Doc({ html });
+  if (result.err) throw new Error(result.err);
+  try {
+    await mkdir(path.dirname(filepath), { recursive: true });
+    await writeFile(filepath, result.result, 'base64');
+    return { filepath };
+  }
+  catch (err) {
+    return { err: err.toString(), status: 500 };
+  }
+}

package/server/plugins/grpc/utils/html2img.js

@@ -0,0 +1,18 @@
+import { mkdir, writeFile } from 'fs/promises';
+import path from 'path';
+import grpc from '../grpc.js';
+
+export default async function html2pdf({
+  html, filepath,
+}) {
+  const result = await grpc.htmlToImg({ html });
+  if (result.err) throw new Error(result.err);
+  try {
+    await mkdir(path.dirname(filepath), { recursive: true });
+    await writeFile(filepath, result.result, 'base64');
+    return { filepath };
+  }
+  catch (err) {
+    return { err: err.toString(), status: 500 };
+  }
+}

package/server/plugins/grpc/utils/html2pdf.js

@@ -0,0 +1,23 @@
+import { mkdir, writeFile } from 'fs/promises';
+import path from 'path';
+
+import grpc from '../grpc.js';
+
+export default async function html2pdf({
+  html, filepath, logger,
+}) {
+  const time = Date.now();
+  try {
+    const result = await grpc.htmlToPdf({ html });
+    logger.file('format/pdf', { msec: Date.now() - time, resp_code: 200 });
+
+    if (result.err) throw new Error(result.err);
+
+    await mkdir(path.dirname(filepath), { recursive: true });
+    await writeFile(filepath, result.result, 'base64');
+    return { filepath };
+  }
+  catch (err) {
+    return { err: err.toString(), status: 500 };
+  }
+}

package/server/plugins/grpc/utils/htmlTemplate.js

@@ -0,0 +1,14 @@
+// TODO delete style when fully switch to the new code with merge
+const createTemplate = ({ domain, html }) => `<!DOCTYPE html>\
+<html>
+<head>
+  <base uri="http://${domain}/">
+  <meta charset="utf-8">
+  <style>html, body {font-size: 10pt !important;}</style>
+</head>
+<body>
+  ${html || ''}
+</body>
+</html`;
+
+export default createTemplate;

package/server/plugins/grpc/utils/json2xls.js

@@ -0,0 +1,13 @@
+import grpc from '../grpc.js';
+
+export default async function json2xls({
+  json,
+}) {
+  try {
+    const result = await grpc.jsonToXls({ buffer: json });
+    return { resultBuffer: result.result };
+  }
+  catch (err) {
+    return { err: err.toString() };
+  }
+}

package/server/plugins/grpc/utils/mergePdf.js

@@ -0,0 +1,20 @@
+import path from 'path';
+import { mkdir, writeFile } from 'fs/promises';
+
+import grpc from '../grpc.js';
+
+export default async function mergePdf({
+  pdfStringList, pathToSave, filename,
+}) {
+  const filename1 = filename || path.basename(pathToSave);
+  const result = grpc.pdfMerge(pdfStringList);
+  if (result.err) return { err: result.err, status: 500 };
+  try {
+    await mkdir(path.dirname(pathToSave), { recursive: true });
+    await writeFile(pathToSave, result.result, 'base64');
+    return { filename: `${filename1}.pdf`, filepath: pathToSave };
+  }
+  catch (err) {
+    return { err: err.toString(), status: 500 };
+  }
+}

package/server/plugins/grpc/utils/office2pdf.proto

@@ -0,0 +1,14 @@
+syntax = "proto3";
+
+service OfficeConverterService {
+  rpc OfficeToPdf(OfficeToPdfRequest) returns (OfficeToPdfResponse) {}
+}
+
+message OfficeToPdfRequest {
+  string file = 1;
+  string ext = 2;
+}
+
+message OfficeToPdfResponse {
+  string file = 1;
+}