@where-org/where-common 2.0.1

package/lib/common/util/casing.js

@@ -0,0 +1,90 @@
+// casing
+const casing = {
+
+  // pascal
+  toPascal: (word) => {
+    return word.replace(/[_-]./g, (s) => s[1].toUpperCase()).replace(/^./, (s) => s.toUpperCase());
+  },
+
+  camelToPascal: (word) => {
+    return word.replace(/^./, (s) => s.toUpperCase());
+  },
+
+  snakeToPascal: (word) => {
+    return word.replace(/_./g, (s) => s[1].toUpperCase()).replace(/^./, (s) => s.toUpperCase());
+  },
+
+  kebabToPascal: (word) => {
+    return word.replace(/-./g, (s) => s[1].toUpperCase()).replace(/^./, (s) => s.toUpperCase());
+  },
+
+  // camel
+  toCamel: (word) => {
+    return word.replace(/[_-]./g, (s) => s[1].toUpperCase()).replace(/^./, (s) => s.toLowerCase());
+  },
+
+  pascalToCamel: (word) => {
+    return word.replace(/^./, (s) => s.toLowerCase());
+  },
+
+  snakeToCamel: (word) => {
+    return word.replace(/_./g, (s) => s[1].toUpperCase());
+  },
+
+  kebabToCamel: (word) => {
+    return word.replace(/-./g, (s) => s[1].toUpperCase());
+  },
+
+  // snake
+  toSnake:(word) => {
+    return word.replace(/^./, (s) => s.toLowerCase()).replace(/([A-Z])/g, (s) => '_' + s[0].toLowerCase()).replace(/-/g, '_');
+  },
+
+  camelToSnake: (word) => {
+    return word.replace(/([A-Z])/g, (s) => '_' + s[0].toLowerCase());
+  },
+
+  pascalToSnake: (word) => {
+    return word.replace(/^./, (s) => s.toLowerCase()).replace(/([A-Z])/g, (s) => '_' + s[0].toLowerCase());
+  },
+
+  kebabToSnake: (word) => {
+    return word.replace(/^./, (s) => s.toLowerCase()).replace(/-/g, '_');
+  },
+
+  // kebab
+  toKebab: (word) => {
+    return word.replace(/^./, (s) => s.toLowerCase()).replace(/([A-Z])/g, (s) => '-' + s[0].toLowerCase()).replace(/_/g, '-');
+  },
+
+  camelToKebab: (word) => {
+    return word.replace(/([A-Z])/g, (s) => '-' + s[0].toLowerCase());
+  },
+
+  pascalToKebab: (word) => {
+    return word.replace(/^./, (s) => s.toLowerCase()).replace(/([A-Z])/g, (s) => '-' + s[0].toLowerCase());
+  },
+
+  snakeToKebab: (word) => {
+    return word.replace(/_/g, '-');
+  },
+
+  ...Object.entries({ keysToCamel: 'toCamel', keysToPascal: 'toPascal', keysToSnake: 'toSnake', keysToKebab : 'toKebab' }).reduce((o, [k, f]) => {
+
+    return { ...o, [k]: (data) => {
+
+      const isArray = Array.isArray(data);
+
+      const [first, ...rest] = (isArray ? data : [data]).map(v => {
+        return Object.entries(v).reduce((o, [k, v]) => ({ ...o, [casing[f](k)]: v }), {});
+      });
+
+      return isArray ? [first, ...rest] : first;
+
+    } };
+
+  }, {}),
+
+};
+
+export { casing };

package/lib/common/util/cast.js

@@ -0,0 +1,18 @@
+import { date } from './date.js';
+
+const cast = (value) => {
+
+  try {
+    return JSON.parse(value);
+  } catch (err) {
+  }
+
+  if (value.match(date.iso8601)) {
+    return new Date(value);
+  }
+
+  return value;
+
+}
+
+export { cast };

package/lib/common/util/date.js

@@ -0,0 +1,25 @@
+const date = {
+
+  iso8601: /^\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d(\.\d+)?([+-][0-2]\d:[0-5]\d|Z)$/,
+
+  isIsoString: (v) => {
+    return (v && v.match && v.match(date.iso8601)) ? true : false;
+  },
+
+  isString: (v) => {
+    return (date.isIsoString(v) || typeof v === 'string' && isNaN(v) && !isNaN(new Date(v).getDate())) ? true : false;
+  },
+
+  isDate: (v) => {
+    return v instanceof Date || Object.prototype.toString.call(v) === '[object Date]'
+  },
+
+  string: (v) => {
+    return new Intl.DateTimeFormat('ja-jp', {
+      year: 'numeric', month : '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit'
+    }).format(v).replace(/\//g, '-');
+  }
+
+};
+
+export { date };

package/lib/common/util/index.js

@@ -0,0 +1,7 @@
+import { casing } from './casing.js';
+import { cast } from './cast.js';
+import { date } from './date.js';
+import { url } from './url.js';
+
+const util = { casing, cast, date, url };
+export { util };

package/lib/common/util/url.js

@@ -0,0 +1,50 @@
+import { UrlException } from '../../exception.js';
+
+const socket = {
+
+  parse: (string) => {
+    const split = new URL(string).pathname.split('/').filter(v => v);
+
+    const lastIndex = split.length - 1,
+          userIndex = (split[lastIndex].match(':')) ? lastIndex - 1 : lastIndex;
+
+    const [app, group, user] = [...Array(3)].map((v, i) => split[userIndex - i]).reverse();
+
+    const option = (lastIndex === userIndex) ? {} : split[lastIndex].split(',').reduce((o, v1) => {
+      const [k, v] = v1.split(':');
+      return { ...o, [k]: v };
+    }, {});
+
+    return { url: string, app, group, user, ...option };
+  },
+
+  string: (pre) => {
+    const { url, group, user, ...option } = pre;
+
+    const optionString = Object.entries(option).map(([k, v]) => {
+      return [k, v].join(':');
+    }).join(',');
+
+    const [app] = url.replace(/\/?$/, '').split('/').reverse();
+    return { url: [url, group, user, optionString].join('/'), app, group, user, ...option };
+  },
+
+  either: (config) => {
+    const { url, group, user, ...option } = config;
+
+    try {
+      return (group && user) ? socket.string(config) : socket.parse(url);
+
+    } catch (err) {
+
+      throw (err instanceof TypeError)
+        ? new UrlException((url) ? `"${url}" invalid URL` : '"url" undefined')
+        : err;
+    }
+
+  }
+
+};
+
+const url = { socket };
+export { url };

package/lib/common.js

@@ -0,0 +1,6 @@
+export * as cq from './cq.js';
+export * as da from './da.js';
+export * as define from './define.js';
+export * as common from './common/index.js';
+
+export * from './exception.js';

package/lib/cq.js

@@ -0,0 +1,122 @@
+import { cast } from './common/util/cast.js';
+
+const operators = [
+  '=', '!', '<', '>', '<=', '>=', '-', '*', '!*',
+];
+
+const shortToLong  = {
+  s: 'select', w: 'where', o: 'order', l: 'limit',
+};
+
+const longToShort = Object.entries(shortToLong).reduce((o, [k, v]) => ({ ...o, [v]: k }), {});
+
+const normalizeKey = Object.entries(shortToLong).reduce((o, [k, v]) => {
+  return { ...o, [k]: v, [v]: v };
+}, {});
+
+// parse
+const parse = (string, ignore) => {
+
+  // prepare
+  const prepare = (string, ignore) => {
+
+    const r1 = /([^\/]*["'].*?["'][^\/]*)|\//,
+          sp = string.trim().replace(/^\/|\/$/g, '').split(r1).filter(v => v);
+
+    return sp.reduce((o, v, i, s) => {
+
+      if (i % 2 !== 0) {
+        return { ...o, [s[i - 1]]: v };
+      }
+
+      if (ignore || normalizeKey[v]) {
+        return o;
+      }
+
+      throw new Error(`${v} is not allowed.`);
+
+    }, {});
+
+  };
+
+  // split
+  const split = (string) => {
+
+    const r1 = /([^:]*?["'].*?["'][^:]*)|:/,
+          r2 = /([^,]*?["'].*?["'][^,]*)|,/,
+          r3 = /^["']|["']$/g;
+
+    return string.split(r1).filter(v => v).reduce((o, v) => {
+
+      const [k, first, ...values] = v.split(r2).filter(v => v).map((v) => cast(v.replace(r3, '')));
+      return { ...o, [k]: (values.length) ? [first, ...values] : (first !== undefined) ? first : null };
+
+    }, {});
+
+  }
+
+  const object = (typeof string === 'string') ? prepare(string, ignore) : string,
+        r1 = /([^\|]*["'].*?["'][^\|]*)|\|/;
+
+  const { select, limit, ...wo } = Object.entries(object).reduce((o, [k, v]) => {
+
+    if (!normalizeKey[k]) {
+      return o;
+    }
+
+    const [first, ...or] = v.split(r1).filter(v => v),
+          values = or.length ?  { or: [first, ...or].map(v => split(v)) } : split(first);
+
+    return { ...o, [normalizeKey[k]]: values };
+
+  }, {});
+
+  const s = (!select) ? {} : {
+
+    select: Object.entries(select).reduce((o, [k, v]) => {
+      return [...o, k, ...(Array.isArray(v) ? v : [v])];
+    }, []).filter(v => v)
+
+  };
+
+  const l = !limit || 'offset' in limit && !('limit' in limit) || 'or' in limit
+    ? {}
+    : { limit: Object.entries(limit).reduce(
+      (o, [k, v]) => (['offset', 'limit'].includes(k) ? { ...o, [k]: v  } : o), {}) };
+
+  return { ...s, ...wo, ...l };
+
+}
+
+// string
+const string = (object) => {
+
+  const join = (object, separator) => {
+    return Object.entries(object).map(([k, v]) => [k, String(v)].join(',')).join(separator);
+  };
+
+  const { select, where, order, limit, ...rest } = object;
+
+  // genmitsu ni suru baai ha reigai wo hassei sasemasu.
+  //if(rest){
+    //throw new Error('no where condition object.');
+  //}
+
+  // s
+  const s = select ? [longToShort.select, select.join(',')].join('/') : undefined;
+
+  // w, o
+  const [w, o] = Object.entries({ where, order }).filter(([k, v]) => v).map(([k, v]) => {
+    const values = (v.or) ? v.or.map(v => join(v, ':')).join('|') : join(v, ':');
+    return [longToShort[k], values].join('/');
+  });
+
+  // l
+  const { offset: lo, limit: lv } = limit ?? {},
+        l = lv ? [longToShort.limit, [lo ? `offset,${lo}` : undefined, `limit,${lv}`].join(':')].join('/') : undefined;
+
+  return [s, w, o, l].filter(v => v).join('/');
+
+}
+
+export { parse, string };

package/lib/da.js

@@ -0,0 +1,291 @@
+import { cast } from './common/util/cast.js';
+import { multipartFormDataKey } from './define.js';
+
+const operators = {
+
+  '=': (k, v, data) => {
+
+    const values = Array.isArray(v) ? v : [v];
+
+    const [first] = values,
+          v1 = (first === null) ? String(first) : first; //.toLowerCase();
+
+    const isNull = {
+      'null' : true, 'not-null': false
+    };
+
+    if (Object.keys(isNull).includes(v1)) {
+      return (v1 === 'null') ? data === null : data !== null;
+
+    } else {
+      return values.filter(v => data === v).length > 0;
+    }
+  },
+
+  '!': (k, v, data) => {
+
+    const values = Array.isArray(v) ? v : [v];
+
+    const [first] = values,
+          v1 = (first === null) ? String(first) : first.toLowerCase();
+
+    const isNull = {
+      'null' : true, 'not-null': false
+    };
+
+    if (Object.keys(isNull).includes(v1)) {
+      return (v1 === 'null') ? data !== null : data === null;
+
+    } else {
+      return values.filter(v => data !== v).length > 0;
+    }
+  },
+
+  '<': (k, v, data) => {
+    const v1 = Array.isArray(v) ? v[0] : v;
+    return (isNaN(v1) || isNaN(data)) ? false : data < v1;
+  },
+
+  '>': (k, v, data) => {
+    const v1 = Array.isArray(v) ? v[0] : v;
+    return (isNaN(v1) || isNaN(data)) ? false : data > v1;
+  },
+
+  '<=':(k, v, data) => {
+    const v1 = Array.isArray(v) ? v[0] : v;
+    return (isNaN(v1) || isNaN(data)) ? false : data <= v1;
+  },
+
+  '>=':(k, v, data) => {
+    const v1 = Array.isArray(v) ? v[0] : v;
+    return (isNaN(v1) || isNaN(data)) ? false : data >= v1;
+  },
+
+  '-': (k, v, data) => {
+
+    if (!Array.isArray(v) || isNaN(data)) {
+      return false;
+    }
+
+    const [v1, v2] = v;
+    return v1 <= data && data <= v2;
+  },
+
+  '*': (k, v, data) => {
+
+    if (Array.isArray(v)) {
+      return false;
+    }
+
+    const v1 = v.replace(/[\\^$.\-+?()[\]{}|]/g, '\\$&').replace(/\*/g, '.*');
+
+    try {
+      return data.match(new RegExp(`^${v1}$`, 's'));
+
+    } catch(err) {
+      return false;
+    }
+
+  },
+
+  '!*': (k, v, data) => {
+
+    if (Array.isArray(v)) {
+      return false;
+    }
+
+    const v1 = v.replace(/[\\^$.\-+?()[\]{}|]/g, '\\$&').replace(/\*/g, '.*');
+
+    try {
+      return !data.match(new RegExp(`^${v1}$`, 's'));
+
+    } catch(err) {
+      return false;
+    }
+
+  },
+
+};
+
+// split
+const split = (operators) => {
+
+  const r1 = operators.map(v => v.replace(/[\\^$.\-*+?()[\]{}|]/g, '\\$&')).join('|'),
+        r2 = new RegExp(`(${r1})$`);
+
+  return (key) => {
+    return [key.replace(r2, ''), (key.match(r2)) ? key.match(r2)[0] : '='];
+  };
+
+}
+
+// pasrse
+const parse = (object, contentType) => {
+
+  // { k1: [v1, v2], k2: [v1 , v2], ... } (multipart/form-data)
+
+  if (contentType && contentType.match(/multipart\/form-data/)) {
+
+    if (object && object[multipartFormDataKey]) {
+      const data = JSON.parse(object[multipartFormDataKey]);
+      return (Array.isArray(data)) ? data : [data];
+    }
+
+    return Object.values(Object.entries(object).reduce((o, [k, v]) => {
+      return ((Array.isArray(v)) ? v : [v]).reduce((o, v, i) => ({ ...o, [i]: { ...o[i], [k]: cast(v) } }), o);
+    }, {}));
+
+  }
+
+  // {k1: v1, ... }
+
+  if (Object.keys(object).filter(v => isNaN(v)).length) {
+    return [object];
+  }
+
+  const [header, ...body] = Object.values(object);
+
+  // [[k1, k2, ... ], [v1, v2, ... ], ... ]
+
+  if (header && Array.isArray(header)) {
+    return body.map((v) => v.reduce((o, v, i) => ({ ...o, [header[i]]: cast(v) }), {}));
+  }
+
+  // [{k1: v1}, {k2: v2}, ...] || {}
+
+  return (Array.isArray(object)) ? object : [object];
+
+}
+
+// filter
+const filter = (() => {
+
+  const sp = split(Object.keys(operators));
+
+  const filter = {
+
+    select: (data, condition) => {
+
+      const [first] = data;
+
+      if (condition.includes('*') || !first) {
+        return data;
+      }
+
+      const keys = Object.keys(first);
+
+      if (condition.includes('count')) {
+
+        return [condition.reduce((o, k) => {
+
+          if (k !== 'count' && !keys.includes(k)) {
+            throw new Error(`No such column ${k}`);
+          }
+          return { ...o, [k]: (k == 'count') ? data.length : first[k] };
+
+        }, {})];
+
+      }
+
+      return condition.reduce((o, k) => {
+
+        if (!keys.includes(k)) {
+          throw new Error(`No such column ${k}`);
+        }
+
+        return o.map((v, i) => ({ ...v, [k]: data[i][k] }));
+
+      }, data.map(v => ({})));
+    },
+
+    where: (data, condition) => {
+
+      const [first] = data;
+
+      if (!first) {
+        return data;
+      }
+
+      const keys = Object.keys(first);
+
+      return data.filter((v) => {
+
+        const or = condition.filter((cv) => {
+
+          const conditionArray = Object.entries(cv);
+
+          return conditionArray.length === conditionArray.filter(([ak, av]) => {
+
+            const [k, op] = sp(ak);
+
+            if (!keys.includes(k)) {
+              throw new Error(`No such column ${k}`);
+            }
+
+            return operators[op](k, av, v[k]);
+
+          }).length;
+
+        });
+
+        return or.length > 0;
+      });
+
+    },
+
+    order: (data, condition) => {
+
+      return Object.entries(condition).reduce((o, [k, v]) => {
+
+        const asc = (v.toLowerCase() !== 'desc') ? true : false;
+
+        return [...o].sort((a, b) => {
+
+          const orderA = (asc) ? a[k] : b[k],
+                orderB = (asc) ? b[k] : a[k];
+
+          if (typeof orderA !== 'string' || typeof orderB !== 'string') {
+            return orderA - orderB;
+          }
+
+          const upperA = orderA.toUpperCase(),
+                upperB = orderB.toUpperCase();
+
+          return (upperA > upperB) ? 1 : (upperA < upperB) ? -1 : 0;
+        });
+
+      }, data);
+
+    },
+
+    limit: (data, condition) => {
+
+      if (!('limit' in condition)) {
+        return data;
+      }
+
+      const { offset = 0, limit } = condition;
+      return data.slice(offset, limit + offset);
+
+    }
+
+  };
+
+  return (object, condition) => {
+
+    const {where: w = null, order: o, select: s, limit: l} = condition || {},
+           where = (w) ? { where: (w.or) ? w.or : [w] } : {};
+
+    const [order, select, limit] = Object.entries({ order: o, select: s, limit: l }).map(([k, v]) => {
+      return (v) ? { [k]: v } : {};
+    });
+
+    return Object.entries({ ...where, ...order, ...select, ...limit }).reduce((o, [k, v]) => {
+      return filter[k](o, v);
+    }, object);
+
+  };
+
+})();
+
+export { split, parse, filter };

package/lib/define.js

@@ -0,0 +1,22 @@
+const multipartFormDataKey = 'where-data-json',
+      filesKey = 'where-data-files';
+
+const status = {
+  // 400
+  code400: { number: 400, message: '400 Bad Request' },
+  code401: { number: 401, message: '401 Unauthorized' },
+  code403: { number: 403, message: '403 Forbidden' },
+  code404: { number: 404, message: '404 Not Found' },
+  code405: { number: 405, message: '405 Method Not Allowed' },
+  code413: { number: 413, message: '413 Payload Too Large' },
+  code418: { number: 418, message: "418 I'm a teapot" },
+  code451: { number: 451, message: '451 Unavailable For Legal Reasons' },
+  // 500
+  code500: { number: 500, message: '500 Internal Server Error' },
+  code501: { number: 501, message: '501 Not Implemented' },
+  code502: { number: 502, message: '502 Bad Gateway' },
+  code503: { number: 503, message: '503 Service Unavailable' },
+  code504: { number: 504, message: '504 Gateway Timeout' },
+};
+
+export { multipartFormDataKey, filesKey, status };