@es-labs/jslib 0.0.1

package/iso/__tests__/fetch.spec.js

@@ -0,0 +1,270 @@
+import assert from 'node:assert/strict';
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import Fetch from '../fetch.js';
+
+function createFetchMock() {
+  const calls = [];
+  const responses = [];
+  const fn = async (...args) => {
+    calls.push(args);
+    const res = responses.shift();
+    if (!res) throw new Error('No mock response configured');
+    return res;
+  };
+
+  fn.calls = calls;
+  fn.mockResolvedValueOnce = (value) => { responses.push(value); return fn; };
+  fn.mockResolvedValue = (value) => { responses.length = 0; responses.push(value); return fn; };
+  fn.mockClear = () => { calls.length = 0; responses.length = 0; };
+  return fn;
+}
+
+describe.skip('fetch.js', () => {
+  let originalFetch;
+  let fetchInstance;
+  let fetchMock;
+
+  beforeEach(() => {
+    originalFetch = global.fetch;
+    fetchMock = createFetchMock();
+    global.fetch = fetchMock;
+    fetchInstance = new Fetch();
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+  });
+
+  describe('constructor', () => {
+    it('should set default options and tokens', () => {
+      assert.strictEqual(fetchInstance.options.baseUrl, '');
+      assert.strictEqual(fetchInstance.options.credentials, 'same-origin');
+      assert.strictEqual(typeof fetchInstance.options.forceLogoutFn, 'function');
+      assert.strictEqual(fetchInstance.options.refreshUrl, '');
+      assert.strictEqual(fetchInstance.options.timeoutMs, 0);
+      assert.strictEqual(fetchInstance.options.maxRetry, 0);
+      assert.deepStrictEqual(fetchInstance.tokens, { access: '', refresh: '' });
+    });
+
+    it('should override options and tokens', () => {
+      const options = { baseUrl: 'http://localhost', timeoutMs: 5000 };
+      const tokens = { access: 'token123', refresh: 'refresh123' };
+      fetchInstance = new Fetch(options, tokens);
+      assert.strictEqual(fetchInstance.options.baseUrl, 'http://localhost');
+      assert.strictEqual(fetchInstance.options.timeoutMs, 5000);
+      assert.strictEqual(fetchInstance.tokens.access, 'token123');
+      assert.strictEqual(fetchInstance.tokens.refresh, 'refresh123');
+    });
+  });
+
+  describe('parseUrl', () => {
+    it('should parse relative URL', () => {
+      const result = Fetch.parseUrl('/api/test', 'http://localhost');
+      assert.deepStrictEqual(result, {
+        urlOrigin: 'http://localhost',
+        urlPath: '/api/test',
+        urlFull: 'http://localhost/api/test',
+        urlSearch: ''
+      });
+    });
+
+    it('should parse absolute URL with query', () => {
+      const result = Fetch.parseUrl('http://localhost/api/test?key=value');
+      assert.deepStrictEqual(result, {
+        urlOrigin: 'http://localhost',
+        urlPath: '/api/test',
+        urlFull: 'http://localhost/api/test',
+        urlSearch: '?key=value'
+      });
+    });
+
+    it('should handle invalid URL', () => {
+      const result = Fetch.parseUrl('invalid-url', 'http://localhost');
+      assert.strictEqual(result.urlOrigin, 'http://localhost');
+      assert.strictEqual(result.urlPath, 'invalid-url');
+      assert.strictEqual(result.urlFull, 'http://localhostinvalid-url');
+      assert.strictEqual(result.urlSearch, '');
+    });
+  });
+
+  describe('setOptions and getOptions', () => {
+    it('should set and get options', () => {
+      fetchInstance.setOptions({ baseUrl: 'http://test.com' });
+      assert.strictEqual(fetchInstance.getOptions().baseUrl, 'http://test.com');
+    });
+  });
+
+  describe('setTokens and getTokens', () => {
+    it('should set and get tokens', () => {
+      fetchInstance.setTokens({ access: 'newtoken' });
+      assert.strictEqual(fetchInstance.getTokens().access, 'newtoken');
+    });
+  });
+
+  describe('http', () => {
+    it('should make a successful GET request', async () => {
+      fetchMock.mockResolvedValueOnce({
+        status: 200,
+        text: () => Promise.resolve('{"data": "test"}')
+      });
+
+      const result = await fetchInstance.http('GET', 'http://localhost/api/test');
+      assert.strictEqual(result.status, 200);
+      assert.deepStrictEqual(result.data, { data: 'test' });
+      assert.strictEqual(fetchMock.calls.length, 1);
+      assert.strictEqual(fetchMock.calls[0][0], 'http://localhost/api/test');
+      assert.strictEqual(fetchMock.calls[0][1].method, 'GET');
+    });
+
+    it('should handle query parameters', async () => {
+      fetchMock.mockResolvedValueOnce({
+        status: 200,
+        text: () => Promise.resolve('')
+      });
+
+      await fetchInstance.http('GET', 'http://localhost/api/test', null, { key: 'value' });
+      assert.strictEqual(fetchMock.calls[0][0], 'http://localhost/api/test?key=value');
+    });
+
+    it('should handle POST with JSON body', async () => {
+      fetchMock.mockResolvedValueOnce({
+        status: 201,
+        text: () => Promise.resolve('')
+      });
+
+      await fetchInstance.http('POST', 'http://localhost/api/test', { name: 'test' });
+      assert.strictEqual(fetchMock.calls[0][0], 'http://localhost/api/test');
+      assert.strictEqual(fetchMock.calls[0][1].method, 'POST');
+      assert.strictEqual(fetchMock.calls[0][1].body, '{"name":"test"}');
+      assert.strictEqual(fetchMock.calls[0][1].headers['Content-Type'], 'application/json');
+    });
+
+    it('should handle POST with URL-encoded body', async () => {
+      fetchMock.mockResolvedValueOnce({
+        status: 201,
+        text: () => Promise.resolve('')
+      });
+      await fetchInstance.http('POST', 'http://localhost/api/test', { name: 'test' }, null, { 'Content-Type': 'application/x-www-form-urlencoded' });
+      assert.strictEqual(fetchMock.calls[0][0], 'http://localhost/api/test');
+      assert.strictEqual(fetchMock.calls[0][1].method, 'POST');
+      assert.strictEqual(fetchMock.calls[0][1].body.toString(), 'name=test');
+      assert.strictEqual(fetchMock.calls[0][1].headers['Content-Type'], 'application/x-www-form-urlencoded');
+    });
+
+    it('should handle POST with octet-stream', async () => {
+      fetchMock.mockResolvedValueOnce({ status: 201, text: () => Promise.resolve('') });
+
+      const binaryData = new Uint8Array(Buffer.from('Hello', 'utf-8'));
+      await fetchInstance.http('POST', 'http://localhost/api/test', binaryData, null, { 'Content-Type': 'application/octet-stream' });
+      assert.strictEqual(fetchMock.calls[0][0], 'http://localhost/api/test');
+      assert.strictEqual(fetchMock.calls[0][1].method, 'POST');
+      assert.strictEqual(fetchMock.calls[0][1].body.toString(), binaryData.toString());
+      assert.strictEqual(fetchMock.calls[0][1].headers['Content-Type'], 'application/octet-stream');
+    });
+
+    it('should handle FormData body', async () => {
+      const formData = new FormData();
+      formData.append('file', 'test');
+      fetchMock.mockResolvedValueOnce({ status: 200, text: () => Promise.resolve('') });
+      await fetchInstance.http('POST', 'http://localhost/api/test', formData);
+      assert.strictEqual(fetchMock.calls[0][0], 'http://localhost/api/test');
+      assert.strictEqual(fetchMock.calls[0][1].method, 'POST');
+      assert.strictEqual(fetchMock.calls[0][1].body, formData);
+    });
+
+    it('should handle 401 with token refresh', async () => {
+      fetchMock.mockResolvedValueOnce({
+        status: 401,
+        text: () => Promise.resolve('{"message": "Token Expired Error"}')
+      });
+      fetchMock.mockResolvedValueOnce({
+        status: 200,
+        text: () => Promise.resolve('{"access_token": "new_access", "refresh_token": "new_refresh"}')
+      });
+      fetchMock.mockResolvedValueOnce({
+        status: 200,
+        text: () => Promise.resolve('{"data": "success"}')
+      });
+
+      fetchInstance.setOptions({ refreshUrl: '/refresh' });
+      fetchInstance.setTokens({ access: 'old_access', refresh: 'old_refresh' });
+
+      const result = await fetchInstance.http('GET', 'http://127.0.0.1/api/test');
+      assert.strictEqual(result.status, 200);
+      assert.deepStrictEqual(result.data, { data: 'success' });
+      assert.strictEqual(fetchInstance.tokens.access, 'new_access');
+      assert.strictEqual(fetchMock.calls.length, 3);
+      assert.strictEqual(fetchMock.calls[1][0], 'http://127.0.0.1/refresh');
+    });
+
+    it('should throw when token refresh fails', { only: false }, async () => {
+      fetchMock.mockResolvedValueOnce({
+        status: 401, text: () => Promise.resolve('{"message": "Token Expired Error"}')
+      });
+      fetchMock.mockResolvedValueOnce({ status: 404, text: () => Promise.resolve('{"message": "error"}') });
+      fetchInstance.setOptions({ refreshUrl: '/refresh' });
+      fetchInstance.setTokens({ access: 'old_access', refresh: 'old_refresh' });
+
+      await assert.rejects(async () => {
+        await fetchInstance.http('GET', 'http://localhost/api/test');
+      }, (err) => {
+        assert.strictEqual(err.status, 404);
+        assert.deepStrictEqual(err.data, { message: 'error' });
+        return true;
+      });
+      assert.strictEqual(fetchInstance.tokens.access, 'old_access');
+      assert.strictEqual(fetchMock.calls.length, 2);
+    });
+
+    it('should throw on error status', async () => {
+      fetchMock.mockResolvedValueOnce({ status: 404, text: () => Promise.resolve('') });
+      await assert.rejects(async () => { await fetchInstance.http('GET', 'http://localhost/api/test'); });
+    });
+
+    it('should call forceLogoutFn on 401/403 without token error', async () => {
+      let logoutCalled = false;
+      fetchInstance.setOptions({ forceLogoutFn: () => { logoutCalled = true; } });
+      fetchMock.mockResolvedValueOnce({
+        status: 401,
+        text: () => Promise.resolve('{"message": "Unauthorized"}')
+      });
+
+      await assert.rejects(async () => { await fetchInstance.http('GET', 'http://localhost/api/test'); });
+      assert.strictEqual(logoutCalled, true);
+    });
+  });
+
+  describe('convenience methods', () => {
+    beforeEach(() => {
+      fetchMock.mockResolvedValue({
+        status: 200,
+        text: () => Promise.resolve('')
+      });
+    });
+
+    it('should call http with correct method for get', async () => {
+      await fetchInstance.get('/api/test');
+      assert.strictEqual(fetchMock.calls[0][1].method, 'GET');
+    });
+
+    it('should call http with correct method for post', async () => {
+      await fetchInstance.post('/api/test', { data: 'test' });
+      assert.strictEqual(fetchMock.calls[0][1].method, 'POST');
+    });
+
+    it('should call http with correct method for put', async () => {
+      await fetchInstance.put('/api/test', { data: 'test' });
+      assert.strictEqual(fetchMock.calls[0][1].method, 'PUT');
+    });
+
+    it('should call http with correct method for patch', async () => {
+      await fetchInstance.patch('/api/test', { data: 'test' });
+      assert.strictEqual(fetchMock.calls[0][1].method, 'PATCH');
+    });
+
+    it('should call http with correct method for del', async () => {
+      await fetchInstance.del('/api/test');
+      assert.strictEqual(fetchMock.calls[0][1].method, 'DELETE');
+    });
+  });
+});

package/iso/csv-utils.js

@@ -0,0 +1,206 @@
+'use strict'
+// RFC 4180 CSV parser and generator
+// https://stackoverflow.com/a/41563966
+// https://www.convertcsv.com/json-to-csv.htm
+// - instead of using npm libraries: csv-parse and @json2csv/plainjs
+// - use process.stdout.write(...) if piping output so no extra carraige return is added
+// - double quote only required if field contains newline characters
+// - check if valid json key syntax
+// - PROBLEMS
+//   1. what if columns are not same (use less or use more) ?
+//   2. what if row is missing
+
+const DELIM_ROW = "\n" // end of line \r\n for Windows \n for Linux
+const DELIM_COL = ','
+const ESCAPE_CHAR = '""' // this should remain as "" for RFC4180 compliance
+const QUOTE_CHAR = '"'
+const CHAR_CR = '\r'
+const CHAR_LF = '\n'
+
+/**
+ * RFC 4180-compliant CSV parser (handles quoted fields with embedded commas/newlines)
+ * - 1. escaped correctly
+ * - 2. same number of columns in each row (TBD?)
+ * - 3. trims white space around fields (TBD?)
+ * @param {string} str - CSV string to parse
+ * @returns {string[][]} - array of rows, each row is an array of fields
+ * @throws {Error} - if CSV is invalid (e.g. unclosed quotes)
+ */
+const parseCSV = (str, delimCol=DELIM_COL) => {
+  const rows = [];
+  let row = [];
+  let field = '';
+  let inQuotes = false;
+  let i = 0;
+
+  while (i < str.length) {
+    const ch = str[i];
+    const next = str[i + 1];
+
+    if (inQuotes) {
+      if (ch === QUOTE_CHAR && next === QUOTE_CHAR) {
+        field += QUOTE_CHAR;   // "" → single "
+        i += 2;
+      } else if (ch === QUOTE_CHAR) {
+        inQuotes = false;
+        i++;
+      } else {
+        field += ch;
+        i++;
+      }
+    } else {
+      if (ch === QUOTE_CHAR) {
+        inQuotes = true;
+        i++;
+      } else if (ch === delimCol) {
+        row.push(field);
+        field = '';
+        i++;
+      } else if (ch === CHAR_LF || ch === CHAR_CR) {
+        row.push(field);
+        rows.push(row);
+        row = [];
+        field = '';
+        if (ch === CHAR_CR && next === CHAR_LF) i++; // handle \r\n
+        i++;
+      } else {
+        field += ch;
+        i++;
+      }
+    }
+  }
+
+  // Push last field/row
+  if (field || row.length) {
+    row.push(field);
+    rows.push(row);
+  }
+
+  if (inQuotes) throw new Error('Unclosed quoted field — invalid CSV');
+  return rows;
+}
+
+/**
+ * Parse a string as CSV and also validate JSON if a field is a JSON field
+ * @param {string[][]} csvString - CSV parsed as array of rows, each row is an array of fields
+ * @returns {object} - { valid: boolean, reason?: string, rows?: string[][] }
+ * @throws {Error} - if CSV is invalid (e.g. unclosed quotes)
+ */
+const parseAndValidateCsv = (csvString) => {
+  try {
+    const rows = parseCSV(csvString);
+    for (const row of rows) {
+      for (const field of row) {
+        // Catches objects {}, arrays [], strings "...", numbers, booleans, null
+        const looksLikeJSON = /^[[{"'\-\d]|^(true|false|null)$/.test(field.trim());
+        if (looksLikeJSON) {
+          try {
+            JSON.parse(field);
+          } catch {
+            return { valid: false, reason: `Corrupted JSON in field: ${field.slice(0, 50)}` };
+          }
+        }
+      }
+    }
+    return { valid: true, rows };
+  } catch (err) {
+    return { valid: false, reason: err.message };
+  }
+}
+
+/**
+ * convert CSV to array of JSON object
+ * @param {object} input - conversion inputs
+ * @param {string} input._text - CSV text to be converted to array
+ * @param {string} input.delimCol - CSV column delimiter, default is comma (,)
+ * @param {boolean} input.ignoreColumnMismatch - whether to ignore column count mismatches
+ * @returns 
+ */
+const csvToJson = ({ _text, delimCol = DELIM_COL, ignoreColumnMismatch = false}) => {
+  const arr = parseCSV(_text, delimCol);
+  const headers = arr.shift() // 1st row is the headers
+  return arr.map((row) => {
+    const rv = {}
+    if (headers.length != row.length && !ignoreColumnMismatch) throw new Error(`Mismatch headers(${headers.length}) != columns (${row.length})`)
+    headers.forEach((_, index) => {
+      rv[headers[index]] = row[index]
+    })
+    return rv
+  })
+}
+
+/**
+ * Converts an array of fields to a CSV row, escaping values as needed.
+ * escape for Excel, Google Sheets, and RFC 4180-compliant parsers
+ * 
+ * @param {*[]} fields - array of field values to convert to a CSV row
+ * @param {string} delimCol - CSV column delimiter, default is comma (,)
+ * @returns {string} - CSV datarow string
+ */
+const arrayToCSVRow = (fields, delimCol = DELIM_COL) =>{
+  return fields.map(field => {
+    if (field === null || field === undefined) return '';
+    if (typeof field === 'object') {
+      const jsonStr = JSON.stringify(field).replace(/"/g, ESCAPE_CHAR);
+      return `"${jsonStr}"`;
+    }
+    // Wrap any plain string containing commas/quotes/newlines too
+    if (typeof field === 'string' && /[",\n]/.test(field)) {
+      return `"${field.replace(/"/g, ESCAPE_CHAR)}"`;
+    }
+    return field;
+  }).join(delimCol);
+}
+
+/**
+ * Converts JSON object values to a CSV data row, escaping values as needed.
+ * escape for Excel, Google Sheets, and RFC 4180-compliant parsers
+ * 
+ * @param {Object} jsonObj - JSON object to convert to a CSV row
+ * @param {string} delimCol - CSV column delimiter, default is comma (,)
+ * @returns {string} - CSV data row string
+ */
+const jsonToCSVRow = (jsonObj, delimCol = DELIM_COL) => arrayToCSVRow(Object.values(jsonObj), delimCol);
+
+/**
+ * Converts JSON object keys to a CSV header row, escaping values as needed.
+ * escape for Excel, Google Sheets, and RFC 4180-compliant parsers
+ * 
+ * @param {Object} jsonObj - JSON object to convert to a CSV row
+ * @param {string} delimCol - CSV column delimiter, default is comma (,)
+ * @returns {string} - CSV header row string
+ */
+const jsonToCSVHeader = (jsonObj, delimCol = DELIM_COL) => arrayToCSVRow(Object.keys(jsonObj), delimCol);
+
+/**
+ * convert array of JSON objects to CSV
+ * @param {Object[]} _json - array of JS objects to be converted to CSV
+ * @param {string} delimRow - CSV row delimiter, default is newline (\n)
+ * @param {string} delimCol - CSV column delimiter, default is comma (,)
+ * @param {boolean} ignoreColumnMismatch - whether to ignore column count mismatches
+ * @returns 
+ */
+const jsonToCsv = (_json, delimCol=DELIM_COL, delimRow=DELIM_ROW, ignoreColumnMismatch=false) => {
+  let csv = ''
+  let headers = []
+  if (Array.isArray(_json)) _json.forEach((row, index) => {
+    if (index === 0) { // create 1st row as header
+      headers = Object.keys(row)
+      csv += (jsonToCSVHeader(row, delimCol) + delimRow)
+    }
+    const data = Object.values(row)
+    if (headers.length !== data.length && !ignoreColumnMismatch) throw new Error(`Mismatch headers(${headers.length}) != columns (${data.length})`)
+    else csv += (arrayToCSVRow(data, delimCol) + delimRow)
+  })
+  return csv
+}
+
+export {
+  arrayToCSVRow,
+  jsonToCSVHeader,
+  jsonToCSVRow,
+  jsonToCsv,
+  parseAndValidateCsv,
+  parseCSV, // to array of arrays, non validating
+  csvToJson,
+}

package/iso/datetime.js

@@ -0,0 +1,103 @@
+/**
+ * Get array of strings with datetime elements after offseting input date by X days
+ * @param {string} isoString - ISO datetime string
+ * @param {Number} days - ISO datetime string
+ * @returns {string[]}} -  return array or YYYY, MM, DD strings - not so useful...
+ */
+export const dateStrAddDay = (dateStr, days = 0) => {
+  const d = new Date(Date.parse(dateStr) - new Date().getTimezoneOffset());
+  d.setDate(d.getDate() + days); // add the days
+  return [d.getFullYear().toString(), (d.getMonth() + 1).toString().padStart(2, 0), d.getDate().toString().padStart(2, 0)];
+}
+
+/**
+ * Get new ISO datetime string date after offseting input date by X days
+ * @param {string} isoString - ISO datetime string
+ * @param {Number} days - ISO datetime string
+ * @returns {string} -  return ISO datetime string
+ */
+export const dateStrAddDayISO = (isoString, days = 0) => {
+  const d = new Date(isoString);
+  d.setDate(d.getDate() + days);
+  return d.toISOString();
+}
+
+/**
+ * Get local,date time and TZ in ISO format
+ * @param {Date|string} dt - Date object or ISO datetime string
+ * @param {string} tz - IANA time zone name, e.g. 'Asia/Singapore'
+ * @returns {string} -  return string format: 2023-10-24 11:40:15 GMT+8
+ */
+export const getLocaleDateTimeTzISO = (dt, tz) => {
+  const opts = {
+    timeZoneName: 'short',
+    hour12: false,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+  }
+  if (tz) opts.timeZone = tz;
+  if (!(dt instanceof Date)) dt = new Date(dt);
+  return dt.toLocaleString('sv', opts);
+}
+
+/**
+ * Get local date in ISO format
+ * @param {string} isoString - ISO datetime string
+ * @param {string} tz - IANA time zone name, e.g. 'Asia/Singapore'
+ * @returns {string}
+ */
+export const getLocaleDateISO = (isoString, tz) => getLocaleDateTimeTzISO(isoString, tz).substring(0, 10);
+
+/**
+ * Get local date in ISO format
+ * @param {string} isoString - ISO datetime string
+ * @param {string} tz - IANA time zone name, e.g. 'Asia/Singapore'
+ * @returns {string}
+ */
+export const getLocaleTimeISO = (isoString, tz) => getLocaleDateTimeTzISO(isoString, tz).substring(11, 19);
+
+/**
+ * Get timezone offset in ISO format (+hh:mm or -hh:mm)
+ * @param {Date|undefined} date - if undefined, will create a date object and use that timezone 
+ * @returns {string}
+ */
+export const getTzOffsetISO = (date) => {
+  const pad = n => `${Math.floor(Math.abs(n))}`.padStart(2, '0'); // Pad a number to 2 digits
+  if (!date) date = new Date();
+  const tzOffset = -date.getTimezoneOffset();
+  return (tzOffset >= 0 ? '+' : '-') + pad(tzOffset / 60) + ':' + pad(tzOffset % 60);
+};
+
+/**
+ * Get return current UTC timestamp YmdHms
+ * @param {Date|undefined} date - if undefined, will create a date object and use that timezone 
+ * @returns {string} YYYYMMDD_HHmmssZ
+ */
+export const getYmdhmsUtc = (date) => {
+  if (!date) date = new Date();
+  const d = date.toISOString();
+  return d.substring(0,4) + d.substring(5,7) + d.substring(8,10) + '_' + d.substring(11,13) + d.substring(14,16) + d.substring(17,19) + 'Z';
+}
+
+/**
+ * Get day of week index (0-6) for a given date and timezone
+ * @param {Date|string} date - Date object or ISO datetime string
+ * @param {string} tz - IANA time zone name, e.g. 'Asia/Singapore'
+ * @returns {Number}
+ */
+export const getDayOfWeek = (date, tz) => {
+  if (!(date instanceof Date)) date = new Date(date)
+  const opts = { weekday: 'short' }
+  if (tz) opts.timeZone = tz
+  const shortDayName = new Intl.DateTimeFormat('en-US', opts).format(date) // Get short day name string for specified timezone  
+  const daysOfWeek = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'] // Map the short name back to a numeric index
+  return daysOfWeek.indexOf(shortDayName);
+}
+
+// Obsolete use getLocaleDateISO and getLocaleTimeISO instead
+// export const dateISO = (date) => new Date(date.getTime() - date.getTimezoneOffset() * 60000).toISOString().substring(0, 10);
+// export const timeISO = (date) => new Date(date.getTime() - date.getTimezoneOffset() * 60000).toISOString().substring(11, 19);