@opengis/fastify-table 1.3.18 → 1.3.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/fastify-table",
-  "version": "1.3.18",
+  "version": "1.3.19",
   "type": "module",
   "description": "core-plugins",
   "keywords": [

package/server/plugins/cron/funcs/addCron.js

@@ -1,89 +1,11 @@
-import { createHash } from 'crypto';
-
 import config from '../../../../config.js';
-import getRedis from '../../redis/funcs/getRedis.js';
-import getPG from '../../pg/funcs/getPG.js';
-import logger from '../../logger/getLogger.js';
-import cronList from '../cronList.js';
-
-const md5 = (string) => createHash('md5').update(string).digest('hex');
-
-const rclient = getRedis();
-async function verifyUnique(name) {
-  const cronId = config.port || 3000 + md5(name);
-  // one per node check
-  const key = `cron:unique:${cronId}`;
-  const unique = await rclient.setnx(key, 1);
-  const ttl = await rclient.ttl(key);
-  if (!unique && ttl !== -1) {
-    return false;
-  }
-  await rclient.expire(key, 20);
-  return true;
-}
-
-const intervalStringMs = {
-  everyMin: 1000 * 60,
-  tenMin: 1000 * 60 * 10,
-  everyHour: 1000 * 60 * 60,
-  isHalfday: 1000 * 60 * 60 * 12,
-  dailyHour: 1000 * 60 * 60 * 24,
-};
 
-const interval2ms = {
-  string: (interval) => {
-    const date = new Date();
-    const intervarSplit = interval.match(/^(\*{2}|(\*)?(\d{1,2})):(\*(\d)|(\d{2}))/);
-    if (!intervarSplit) {
-      throw new Error(`interval ${interval} not suported`);
-    }
-    const [, , isHalfday, dailyHour, , tenMin, HourlyMin] = intervarSplit;
-    const intervalMs = (isHalfday && intervalStringMs.isHalfday)
-      || (dailyHour && intervalStringMs.dailyHour)
-      || (tenMin && intervalStringMs.tenMin)
-      || intervalStringMs.everyHour;
-    const offsetDay = ((+dailyHour || 0) * 60 + (+tenMin || +HourlyMin)) * 60 * 1000;
-    const offsetCur = (date - date.getTimezoneOffset() * 1000 * 60) % intervalMs;
-    const waitMs = (offsetDay - offsetCur + intervalMs) % intervalMs;
-    return [waitMs, intervalMs];
-  },
-  number: (interval) => {
-    const date = new Date();
-    const intervalMs = interval * 1000;
-    const dateWithTZ = date - date.getTimezoneOffset() * 1000 * 60;
-    const offsetCur = dateWithTZ % intervalMs;
-    // start every cron within 1 hour
-    const sixtyMinutesStartMs = 3600000;
-    const waitMs = (intervalMs - offsetCur) % sixtyMinutesStartMs;
-    return [waitMs, intervalMs];
-  },
-};
-
-async function runCron({
-  func, name,
-}) {
-  const pg = getPG();
-
-  const unique = await verifyUnique(name);
-
-  if (!unique) return;
-  const db = pg.options.database;
+import logger from '../../logger/getLogger.js';
+import pgClients from '../../pg/pgClients.js';
 
-  try {
-    // console.log(`cron:${name}`);
-    const data = await func({ pg });
-    const subdir = !!data ? 'cron' : 'cron/null';
-    logger.file(subdir, {
-      db, name, result: data,
-    });
-  }
-  catch (err) {
-    logger.file('cron', {
-      db, name, error: err.toString(),
-    });
-    logger.error(err);
-  }
-}
+import cronList from '../cronList.js';
+import runCron from './runCron.js';
+import interval2ms from './interval2ms.js';
 
 /**
  * interval:
@@ -97,7 +19,7 @@ async function runCron({
  * - 10 * 60 - every 10 minutes
  */
 
-export default async function addCron(func, interval) {
+export default async function addCron(func, interval, pg = pgClients.client) {
   const { time = {}, disabled = [] } = config.cron || {};
 
   const name = func.name || func.toString().split('/').at(-1).split('\'')[0];
@@ -115,16 +37,16 @@ export default async function addCron(func, interval) {
   const [waitMs, intervalMs] = interval2ms[typeof interval](userInterval);
 
   if (intervalMs < 1000) {
-    logger.file('cron', { name, error: `interval ${interval} to small` });
+    logger.file('cron', { name, error: `interval ${interval} too small` });
     return;
   }
 
   // setTimeout to w8 for the time to start
   setTimeout(() => {
-    runCron({ func, name });
+    runCron({ pg, func, name });
     // interval
     setInterval(() => {
-      runCron({ func, name });
+      runCron({ pg, func, name });
     }, intervalMs);
   }, waitMs);
 }

package/server/plugins/cron/funcs/interval2ms.js

@@ -0,0 +1,40 @@
+const intervalStringMs = {
+    everyMin: 1000 * 60,
+    tenMin: 1000 * 60 * 10,
+    everyHour: 1000 * 60 * 60,
+    isHalfday: 1000 * 60 * 60 * 12,
+    dailyHour: 1000 * 60 * 60 * 24,
+};
+
+const interval2ms = {
+    string: (interval) => {
+        const date = new Date();
+        const intervarSplit = interval.match(/^(\*{2}|(\*)?(\d{1,2})):(\*(\d)|(\d{2}))/);
+
+        if (!intervarSplit) {
+            throw new Error(`interval ${interval} not suported`);
+        }
+
+        const [, , isHalfday, dailyHour, , tenMin, HourlyMin] = intervarSplit;
+        const intervalMs = (isHalfday && intervalStringMs.isHalfday)
+            || (dailyHour && intervalStringMs.dailyHour)
+            || (tenMin && intervalStringMs.tenMin)
+            || intervalStringMs.everyHour;
+        const offsetDay = ((+dailyHour || 0) * 60 + (+tenMin || +HourlyMin)) * 60 * 1000;
+        const offsetCur = (date - date.getTimezoneOffset() * 1000 * 60) % intervalMs;
+        const waitMs = (offsetDay - offsetCur + intervalMs) % intervalMs;
+        return [waitMs, intervalMs];
+    },
+    number: (interval) => {
+        const date = new Date();
+        const intervalMs = interval * 1000;
+        const dateWithTZ = date - date.getTimezoneOffset() * 1000 * 60;
+        const offsetCur = dateWithTZ % intervalMs;
+        // start every cron within 1 hour
+        const sixtyMinutesStartMs = 3600000;
+        const waitMs = (intervalMs - offsetCur) % sixtyMinutesStartMs;
+        return [waitMs, intervalMs];
+    },
+};
+
+export default interval2ms;

package/server/plugins/cron/funcs/runCron.js

@@ -0,0 +1,23 @@
+import logger from '../../logger/getLogger.js';
+import pgClients from '../../pg/pgClients.js';
+
+import verifyUnique from './verifyUnique.js';
+
+export default async function runCron({
+    pg = pgClients.client, func, name,
+}) {
+    const unique = await verifyUnique(name);
+    if (!unique) return;
+
+    const db = pg.options.database;
+
+    try {
+        const data = await func({ pg });
+        const subdir = !!data ? 'cron' : 'cron/null';
+        logger.file(subdir, { db, name, result: data });
+    }
+    catch (err) {
+        logger.file('cron', { db, name, error: err.toString() });
+        logger.error(err);
+    }
+}

package/server/plugins/cron/funcs/verifyUnique.js

@@ -0,0 +1,22 @@
+import { createHash } from 'node:crypto';
+
+import config from '../../../../config.js';
+
+import getRedis from '../../redis/funcs/getRedis.js';
+
+const md5 = (string) => createHash('md5').update(string).digest('hex');
+
+const rclient = getRedis();
+
+export default async function verifyUnique(name) {
+    const cronId = config.port || 3000 + md5(name);
+    // one per node check
+    const key = `cron:unique:${cronId}`;
+    const unique = await rclient.setnx(key, 1);
+    const ttl = await rclient.ttl(key);
+    if (!unique && ttl !== -1) {
+        return false;
+    }
+    await rclient.expire(key, 20);
+    return true;
+}

package/server/plugins/cron/index.js

@@ -1,6 +1,74 @@
-import addCron from './funcs/addCron.js';
+import { createHash } from 'node:crypto';
+
+import config from "../../../config.js";
+
+import getPG from "../pg/funcs/getPG.js";
+import pgClients from "../pg/pgClients.js";
+import getRedis from '../redis/funcs/getRedis.js';
+import logger from "../logger/getLogger.js";
+import interval2ms from "./funcs/interval2ms.js";
+
+const rclient = getRedis();
+
+async function runCron({
+    pg = pgClients.client, query, name,
+}) {
+    const db = pg.options.database;
+
+    // verifyUnique
+    const key = `cron:unique:${name}`;
+    const unique = await rclient.setnx(key, 1);
+    const ttl = await rclient.ttl(key);
+
+    if (!unique && ttl !== -1) {
+        // if (config.trace) console.log(name, db, query, 'skip unique');
+        return;
+    }
+
+    await rclient.expire(key, 20);
+
+    try {
+        if (!pg.pk) await pg.init();
+
+        if (config.trace) console.time(`${db}:${query}`);
+        const { command, rows = [], rowCount } = await pg.query(query);
+        if (config.trace) console.timeEnd(`${db}:${query}`);
+
+        logger.file('cron', { db, name, result: { command, rows, rowCount } });
+    }
+    catch (err) {
+        if (config.trace) console.error(name, err.toString());
+        logger.file('cron/error', { db, name, error: err.toString() });
+        logger.error(err);
+    }
+}
 
 async function plugin(fastify) {
-//   fastify.decorate('addCron', addCron);
+    if (config.cronList?.length) {
+        config.cronList?.filter(el => el.query && !el.disabled)?.forEach?.((el, idx) => {
+            const { interval, db, query } = el;
+            const name = createHash('md5').update(`${config.port || 3000}:${db}:${query}`).digest('hex');
+            const pg = getPG(db);
+
+            if (config.trace) console.log('cron-list: init', db, idx);
+
+            const [waitMs, intervalMs] = interval2ms[typeof interval](interval);
+
+            if (intervalMs < 1000) {
+                if (config.trace) console.error('cron-list: skip too small interval', db, idx);
+                logger.file('cron', { name, error: `interval ${interval} too small` });
+                return;
+            }
+
+            // setTimeout to w8 for the time to start
+            setTimeout(() => {
+                runCron({ pg, query, name });
+                // interval
+                setInterval(() => {
+                    runCron({ pg, query, name });
+                }, intervalMs);
+            }, waitMs);
+        });
+    }
 }
 export default plugin;