@coolgk/utils

v3.1.4

Published

2 years ago

javascript, typescript utility and wrapper functions and classes: array, string, base64, ampq, bcrypt, cache, captcha, csv, email, jwt, number, pdf, tmp, token, unit conversion, url params, session, form data, google sign in, facebook sign in

Downloads

npm install @coolgk/utils

You can install and use the modules below as standalone packages. If you wish to use @coolgk/utils as an all-in-one package, replace @coolgk/[module] with @coolgk/utils/[module] in the require() or import statements in the examples below.

Report bugs here: https://github.com/coolgk/node-utils/issues

Also see:

@coolgk/mongo

A javascript / typescript MongoDB modelling library which enables joins in collections, simplifies CRUD operations for sub / nested documents and implements schema based data validation.

@coolgk/mvc

A simple, lightweight javascript / typescript MxC framework that helps you to create object oriented, modular and testable code.

@coolgk/array

a javascript / typescript module

npm install @coolgk/array

array utilities

Report bugs here: https://github.com/coolgk/node-utils/issues

Examples

import { toArray } from '@coolgk/array';
// OR
// const { toArray } = require('@coolgk/array');

const a = undefined;
const b = false;
const c = '';
const d = [1,2,3];
const e = {a:1};

console.log(toArray(a)); // []
console.log(toArray(b)); // [ false ]
console.log(toArray(c)); // [ '' ]
console.log(toArray(d)); // [ 1, 2, 3 ]
console.log(toArray(e)); // [ { a: 1 } ]

toArray(data) ⇒ array

Kind: global function

| Param | Type | Description | | --- | --- | --- | | data | * | any data to be type cast to array |

@coolgk/amqp

a javascript / typescript module

npm install @coolgk/amqp

a simple RabbitMQ (amqp wrapper) class for publishing and consuming messages

Report bugs here: https://github.com/coolgk/node-utils/issues

Examples

import { Amqp } from '@coolgk/amqp';
// OR
// const { Amqp } = require('@coolgk/amqp');

const amqp = new Amqp({
    url: 'amqp://localhost/vhost'
});

const message = {
    a: 1,
    b: 'b'
};

// CONSUMER MUST BE STARTED FIRST BEFORE PUSHLISHING ANY MESSAGE

// consumer.js
// consume message and return (send) a response back to publisher
amqp.consume(({rawMessage, message}) => {
    console.log('consumer received', message); // consumer received ignore response
                                               // consumer received { a: 1, b: 'b' }
    return {
        response: 'response message'
    }
});

// publisher.js
// publish a message, no response from consumer
amqp.publish('ignore response');

// publish a message and handle response from consumer
amqp.publish(message, ({rawResponseMessage, responseMessage}) => {
    console.log('response from consumer', responseMessage); // response from consumer { response: 'response message' }
});


// example to add:
// consume from (multiple) routes
// round robin consumers
// direct route + a catch all consumer

Amqp

Kind: global class

Amqp
- new Amqp(options)
- .closeConnection() ⇒ void
- .publish(message, [callback], [options]) ⇒ promise.<Array.<boolean>>
- .getChannel() ⇒ promise

new Amqp(options)

| Param | Type | Description | | --- | --- | --- | | options | object | | | options.url | string | connection string e.g. amqp://localhost | | [options.sslPem] | string | pem file path | | [options.sslCa] | string | sslCa file path | | [options.sslPass] | string | password |

amqp.closeConnection() ⇒ void

Kind: instance method of Amqp

amqp.publish(message, [callback], [options]) ⇒ promise.<Array.<boolean>>

Kind: instance method of Amqp

| Param | Type | Default | Description | | --- | --- | --- | --- | | message | * | | message any type that can be JSON.stringify'ed | | [callback] | function | | callback(message) for processing response from consumers | | [options] | object | | | | [options.routes] | string | Array.<string> | "['#']" | route names | | [options.exchangeName] | string | "'defaultExchange'" | exchange name |

amqp.getChannel() ⇒ promise

Kind: instance method of Amqp
Returns: promise - - promise

@coolgk/base64

a javascript / typescript module

npm install @coolgk/base64

base64 encoded decode functions

Report bugs here: https://github.com/coolgk/node-utils/issues

Examples

import { encode, decode, encodeUrl, decodeUrl } from '@coolgk/base64';
// OR
// const { encode, decode, encodeUrl, decodeUrl } = require('@coolgk/base64');

const a = 'https://www.google.co.uk/?a=b'
const hash = encode(a);
const urlHash = encodeUrl(a);

console.log(a); // https://www.google.co.uk/?a=b
console.log(hash); // aHR0cHM6Ly93d3cuZ29vZ2xlLmNvLnVrLz9hPWI=
console.log(decode(hash)); // https://www.google.co.uk/?a=b

console.log(urlHash); // aHR0cHM6Ly93d3cuZ29vZ2xlLmNvLnVrLz9hPWI
console.log(decodeUrl(urlHash)); // https://www.google.co.uk/?a=b

Functions

encode(data) ⇒ string

Kind: global function

| Param | Type | Description | | --- | --- | --- | | data | string | string to encode |

decode(data) ⇒ string

Kind: global function

| Param | Type | Description | | --- | --- | --- | | data | string | encoded hash |

encodeUrl(data) ⇒ string

Kind: global function

| Param | Type | Description | | --- | --- | --- | | data | string | string to encode |

decodeUrl(data) ⇒ string

Kind: global function

| Param | Type | Description | | --- | --- | --- | | data | string | base64 encoded url to decode |

@coolgk/bcrypt

a javascript / typescript module

npm install @coolgk/bcrypt

just a promise wrapper

Report bugs here: https://github.com/coolgk/node-utils/issues

Examples

import { encrypt, verify } from '@coolgk/bcrypt';
// OR
// const { encrypt, verify } = require('@coolgk/bcrypt');

const password = 'abc123';

encrypt(password).then((hash) => {
    verify(password, hash).then(console.log); // true
    verify(password, 'invalidhash').then(console.log, console.error); // Not a valid BCrypt hash.
    verify('invalidpass', hash).then(console.log); // false
});

Functions

encrypt(value, salt) ⇒ promise.<string>

Kind: global function

| Param | Type | Description | | --- | --- | --- | | value | string | string to encrypt | | salt | string | salt |

verify(value, hashedString) ⇒ promise.<boolean>

Kind: global function

| Param | Type | Description | | --- | --- | --- | | value | string | string to check | | hashedString | string | encrypted hash |

@coolgk/cache

a javascript / typescript module

npm install @coolgk/cache

a redis wrapper

Report bugs here: https://github.com/coolgk/node-utils/issues

Examples

import { Cache } from '@coolgk/cache';
import { createClient } from 'redis';
// OR
// const { Cache } = require('@coolgk/cache');
// const { createClient } = require('redis');

const client = createClient({
    host: 'localhost',
    port: 12869,
    password: '----'
});

const cache = new Cache({
    redisClient: client
});

cache.set('abc', {a: 1}, 1).then(console.log); // 'OK'

cache.get('abc').then(console.log); // { a: 1 }

setTimeout(() => {
    cache.get('abc').then(console.log); // null
    client.quit();
}, 1500);

cache.getSetIfNull(
    'abc',
    () => Promise.resolve('data'),
    10
).then((v) => {
    console.log(v); // { a: 1 }
});

Promise.all([
    cache.set('x', 'val x'),
    cache.set('y', 'val y'),
    cache.set('z', 'val z')
]).then(
    () => Promise.all([
        cache.get('x').then(console.log), // val x
        cache.get('y').then(console.log), // val y
        cache.get('z').then(console.log) // val z
    ])
).then(
    () => Promise.all([
        cache.delete('x'),
        cache.delete('y'),
        cache.delete('z')
    ])
).then(
    () => Promise.all([
        cache.get('x').then(console.log), // null
        cache.get('y').then(console.log), // null
        cache.get('z').then(console.log) // null
    ])
);

Cache

Kind: global class

Cache
- new Cache(options)
- .set(name, value, [expiry]) ⇒ promise
- .get(name) ⇒ promise
- .delete(name) ⇒ promise
- .getSetIfNull(name, callback, [expiry]) ⇒ promise
- .command(command, ...params) ⇒ promise

new Cache(options)

| Param | Type | Description | | --- | --- | --- | | options | object | | | [options.redisClient] | object | redis client from redis.createClient() redisClient needs to be passed in so the same connection can be used elsewhere and get closed outside this class |

cache.set(name, value, [expiry]) ⇒ promise

Kind: instance method of Cache

| Param | Type | Default | Description | | --- | --- | --- | --- | | name | string | | name of the variable | | value | * | | value is always JSON.stringify'ed | | [expiry] | number | 0 | expire time in seconds. 0 = never expire |

cache.get(name) ⇒ promise

Kind: instance method of Cache
Returns: promise - - cached value

| Param | Type | Description | | --- | --- | --- | | name | string | name of the variable |

cache.delete(name) ⇒ promise

Kind: instance method of Cache

| Param | Type | Description | | --- | --- | --- | | name | string | Array.<string> | name(s) of the variable |

cache.getSetIfNull(name, callback, [expiry]) ⇒ promise

get the cached value, if not set, resolve "callback()" and save the value then return it

Kind: instance method of Cache
Returns: promise - - cached value

| Param | Type | Default | Description | | --- | --- | --- | --- | | name | string | | name of the variable | | callback | function | | a callback function which returns a value or a promise | | [expiry] | number | 0 | expire time in seconds. 0 = never expire |

cache.command(command, ...params) ⇒ promise

Kind: instance method of Cache

| Param | Type | Description | | --- | --- | --- | | command | string | redis command to run | | ...params | array | params for the command |

@coolgk/captcha

a javascript / typescript module

npm install @coolgk/captcha

recapcha wrapper

Report bugs here: https://github.com/coolgk/node-utils/issues

Examples

const { verify } = require('@coolgk/captcha');
const secret = '-------';

verify(secret, captchaResponse).then((response) => {
    console.log(response); // { success: true, challenge_ts: '2017-12-03T08:19:48Z', hostname: 'www.google.com' }
                           // { success: false, 'error-codes': [ 'invalid-input-response' ] }
});

// OR

import { Captcha } from '@coolgk/captcha';
// OR
// const { Captcha } = require('@coolgk/captcha');

const captcha = new Captcha({ secret });

const captchaResponse = '---------';

captcha.verify(captchaResponse).then((response) => {
    console.log(response); // { success: true, challenge_ts: '2017-12-03T08:19:48Z', hostname: 'www.google.com' }
                           // { success: false, 'error-codes': [ 'invalid-input-response' ] }
});

Captcha

Kind: global class

Captcha
- new Captcha(options)
- .verify(response, [remoteip])

new Captcha(options)

| Param | Type | Description | | --- | --- | --- | | options | object | | | options.secret | object | google captcha secret https://www.google.com/recaptcha/admin#site/337294176 |

captcha.verify(response, [remoteip])

Kind: instance method of Captcha

| Param | Type | Description | | --- | --- | --- | | response | string | repsonse from recaptcha | | [remoteip] | string | ip address | | | promise | |

@coolgk/csv

a javascript / typescript module

npm install @coolgk/csv

read and write csv files

Report bugs here: https://github.com/coolgk/node-utils/issues

Examples

import { Csv } from '@coolgk/csv';
// OR
// const { Csv } = require('@coolgk/csv');

const csv = new Csv({
    tmpConfig: { dir: '/tmp/csv' } // optional
});

const arrayData = [
    [1,2,3,4,5],
    [6,7,7,8,9],
    [0,5,8,90,65]
];

const objectData = [
    {col1: 'ab', col2: 'cd', col3: 'ef'},
    {col1: '2ab', col2: '2cd', col3: '2ef'},
    {col1: '3ab', col2: '3cd', col3: '3ef'}
];

csv.createFile(
    arrayData,
    {
        columns: ['column 1', 'column 2', 'column 3', 'h4', 'h5'],
        formatter: (row) => {
            return row.map((value) => 'formatted-' + value);
        }
    }
).then((csvFilePath) => {
    console.log(csvFilePath); // /tmp/csv/151229255018910356N9qKqUgrpzG2.csv
    read(csvFilePath, ['column 1', 'column 2', 'column 3', 'h4', 'h5']);
});

csv.createFile(
    objectData,
    {
        columns: ['col1', 'col2', 'col3'],
        formatter: (row) => {
            return [row.col1 + '+format', row.col2 + '+format', row.col3 + '+format'];
        }
    }
).then((csvFilePath) => {
    console.log(csvFilePath); // /tmp/csv/151229255019910356AlO9kbzkdqjq.csv
    read(csvFilePath, ['col1', 'col2', 'col3']);
});

function read (file, columns) {
    // with columns/headers
    // read lines as object
    const lines = csv.readFile(file, {columns: columns});
    lines.forEach(
        (lineArray, index) => {
            console.log(lineArray, index);
            // {
                // 'column 1': 'formatted-1',
                // 'column 2': 'formatted-2',
                // 'column 3': 'formatted-3',
                // h4: 'formatted-4',
                // h5: 'formatted-5'
            // } 1
        },
        (total) => {
            console.log('read done, total:', total); // read done, total: 4
        }
    );

    // without columns/headers
    // read lines as array
    const lines2 = csv.readFile(file);
    lines2.forEach(
        (lineArray, index) => {
            console.log(lineArray, index); // [ 'formatted-1', 'formatted-2', 'formatted-3', 'formatted-4', 'formatted-5' ] 1
        },
        (total) => {
            console.log('read done, total:', total); // read done, total: 4
        }
    );
}

@coolgk/email

a javascript / typescript module

npm install @coolgk/email

a email sender wrapper class

Report bugs here: https://github.com/coolgk/node-utils/issues

Examples

import { Email } from '@coolgk/email';
// OR
// const { Email } = require('@coolgk/email');

const email = new Email({host: 'localhost'});

email.send({
    subject: 'hello this is email subject',
    from: {
            name: 'Daniel Gong',
            email: '[email protected]'
    },
    to: [
        {
            name: 'Dan Go',
            email: '[email protected]'
        },
        '[email protected]'
    ],
    message: '<html><body><h1>test</h1>some message here <img src="cid:my-image" width="500" height="250"></body></html>',
    attachments: [
        {
            path: '/tmp/test.png',
            name: 'screenshot.png'
        },
        {
            path:"/tmp/test.png",
            headers:{"Content-ID": "<my-image>"}
        }
    ]
}).then((sentMessage) => {
    console.log(sentMessage);
}).catch((error) => {
    console.log(error);
});

Email

Kind: global class
See: https://www.npmjs.com/package/emailjs#emailserverconnectoptions

Email
- new Email(options)
- .send(options, [attachments]) ⇒ promise

new Email(options)

| Param | Type | Default | Description | | --- | --- | --- | --- | | options | object | | | | [options.user] | string | | username for logging into smtp | | [options.password] | string | | password for logging into smtp | | [options.host] | string | "'localhost'" | smtp host | | [options.port] | string | | smtp port (if null a standard port number will be used) | | [options.ssl] | boolean | | boolean (if true or object, ssl connection will be made) | | [options.tls] | boolean | | boolean (if true or object, starttls will be initiated) | | [options.domain] | string | | domain to greet smtp with (defaults to os.hostname) | | [options.authentication] | Array.<string> | | authentication methods |

email.send(options, [attachments]) ⇒ promise

Kind: instance method of Email
Returns: promise - - message sent

| Param | Type | Description | | --- | --- | --- | | options | object | | | options.subject | string | email subject | | [options.message] | string | html email message | | options.to | Array.<(string|object)> | to email address | | options.to[].name | string | name of the recipient | | options.to[].email | string | email address of the recipient | | [options.from] | string | object | see options.to | | [options.cc] | Array.<(string|object)> | see options.to | | [options.bcc] | Array.<(string|object)> | see options.to | | [attachments] | Array.<object> | email attachments | | attachments.path | string | file path | | [attachments.name] | string | file name | | [attachments.type] | string | file mime type | | [attachments.method] | string | method to send attachment as (used by calendar invites) | | [attachments.headers] | object | attachment headers, header: value pairs, e.g. {"Content-ID":""} |

@coolgk/facebook-sign-in

a javascript / typescript module

npm install @coolgk/facebook-sign-in

facebook sign in module which verifies client access token and returns account data

Report bugs here: https://github.com/coolgk/node-utils/issues

Examples

const { FacebookSignIn } = require('@coolgk/facebook-sign-in');
// OR
// import { FacebookSignIn } from '@coolgk/facebook-sign-in';

const facebookSignIn = new FacebookSignIn({
    clientId: '...',
    secret: '...'
});

const invalidToken = '...';
const validToken = '...';

(async () => {
    const account1 = await facebookSignIn.verify(invalidToken);
    console.log(account1); // false

    const account2 = await facebookSignIn.verify(validToken);
    console.log(account2); // { email: '[email protected]', id: '123123123123123123' }
})()

FacebookSignIn

Kind: global class

FacebookSignIn
- instance
  - .verify(token, [fields]) ⇒ Promise.<(false|object)>
- static
  - .FacebookSignIn
    - new FacebookSignIn(options)

facebookSignIn.verify(token, [fields]) ⇒ Promise.<(false|object)>

verify access token from clients and return false or account data

Kind: instance method of FacebookSignIn
Returns: Promise.<(false|object)> - - false if access token is invalid otherwise returns account data

| Param | Type | Default | Description | | --- | --- | --- | --- | | token | string | | facebook user's token string | | [fields] | string | "'email'" | fields to fetch from user's facebook account. comma separated value e.g. id,name,email |

FacebookSignIn.FacebookSignIn

Kind: static class of FacebookSignIn

new FacebookSignIn(options)

| Param | Type | Description | | --- | --- | --- | | options | object | | | options.clientId | string | facebook app id | | options.secret | string | facebook app secret |

@coolgk/formdata

a javascript / typescript module

npm install @coolgk/formdata

A http request form data parser (large file friendly) for 'application/json', 'application/x-www-form-urlencoded' and 'multipart/form-data'. It only parses form data when you ask for it.

Report bugs here: https://github.com/coolgk/node-utils/issues

Example Form

<form method="POST" enctype="multipart/form-data">
    <input type="text" name="name">
    <input type="text" name="age">
    <input type="file" name="photo">
    <input type="file" name="photo">
    <input type="file" name="id">
</form>

Express Middleware

// express middleware
const app = require('express')();
const formdata = require('@coolgk/formdata');

app.use(formdata.express());

app.post('/id-only', async (request, response, next) => {
    const post = await request.formdata.getData('id'); // upload 3 files but only parse 1, ignore others
    console.log(post);
    response.json(post);
    // output
    // {
        // "name": "Tim",
        // "age": "33",
        // "id": {
            // "error": null,
            // "fieldname": "id",
            // "filename": "test.txt",
            // "encoding": "7bit",
            // "mimetype": "text/plain",
            // "size": 13,
            // "path": "/tmp/151605931497716067xZGgxPUdNvoj"
        // }
    // }
});

app.post('/all-files', async (request, response, next) => {
    const post = await request.formdata.getData(['id', 'photo']); // parse all files
    console.log(post);
    response.json(post);
    // output
    // {
        // "name": "Tim",
        // "age": "33",
        // "photo": [
            // {
                // "error": null,
                // "fieldname": "photo",
                // "filename": "test.png",
                // "encoding": "7bit",
                // "mimetype": "image/png",
                // "size": 604,
                // "path": "/tmp/151605931497716067xZGgxPUdNvoj"
            // },
            // {
                // "error": null,
                // "fieldname": "photo",
                // "filename": "test.svg",
                // "encoding": "7bit",
                // "mimetype": "image/svg+xml",
                // "size": 2484,
                // "path": "/tmp/151605931497916067EAUAa3yB4q42"
            // }
        // ],
        // "id": {
            // "error": null,
            // "fieldname": "id",
            // "filename": "test.txt",
            // "encoding": "7bit",
            // "mimetype": "text/plain",
            // "size": 13,
            // "path": "/tmp/151605931498016067zqZe6dlhidQ5"
        // }
    // }
});

app.listen(8888);

Native Node App

const { formData, express, getFormData, FormDataError } = require('@coolgk/formdata');
const http = require('http');
http.createServer(async (request, response) => {

    const data = await getFormData(request, { fileFieldNames: ['id', 'photo'] });

    // OR
    // const formdata = formData(request);
    // ... some middelware
    // ... in some routes
    // const data = formdata.getData(['id', 'photo']);

    console.log(data);
    response.end(JSON.stringify(data));

    // {
        // "name": "Tim",
        // "age": "33",
        // "photo": [
            // {
                // "error": null,
                // "fieldname": "photo",
                // "filename": "test.png",
                // "encoding": "7bit",
                // "mimetype": "image/png",
                // "size": 604,
                // "path": "/tmp/151605931497716067xZGgxPUdNvoj"
            // },
            // {
                // "error": null,
                // "fieldname": "photo",
                // "filename": "test.svg",
                // "encoding": "7bit",
                // "mimetype": "image/svg+xml",
                // "size": 2484,
                // "path": "/tmp/151605931497916067EAUAa3yB4q42"
            // }
        // ],
        // "id": {
            // "error": null,
            // "fieldname": "id",
            // "filename": "test.txt",
            // "encoding": "7bit",
            // "mimetype": "text/plain",
            // "size": 13,
            // "path": "/tmp/151605931498016067zqZe6dlhidQ5"
        // }
    // }

}).listen(8888);

@coolgk/google-sign-in

a javascript / typescript module

npm install @coolgk/google-sign-in

google sign in module which verifies id token and returns account data

Report bugs here: https://github.com/coolgk/node-utils/issues

Examples

const { GoogleSignIn } = require('@coolgk/google-sign-in');
// OR
// import { GoogleSignIn } from '@coolgk/google-sign-in';

const googleSignIn = new GoogleSignIn({
    clientId: '......'
});

const invalidToken = '...';
const validToken = '...';

(async () => {
    const account1 = await googleSignIn.verify(invalidToken);
    console.log(account1); // false

    const account2 = await googleSignIn.verify(validToken);
    console.log(account2);
    // {
    //     azp: '...',
    //     aud: '...',
    //     sub: '123123123',
    //     email: '[email protected]',
    //     email_verified: true,
    //     at_hash: 'asdfasdfasdfasdfa',
    //     exp: 1520633389,
    //     iss: 'accounts.google.com',
    //     jti: 'qfwfasdfasdfasdfasdfasdfasdfadsf',
    //     iat: 1520629789,
    //     name: 'first last',
    //     picture: 'https://lh6.googleusercontent.com/.../photo.jpg',
    //     given_name: 'first',
    //     family_name: 'last',
    //     locale: 'en-GB'
    // }
})()

GoogleSignIn

Kind: global class

GoogleSignIn
- instance
  - .verify(token) ⇒ Promise.<(boolean|object)>
- static
  - .GoogleSignIn
    - new GoogleSignIn(options)

googleSignIn.verify(token) ⇒ Promise.<(boolean|object)>

Kind: instance method of GoogleSignIn
Returns: Promise.<(boolean|object)> - - false if id token is invalid otherwise returns account data

| Param | Type | Description | | --- | --- | --- | | token | string | google id token string |

GoogleSignIn.GoogleSignIn

Kind: static class of GoogleSignIn

new GoogleSignIn(options)

| Param | Type | Description | | --- | --- | --- | | options | object | | | options.clientId | string | google client id |

@coolgk/jwt

a javascript / typescript module

npm install @coolgk/jwt

a simple jwt token class

Report bugs here: https://github.com/coolgk/node-utils/issues

Examples

import { Jwt } from '@coolgk/jwt';
// OR
// const { Jwt } = require('@coolgk/jwt');

const jwt = new Jwt({secret: 'abc'});

const string = 'http://example.com/a/b/c?a=1';

const token = jwt.generate(string);

console.log(
    jwt.verify(token), // { exp: 0, iat: 1512307492763, rng: 0.503008668963175, data: 'http://example.com/a/b/c?a=1' }
    jwt.verify(token+'1') // false
);

const token2 = jwt.generate(string, 200);

console.log(
    jwt.verify(token2), // { exp: 1512307493026, iat: 1512307492826, rng: 0.5832258275608753, data: 'http://example.com/a/b/c?a=1' }
    jwt.verify(token+'1') // false
);

setTimeout(() => {
    console.log(jwt.verify(token2)); // false
}, 250);

Jwt

Kind: global class

Jwt
- new Jwt(options)
- .generate(data, [expiry]) ⇒ string
- .verify(token) ⇒ boolean | object

new Jwt(options)

| Param | Type | Description | | --- | --- | --- | | options | object | | | options.secret | string | for encryption |

jwt.generate(data, [expiry]) ⇒ string

Kind: instance method of Jwt

| Param | Type | Default | Description | | --- | --- | --- | --- | | data | * | | any data can be JSON.stringify'ed | | [expiry] | number | 0 | in milliseconds 0 = never expire |

jwt.verify(token) ⇒ boolean | object

Kind: instance method of Jwt
Returns: boolean | object - - false or the payload of the token

| Param | Type | Description | | --- | --- | --- | | token | string | token to verify |

@coolgk/number

a javascript / typescript module

npm install @coolgk/number

number utitlies

Report bugs here: https://github.com/coolgk/node-utils/issues

Examples

import { round } from '@coolgk/number';
// OR
// const { round } = require('@coolgk/number');

console.log(round(1.3923, 2)); // 1.39
console.log(round(100, 2)); // 100
console.log(round(100.1264, 2)); // 100.13
console.log(round(100.958747, 4)); // 100.9587

round(value, precision) ⇒ number

Kind: global function

| Param | Type | Default | Description | | --- | --- | --- | --- | | value | number | | number to round | | precision | number | 2 | precision |

@coolgk/pdf

a javascript / typescript module

npm install @coolgk/pdf

html to PDF module. create PDF files from html string or file.

Report bugs here: https://github.com/coolgk/node-utils/issues

Examples

// for "error while loading shared libraries: libfontconfig.so" run "sudo apt-get -y install libfontconfig"

import { Pdf, Format, Orientation } from '@coolgk/pdf';
// OR
// const { Pdf, Format, Orientation } = require('@coolgk/pdf');

const pdf = new Pdf({
    tmpConfig: { dir: '/tmp/pdf' } // optional
});

pdf.createFromHtmlFile(
    '/tmp/test.html',
    {
        header: {
            height: '1cm',
            contents: "<strong style='color: red'>Page ${pageNumber} of ${numberOfPages} - ${pageNumber}</strong>"
        },
        footer: {
            height: '1cm',
            contents: 'footer <strong>Page ${pageNumber} of ${numberOfPages}</strong>'
        },
        margin: '0.5cm'
    }
).then((pdfFile) => {
    console.log(pdfFile);
});

const htmlCode = `<!DOCTYPE html><html><head>
        <title>CCES</title>
        <style>
            .pagebreak { page-break-after: always; }
            h2, h1 { color: red }
        </style>
    </head>
    <body>
        <div>
            <h1>page 1</h1>
            <p>some text <img src='https://dummyimage.com/600x400/3bbda9/f516ae.jpg'></p>
        </div>
        <div class="pagebreak"></div>
        <div>
            <h2>page 2</h2>
            <table>
                <tr>
                    <td>texgt</td>
                    <td>text</td>
                </tr>
            </table>
        </div>
    </body>
</html>`;

pdf.createFromHtmlString(htmlCode).then((pdfFile) => {
    console.log(pdfFile);
});

@coolgk/session

a javascript / typescript module

npm install @coolgk/session

An session handler that works without cookie (and with cookie too).

Report bugs here: https://github.com/coolgk/node-utils/issues

When working without cookie, this class reads the session token from the "Authorization" header. e.g. Authorization : Bearer cn389ncoiwuencr...

Express Middleware Example

// express middleware
const session = require('@coolgk/session');
const app = require('express')();

app.use(
    session.express({
        redisClient: require('redis').createClient({
            host: process.env.REDIS_HOST,
            port: process.env.REDIS_PORT,
            password: process.env.REDIS_PASSWORD
        }),
        secret: '123' // secret is required for creating the session token / id
    })
);

app.use(async (request, response, next) => {
    // allow access if it's the login page or the request has a valid session
    if ('/login' === request.url || await request.session.verifyAndRenew()) { // if session is verified, renew session
        next();
    } else { // deny access
        response.send('Please Login');
        // output
        // 'Please Login'
    }
});

app.get('/login', async (request, response, next) => {
    // start a new session (create a new session id)
    const accessToken = await request.session.init();
    // set session variables
    await request.session.set('user', { id: 1, username: 'abc' });
    // send session token/id back
    response.json({ accessToken });
    // output
    // {"accessToken":"eyJleHAiOjAsIml..."}
});

app.get('/user', async (request, response, next) => {
    // get session variable
    response.json(await request.session.get('user'));
    // output
    // {"id":1,"username":"abc"}
});

app.get('/session', async (request, response, next) => {
    // get all session values
    response.json(await request.session.getAll());
    // output
    // {"user":{"id":1,"username":"abc"}}
});

app.get('/logout', async (request, response, next) => {
    // destroy current session
    await request.session.destroy();
    response.json(await request.session.getAll());
    // output
    // {}
});

app.listen(8888);

Native Node App Example

import { Session } from '@coolgk/session';
// OR
// const { Session } = require('@coolgk/session');

const http = require('http');
http.createServer(async (request, response) => {

    const session = new Session({
        redisClient: require('redis').createClient({
            host: process.env.REDIS_HOST,
            port: process.env.REDIS_PORT,
            password: process.env.REDIS_PASSWORD
        }),
        secret: '123',
        request,
        response
    });

    // ... some middelware
    // ... in some routes
    // set sesstion
    await session.start();
    await session.set('user', {id: 1, username: '[email protected]'});

    // check session and renew if verified
    const verified = await session.verifyAndRenew();
    if (verified) {
        // session exists, logged in, do something
    } else {
        // deny access or show login screen
    }

    // show session data
    response.end(
        JSON.stringify(
            await session.getAll()
        )
    ); // {"user":{"id":1,"username":"[email protected]"}}

}).listen(8888);

To use without cookie

Create a session without the "response" property and the sessoin object will read the session id from the "Authorization" header i.e. Authorization : Bearer cn389ncoiwuencr...

const session = new Session({
    redisClient: require('redis').createClient({
        host: process.env.REDIS_HOST,
        port: process.env.REDIS_PORT,
        password: process.env.REDIS_PASSWORD
    }),
    secret: '123',
    request
});

Session

This class extends @coolgk/token see set(), get(), delete(), getAll() in @coolgk/token

Kind: global class

Session
- .destroy() ⇒ promise
- .renew([expiry]) ⇒ promise

session.destroy() ⇒ promise

destory the current session

Kind: instance method of Session

session.renew([expiry]) ⇒ promise

renew session optionally with a different expiry time

Kind: instance method of Session
Returns: promise - - false if session has not been started or has a invalid token string

| Param | Type | Description | | --- | --- | --- | | [expiry] | number | in seconds |

@coolgk/queue

a javascript / typescript module

npm install @coolgk/queue

This is a super lightweight function that limits the number of async functions run concurrently and run them in order.

Report bugs here: https://github.com/coolgk/node-utils/issues

Put async functions in a queue and limit the number of async functions that run concurrently.
Run async functions in order
Run x number of functions in parallel per batch in order. similar to async / await when the second parameter is 1.

Examples

import { queue } from '@coolgk/queue';
// OR
// const { queue } = require('@coolgk/queue');

function a (x) {
    console.log('start a');
    return new Promise((resolve) => setTimeout(() => { console.log('end a', x); resolve('a') }, 1300));
}

function b (x) {
    console.log('start b');
    return new Promise((resolve) => setTimeout(() => { console.log('end b', x); resolve('b') }, 1200));
}

function c (x) {
    console.log('start c');
    return new Promise((resolve) => setTimeout(() => { console.log('end c', x); resolve('c') }, 100));
}

// call a, b, c in order i.e. b does not start until a resolves
queue(a);
queue(b);
queue(c);

// call a 5 times, each waits until the previous call resolves
[1,2,3,4,5].forEach(() => {
    queue(a)
});

// run 3 jobs at a time
[1,2,3,4,5,6,7,8,9,10].forEach(() => {
    queue(a, 3)
});

queue(callback, [limit]) ⇒ promise

Kind: global function

| Param | Type | Default | Description | | --- | --- | --- | --- | | callback | function | | callback function that returns a promise or any other types | | [limit] | number | 1 | number of callback to run at the same time, by default one callback at a time |

@coolgk/string

a javascript / typescript module

npm install @coolgk/string

string utility functions

Report bugs here: https://github.com/coolgk/node-utils/issues

Examples

import { stripTags, escapeHtml, unescapeHtml, prepad0 } from '@coolgk/string';
// OR
// const { stripTags, escapeHtml, unescapeHtml, prepad0 } = require('@coolgk/string');

const str = '<h1>test</h1><script>alert(1)</script>'

console.log(stripTags(str)); //  test alert(1)
console.log(escapeHtml(str)); // &lt;h1&gt;test&lt;/h1&gt;&lt;script&gt;alert(1)&lt;/script&gt;
console.log(unescapeHtml(escapeHtml(str))); // <h1>test</h1><script>alert(1)</script>

console.log(prepad0(7, 2)); // 07
console.log(prepad0(70, 3)); // 070
console.log(prepad0(70, 4)); // 0070
console.log(prepad0(1, 4)); // 0001
console.log(prepad0(1000, 2)); // 1000

Functions

stripTags(a) ⇒ string

strip html tags e.g. "<h1>header</h1><p>message</p>" becomes "header message"

Kind: global function
Returns: string - - string with tags stripped

| Param | Type | Description | | --- | --- | --- | | a | string | string |

escapeHtml(value) ⇒ string

escaping user input e.g. html code in a message box

Kind: global function

| Param | Type | Description | | --- | --- | --- | | value | string | string to escape |

unescapeHtml(string) ⇒ string

unescaping strings escaped by escapeHtml()

Kind: global function

| Param | Type | Description | | --- | --- | --- | | string | string | string to unescape |

prepad0(value, length) ⇒ string

use padStart instead

Kind: global function
See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

| Param | Type | Default | Description | | --- | --- | --- | --- | | value | number | | an integer in string or number format | | length | number | 2 | length of the output e.g. length = 2, 8 becomes 08. length = 3, 70 = 070. |

@coolgk/tmp

a javascript / typescript module

npm install @coolgk/tmp

wrapper functions, generate tmp file or folders

Report bugs here: https://github.com/coolgk/node-utils/issues

Examples

import { generateFile, generateDir, generateTmpName } from '@coolgk/tmp';
// OR
// const { generateFile, generateDir, generateTmpName } = require('@coolgk/tmp');

generateFile({dir: '/tmp/test'}).then((r) => console.log('file', r));
    // file { path: '/tmp/test/1512307052908140480ZZj6J0LOIJb.tmp' }

generateDir({dir: '/tmp/test'}).then((r) => console.log('dir',r));
    // dir { path: '/tmp/test/1512307052918140484Pnv1m95ZS2b' }

generateTmpName({dir: '/tmp/test'}).then((r) => console.log('name', r));
    // name { path: '/tmp/test/151230705292114048hb3XIds0FO9Y' }

Functions

generateFile([options]) ⇒ promise

Kind: global function
Returns: promise - - { path: ..., cleanupCallback: ... } calling cleanupCallback() removes the generated file

| Param | Type | Default | Description | | --- | --- | --- | --- | | [options] | object | | | | [options.mode] | number | 0600 | the file mode to create with, defaults to 0600 on file and 0700 on directory | | [options.prefix] | string | "Date.now()" | the optional prefix, fallbacks to tmp- if not provided | | [options.postfix] | string | "'.tmp'" | the optional postfix, fallbacks to .tmp on file creation | | [options.dir] | string | "/tmp" | the optional temporary directory, fallbacks to system default | | [options.keep] | boolean | false | if to keep the file |

generateDir([options]) ⇒ promise

Kind: global function
Returns: promise - - { path: ..., cleanupCallback: ... } calling cleanupCallback() removes the generated file

generateTmpName([options]) ⇒ promise

Kind: global function
Returns: promise - - { path: ... }

@coolgk/token

a javascript / typescript module

npm install @coolgk/token

an expirable, revocable, renewable token with data storage

Report bugs here: https://github.com/coolgk/node-utils/issues

Examples

import { Token } from '@coolgk/token';
import { createClient } from 'redis';
// OR
// const { Token } = require('@coolgk/token');
// const createClient = require('redis').createClient;

(async () => {

    const redisClient = createClient({
        host: 'localhost',
        port: 6379,
        password: '----'
    });

    const token = new Token({
        redisClient: redisClient,
        expiry: 5,
        token: 'abcde'
    });

    console.log(
        await token.verify()
    ) // false

    await token.renew();

    console.log(
        await token.verify()
    ) // true

    console.log(
        await token.get('var1');
    ); // null

    console.log(
        await token.getAll()
    ); // {}

    await token.set('var1', {a: 'var1', b: false});

    console.log(
        await token.get('var1');
    ); // {a: 'var1', b: false}

    await token.set('var2', 'string var 2');

    console.log(
        await token.getAll()
    ); // { var1: { a: 'var1', b: false }, var2: 'string var 2' }

    await token.delete('var2');

    console.log(
        await token.get('var2');
    ); // null

    console.log(
        await token.getAll()
    ); // { var1: { a: 'var1', b: false } }

    await token.destroy();

    console.log(
        await token.verify()
    ) // false

    console.log(
        await token.get('var1');
    ); // null

    console.log(
        await token.getAll()
    ); // {}

    redisClient.quit();
})()

Classes

Constants

Token

Kind: global class

Token
- new Token(options)
- .renew([expiry]) ⇒ promise
- .set(name, value) ⇒ promise
- .verify() ⇒ promise.<boolean>
- .get(name) ⇒ promise
- .destroy() ⇒ promise
- .delete(name) ⇒ promise
- .getAll() ⇒ promise.<{}>
- .setToken(token)

new Token(options)

| Param | Type | Default | Description | | --- | --- | --- | --- | | options | object | | | | options.token | string | | token string for creating a token object | | options.redisClient | object | | redis client from redis.createClient() | | [options.prefix] | string | "'token'" | prefix used in redis e.g. token:[TOKEN_STRING...] | | [options.expiry] | number | 0 | in seconds. 0 = never expire |

token.renew([expiry]) ⇒ promise

Kind: instance method of Token

| Param | Type | Description | | --- | --- | --- | | [expiry] | number | in seconds |

token.set(name, value) ⇒ promise

set a data field value

Kind: instance method of Token

| Param | Type | Description | | --- | --- | --- | | name | string | field name | | value | * | anything can be JSON.stringify'ed |

token.verify() ⇒ promise.<boolean>

verify if token has expired

Kind: instance method of Token

token.get(name) ⇒ promise

get the value of a data field

Kind: instance method of Token

| Param | Type | Description | | --- | --- | --- | | name | string | data field name |

token.destroy() ⇒ promise

delete the token

Kind: instance method of Token

token.delete(name) ⇒ promise

delete a data field in the token

Kind: instance method of Token

| Param | Type | Description | | --- | --- | --- | | name | string | data field name |

token.getAll() ⇒ promise.<{}>

get the values of all data fields in the token

Kind: instance method of Token

token.setToken(token)

set a new token string

Kind: instance method of Token

| Param | Type | Description | | --- | --- | --- | | token | string | new token string |

TokenError : object

Error Codes

Kind: global constant
Properties

| Name | Type | Description | | --- | --- | --- | | INVALID_TOKEN | string | invalid token string | | RESERVED_NAME | string | reserved names are used when setting token variables e.g. _timestamp | | EXPIRED_TOKEN | string | token expired or renew() has not been called |

@coolgk/unit

a javascript / typescript module

npm install @coolgk/unit

unit conversion

Report bugs here: https://github.com/coolgk/node-utils/issues

Examples

import { bytesToString, millisecondsToString } from '@coolgk/unit';
// OR
// const { bytesToString, millisecondsToString } = require('@coolgk/unit');

console.log(
    bytesToString(500), // 500B
    bytesToString(5000), // 4.88KB
    bytesToString(5000000), // 4.77MB
    bytesToString(5000000000), // 4.66GB
    bytesToString(5000000000000), // 4.55TB
    bytesToString(5000000000000000), // 4547.47TB
    bytesToString(5000000000000000000) // 4547473.51TB
);

console.log('1 sec', millisecondsToString(1 * 1000)); // 1 second
console.log('1 min', millisecondsToString(60 * 1000)); // 1 minute
console.log('100 sec', millisecondsToString(100 * 1000)); // 1 minute
console.log('3 hrs', millisecondsToString(60 * 60 * 3 * 1000)); // 3 hour
console.log('1.5 days', millisecondsToString(60 * 60 * 24 * 1.5 * 1000)); // 1 day
console.log('65 days', millisecondsToString(60 * 60 * 24 * 65 * 1000)); // 2 month
console.log('365 days', millisecondsToString(60 * 60 * 24 * 365 * 1000)); // 1 year
console.log('500 days', millisecondsToString(60 * 60 * 24 * 500 * 1000)); // 1 year
console.log('900 days', millisecondsToString(60 * 60 * 24 * 900 * 1000));// 2 year
console.log('1900 days', millisecondsToString(60 * 60 * 24 * 1900 * 1000)); // 5 year
console.log('365001 days', millisecondsToString(60 * 60 * 24 * 365001 * 1000)); // 1013 year

Functions

bytesToString(value) ⇒ string

or use https://www.npmjs.com/package/filesize

Kind: global function
Returns: string - value in KB, MB, GB or TB

| Param | Type | Description | | --- | --- | --- | | value | number | value in byte |

millisecondsToString(value) ⇒ string

Kind: global function
Returns: string - value in second, minute, hour, day, month or year

| Param | Type | Description | | --- | --- | --- | | value | number | number of milliseconds |

@coolgk/url

a javascript / typescript module

npm install @coolgk/url

a simple function for parsing parameters in a url

Report bugs here: https://github.com/coolgk/node-utils/issues

Examples

import { getParams } from '@coolgk/url';
// OR
// const { getParams } = require('@coolgk/url');

const url = '/123';
const pattern = '/:id';

console.log(getParams(url, pattern)); // { id: '123' }

const url2 = '/123/abc/456';
const pattern2 = '/:id/abc/:value';

console.log(getParams(url2, pattern2)); // { id: '123', value: '456' }

const url3 = '/123/456';
const pattern3 = ':id/:value';

console.log(getParams(url3, pattern3)); // { id: '123', value: '456' }

getParams(url, pattern) ⇒ object

a simple function to get params in a url e.g. with url: user/123, pattern: user/:id returns {id: 123}

Kind: global function
Returns: object - - e.g. {userid: 123}

| Param | Type | Description | | --- | --- | --- | | url | string | url after the domain name e.g. http://abc.com/user/:id url should be /user/:id | | pattern | string | e.g. /:userid/:name |

Published

Vulnerabilities

Links

Maintainers

Keywords

Readme

@coolgk/array

Examples

toArray(data) ⇒ array

@coolgk/amqp

Examples

Amqp

new Amqp(options)

amqp.closeConnection() ⇒ void

amqp.publish(message, [callback], [options]) ⇒ promise.<Array.<boolean>>

amqp.getChannel() ⇒ promise

@coolgk/base64

Examples

Functions

encode(data) ⇒ string

decode(data) ⇒ string

encodeUrl(data) ⇒ string

decodeUrl(data) ⇒ string

@coolgk/bcrypt

Examples

Functions

encrypt(value, salt) ⇒ promise.<string>

verify(value, hashedString) ⇒ promise.<boolean>

@coolgk/cache

Examples

Cache

new Cache(options)

cache.set(name, value, [expiry]) ⇒ promise

cache.get(name) ⇒ promise

cache.delete(name) ⇒ promise

cache.getSetIfNull(name, callback, [expiry]) ⇒ promise

cache.command(command, ...params) ⇒ promise

@coolgk/captcha

Examples

Captcha

new Captcha(options)

captcha.verify(response, [remoteip])

@coolgk/csv

Examples

@coolgk/email

Examples

Email

new Email(options)

email.send(options, [attachments]) ⇒ promise

@coolgk/facebook-sign-in

Examples

FacebookSignIn

facebookSignIn.verify(token, [fields]) ⇒ Promise.<(false|object)>

FacebookSignIn.FacebookSignIn

new FacebookSignIn(options)

@coolgk/formdata

Example Form

Express Middleware

Native Node App

@coolgk/google-sign-in

Examples

GoogleSignIn

googleSignIn.verify(token) ⇒ Promise.<(boolean|object)>

GoogleSignIn.GoogleSignIn

new GoogleSignIn(options)

@coolgk/jwt

Examples

Jwt

new Jwt(options)

jwt.generate(data, [expiry]) ⇒ string

jwt.verify(token) ⇒ boolean | object

@coolgk/number

Examples

round(value, precision) ⇒ number

@coolgk/pdf

Examples

@coolgk/session

Express Middleware Example

Native Node App Example

To use without cookie