@opengis/fastify-table 1.4.47 → 1.4.49

package/index.js

@@ -1,8 +1,9 @@
 import path from 'node:path';
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import fp from 'fastify-plugin';
 import { fileURLToPath } from 'node:url';
 
+import fp from 'fastify-plugin';
+
 import config from './config.js';
 
 const { maxFileSize = 512 } = config;
@@ -15,6 +16,7 @@ import cronPlugin from './server/plugins/cron/index.js';
 import crudPlugin from './server/plugins/crud/index.js';
 
 import pgPlugin from './server/plugins/pg/index.js';
+import sqlitePlugin from './server/plugins/sqlite/index.js';
 import policyPlugin from './server/plugins/policy/index.js';
 import metricPlugin from './server/plugins/metric/index.js';
 import redisPlugin from './server/plugins/redis/index.js';
@@ -95,12 +97,20 @@ async function plugin(fastify, opt) {
   redisPlugin(fastify);
   // helperPlugin(fastify);
   await pgPlugin(fastify, opt);
+  await sqlitePlugin(fastify, opt);
   tablePlugin(fastify, opt);
   crudPlugin(fastify, opt);
   utilPlugin(fastify, opt);
   cronPlugin(fastify, opt);
   loggerPlugin(fastify, opt);
 
+  await fastify.register(import('@fastify/rate-limit'), {
+    max: 100,
+    timeWindow: '1 minute',
+    global: true,
+    keyGenerator: (req) => `${req.ip}-${req.raw.url.split('?')[0]}`,
+  });
+
   if (config.dblist) {
     dblistRoutes(fastify, opt);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/fastify-table",
-  "version": "1.4.47",
+  "version": "1.4.49",
   "type": "module",
   "description": "core-plugins",
   "keywords": [
@@ -34,8 +34,10 @@
     "@aws-sdk/client-s3": "3.554.0",
     "@fastify/http-proxy": "11.1.2",
     "@fastify/multipart": "9.0.3",
+    "@fastify/rate-limit": "10.3.0",
     "@grpc/grpc-js": "1.10.6",
     "@grpc/proto-loader": "0.7.12",
+    "better-sqlite3": "12.2.0",
     "dotenv": "16.5.0",
     "fastify": "5.3.3",
     "fastify-plugin": "5.0.1",

package/server/plugins/grpc/grpc.js

@@ -1,26 +1,33 @@
-/* eslint-disable consistent-return */
+import path from 'node:path';
+import { fileURLToPath } from 'url';
+
 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 filename = fileURLToPath(import.meta.url);
+const dirname = path.dirname(filename);
 
-// const { convertServerAddress = '193.239.152.181:44003' } = config;
+config.ready = config.ready || {};
 
 // 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 defaultConvertServerAddress = config.pg?.host?.startsWith?.('192.168.3')
+  ? '192.168.1.96:4003'
+  : '193.239.152.181:44003';
 
-const convertServerAddress = config.convertServerAddress || defaultConvertServerAddress;
+const convertServerAddress = config.convertServerAddress === true
+  ? defaultConvertServerAddress
+  : config.convertServerAddress;
 
-console.log('convertServerAddress: ', convertServerAddress, !!config.convertServerAddress);
+if (config.local || config.debug) 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 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, {
+  protoLoader.loadSync(`${dirname}/utils/convertp.proto`, {
     keepCase: true,
     longs: String,
     enums: String,
@@ -29,267 +36,85 @@ const proto = grpc.loadPackageDefinition(
   }),
 );
 
-const convertClient = new proto.Convert(
+const convertClient = convertServerAddress ? 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);
+) : {};
+
+if (convertServerAddress) {
+  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
+    }
+  });
+}
+
+const methodNames = [
+  'pdfMerge',
+  'htmlToPdf',
+  'csvToXls',
+  'jsonToXls',
+  'excelToJson',
+  'xmlToJson',
+  'htmlToDoc',
+  'htmlToImage',
+  'shpToGeojson',
+  'geojsonToShp',
+  'geojsonToGpkg',
+  'docToPDF',
+  'mergeImages',
+  'resizeImage',
+  'jsonToYaml',
+  'yamlToJson',
+  'log',
+];
+
+const wrapGrpcCall = (methodName) => async (data) => new Promise((res, rej) => {
+  if (!convertServerAddress) {
+    logger.file('grpc/convert', {
+      method: methodName,
+      error: 'grpc convert not set',
+      stack: new Error().stack,
+    });
+    return rej(new Error('grpc convert not set'));
   }
-  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) => {
+  convertClient[methodName](data, (err, response) => {
     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);
-  });
-});
+      logger.file('grpc/convert', {
+        method: methodName,
+        error: err.toString(),
+        stack: err.stack,
+        ready: config.ready.convert,
+      });
 
-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);
+    return res(response);
   });
 });
 
-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 grpcMethods = methodNames.reduce((acc, name) => {
+  acc[name] = wrapGrpcCall(name);
+  return acc;
+}, {});
 
 const getGRPC = () => ({
-  pdfMerge,
-  htmlToPdf,
-  csvToXls,
-  jsonToXls,
-  excelToJson,
-  xmlToJson,
-  html2Doc,
-  htmlToImg,
-  shpToGeojson,
-  geojsonToShp,
-  geojsonToGpkg,
-  docToPDF,
-  mergeImages,
-  resizeImage,
-  jsonToYaml,
-  yamlToJson,
-  log,
+  ...grpcMethods,
   convertServerAddress,
 });
 

package/server/plugins/grpc/office2pdf.js

@@ -1,24 +1,33 @@
-/* eslint-disable consistent-return */
+import path from 'node:path';
+import { fileURLToPath } from 'url';
+
 import grpc from '@grpc/grpc-js';
 import protoLoader from '@grpc/proto-loader';
 
 import config from '../../../config.js';
 import logger from '../logger/getLogger.js';
 
+const filename = fileURLToPath(import.meta.url);
+const dirname = path.dirname(filename);
+
 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 defaultOfficeConverterServerAddress = config.pg?.host?.startsWith?.('192.168.3')
+  ? '192.168.1.96:4011'
+  : '193.239.152.181:44011';
 
-const officeConverterServerAddress = config.officeConverterServerAddress || defaultOfficeConverterServerAddress;
+const officeConverterServerAddress = config.officeConverterServerAddress === true
+  ? defaultOfficeConverterServerAddress
+  : config.officeConverterServerAddress;
 
 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 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, {
+  protoLoader.loadSync(`${dirname}/utils/office2pdf.proto`, {
     keepCase: true,
     longs: String,
     enums: String,
@@ -27,28 +36,38 @@ const proto = grpc.loadPackageDefinition(
   }),
 );
 
-const officeClient = new proto.OfficeConverterService(
+const officeClient = officeConverterServerAddress ? 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
-  }
-});
+if (officeConverterServerAddress) {
+  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) => {
+  if (!officeConverterServerAddress) {
+    logger.file('grpc/convert', {
+      method: 'officeToPdf',
+      error: 'grpc office2pdf not set',
+      stack: new Error().stack,
+    });
+    return rej(new Error('grpc office2pdf not set'));
+  }
   officeClient.OfficeToPdf(data, (err, data1) => {
     if (err) {
       logger.file('grpc/office2pdf', { error: err.toString(), stack: err.stack, ready: config.ready.office2pdf });

package/server/plugins/logger/index.js

@@ -3,6 +3,12 @@ import logger from './getLogger.js';
 import pgClients from '../pg/pgClients.js';
 
 async function plugin(fastify) {
+  fastify.addHook('onResponse', async (req, reply) => {
+    if (reply?.statusCode && reply.statusCode >= 400) {
+      logger.metrics(`error-count:${reply.statusCode}`);
+    }
+  });
+
   fastify.setErrorHandler(async (error, request, reply) => {
     // validation not error
     if (error.validation) {
@@ -19,6 +25,7 @@ async function plugin(fastify) {
 
     return reply.status(error.statusCode || 500).send(msg);
   });
+
   fastify.addHook('onListen', async () => {
     logger.file('init', { db: pgClients.client?.options?.database });
   });

package/server/plugins/migration/exec.migrations.js

@@ -7,33 +7,57 @@ import pgClients from '../pg/pgClients.js';
 // import getCallerDir from './get.caller.dir.js';
 
 const time = Date.now();
+const debug = config.debug || config.local;
 
 export default async function execMigrations(dirPath, pg = pgClients.client, iscore = false) {
-  if (
-    !dirPath
-    || (config.migrationsCore === false && iscore)
-    || config.migrations === false
-    || process.env.NODE_ENV === 'unit test'
-  ) {
-    console.log('migrations skip', 'core: ', !!iscore, 'dir: ', dirPath || 'not specified');
-    return;
+  if (!dirPath) {
+    const txt = 'migrations skip: path not specified';
+    if (debug) console.warn(txt);
+    return txt;
   }
 
-  console.log('migrations start', dirPath, Date.now() - time);
+  if (config.migrationsCore === false && iscore) {
+    const txt = `migrations skip: core - ${dirPath}`;
+    if (debug) console.log(txt);
+    return txt;
+  }
+
+  if (config.migrations === false && !iscore) {
+    const txt = `migrations skip: path - ${dirPath}`;
+    if (debug) console.log(txt);
+    return txt;
+  }
+
+  if (process.env.NODE_ENV !== 'production' && (!config.migrations || !(config.migrationsCore && iscore))) {
+    const txt = `migrations skip: not a production environment - ${iscore ? 'core' : 'path'} : ${dirPath}`;
+    if (debug) console.log(txt);
+    return txt;
+  }
+
+  if (debug) console.log('migrations start', dirPath, Date.now() - time);
 
   const exists = existsSync(dirPath);
 
-  if (exists) {
-    // get directory sql file list
-    const content = readdirSync(dirPath, { withFileTypes: true })
-      ?.filter((el) => el.isFile() && path.extname(el.name) === '.sql')
-      ?.map((el) => el.name) || [];
+  if (!exists) {
+    const txt = `migrations skip: directory not found - ${dirPath}`;
+    if (debug) console.warn(txt);
+    return txt;
+  }
+
+  // get directory sql file list
+  const content = readdirSync(dirPath, { withFileTypes: true })
+    ?.filter((el) => el.isFile() && path.extname(el.name) === '.sql')
+    ?.map((el) => el.name) || [];
 
-    // execute sql files
-    if (content?.length) {
-      await content.reduce((promise, filename) => promise.then(() => execSql(path.join(dirPath, filename), pg)), Promise.resolve());
-    }
+  // execute sql files
+  if (!content?.length) {
+    const txt = `migrations skip: no sql in specified directory - ${dirPath}`;
+    if (debug) console.warn(txt);
+    return txt;
   }
 
-  console.log('migrations finish', dirPath, exists, Date.now() - time);
+  await content.reduce((promise, filename) => promise.then(() => execSql(path.join(dirPath, filename), pg)), Promise.resolve());
+  if (debug) console.log('migrations success', dirPath, exists, Date.now() - time);
+
+  return 'success';
 }

package/server/plugins/migration/exec.sql.js

@@ -12,6 +12,8 @@ import getRedis from '../redis/funcs/getRedis.js';
 
 const rclient = getRedis();
 
+const debug = config.debug || config.local;
+
 export default async function execSql(filepath, pg = pgClients.client) {
     const start = Date.now();
 
@@ -33,16 +35,16 @@ export default async function execSql(filepath, pg = pgClients.client) {
     const hash = createHash('md5').update(sql).digest('hex');
     const hashes = config.redis ? await rclient.hgetall(`${pg?.options?.database}:migration-hashes`).then(obj => Object.keys(obj)) : [];
 
-    if (hashes.includes(hash) && !config.disableCache) {
+    if (hashes.includes(hash) && !config.disableCache && debug) {
         console.log(filename, 'skip equal hash', Date.now() - start);
         return null;
     }
 
     try {
-        console.log(filename, 'start', Date.now() - start);
+        if (debug) console.log(filename, 'start', Date.now() - start);
         await pg.query(sql);
         if (!config.disableCache && config.redis) await rclient.hset(`${pg?.options?.database}:migration-hashes`, hash, 1);
-        console.log(filename, 'finish', Date.now() - start);
+        if (debug) console.log(filename, 'finish', Date.now() - start);
         logger.file('migration/success', {
             filepath,
             result: 'success',
@@ -51,7 +53,7 @@ export default async function execSql(filepath, pg = pgClients.client) {
         return 'ok';
     }
     catch (err) {
-        console.log(filename, 'error', err.toString(), Date.now() - start);
+        console.error(filename, 'error', err.toString(), Date.now() - start);
         logger.file('migration/error', {
             filepath,
             result: 'error',

package/server/plugins/pg/funcs/init.js

@@ -109,6 +109,7 @@ async function init(client) {
   Object.assign(client, {
     one, pgType, pk, tlist, relkinds, queryCache, queryNotice, querySafe,
   });
+  console.log('db connected', client.options?.database);
 }
 
 // export default client;

package/server/plugins/redis/funcs/getRedis.js

@@ -17,7 +17,7 @@ function getRedis({ db } = { db: 0 }) {
   };
 
   redisClients[db] = new Redis(redisConfig);
-
+  console.log('redis connected', db);
   return redisClients[db];
 }
 

package/server/plugins/sqlite/funcs/getSqlite.js

@@ -0,0 +1,32 @@
+import Database from 'better-sqlite3';
+
+import config from '../../../../config.js';
+import sqliteClients from '../sqliteClients.js';
+import init from './init.js';
+
+function getSqliteAsync({
+  name,
+  readonly = false,
+  fileMustExist = false,
+  statement_timeout: timeout = 10000,
+} = {}) {
+  if (!config.sqlite) return null;
+
+  if (sqliteClients.client?.tlist) {
+    return sqliteClients.client;
+  }
+
+  const dbConfig = {
+    readonly,
+    fileMustExist,
+    timeout,
+    verbose: config.trace ? console.log : undefined,
+  };
+
+  sqliteClients.client = new Database(name || ':memory:', dbConfig);
+  init(sqliteClients.client);
+
+  return sqliteClients.client;
+}
+
+export default getSqliteAsync;

package/server/plugins/sqlite/funcs/init.js

@@ -0,0 +1,51 @@
+function init(client) {
+  if (!client) { return; }
+
+  const rows = client.prepare(`WITH tables AS (
+    SELECT name AS table_name
+    FROM sqlite_master
+    WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
+  ),
+  pk_columns AS (
+    SELECT
+      m.name AS table_name,
+      ti.name AS column_name,
+      ti.pk
+    FROM sqlite_master m
+    JOIN pragma_table_info(m.name) AS ti
+    WHERE ti.pk = 1
+  )
+  SELECT table_name, column_name
+  FROM pk_columns
+  WHERE table_name IN (
+    SELECT table_name
+    FROM pk_columns
+    GROUP BY table_name
+    HAVING COUNT(*) = 1
+  )
+  ORDER BY table_name;`).all();
+
+  const pk = Object.fromEntries(
+    rows.map(row => [row.table_name, row.column_name]),
+  );
+
+  const tlist = client.prepare('SELECT name FROM sqlite_master WHERE type=\'table\' AND name NOT LIKE \'sqlite_%\';').all().reduce((acc, curr) => {
+    acc.push(curr.name);
+    return acc;
+  }, []);
+
+  async function query(q, args = []) {
+    const data = client.prepare(q.replace(/\$\d+/g, '?')).all(...args);
+    return Promise.resolve({ rows: data, rowCount: data.length });
+  }
+
+  Object.assign(client, {
+    query,
+    pk,
+    tlist,
+  });
+
+  console.log('db connected', client.name || ':memory:');
+}
+
+export default init;

package/server/plugins/sqlite/index.js

@@ -0,0 +1,11 @@
+import fp from 'fastify-plugin';
+
+import sqliteClients from './sqliteClients.js';
+
+async function dbPlugin(app, opts) {
+  app.addHook('onClose', async () => {
+    Object.keys(sqliteClients).forEach(key => sqliteClients[key].close());
+  });
+}
+
+export default fp(dbPlugin);

package/server/plugins/sqlite/sqliteClients.js

@@ -0,0 +1,19 @@
+import Database from 'better-sqlite3';
+
+import config from '../../../config.js';
+import init from './funcs/init.js';
+
+const sqliteClients = {};
+
+if (config.sqlite) {
+  const client = new Database(config.sqlite?.name || ':memory:', {
+    readonly: config.sqlite?.readonly || false,
+    fileMustExist: config.sqlite?.fileMustExist || false,
+    timeout: config.sqlite?.statement_timeout || 10000,
+    verbose: config.trace ? console.log : undefined,
+  });
+  client.init = () => init(client);
+  client.init();
+  sqliteClients.client = client;
+}
+export default sqliteClients;

package/server/plugins/util/funcs/unflattenObject.js

@@ -14,8 +14,11 @@ export default function unflattenObject(flatObj) {
                         nestedObj[part] = flatObj[key]; // fallback to original value if parsing fails
                     }
                 }
+                else if (['true', 'false'].includes(flatObj[key]) || !isNaN(flatObj[key])) {
+                    nestedObj[part] = JSON.parse(flatObj[key]);
+                }
                 else {
-                    nestedObj[part] = ['true', 'false'].includes(flatObj[key]) ? JSON.parse(flatObj[key]) : flatObj[key];
+                    nestedObj[part] = flatObj[key];
                 }
             }
             else {

package/server/routes/logger/index.js

@@ -16,7 +16,7 @@ const loggerSchema = {
 };
 
 async function plugin(app) {
-  app.get('/logger-file/*', { config: { policy: ['public'] }, schema: loggerSchema }, loggerFile);
+  app.get('/logger-file/*', { config: { policy: ['public'], rateLimit: false }, schema: loggerSchema }, loggerFile);
 }
 
 export default plugin;

package/server/routes/table/index.js

@@ -27,7 +27,16 @@ async function plugin(app, config = {}) {
   app.get(`${prefix}/table-filter/:table`, { config: { policy }, schema: filterSchema }, filter);
 
   app.get(`${prefix}/table-info/:table/:id?`, { config: { policy }, schema: tableDataSchema }, tableInfo);
-  app.get(`${prefix}/suggest/:data`, { config: { policy }, schema: suggestSchema }, suggest);
+  app.get(`${prefix}/suggest/:data`, {
+    config: {
+      policy,
+      rateLimit: {
+        max: 10000,
+        timeWindow: '1 minute',
+      },
+    },
+    schema: suggestSchema,
+  }, suggest);
   app.get(`${prefix}/data/:table/:id?`, { config: { policy: ['public', 'no-sql'] }, schema: tableSchema }, data);
   app.get(`${prefix}/table-data/:table`, { config: { policy: ['user', 'no-sql'] }, schema: tableDataSchema }, data);
   app.get(`${prefix}/table-data/:table/:id`, { config: { policy }, schema: tableDataIdSchema }, cardData);

package/utils.js

@@ -7,6 +7,9 @@ import { handlebars, handlebarsSync } from './server/helpers/index.js';
 // pg
 import getPG from './server/plugins/pg/funcs/getPG.js';
 import getPGAsync from './server/plugins/pg/funcs/getPGAsync.js';
+import getSqlite from './server/plugins/sqlite/funcs/getSqlite.js';
+import initSqlite from './server/plugins/sqlite/funcs/init.js';
+import sqliteClients from './server/plugins/sqlite/sqliteClients.js';
 import getDBParams from './server/plugins/pg/funcs/getDBParams.js';
 import initPG from './server/plugins/pg/funcs/init.js';
 import pgClients from './server/plugins/pg/pgClients.js';
@@ -170,6 +173,11 @@ export {
   pgClients,
   getDBParams,
 
+  // sqlite
+  getSqlite,
+  initSqlite,
+  sqliteClients,
+
   // select
   getSelectVal,
   getSelectMeta,