@miso.ai/server-commons 0.5.0-beta.1

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@miso.ai/server-commons",
+  "description": "Miso Utility Functions",
+  "type": "module",
+  "main": "src/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {},
+  "repository": "MisoAI/miso-server-js-sdk",
+  "license": "MIT",
+  "contributors": [
+    "simonpai <simon.pai@askmiso.com>"
+  ],
+  "dependencies": {},
+  "version": "0.5.0-beta.1"
+}

package/src/date.js

@@ -0,0 +1,96 @@
+const DURATION_EXPR = /^(\d+)([s|m|h|d])$/;
+const TS_PER_UNIT = {
+  ms: 1,
+  s: 1000,
+};
+TS_PER_UNIT.m = TS_PER_UNIT.s * 60;
+TS_PER_UNIT.h = TS_PER_UNIT.m * 60;
+TS_PER_UNIT.d = TS_PER_UNIT.h * 24;
+//TS_PER_UNIT.M = TS_PER_UNIT.d * 31;
+//TS_PER_UNIT.y = TS_PER_UNIT.d * 366;
+
+export function parseDuration(expr, unit) {
+  if (expr === undefined || typeof expr === 'number') {
+    return expr;
+  }
+  let value = expr;
+  if (typeof unit !== 'string') {
+    const m = expr.match(DURATION_EXPR);
+    if (!m) {
+      throw new Error(`Unrecognized expression: ${expr}`);
+    }
+    [value, unit] = m.slice(1);
+  }
+  const ts = TS_PER_UNIT[unit.toLowerCase()];
+  if (!ts) {
+    throw new Error(`Unrecognized time unit: ${expr}`);
+  }
+  return value * ts;
+}
+
+export function startOfDate(expr) {
+  if (expr === undefined) {
+    return undefined;
+  }
+  if (typeof expr === 'number') {
+    if (expr < 10000) {
+      expr = startOfYearByYearNum(expr);
+    }
+    return expr;
+  }
+  const ts = Date.parse(expr);
+  if (isNaN(ts)) {
+    throw new Error(`Unrecognized date: ${expr}`);
+  }
+  return ts;
+}
+
+const RE_YEAR = /^\d{4}$/g;
+const RE_MONTH = /^\d{4}-\d{2}$/g;
+const RE_DATE = /^\d{4}-\d{2}-\d{2}$/g;
+
+// TODO: support end of hour, minute
+
+export function endOfDate(expr) {
+  if (expr === undefined) {
+    return undefined;
+  }
+  if (typeof expr === 'number') {
+    if (expr < 10000) {
+      expr = endOfYearByYearNum(expr);
+    }
+    return expr;
+  }
+  let ts = Date.parse(expr);
+  if (isNaN(ts)) {
+    throw new Error(`Unrecognized date: ${expr}`);
+  }
+  return expr.match(RE_YEAR) ? endOfYear(ts) :
+    expr.match(RE_MONTH) ? endOfMonth(ts) :
+    expr.match(RE_DATE) ? endOfDay(ts) : ts;
+}
+
+function endOfYear(ts) {
+  return endOfYearByYearNum(new Date(ts).getFullYear());
+}
+
+function startOfYearByYearNum(fullYear) {
+  return new Date(fullYear, 0, 1).getTime();
+}
+
+function endOfYearByYearNum(fullYear) {
+  return new Date(fullYear + 1, 0, 1).getTime() - 1000;
+}
+
+function endOfMonth(ts) {
+  const date = new Date(ts);
+  const year = date.getFullYear();
+  const month = date.getMonth();
+  return (month == 11 ? new Date(year + 1, 0, 1) : new Date(year, month + 1, 1)).getTime() - 1000;
+}
+
+const MS_PER_DAY = 1000 * 60 * 60 * 24;
+
+function endOfDay(ts) {
+  return (Math.floor(ts / MS_PER_DAY) + 1) * MS_PER_DAY - 1000;
+}

package/src/functions.js

@@ -0,0 +1,3 @@
+export function concatFns(...fns) {
+  return v => fns.reduce((v, fn) => fn(v), v);
+}

package/src/index.js

@@ -0,0 +1,5 @@
+export * from './object.js';
+export * from './functions.js';
+export * from './stream.js';
+export * from './date.js';
+export { default as TaskQueue } from './task-queue.js';

package/src/object.js

@@ -0,0 +1,25 @@
+/**
+ * Remove object properties with undefined values and return the object itself.
+ */
+export function trimObj(obj) {
+  if (typeof obj !== 'object') {
+    return obj;
+  }
+  for (const k in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, k) && obj[k] === undefined) {
+      delete obj[k];
+    }
+  }
+  return obj;
+}
+
+export function asArray(value) {
+  return Array.isArray(value) ? value : value === undefined ? [] : [value];
+}
+
+export function asMap(objects, {key = 'id', target = {}} = {}) {
+  return objects.reduce((acc, c) => {
+    acc[c[key]] = c;
+    return acc;
+  }, target);
+}

package/src/stream.js

@@ -0,0 +1,43 @@
+import { Transform, pipeline as _pipeline } from 'stream';
+
+export function stringify() {
+  return new Transform({
+    transform(chunk, _, callback) {
+      callback(null, JSON.stringify(chunk) + '\n');
+    },
+    writableObjectMode: true,
+  });
+}
+
+export async function pipelineToStdout(...streams) {
+  return new Promise((resolve, reject) => 
+    _pipeline(...streams, err => err ? reject(err) : resolve())
+      .pipe(process.stdout, { end: false })
+  );
+}
+
+export async function collectStream(stream) {
+  const records = [];
+  for await (const record of stream) {
+    records.push(record);
+  }
+  return records;
+}
+
+// from https://github.com/maxogden/concat-stream/issues/66
+export async function * concatStreams(...streams) {
+  for (const stream of streams) yield * stream
+}
+
+export function transform(fn, { transform: _, ...options } = {}) {
+  return new Transform({
+    ...options,
+    transform(chunk, encoding, next) {
+      try {
+        next(undefined, fn(chunk, encoding));
+      } catch (error) {
+        next(error);
+      }
+    },
+  });
+}

package/src/task-queue.js

@@ -0,0 +1,60 @@
+export default class TaskQueue {
+
+  constructor() {
+    this._index = 0;
+    this._finished = -1;
+    this._promises = {};
+  }
+
+  request() {
+    return this._index++;
+  }
+
+  async push(index, fn) {
+    if (typeof index === 'function') {
+      fn = index;
+      index = this.request();
+    }
+    if (index > this._finished) {
+      await this._waitFor(index - 1);
+    }
+    try {
+      const value = await fn();
+      this._resolve(index, value);
+    } catch (error) {
+      this._reject(index, error);
+    }
+  }
+
+  _resolve(index, value) {
+    const promises = this._promises;
+    if (promises[index]) {
+      promises[index].resolve(value);
+      delete promises[index];
+    }
+    this._finished = index;
+  }
+
+  _reject(index, error) {
+    const promises = this._promises;
+    if (promises[index]) {
+      promises[index].reject(error);
+      delete promises[index];
+    }
+    this._finished = index;
+  }
+
+  _waitFor(index) {
+    if (this._finished >= index) {
+      return;
+    }
+    const promises = this._promises;
+    if (promises[index]) {
+      throw new Error();
+    }
+    return new Promise((resolve, reject) => {
+      promises[index] = { resolve, reject };
+    });
+  }
+
+}