init source

node_modules/sequelize/lib/utils/classToInvokable.js

@@ -0,0 +1,24 @@
+'use strict';
+
+/**
+ * Wraps a constructor to not need the `new` keyword using a proxy.
+ * Only used for data types.
+ *
+ * @param {Function} Class The class instance to wrap as invocable.
+ * @returns {Proxy} Wrapped class instance.
+ * @private
+ */
+function classToInvokable(Class) {
+  return new Proxy(Class, {
+    apply(Target, thisArg, args) {
+      return new Target(...args);
+    },
+    construct(Target, args) {
+      return new Target(...args);
+    },
+    get(target, p) {
+      return target[p];
+    }
+  });
+}
+exports.classToInvokable = classToInvokable;

node_modules/sequelize/lib/utils/deprecations.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const { deprecate } = require('util');
+
+const noop = () => {};
+
+exports.noRawAttributes = deprecate(noop, 'Use sequelize.fn / sequelize.literal to construct attributes', 'SEQUELIZE0001');
+exports.noTrueLogging = deprecate(noop, 'The logging-option should be either a function or false. Default: console.log', 'SEQUELIZE0002');
+exports.noStringOperators = deprecate(noop, 'String based operators are deprecated. Please use Symbol based operators for better security, read more at https://sequelize.org/master/manual/querying.html#operators', 'SEQUELIZE0003');
+exports.noBoolOperatorAliases = deprecate(noop, 'A boolean value was passed to options.operatorsAliases. This is a no-op with v5 and should be removed.', 'SEQUELIZE0004');
+exports.noDoubleNestedGroup = deprecate(noop, 'Passing a double nested nested array to `group` is unsupported and will be removed in v6.', 'SEQUELIZE0005');

node_modules/sequelize/lib/utils/logger.js

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * Sequelize module for debug and deprecation messages.
+ * It require a `context` for which messages will be printed.
+ *
+ * @module logging
+ * @private
+ */
+
+const debug = require('debug');
+const util = require('util');
+
+class Logger {
+  constructor(config) {
+
+    this.config = Object.assign({
+      context: 'sequelize',
+      debug: true
+    }, config);
+  }
+
+  warn(message) {
+    // eslint-disable-next-line no-console
+    console.warn(`(${this.config.context}) Warning: ${message}`);
+  }
+
+  inspect(value) {
+    return util.inspect(value, false, 3);
+  }
+
+  debugContext(name) {
+    return debug(`${this.config.context}:${name}`);
+  }
+}
+
+exports.logger = new Logger();
+
+exports.Logger = Logger;

node_modules/sequelize/lib/utils/validator-extras.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const _ = require('lodash');
+const validator = _.cloneDeep(require('validator'));
+const moment = require('moment');
+
+const extensions = {
+  extend(name, fn) {
+    this[name] = fn;
+
+    return this;
+  },
+  notEmpty(str) {
+    return !str.match(/^[\s\t\r\n]*$/);
+  },
+  len(str, min, max) {
+    return this.isLength(str, min, max);
+  },
+  isUrl(str) {
+    return this.isURL(str);
+  },
+  isIPv6(str) {
+    return this.isIP(str, 6);
+  },
+  isIPv4(str) {
+    return this.isIP(str, 4);
+  },
+  notIn(str, values) {
+    return !this.isIn(str, values);
+  },
+  regex(str, pattern, modifiers) {
+    str += '';
+    if (Object.prototype.toString.call(pattern).slice(8, -1) !== 'RegExp') {
+      pattern = new RegExp(pattern, modifiers);
+    }
+    return str.match(pattern);
+  },
+  notRegex(str, pattern, modifiers) {
+    return !this.regex(str, pattern, modifiers);
+  },
+  isDecimal(str) {
+    return str !== '' && !!str.match(/^(?:-?(?:[0-9]+))?(?:\.[0-9]*)?(?:[eE][+-]?(?:[0-9]+))?$/);
+  },
+  min(str, val) {
+    const number = parseFloat(str);
+    return isNaN(number) || number >= val;
+  },
+  max(str, val) {
+    const number = parseFloat(str);
+    return isNaN(number) || number <= val;
+  },
+  not(str, pattern, modifiers) {
+    return this.notRegex(str, pattern, modifiers);
+  },
+  contains(str, elem) {
+    return !!elem && str.includes(elem);
+  },
+  notContains(str, elem) {
+    return !this.contains(str, elem);
+  },
+  is(str, pattern, modifiers) {
+    return this.regex(str, pattern, modifiers);
+  }
+};
+exports.extensions = extensions;
+
+// instance based validators
+validator.isImmutable = function(value, validatorArgs, field, modelInstance) {
+  return modelInstance.isNewRecord || modelInstance.dataValues[field] === modelInstance._previousDataValues[field];
+};
+
+// extra validators
+validator.notNull = function(val) {
+  return val !== null && val !== undefined;
+};
+
+// https://github.com/chriso/validator.js/blob/6.2.0/validator.js
+_.forEach(extensions, (extend, key) => {
+  validator[key] = extend;
+});
+
+// map isNull to isEmpty
+// https://github.com/chriso/validator.js/commit/e33d38a26ee2f9666b319adb67c7fc0d3dea7125
+validator.isNull = validator.isEmpty;
+
+// isDate removed in 7.0.0
+// https://github.com/chriso/validator.js/commit/095509fc707a4dc0e99f85131df1176ad6389fc9
+validator.isDate = function(dateString) {
+  // avoid http://momentjs.com/guides/#/warnings/js-date/
+  // by doing a preliminary check on `dateString`
+  const parsed = Date.parse(dateString);
+  if (isNaN(parsed)) {
+    // fail if we can't parse it
+    return false;
+  }
+  // otherwise convert to ISO 8601 as moment prefers
+  // http://momentjs.com/docs/#/parsing/string/
+  const date = new Date(parsed);
+  return moment(date.toISOString()).isValid();
+};
+
+exports.validator = validator;