ts-server-lib 0.0.17

package/ussd/TSUssdScreen.js

@@ -0,0 +1,218 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSUssdScreen = void 0;
+const i18n_1 = __importDefault(require("i18n"));
+const TSUssdMenu_1 = require("./TSUssdMenu");
+class TSUssdScreen {
+    menu;
+    storage;
+    strategies = {
+        truncate: (data, c, factor) => {
+            let parts = [];
+            let factors = {};
+            let f = 0;
+            TSUssdMenu_1.TSUssdMenu.forOwn(data, (i) => {
+                const item = i;
+                factors = {};
+                if (item.name && item.name.length > factor) {
+                    parts = item.name.split(c.term);
+                    if (parts.length > 1) {
+                        f = factor / parts.length;
+                        if (parts[0].length < f) {
+                            factors[1] = factor - parts[0].length;
+                            factors[0] = parts[0].length;
+                        }
+                        else if (parts[1].length < f) {
+                            factors[0] = factor - parts[1].length;
+                            factors[1] = parts[1].length;
+                        }
+                        parts.forEach((v, k) => parts[k] = v.substring(0, factors[k] ?? f));
+                        item.name = parts.join(c.term);
+                    }
+                }
+            });
+            return data;
+        }
+    };
+    static nav(command) {
+        return TSUssdMenu_1.TSUssdMenu.config.navigation[String(command)];
+    }
+    static pagerChoice(max = 3, min = 1) {
+        return '*\\^\\[' + min + '-' + max + '\\]\\{1\\}\\$';
+    }
+    constructor(menu, storage) {
+        this.menu = menu;
+        this.storage = storage;
+    }
+    render(items) {
+        TSUssdMenu_1.TSUssdMenu.forOwn(items, (m) => { const mr = m; if (mr)
+            TSUssdMenu_1.TSUssdMenu.forOwn(mr, (v, k) => { if (v !== undefined && k !== undefined)
+                this.bind(k, v); }); });
+    }
+    bind(m, s) {
+        const sObj = s;
+        if (m === 'start') {
+            this.menu.startState({
+                run: () => this.menu.con(sObj.next ? i18n_1.default.__(String(m) + '.' + sObj.key, TSUssdMenu_1.TSUssdMenu.config.general || {}) : this.screen(m, sObj)), next: sObj.next ? sObj.next : sObj
+            });
+        }
+        else {
+            let options = {};
+            if (typeof s === 'function') {
+                options.run = s;
+            }
+            else if (typeof s === 'object' && s !== null && Object.hasOwn(s, 'next')) {
+                const navMain = TSUssdScreen.nav('main');
+                sObj.next = { [navMain]: TSUssdMenu_1.TSUssdMenu.START_STATE, ...sObj.next };
+                options = sObj;
+            }
+            else {
+                options.run = () => this.menu.con(this.screen(m, sObj));
+                const navMain = TSUssdScreen.nav('main');
+                options.next = { [navMain]: TSUssdMenu_1.TSUssdMenu.START_STATE, ...sObj };
+            }
+            this.menu.state(String(m), options);
+        }
+    }
+    screen(title, items) {
+        let context = i18n_1.default.__(String(title), TSUssdMenu_1.TSUssdMenu.config.general || {});
+        const data = TSUssdMenu_1.TSUssdMenu.config.general || {};
+        TSUssdMenu_1.TSUssdMenu.forOwn(items, (v, k) => {
+            if (v != null && !isNaN(Number(k))) {
+                context += isNaN(Number(k)) ? '\n' : '\n' + k + data.separator + ' ';
+                context += i18n_1.default.__(String(title) + '.' + v, data || {});
+            }
+        });
+        if (this.menu.current.name !== TSUssdMenu_1.TSUssdMenu.START_STATE) {
+            context += '\n' + TSUssdScreen.nav('main');
+            context += data.separator + ' ' + i18n_1.default.__('main', data);
+        }
+        return context;
+    }
+    list(items, title = '', key = 'name', meta = { back: true, main: true }) {
+        let context = title;
+        TSUssdMenu_1.TSUssdMenu.forOwn(items, (v, k) => {
+            if (typeof v === 'object' && v !== null && key in v) {
+                context += isNaN(Number(k)) ? '\n' : '\n' + (parseInt(String(k), 10) + 1) + TSUssdMenu_1.TSUssdMenu.config.general.separator + ' ';
+                context += v[key];
+            }
+            else if (['number', 'string', 'boolean'].includes(typeof v)) {
+                context += String(v).indexOf('\n') === -1 ? '\n' + v : String(v);
+            }
+            else {
+                console.error(`TSUssdScreen:list[${key} -> ${k}] not mapped with ->`, JSON.stringify(v, null, 2));
+            }
+        });
+        TSUssdMenu_1.TSUssdMenu.forOwn(meta, (v, k) => { if (k !== undefined)
+            context += '\n' + TSUssdScreen.nav(String(k)) + TSUssdMenu_1.TSUssdMenu.config.general.separator + ' ' + i18n_1.default.__(String(k)); });
+        return context;
+    }
+    async getAndSet(key, field) {
+        if (!this.storage)
+            throw new Error('TSUssdScreen: storage not configured');
+        let data = await this.storage.hget(String(this.menu.args.phoneNumber), field);
+        if (this.menu.val && this.menu.val.toString().length > 0) {
+            if (!data) {
+                data = { [key]: this.menu.val };
+            }
+            else {
+                data[key] = this.menu.val;
+            }
+            await this.storage.hset(String(this.menu.args.phoneNumber), field, data);
+        }
+        return data;
+    }
+    async pager(items = [], key, pagerSize) {
+        let length = 0;
+        const result = await this._pager(items, key, pagerSize);
+        TSUssdMenu_1.TSUssdMenu.forOwn(result.data, (i) => { const it = i; length += (it.name?.length ?? 0) || (it.length ?? 0); });
+        if (TSUssdMenu_1.TSUssdMenu.config.pager.maxLength < length) {
+            TSUssdMenu_1.TSUssdMenu.forOwn(TSUssdMenu_1.TSUssdMenu.config.pager.strategies, (s) => {
+                const strat = s;
+                if (strat.enabled && strat.type && this.strategies[strat.type]) {
+                    this.strategies[strat.type](result.data, strat, parseInt((TSUssdMenu_1.TSUssdMenu.config.pager.maxLength / pagerSize).toString(), 10));
+                }
+            });
+        }
+        return result;
+    }
+    async _pager(items = [], key, pagerSize) {
+        if (!this.storage)
+            throw new Error('TSUssdScreen: storage not configured');
+        const pagerOptions = (await this.storage.hget(String(this.menu.args.phoneNumber), key + 'Pager') || {}), command = parseInt(this.menu.val, 10), calculatePaging = () => {
+            if (pagerSize >= items.length) {
+                offset = 0;
+                limit = pagerSize;
+            }
+            else if (command === 7) {
+                limit = offset;
+                offset -= pagerSize;
+                if (offset < 0) {
+                    offset = 0;
+                    limit = pagerSize;
+                }
+            }
+            else if (command === 9) {
+                offset = limit;
+                limit = offset + pagerSize;
+                if (limit > items.length) {
+                    limit = items.length;
+                    offset = limit - pagerSize;
+                }
+            }
+        };
+        let offset = pagerOptions.offset || 0, limit = pagerOptions.limit || (offset + pagerSize);
+        calculatePaging();
+        let data = items.slice(offset, limit), { length } = data, dataLength = 0;
+        TSUssdMenu_1.TSUssdMenu.forOwn(data, (i) => { const it = i; dataLength += it.name ? it.name.length : (it.length ?? 0); });
+        if (TSUssdMenu_1.TSUssdMenu.config.pager.maxLength < dataLength) {
+            pagerSize = pagerSize - 1;
+            offset = pagerOptions.offset || 0;
+            limit = pagerOptions.limit || (offset + pagerSize);
+            calculatePaging();
+            data = items.slice(offset, limit);
+            length = data.length;
+        }
+        await this.storage.hset(String(this.menu.args.phoneNumber), key + 'Pager', { offset: offset, limit: limit });
+        if (offset < 1 && items.length > limit) {
+            data.push(i18n_1.default.__('\n9 [Next]', TSUssdMenu_1.TSUssdMenu.config.general));
+        }
+        else if (items.length > limit && offset > 0) {
+            data.push(i18n_1.default.__('\n7 [Prev] | 9 [Next]', TSUssdMenu_1.TSUssdMenu.config.general));
+        }
+        else if (offset > 0) {
+            data.push(i18n_1.default.__('\n7 [Prev]', TSUssdMenu_1.TSUssdMenu.config.general));
+        }
+        return { meta: { command: command, total: items.length, length: length, offset: offset, limit: limit }, data: data };
+    }
+    async pagerPickAndSet(dataSet = [], field, size = 0) {
+        if (!this.storage)
+            throw new Error('TSUssdScreen: storage not configured');
+        const pagerOptions = (await this.storage.hget(String(this.menu.args.phoneNumber), field + 'Pager') || {}), offset = pagerOptions.offset || 0, limit = pagerOptions.limit || (offset + size), cursor = parseInt(this.menu.val, 10) - 1;
+        let data;
+        dataSet = size ? dataSet.slice(offset, limit) : dataSet;
+        if (size && dataSet.length >= cursor) {
+            data = dataSet[cursor];
+        }
+        if (!size) {
+            data = dataSet[cursor + offset];
+        }
+        await this.storage.hset(String(this.menu.args.phoneNumber), field, data);
+        return data;
+    }
+    checkPick(entity, state) {
+        if (!entity && state) {
+            this.menu.go(state);
+            return false;
+        }
+        else if (!entity) {
+            this.menu.end(i18n_1.default.__('invalid.input', { input: this.menu.val }));
+            return false;
+        }
+        return true;
+    }
+}
+exports.TSUssdScreen = TSUssdScreen;

package/ussd/index.d.ts

@@ -0,0 +1,3 @@
+export * from './TSUssdMenu';
+export * from './TSUssdScreen';
+export * from './providers/index';

package/ussd/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./TSUssdMenu"), exports);
+__exportStar(require("./TSUssdScreen"), exports);
+__exportStar(require("./providers/index"), exports);

package/ussd/providers/AfricasTalking.d.ts

@@ -0,0 +1,3 @@
+export declare function response(text: string, _rr?: unknown): string;
+export declare function request(request: any, _response: unknown): any;
+export declare function text(_prev: string | undefined, body: any): any;

package/ussd/providers/AfricasTalking.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.response = response;
+exports.request = request;
+exports.text = text;
+const _1 = require("./_");
+function response(text, _rr) {
+    return text;
+}
+function request(request, _response) {
+    const body = (0, _1.body)(request);
+    request.body = (0, _1.mapArgs)(body, _1.providersMap[_1.TSUssdProviders.africastalking]);
+    return request.body;
+}
+function text(_prev = '', body) {
+    return body.message;
+}

package/ussd/providers/AirtelDRC.d.ts

@@ -0,0 +1,9 @@
+export declare function response(text: string, { response }: {
+    response: {
+        set: (key: string, val: string) => void;
+    };
+}): string;
+export declare function request(request: {
+    body?: Record<string, unknown>;
+}, response: Record<string, unknown>): Record<string, unknown>;
+export declare function text(prev: string | undefined, body: Record<string, unknown>): string;

package/ussd/providers/AirtelDRC.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.response = response;
+exports.request = request;
+exports.text = text;
+const _1 = require("./_");
+function response(text, { response }) {
+    const action = text.startsWith('CON ');
+    response.set('Freeflow', action ? 'FC' : 'FB');
+    text = text.replace(/CON\s|END\s/g, '');
+    return text;
+}
+function request(request, response) {
+    const body = (0, _1.body)(request);
+    response.type('text/html');
+    response.charset = 'UTF-8';
+    if (!String(body.MBILE_NUMBER ?? '').startsWith('+')) {
+        body.MBILE_NUMBER = '+' + String(body.MBILE_NUMBER);
+    }
+    if (Object.hasOwn(body, 'INPUT')) {
+        body.message = body.INPUT;
+    }
+    request.body = (0, _1.mapArgs)(body, _1.providersMap[_1.TSUssdProviders.airteldrc]);
+    return request.body;
+}
+function text(prev = '', body) {
+    if (Object.hasOwn(body, 'message') && body.message !== body.serviceCode) {
+        prev += '*' + (0, _1.purify)(String(body.message ?? ''));
+    }
+    return prev;
+}

package/ussd/providers/OrangeDRC.d.ts

@@ -0,0 +1,5 @@
+export declare function response(text: string, _rr?: unknown): string;
+export declare function request(request: {
+    body?: Record<string, unknown>;
+}, response: Record<string, unknown>): Record<string, unknown>;
+export declare function text(prev: string | undefined, body: Record<string, unknown>): string;

package/ussd/providers/OrangeDRC.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.response = response;
+exports.request = request;
+exports.text = text;
+const _1 = require("./_");
+class OrangeTextUSSD {
+    text;
+    description;
+    attribute;
+    constructor() {
+        this.text = '';
+        this.description = String(Math.random().toFixed(9));
+        this.attribute = { nav: 'default' };
+    }
+    /**
+     * Append a line text without <br/>
+     * @param text
+     */
+    appendText(text) {
+        this.text += text;
+    }
+    /**
+     * Append a line text with <br/>
+     * @param text
+     */
+    appendLineText(text) {
+        this.text += '<br/>' + text;
+    }
+    /**
+     * define the text of page
+     * @param text
+     */
+    setText(text) {
+        this.text = text;
+    }
+    /**
+     * define the value of description of the page
+     * @param value
+     */
+    setPageDescription(value) {
+        this.description = value;
+    }
+    /**
+     * add a attribute in page header
+     * @param key
+     * @param value
+     */
+    setAttribute(key, value) {
+        this.attribute[key] = value;
+    }
+    /**
+     * remove a key in a header page
+     * @param key
+     */
+    removeAttribute(key) {
+        delete this.attribute[key];
+    }
+    /**
+     * get the value of the key in the header page
+     * @param key
+     * @return {*}
+     */
+    getAttribute(key) {
+        return this.attribute[key];
+    }
+    /**
+     * get all attributes values in a object
+     * @return {{count: boolean}|*}
+     */
+    getAllAttributes() {
+        return this.attribute;
+    }
+    /**
+     * generate a string of key and value
+     * @return {string}
+     * @private
+     */
+    __attributeToString() {
+        const attr = this.attribute;
+        let result = '';
+        for (const key in attr) {
+            if (Object.hasOwn(attr, key)) {
+                result += key + '=\'' + attr[key] + '\' ';
+            }
+        }
+        return result;
+    }
+    /**
+     * Generate the body of page
+     * @return {string|*}
+     * @protected
+     */
+    __toGenerateBody() {
+        return this.text;
+    }
+    /**
+     * generate the page
+     * @param body the body of page
+     * @return {string}
+     * @private
+     */
+    __toGeneratePage(body) {
+        let page = '<?xml version=\'1.0\' encoding=\'UTF-8\'?>';
+        page += '<!DOCTYPE pages SYSTEM \'cellflash-1.3.dtd\'>';
+        page += '<pages descr=\'' + this.description + '\'>';
+        page += '<page ' + this.__attributeToString() + '>';
+        page += body;
+        page += '</page></pages>';
+        return page;
+    }
+    /**
+     * generate the form
+     * @param text
+     * @param action
+     * @param name
+     * @return {string}
+     */
+    form(text = ' ', action = '', name = '_input') {
+        return '<form keywords=\'disable\' action=\'' + action + '\'><entry var=\'' + name + '\'><prompt>' + text + '</prompt></entry></form>';
+    }
+    /**
+     * generate a anchor
+     * @param key
+     * @param href
+     * @param text
+     * @return {string}
+     */
+    anchor(text = ' ', href, key) {
+        let attr = '';
+        if (key) {
+            attr += 'key=\'' + key + '\' ';
+        }
+        if (href) {
+            attr += 'href=\'' + href + '\'';
+        }
+        return '<a ' + attr + '>' + text + '</a>';
+    }
+    /**
+     * generate the page
+     * @return {string}
+     */
+    toXml() {
+        return this.__toGeneratePage(this.__toGenerateBody());
+    }
+    escapeXml(unsafe) {
+        return this.unEscapeXml(unsafe).replace(/[&<>'"]/g, c => {
+            if (c === '&')
+                return '&amp;';
+            if (c === '<')
+                return '&lt;';
+            if (c === '>')
+                return '&gt;';
+            if (c === '\'')
+                return '&apos;';
+            if (c === '"')
+                return '&quot;';
+            return c;
+        });
+    }
+    unEscapeXml(text) {
+        const entities = [
+            ['amp', '&'], ['apos', '\''], ['#x27', '\''], ['#x2F', '/'],
+            ['nbsp', ' '], ['#39', '\''], ['#47', '/'], ['lt', '<'], ['gt', '>'], ['quot', '"']
+        ];
+        for (let i = 0, max = entities.length; i < max; ++i) {
+            text = text.replace(new RegExp('&' + entities[i][0] + ';', 'g'), entities[i][1]);
+        }
+        return text;
+    }
+}
+function response(text, _rr) {
+    let action = 'request', oText;
+    const otu = new OrangeTextUSSD();
+    if (text.startsWith('END ')) {
+        otu.setAttribute('nav', 'end');
+        action = 'end';
+    }
+    oText = otu.escapeXml(text.replace(/CON\s|END\s/g, '')).replace(/\n/g, '<br />');
+    otu.setAttribute('volatile', true);
+    otu.setAttribute('menutext', 'notext');
+    otu.setAttribute('backtext', 'notext');
+    if (action !== 'end') {
+        oText += otu.form();
+    }
+    if (oText.match(/#0/g)) {
+        // outputText = outputText.replace('#0)', otu.anchor('#0)', '/?_input=#0'));
+    }
+    if (oText.match(/#1/g)) {
+        // outputText = outputText.replace('#1)', otu.anchor('#1)', '/?_input=#1'));
+    }
+    otu.setText(oText);
+    return otu.toXml();
+}
+function request(request, response) {
+    const body = (0, _1.body)(request);
+    response.type('application/xml');
+    response.charset = 'UTF-8';
+    if (!String(body['user-msisdn'] ?? '').startsWith('+')) {
+        body['user-msisdn'] = '+' + body['user-msisdn'];
+    }
+    if (Object.hasOwn(body, '_input')) {
+        body.message = body._input;
+    }
+    request.body = (0, _1.mapArgs)(body, _1.providersMap[_1.TSUssdProviders.orangedrc]);
+    return request.body;
+}
+function text(prev = '', body) {
+    if (Object.hasOwn(body, 'message')) {
+        prev += '*' + (0, _1.purify)(String(body.message ?? ''));
+    }
+    return prev;
+}

package/ussd/providers/VodacomDRC.d.ts

@@ -0,0 +1,9 @@
+export declare function response(text: string, { request: { body } }: {
+    request: {
+        body: Record<string, unknown>;
+    };
+}): string;
+export declare function request(request: {
+    body?: Record<string, unknown>;
+}, response: Record<string, unknown>): Record<string, unknown>;
+export declare function text(prev: string | undefined, body: Record<string, unknown>): string;

package/ussd/providers/VodacomDRC.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.response = response;
+exports.request = request;
+exports.text = text;
+const _1 = require("./_");
+function response(text, { request: { body } }) {
+    let action = 'request';
+    if (text.startsWith('END ')) {
+        action = 'end';
+    }
+    text = text.replace(/CON\s|END\s/g, '');
+    text = '<?xml version="1.0" encoding="UTF-8" ?>' +
+        '<methodResponse><params><param><value><struct>' +
+        '<member><name>USSDResponseString</name><value><string>' + text + '</string></value></member>' +
+        '<member><name>action</name><value><string>' + action + '</string></value></member>' +
+        '<member><name>TransactionTime</name><value><dateTime.iso8601>' + body.transactionTime + '</dateTime.iso8601></value></member>' +
+        '<member><name>TransactionId</name><value><string>' + body.sessionId + '</string></value></member>' +
+        '</struct></value></param></params></methodResponse>';
+    return text;
+}
+function request(request, response) {
+    const body = (0, _1.body)(request);
+    response.type('text/xml');
+    response.charset = 'UTF-8';
+    const transTime = body.TransactionTime;
+    body.transactionTime = transTime?.['datetime.iso8601']?.[0];
+    if (!String(body.MSISDN ?? '').startsWith('+')) {
+        body.MSISDN = '+' + String(body.MSISDN);
+    }
+    delete body.TransactionTime;
+    request.body = (0, _1.mapArgs)(body, {
+        vodacom: 'provider',
+        TransactionId: 'sessionId',
+        USSDServiceCode: 'serviceCode',
+        MSISDN: 'phoneNumber',
+        networkCode: 'networkCode',
+        USSDRequestString: 'message'
+    });
+    request.body = (0, _1.mapArgs)(body, _1.providersMap[_1.TSUssdProviders.vodacomdrc]);
+    return request.body;
+}
+function text(prev = '', body) {
+    if (!/(null|fecofa)/i.test(String(body.message ?? ''))) {
+        prev += '*' + (0, _1.purify)(String(body.message ?? ''));
+    }
+    return prev;
+}

package/ussd/providers/_.d.ts

@@ -0,0 +1,55 @@
+export declare enum TSUssdProviders {
+    vodacomdrc = "vodacom",
+    orangedrc = "orange",
+    airteldrc = "airtel",
+    africastalking = "africastalking"
+}
+export declare function body(request: {
+    headers?: Record<string, unknown>;
+    body?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    params?: Record<string, unknown>;
+}): {
+    [x: string]: unknown;
+};
+export declare function mapArgs(args?: Record<string, unknown>, map?: Record<string, unknown>): Record<string, unknown>;
+export declare function purify(text?: string): string;
+export declare function provider({ headers, body, query }: {
+    headers?: Record<string, unknown>;
+    body?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+}): TSUssdProviders;
+export declare const providersMap: {
+    africastalking: {
+        africastalking: string;
+        sessionId: string;
+        serviceCode: string;
+        phoneNumber: string;
+        networkCode: string;
+        text: string;
+    };
+    vodacom: {
+        vodacom: string;
+        TransactionId: string;
+        USSDServiceCode: string;
+        MSISDN: string;
+        networkCode: string;
+        USSDRequestString: string;
+    };
+    orange: {
+        orange: string;
+        'user-session': string;
+        'user-imsi': string;
+        'user-msisdn': string;
+        networkCode: string;
+        'user-identity': string;
+    };
+    airtel: {
+        airtel: string;
+        MBILE_NUMBER: string;
+        USSDServiceCode: string;
+        SESSION_ID: string;
+        INPUT: string;
+        IMEI: string;
+    };
+};