@opengis/pay 1.2.3 → 1.3.0

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

@@ -0,0 +1,39 @@
+import pg from 'pg';
+
+const { types } = pg;
+types.setTypeParser(1082, (stringValue) => stringValue);
+types.setTypeParser(1114, (stringValue) => stringValue);
+
+import config from '../../../../config.js';
+import pgClients from '../pgClients.js';
+import init from './init.js';
+import getDBParams from './getDBParams.js';
+
+function getPG(param) {
+  if (!config.pg) return null;
+  const {
+    user, password, host, port, db, database, name: origin,
+  } = (typeof param === 'string' ? getDBParams(param) : param || {});
+  const name = origin || db || database || param || 'client';
+  if (pgClients[name]) return pgClients[name];
+
+  const dbConfig = {
+    user: user || config.pg?.user || 'postgres',
+    password: password || config.pg?.password || 'postgres',
+    host: host || config.pg?.host,
+    port: port || config.pg?.port,
+    database: db || database || config.pg?.db || config.pg?.database,
+    statement_timeout: config.pg?.statement_timeout || 10000,
+  };
+
+  if (!dbConfig.database) { return null; }
+
+  pgClients[name] = new pg.Pool(dbConfig);
+  pgClients[name].init = async () => {
+    await init(pgClients[name]);
+  };
+  init(pgClients[name]);
+  return pgClients[name];
+}
+
+export default getPG;

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

@@ -0,0 +1,40 @@
+import pg from 'pg';
+
+const { types } = pg;
+types.setTypeParser(1082, (stringValue) => stringValue);
+types.setTypeParser(1114, (stringValue) => stringValue);
+
+import config from '../../../../config.js';
+import pgClients from '../pgClients.js';
+import init from './init.js';
+import getDBParams from './getDBParams.js';
+
+async function getPGAsync(param) {
+  if (!config.pg) return null;
+
+  const {
+    user, password, host, port, db, database, name: origin,
+  } = (typeof param === 'string' ? getDBParams(param) : param || {});
+  const name = origin || db || database || param || 'client';
+
+  if (pgClients[name]?.tlist) return pgClients[name];
+
+  const dbConfig = {
+    user: user || config.pg?.user || 'postgres',
+    password: password || config.pg?.password || 'postgres',
+    host: host || config.pg?.host,
+    port: port || config.pg?.port,
+    database: db || database || config.pg?.db || config.pg?.database,
+    statement_timeout: config.pg?.statement_timeout || 10000,
+  };
+
+  if (!dbConfig.database) { return null; }
+
+  pgClients[name] = new pg.Pool(dbConfig);
+
+  await init(pgClients[name]);
+
+  return pgClients[name];
+}
+
+export default getPGAsync;

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

@@ -0,0 +1,113 @@
+import { createHash } from 'node:crypto';
+
+import config from '../../../../config.js';
+import getRedis from '../../redis/funcs/getRedis.js';
+
+const rclient = getRedis({ db: 0 });
+
+async function init(client) {
+  if (!client?.options?.database) { return; }
+
+  const textQuery = `select 
+  (select json_object_agg(conrelid::regclass  ,(SELECT attname FROM pg_attribute WHERE attrelid = c.conrelid and attnum = c.conkey[1]))
+  from   pg_constraint c where contype='p' and connamespace::regnamespace::text not in ('sde')) as pk,
+  (SELECT json_object_agg(t.oid::text,pg_catalog.format_type(t.oid, NULL)) FROM pg_catalog.pg_type t) as "pgType"`;
+  const { pgType, pk } = await client.query(textQuery).then((d) => d.rows[0]);
+
+  const tlist = await client.query(`select array_agg((select nspname from pg_namespace where oid=relnamespace)||'.'||relname) tlist 
+    from pg_class where relkind in ('r','v')`).then((d) => d.rows[0].tlist);
+
+  const { rows = [] } = await client.query(`select (select nspname from pg_namespace where oid=relnamespace)||'.'||relname as tname, relkind
+      from pg_class where relkind in ('r','v')`);
+  const relkinds = rows.reduce((acc, curr) => Object.assign(acc, { [curr.tname]: curr.relkind }), {});
+
+  async function query(q, args = [], isstream = false) {
+    try {
+      if (isstream) {
+        await client.query('set statement_timeout to 100000000');
+      }
+      const data = await client.query(q, args);
+      await client.query('set statement_timeout to 0');
+      return data;
+    }
+    catch (err) {
+      await client.query('set statement_timeout to 0');
+      if (err.message === 'canceling statement due to statement timeout') {
+        console.warn('timeout/query', q, err.stack);
+        return { rows: [], timeout: true };
+      }
+      throw new Error(err);
+    }
+  }
+
+  async function querySafe(q, param = {}) {
+    const { args, isstream } = param;
+    const data = await query(q, args, isstream);
+    return data;
+  }
+
+  async function one(q, param = {}) {
+    const data = await query(q, Array.isArray(param) ? param : param.args || []);
+    const result = ((Array.isArray(data) ? data.pop() : data)?.rows || [])[0] || {};
+    return result;
+  }
+
+  async function queryNotice(q, args = [], cb = () => { }) {
+    const clientCb = await client.connect();
+    clientCb.on('notice', (e) => {
+      cb(e.message);
+    });
+    let result;
+    try {
+      result = await clientCb.query(q, args);
+      clientCb.end();
+    }
+    catch (err) {
+      clientCb.end();
+      cb(err.toString(), 1);
+      throw err;
+    }
+    return result;
+  }
+
+  async function queryCache(q, param = {}) {
+    const { table, args = [], time = 15 } = param;
+    const seconds = typeof time !== 'number' || time < 0 ? 0 : time * 60;
+
+    if (seconds === 0 || config.disableCache) {
+      const data = await query(q, args || []);
+      return data;
+    }
+
+    // CRUD table state
+    const keyCacheTable = `pg:${table}:crud`;
+    const crudInc = table && config.redis ? (await rclient.get(keyCacheTable) || 0) : 0;
+
+    //
+    const hash = createHash('sha1').update([q, JSON.stringify(args)].join()).digest('base64');
+    const keyCache = `pg:${hash}:${crudInc}`;
+
+    const cacheData = config.redis ? await rclient.get(keyCache) : null;
+
+    if (cacheData && !config.local) {
+      // console.log('from cache', table, query);
+      return JSON.parse(cacheData);
+    }
+
+    const data = await query(q, args || []);
+
+    if (seconds > 0 && config.redis) {
+      rclient.set(keyCache, JSON.stringify(data), 'EX', seconds);
+    }
+
+    // console.log('no cache', table, crudInc, query);
+    return data;
+  }
+
+  Object.assign(client, {
+    one, pgType, pk, tlist, relkinds, queryCache, queryNotice, querySafe,
+  });
+}
+
+// export default client;
+export default init;

package/server/plugins/pg/index.js

@@ -0,0 +1,24 @@
+import pgClients from './pgClients.js';
+import getPGAsync from './funcs/getPGAsync.js';
+
+function close() {
+  Object.keys(pgClients).forEach((el) => {
+    pgClients[el].end();
+  });
+}
+
+export default async function plugin(app, config) {
+  const client = await getPGAsync({ ...config.pg || {}, name: 'client' });
+
+  app.addHook('onRequest', async (req) => {
+    req.pg = req.pg || client;
+  });
+
+  app.addHook('onError', async (req, reply, err) => {
+    if (err.message === 'canceling statement due to statement timeout') {
+      console.warn('request timeout', req.method, req.url, req.headers?.referer, err.stack);
+    }
+  });
+
+  app.addHook('onClose', close);
+}

package/server/plugins/pg/pgClients.js

@@ -0,0 +1,22 @@
+import pg from 'pg';
+
+import config from '../../../config.js';
+import init from './funcs/init.js';
+
+const pgClients = {};
+if (config.pg) {
+  const client = new pg.Pool({
+    host: config.pg?.host || '127.0.0.1',
+    port: config.pg?.port || 5432,
+    database: config.pg?.database || 'postgres',
+    user: config.pg?.user || 'postgres',
+    password: config.pg?.password || 'postgres',
+    statement_timeout: config.pg?.statement_timeout || 10000,
+  });
+  client.init = async () => {
+    await init(client);
+  };
+  client.init();
+  pgClients.client = client;
+}
+export default pgClients;

package/server/plugins/redis/client.js

@@ -0,0 +1,8 @@
+import redisClients from './funcs/redisClients.js';
+import getRedis from './funcs/getRedis.js';
+
+if (!redisClients[0]) {
+  getRedis({ db: 0 });
+}
+
+export default redisClients[0];

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

@@ -0,0 +1,24 @@
+import Redis from 'ioredis';
+
+import config from '../../../../config.js';
+import redisClients from './redisClients.js';
+
+function getRedis({ db } = { db: 0 }) {
+  if (!config.redis) return null;
+  if (redisClients[db]) return redisClients[db];
+
+  const redisConfig = {
+    db,
+    keyPrefix: `${config.db}:`,
+    host: config.redis?.host || '127.0.0.1',
+    port: config.redis?.port || 6379, // Redis port
+    family: 4, // 4 (IPv4) or 6 (IPv6)
+    closeClient: true,
+  };
+
+  redisClients[db] = new Redis(redisConfig);
+
+  return redisClients[db];
+}
+
+export default getRedis;

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

@@ -0,0 +1,3 @@
+const redisClients = {};
+
+export default redisClients;

package/server/plugins/redis/index.js

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

package/server/routes/liqpay/controllers/liqpay.redirect.js

@@ -1,9 +1,10 @@
 import request from 'request-promise';
 import LiqPay from 'liqpayjs-sdk';
 
-import {
-    config, logger, pgClients, dataInsert, dataUpdate, handlebarsSync,
-} from '@opengis/fastify-table/utils.js';
+import config from '../../../../config.js';
+import pgClients from '../../../plugins/pg/pgClients.js';
+import dataInsert from '../../../plugins/crud/dataInsert.js';
+import dataUpdate from '../../../plugins/crud/dataUpdate.js';
 
 const { prefix = '/api' } = config;
 
@@ -64,7 +65,7 @@ export default async function liqpayRedirect(req, reply) {
         table: 'billing.payments',
         id: paymentId,
         data: {
-            referer_url: paymentRedirect ? handlebarsSync.compile(paymentRedirect)({ id: paymentId }) : headers?.referer,
+            referer_url: paymentRedirect ? paymentRedirect.replace(/{{id}}/g, paymentId) : headers?.referer,
             payment_status: 'inprogress',
         },
         uid: user?.uid || '0',
@@ -73,10 +74,6 @@ export default async function liqpayRedirect(req, reply) {
     const protocol = headers?.referer?.split?.('://')?.shift?.() || req.protocol || 'https';
     const rootPageUrl = `${protocol || 'https'}://${domain}`;
 
-    /* const resultUrl = paymentRedirect
-        ? `${rootPageUrl}${handlebarsSync.compile(paymentRedirect)({ id: paymentId })}`
-        : headers?.referer || `${rootPageUrl}`; */
-
     // redirect to api to check payment status and redirect user to page afterwards
     const serverUrl = `${rootPageUrl}${prefix}/liqpay/${paymentId}/success`;
 
@@ -130,12 +127,11 @@ export default async function liqpayRedirect(req, reply) {
         }
 
         Object.assign(logObj, { paymentId, redirect: response.headers?.location, status: 302 });
-        logger.file('payments', logObj);
+        console.log('payments/info', JSON.stringify(logObj));
         return reply.redirect(response.headers.location);
     }
     catch (err) {
-        Object.assign(logObj, { error: err.toString() });
-        logger.file('payments/error', logObj);
+        console.error('payments/error', JSON.stringify(logObj), err.toString(), err.stack);
         return reply.status(500).send(err.toString());
     }
 }

package/server/routes/liqpay/controllers/liqpay.status.js

@@ -1,13 +1,19 @@
 import LiqPay from 'liqpayjs-sdk';
+import path from 'node:path';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'url';
 
-import {
-    config, logger, pgClients, dataUpdate, getTemplate,
-} from '@opengis/fastify-table/utils.js';
+import config from '../../../../config.js';
+import pgClients from '../../../plugins/pg/pgClients.js';
+import dataUpdate from '../../../plugins/crud/dataUpdate.js';
 
-import { sendNotification } from '@opengis/admin/utils.js';
+import sendNotification from '../../../utils/sendNotification.js';
 
 import checkStatus from '../utils/check.status.js';
 
+const dirname = path.dirname(fileURLToPath(import.meta.url));
+const ptBody = readFileSync(path.join(dirname, '../../../../module/pay/pt/marketplace-service-payment-client-template.html'));
+
 const newDate = () => {
     const date = new Date();
     const tzOffset = date.getTimezoneOffset();
@@ -72,14 +78,14 @@ export default async function liqpayStatus(req, reply) {
         );
 
         if (body.signature !== sign) {
-            logger.file('payments/warn', {
+            console.warn('payments/warn', JSON.stringify({
                 type: 'status',
                 service: 'liqpay',
                 paymentId,
                 origin,
                 uid: user?.uid || '0',
                 message: 'Transaction signature does not match',
-            });
+            }));
             return reply.status(403).send('access restricted: signature mismatch');
         }
     }
@@ -97,14 +103,14 @@ export default async function liqpayStatus(req, reply) {
     } = data;
 
     if (trxStatus === 'success') {
-        logger.file('payments/skip', {
+        console.info('payments/skip', JSON.stringify({
             type: 'status',
             service: 'liqpay',
             paymentId,
             origin,
             uid: user?.uid || '0',
             message: 'Transaction was already processed',
-        });
+        }));
         return reply.status(400).send('Transaction was already processed');
     }
 
@@ -116,7 +122,7 @@ export default async function liqpayStatus(req, reply) {
         return reply.status(400).send('Payment not registered via liqpay service');
     }
 
-    logger.file('payments', {
+    console.log('payments/info', JSON.stringify({
         type: 'status',
         service: 'liqpay',
         paymentId,
@@ -125,7 +131,7 @@ export default async function liqpayStatus(req, reply) {
         refill: refillSum,
         body,
         params,
-    });
+    }));
 
     // last trx contains total balance
     const { total_balance: totalBalance = 0 } = await pg.query(`select total_balance from billing.payments 
@@ -153,7 +159,7 @@ export default async function liqpayStatus(req, reply) {
     const { account_email: to } = await pg.query('select account_email from billing.accounts where account_id=$1', [accountId])
         .then(el => el.rows?.[0] || {});
 
-    logger.file('payments', {
+    console.log('payments/info2', JSON.stringify({
         type: 'status',
         service: 'liqpay',
         paymentId,
@@ -162,7 +168,7 @@ export default async function liqpayStatus(req, reply) {
         origin,
         redirect: redirectUrl,
         uid: user.uid || '0',
-    });
+    }));
 
     Object.assign(data, {
         domain: req.hostname,
@@ -170,13 +176,18 @@ export default async function liqpayStatus(req, reply) {
     });
 
     if (to) {
-        const pt = await getTemplate('pt', 'marketplace-service-payment-client-template');
+        const pt = ptBody
+            .replace(/{{domain}}/g, req.hostname)
+            .replace(/{{total_balance}}/g, +(refillSum || 0) + (+totalBalance || 0))
+            .replace(/{{username}}/g, to)
+            .replace(/{{created_at}}/g, (data?.cdate || data?.created_at || new Date()).toLocaleString('uk-UA'))
+            .replace(/{{payment_status}}/g, responseStatus)
+            .replace(/{{payment_amount}}/g, refillSum || 0);
         const options = {
             pg,
             to,
             title: `Поповнення рахунку на порталі ${req.hostname}`,
-            template: pt?.html || pt,
-            data,
+            pt,
             nocache: config?.local,
         };
         await sendNotification(options);

package/server/routes/liqpay/utils/check.status.js

@@ -1,7 +1,7 @@
 import LiqPay from 'liqpayjs-sdk';
 import request from 'request-promise';
 
-import { config } from '@opengis/fastify-table/utils.js';
+import config from '../../../../config.js';
 
 const { publicKey, privateKey } = config.integrations?.liqpay || {};
 

package/server/routes/monopay/controllers/monopay.redirect.js

@@ -0,0 +1,141 @@
+import config from '../../../../config.js';
+import pgClients from '../../../plugins/pg/pgClients.js';
+import dataInsert from '../../../plugins/crud/dataInsert.js';
+import dataUpdate from '../../../plugins/crud/dataUpdate.js';
+
+const { prefix = '/api' } = config;
+const {
+    host = 'https://api.monobank.ua', token, paymentRedirect, merchantPaymInfo,
+} = config.integrations?.monopay || {};
+
+// http://billing.local.ua/api/monopay-redirect?price=50
+
+export default async function monopayRedirect(req, reply) {
+    const {
+        pg = pgClients.client, query = {}, user = {}, headers = {},
+    } = req;
+
+    if (!token) {
+        return reply.status(400).send('invalid monopay integration settings');
+    }
+
+    const domain = req.hostname.split(':').shift();
+
+    const paymentData = query.id ? await pg.query('select payment_id, account_id, payment_amount, payment_status from billing.payments where payment_id=$1', [query.id])
+        .then(el => el.rows?.[0] || {}) : {};
+
+    if (paymentData.payment_status && paymentData.payment_status === 'success') {
+        return reply.status(400).send('already processed');
+    }
+
+    const paymentAmount = paymentData.payment_amount || query.price;
+
+    if (!paymentAmount) {
+        return reply.status(400).send('price is required');
+    }
+
+    const accountId = paymentData.account_id
+        || (user?.uid ? await pg.query('select account_id from billing.account_user where user_id=$1 limit 1', [user?.uid]).then(el => el.rows?.[0]?.account_id) : null);
+
+    if (!accountId) {
+        return reply.status(400).send('account_id is required');
+    }
+
+    const { payment_id: paymentId } = !paymentData.payment_id
+        ? await dataInsert({
+            table: 'billing.payments',
+            data: {
+                payment_amount: paymentAmount,
+                account_id: accountId,
+                payment_service: 'monopay',
+                payment_status: 'inprogress',
+            },
+            uid: user?.uid || '0',
+        }).then(el => el.rows?.[0] || {})
+        : { payment_id: paymentData.payment_id };
+
+    if (!paymentId) {
+        return { message: 'payment not found', status: 404 };
+    }
+
+    await dataUpdate({
+        table: 'billing.payments',
+        id: paymentId,
+        data: {
+            referer_url: paymentRedirect ? paymentRedirect.replace(/{{id}}/g, paymentId) : headers?.referer,
+            payment_status: 'inprogress',
+            payment_service: 'monopay',
+        },
+        uid: user?.uid || '0',
+    });
+
+    const protocol = headers?.referer?.split?.('://')?.shift?.() || req.protocol || 'https';
+    const rootPageUrl = `${protocol || 'https'}://${domain}`;
+
+    // redirect to api to check payment status and redirect user to page afterwards
+    const serverUrl = `${rootPageUrl}${prefix}/monopay/${paymentId}/success`;
+
+    const paymentOptions = {
+        amount: paymentAmount * 100, // price=1 === 0.01 uah
+        ccy: 980, // ISO 4217, 980 = UAH
+        merchantPaymInfo,
+        redirectUrl: serverUrl,
+        // redirectUrl: (paymentRedirect ? `${rootPageUrl}${paymentRedirect.replace(/{{id}}/g, paymentId)}` : headers?.referer) || rootPageUrl,
+        webHookUrl: serverUrl,
+        validity: 86400, // 1 day by default, then invalid
+        paymentType: 'debit',
+        // displayType: 'iframe', // default = null > url to mono
+    };
+
+    const logObj = {
+        type: 'redirect',
+        paymentId,
+        accountId,
+        price: paymentAmount,
+        service: 'monopay',
+        domain,
+        paymentRedirectUrl: serverUrl,
+        uid: user?.uid || '0',
+    };
+
+    try {
+        // create payment, get redirect url
+        const resp = await fetch(`${host}/api/merchant/invoice/create`, {
+            method: 'POST',
+            headers: { 'x-token': token },
+            body: JSON.stringify(paymentOptions),
+            signal: AbortSignal.timeout(5000),
+        });
+
+        const contentType = resp.headers.get('Content-Type');
+
+        const body = contentType.includes('application/json') && resp.status === 200
+            ? await resp.json()
+            : await resp.text();
+
+        if (query.debug) {
+            return body;
+        }
+
+        await dataUpdate({
+            table: 'billing.payments',
+            id: paymentId,
+            data: {
+                payment_data: resp.status === 200 ? body : { response: body },
+            },
+            uid: user?.uid || '0',
+        });
+
+        console.log('payments/info', JSON.stringify({ ...logObj, response: body }));
+
+        if (!body.pageUrl) {
+            return reply.status(501).send('monopay service temporary unavailable');
+        }
+
+        return reply.redirect(body.pageUrl);
+    }
+    catch (err) {
+        console.error('payments/error', JSON.stringify(logObj), err.toString(), err.stack);
+        return reply.status(500).send(err.toString());
+    }
+}

package/server/routes/monopay/controllers/monopay.status.js

@@ -0,0 +1,70 @@
+import config from '../../../../config.js';
+import pgClients from '../../../plugins/pg/pgClients.js';
+import dataUpdate from '../../../plugins/crud/dataUpdate.js';
+
+const {
+    host = 'https://api.monobank.ua',
+    token,
+} = config.integrations?.monopay || {};
+
+const timeoutMs = 5000;
+
+export default async function monopayStatus({
+    pg = pgClients.client, params = {}, user = {},
+}, reply) {
+    const { id, status = 'success' } = params;
+
+    if (!id) {
+        return reply.status(400).send('not enough params: id');
+    }
+
+    const {
+        paymentId, refererUrl, paymentStatus, invoiceId, accountId,
+    } = await pg.query('select payment_id as "paymentId", account_id as "accountId", payment_status as "paymentStatus", referer_url as "refererUrl", payment_data->>\'invoiceId\' as "invoiceId" from billing.payments where payment_id=$1', [id])
+        .then(el => el.rows?.[0] || {});
+
+    if (!paymentId) {
+        return reply.status(404).send('payment not found');
+    }
+    if (!invoiceId) {
+        return reply.status(404).send('invoice not found');
+    }
+
+    if (['success', 'error'].includes(paymentStatus)) {
+        return reply.status(404).send('payment already processed');
+    }
+
+    if (status !== 'success') {
+        return reply.redirect(refererUrl);
+    }
+
+    const resp = await fetch(`${host}/api/merchant/invoice/status?invoiceId=${invoiceId}`, {
+        method: 'GET',
+        headers: { 'x-token': token },
+        signal: AbortSignal.timeout(timeoutMs),
+    }).catch(err => reply.status(501).send('monopay request timeout'));
+
+    const contentType = resp.headers.get('Content-Type');
+
+    const body = contentType.includes('application/json') && resp.status === 200
+        ? await resp.json()
+        : await resp.text();
+
+    const totalBalanceBefore = await pg.query(`select total_balance from billing.payments 
+        where account_id=$1 and payment_status in ('success', 'error') and total_balance is not null order by cdate desc limit 1`, [accountId])
+        .then(el => el.rows?.[0]?.total_balance || 0);
+
+    await dataUpdate({
+        table: 'billing.payments',
+        id: paymentId,
+        data: {
+            total_balance: (body.amount / 100) + +totalBalanceBefore,
+            success_date: new Date(), // newDate(),
+            payment_status: body?.status || 'error',
+            payment_data: resp.status === 200 ? body : { response: body },
+        },
+        uid: user?.uid || '0',
+    });
+
+    return reply.redirect(refererUrl || '/');
+}