@opengis/fastify-table/server/plugins/grpc/grpc.js

core-plugins

/* eslint-disable consistent-return */
import grpc from '@grpc/grpc-js';
import protoLoader from '@grpc/proto-loader';

import config from '../../../config.js';
import logger from '../logger/getLogger.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;