FM / lib

/var/www/verywell.gr/server/delivery/node_modules/sequelize/lib/

/var/www/verywell.gr/server/delivery/node_modules/sequelize/lib

Name	Size	Mode	Actions
associations/	-	0755	rm
dialects/	-	0755	rm
errors/	-	0755	rm
generic/	-	0755	rm
utils/	-	0755	rm
data-types.js	17860	0644	edit dl rm
data-types.js.map	42895	0644	edit dl rm
deferrable.js	1344	0644	edit dl rm
deferrable.js.map	4058	0644	edit dl rm
hooks.js	4748	0644	edit dl rm
hooks.js.map	19415	0644	edit dl rm
index-hints.js	146	0644	edit dl rm
index-hints.js.map	482	0644	edit dl rm
index.js	89	0644	edit dl rm
index.js.map	341	0644	edit dl rm
index.mjs	4638	0644	edit dl rm
instance-validator.js	8825	0644	edit dl rm
instance-validator.js.map	18489	0644	edit dl rm
model-manager.js	2463	0644	edit dl rm
model-manager.js.map	4740	0644	edit dl rm
model.js	110174	0644	edit dl rm
model.js.map	264635	0644	edit dl rm
operators.js	1741	0644	edit dl rm
operators.js.map	10947	0644	edit dl rm
query-types.js	436	0644	edit dl rm
query-types.js.map	1230	0644	edit dl rm
sequelize.js	23146	0644	edit dl rm
sequelize.js.map	70914	0644	edit dl rm
sql-string.js	3129	0644	edit dl rm
sql-string.js.map	5824	0644	edit dl rm
table-hints.js	476	0644	edit dl rm
table-hints.js.map	1308	0644	edit dl rm
transaction.js	5852	0644	edit dl rm
transaction.js.map	13385	0644	edit dl rm
utils.js	13295	0644	edit dl rm
utils.js.map	26127	0644	edit dl rm

Edit: /var/www/verywell.gr/server/delivery/node_modules/sequelize/lib/sequelize.js (23146B)

"use strict";
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
const url = require("url");
const path = require("path");
const pgConnectionString = require("pg-connection-string");
const retry = require("retry-as-promised");
const _ = require("lodash");
const Utils = require("./utils");
const Model = require("./model");
const DataTypes = require("./data-types");
const Deferrable = require("./deferrable");
const ModelManager = require("./model-manager");
const Transaction = require("./transaction");
const QueryTypes = require("./query-types");
const TableHints = require("./table-hints");
const IndexHints = require("./index-hints");
const sequelizeErrors = require("./errors");
const Hooks = require("./hooks");
const Association = require("./associations/index");
const Validator = require("./utils/validator-extras").validator;
const Op = require("./operators");
const deprecations = require("./utils/deprecations");
const { QueryInterface } = require("./dialects/abstract/query-interface");
const { BelongsTo } = require("./associations/belongs-to");
const HasOne = require("./associations/has-one");
const { BelongsToMany } = require("./associations/belongs-to-many");
const { HasMany } = require("./associations/has-many");
const { withSqliteForeignKeysOff } = require("./dialects/sqlite/sqlite-utils");
const { injectReplacements } = require("./utils/sql");
class Sequelize {
  constructor(database, username, password, options) {
    let config;
    if (arguments.length === 1 && typeof database === "object") {
      options = database;
      config = _.pick(options, "host", "port", "database", "username", "password");
    } else if (arguments.length === 1 && typeof database === "string" || arguments.length === 2 && typeof username === "object") {
      config = {};
      options = username || {};
      const urlParts = url.parse(arguments[0], true);
      options.dialect = urlParts.protocol.replace(/:$/, "");
      options.host = urlParts.hostname;
      if (options.dialect === "sqlite" && urlParts.pathname && !urlParts.pathname.startsWith("/:memory")) {
        const storagePath = path.join(options.host, urlParts.pathname);
        options.storage = path.resolve(options.storage || storagePath);
      }
      if (urlParts.pathname) {
        config.database = urlParts.pathname.replace(/^\//, "");
      }
      if (urlParts.port) {
        options.port = urlParts.port;
      }
      if (urlParts.auth) {
        const authParts = urlParts.auth.split(":");
        config.username = authParts[0];
        if (authParts.length > 1)
          config.password = authParts.slice(1).join(":");
      }
      if (urlParts.query) {
        if (urlParts.query.host) {
          options.host = urlParts.query.host;
        }
        if (options.dialectOptions) {
          Object.assign(options.dialectOptions, urlParts.query);
        } else {
          options.dialectOptions = urlParts.query;
          if (urlParts.query.options) {
            try {
              const o = JSON.parse(urlParts.query.options);
              options.dialectOptions.options = o;
            } catch (e) {
            }
          }
        }
      }
      if (["postgres", "postgresql"].includes(options.dialect)) {
        Object.assign(options.dialectOptions, pgConnectionString.parse(arguments[0]));
      }
    } else {
      options = options || {};
      config = { database, username, password };
    }
    Sequelize.runHooks("beforeInit", config, options);
    this.options = __spreadValues({
      dialect: null,
      dialectModule: null,
      dialectModulePath: null,
      host: "localhost",
      protocol: "tcp",
      define: {},
      query: {},
      sync: {},
      timezone: "+00:00",
      standardConformingStrings: true,
      logging: console.log,
      omitNull: false,
      native: false,
      replication: false,
      ssl: void 0,
      pool: {},
      quoteIdentifiers: true,
      hooks: {},
      retry: {
        max: 5,
        match: [
          "SQLITE_BUSY: database is locked"
        ]
      },
      transactionType: Transaction.TYPES.DEFERRED,
      isolationLevel: null,
      databaseVersion: 0,
      typeValidation: false,
      benchmark: false,
      minifyAliases: false,
      logQueryParameters: false
    }, options);
    if (!this.options.dialect) {
      throw new Error("Dialect needs to be explicitly supplied as of v4.0.0");
    }
    if (this.options.dialect === "postgresql") {
      this.options.dialect = "postgres";
    }
    if (this.options.dialect === "sqlite" && this.options.timezone !== "+00:00") {
      throw new Error("Setting a custom timezone is not supported by SQLite, dates are always returned as UTC. Please remove the custom timezone parameter.");
    }
    if (this.options.logging === true) {
      deprecations.noTrueLogging();
      this.options.logging = console.log;
    }
    this._setupHooks(options.hooks);
    this.config = {
      database: config.database || this.options.database,
      username: config.username || this.options.username,
      password: config.password || this.options.password || null,
      host: config.host || this.options.host,
      port: config.port || this.options.port,
      pool: this.options.pool,
      protocol: this.options.protocol,
      native: this.options.native,
      ssl: this.options.ssl,
      replication: this.options.replication,
      dialectModule: this.options.dialectModule,
      dialectModulePath: this.options.dialectModulePath,
      keepDefaultTimezone: this.options.keepDefaultTimezone,
      dialectOptions: this.options.dialectOptions
    };
    let Dialect;
    switch (this.getDialect()) {
      case "mariadb":
        Dialect = require("./dialects/mariadb");
        break;
      case "mssql":
        Dialect = require("./dialects/mssql");
        break;
      case "mysql":
        Dialect = require("./dialects/mysql");
        break;
      case "postgres":
        Dialect = require("./dialects/postgres");
        break;
      case "sqlite":
        Dialect = require("./dialects/sqlite");
        break;
      case "db2":
        Dialect = require("./dialects/db2");
        break;
      case "snowflake":
        Dialect = require("./dialects/snowflake");
        break;
      default:
        throw new Error(`The dialect ${this.getDialect()} is not supported. Supported dialects: mssql, mariadb, mysql, postgres, db2 and sqlite.`);
    }
    this.dialect = new Dialect(this);
    this.dialect.queryGenerator.typeValidation = options.typeValidation;
    if (_.isPlainObject(this.options.operatorsAliases)) {
      deprecations.noStringOperators();
      this.dialect.queryGenerator.setOperatorsAliases(this.options.operatorsAliases);
    } else if (typeof this.options.operatorsAliases === "boolean") {
      deprecations.noBoolOperatorAliases();
    }
    this.queryInterface = this.dialect.queryInterface;
    this.models = {};
    this.modelManager = new ModelManager(this);
    this.connectionManager = this.dialect.connectionManager;
    Sequelize.runHooks("afterInit", this);
  }
  refreshTypes() {
    this.connectionManager.refreshTypeParser(DataTypes);
  }
  getDialect() {
    return this.options.dialect;
  }
  getDatabaseName() {
    return this.config.database;
  }
  getQueryInterface() {
    return this.queryInterface;
  }
  define(modelName, attributes, options = {}) {
    options.modelName = modelName;
    options.sequelize = this;
    const model = class extends Model {
    };
    model.init(attributes, options);
    return model;
  }
  model(modelName) {
    if (!this.isDefined(modelName)) {
      throw new Error(`${modelName} has not been defined`);
    }
    return this.modelManager.getModel(modelName);
  }
  isDefined(modelName) {
    return !!this.modelManager.models.find((model) => model.name === modelName);
  }
  async query(sql, options) {
    options = __spreadValues(__spreadValues({}, this.options.query), options);
    if (options.instance && !options.model) {
      options.model = options.instance.constructor;
    }
    if (!options.instance && !options.model) {
      options.raw = true;
    }
    if (options.mapToModel) {
      options.fieldMap = _.get(options, "model.fieldAttributeMap", {});
    }
    options = _.defaults(options, {
      logging: Object.prototype.hasOwnProperty.call(this.options, "logging") ? this.options.logging : console.log,
      searchPath: Object.prototype.hasOwnProperty.call(this.options, "searchPath") ? this.options.searchPath : "DEFAULT"
    });
    if (!options.type) {
      if (options.model || options.nest || options.plain) {
        options.type = QueryTypes.SELECT;
      } else {
        options.type = QueryTypes.RAW;
      }
    }
    if (!this.dialect.supports.searchPath || !this.options.dialectOptions || !this.options.dialectOptions.prependSearchPath || options.supportsSearchPath === false) {
      delete options.searchPath;
    } else if (!options.searchPath) {
      options.searchPath = "DEFAULT";
    }
    if (typeof sql === "object") {
      if (sql.values !== void 0) {
        if (options.replacements !== void 0) {
          throw new Error("Both `sql.values` and `options.replacements` cannot be set at the same time");
        }
        options.replacements = sql.values;
      }
      if (sql.bind !== void 0) {
        if (options.bind !== void 0) {
          throw new Error("Both `sql.bind` and `options.bind` cannot be set at the same time");
        }
        options.bind = sql.bind;
      }
      if (sql.query !== void 0) {
        sql = sql.query;
      }
    }
    sql = sql.trim();
    if (options.replacements && options.bind) {
      throw new Error("Both `replacements` and `bind` cannot be set at the same time");
    }
    if (options.replacements) {
      sql = injectReplacements(sql, this.dialect, options.replacements);
    }
    let bindParameters;
    if (options.bind) {
      [sql, bindParameters] = this.dialect.Query.formatBindParameters(sql, options.bind, this.options.dialect);
    }
    const checkTransaction = () => {
      if (options.transaction && options.transaction.finished && !options.completesTransaction) {
        const error = new Error(`${options.transaction.finished} has been called on this transaction(${options.transaction.id}), you can no longer use it. (The rejected query is attached as the 'sql' property of this error)`);
        error.sql = sql;
        throw error;
      }
    };
    const retryOptions = __spreadValues(__spreadValues({}, this.options.retry), options.retry);
    return retry(async () => {
      if (options.transaction === void 0 && Sequelize._cls) {
        options.transaction = Sequelize._cls.get("transaction");
      }
      checkTransaction();
      const connection = await (options.transaction ? options.transaction.connection : this.connectionManager.getConnection(options));
      if (this.options.dialect === "db2" && options.alter) {
        if (options.alter.drop === false) {
          connection.dropTable = false;
        }
      }
      const query = new this.dialect.Query(connection, this, options);
      try {
        await this.runHooks("beforeQuery", options, query);
        checkTransaction();
        return await query.run(sql, bindParameters);
      } finally {
        await this.runHooks("afterQuery", options, query);
        if (!options.transaction) {
          this.connectionManager.releaseConnection(connection);
        }
      }
    }, retryOptions);
  }
  async set(variables, options) {
    options = __spreadValues(__spreadValues({}, this.options.set), typeof options === "object" && options);
    if (!["mysql", "mariadb"].includes(this.options.dialect)) {
      throw new Error("sequelize.set is only supported for mysql or mariadb");
    }
    if (!options.transaction || !(options.transaction instanceof Transaction)) {
      throw new TypeError("options.transaction is required");
    }
    options.raw = true;
    options.plain = true;
    options.type = "SET";
    const query = `SET ${_.map(variables, (v, k) => `@${k} := ${typeof v === "string" ? `"${v}"` : v}`).join(", ")}`;
    return await this.query(query, options);
  }
  escape(value) {
    return this.dialect.queryGenerator.escape(value);
  }
  async createSchema(schema, options) {
    return await this.getQueryInterface().createSchema(schema, options);
  }
  async showAllSchemas(options) {
    return await this.getQueryInterface().showAllSchemas(options);
  }
  async dropSchema(schema, options) {
    return await this.getQueryInterface().dropSchema(schema, options);
  }
  async dropAllSchemas(options) {
    return await this.getQueryInterface().dropAllSchemas(options);
  }
  async sync(options) {
    options = __spreadProps(__spreadValues(__spreadValues(__spreadValues({}, this.options), this.options.sync), options), {
      hooks: options ? options.hooks !== false : true
    });
    if (options.match) {
      if (!options.match.test(this.config.database)) {
        throw new Error(`Database "${this.config.database}" does not match sync match parameter "${options.match}"`);
      }
    }
    if (options.hooks) {
      await this.runHooks("beforeBulkSync", options);
    }
    if (options.force) {
      await this.drop(options);
    }
    if (this.modelManager.models.length === 0) {
      await this.authenticate(options);
    } else {
      const models = this.modelManager.getModelsTopoSortedByForeignKey();
      if (models == null) {
        return this._syncModelsWithCyclicReferences(options);
      }
      models.reverse();
      for (const model of models) {
        await model.sync(options);
      }
    }
    if (options.hooks) {
      await this.runHooks("afterBulkSync", options);
    }
    return this;
  }
  async _syncModelsWithCyclicReferences(options) {
    if (this.dialect.name === "sqlite") {
      await withSqliteForeignKeysOff(this, options, async () => {
        for (const model of this.modelManager.models) {
          await model.sync(options);
        }
      });
      return;
    }
    for (const model of this.modelManager.models) {
      await model.sync(__spreadProps(__spreadValues({}, options), { withoutForeignKeyConstraints: true }));
    }
    for (const model of this.modelManager.models) {
      await model.sync(__spreadProps(__spreadValues({}, options), { force: false, alter: true }));
    }
  }
  async truncate(options) {
    const sortedModels = this.modelManager.getModelsTopoSortedByForeignKey();
    const models = sortedModels || this.modelManager.models;
    const hasCyclicDependencies = sortedModels == null;
    if (hasCyclicDependencies && (!options || !options.cascade)) {
      throw new Error('Sequelize#truncate: Some of your models have cyclic references (foreign keys). You need to use the "cascade" option to be able to delete rows from models that have cyclic references.');
    }
    if (hasCyclicDependencies && this.dialect.name === "sqlite") {
      return withSqliteForeignKeysOff(this, options, async () => {
        await Promise.all(models.map((model) => model.truncate(options)));
      });
    }
    if (options && options.cascade) {
      for (const model of models)
        await model.truncate(options);
    } else {
      await Promise.all(models.map((model) => model.truncate(options)));
    }
  }
  async drop(options) {
    if (options && options.cascade) {
      for (const model of this.modelManager.models) {
        await model.drop(options);
      }
    }
    const sortedModels = this.modelManager.getModelsTopoSortedByForeignKey();
    if (sortedModels) {
      for (const model of sortedModels) {
        await model.drop(options);
      }
    }
    if (this.dialect.name === "sqlite") {
      await withSqliteForeignKeysOff(this, options, async () => {
        for (const model of this.modelManager.models) {
          await model.drop(options);
        }
      });
      return;
    }
    for (const model of this.modelManager.models) {
      const tableName = model.getTableName();
      const foreignKeys = await this.queryInterface.getForeignKeyReferencesForTable(tableName, options);
      await Promise.all(foreignKeys.map((foreignKey) => {
        return this.queryInterface.removeConstraint(tableName, foreignKey.constraintName, options);
      }));
    }
    for (const model of this.modelManager.models) {
      await model.drop(options);
    }
  }
  async authenticate(options) {
    options = __spreadValues({
      raw: true,
      plain: true,
      type: QueryTypes.SELECT
    }, options);
    await this.query("SELECT 1+1 AS result", options);
    return;
  }
  async databaseVersion(options) {
    return await this.getQueryInterface().databaseVersion(options);
  }
  random() {
    if (["postgres", "sqlite", "snowflake"].includes(this.getDialect())) {
      return this.fn("RANDOM");
    }
    return this.fn("RAND");
  }
  static fn(fn, ...args) {
    return new Utils.Fn(fn, args);
  }
  static col(col) {
    return new Utils.Col(col);
  }
  static cast(val, type) {
    return new Utils.Cast(val, type);
  }
  static literal(val) {
    return new Utils.Literal(val);
  }
  static and(...args) {
    return { [Op.and]: args };
  }
  static or(...args) {
    return { [Op.or]: args };
  }
  static json(conditionsOrPath, value) {
    return new Utils.Json(conditionsOrPath, value);
  }
  static where(attr, comparator, logic) {
    return new Utils.Where(attr, comparator, logic);
  }
  async transaction(options, autoCallback) {
    if (typeof options === "function") {
      autoCallback = options;
      options = void 0;
    }
    const transaction = new Transaction(this, options);
    if (!autoCallback) {
      await transaction.prepareEnvironment(false);
      return transaction;
    }
    return Sequelize._clsRun(async () => {
      await transaction.prepareEnvironment(true);
      let result;
      try {
        result = await autoCallback(transaction);
      } catch (err) {
        try {
          await transaction.rollback();
        } catch (ignore) {
        }
        throw err;
      }
      await transaction.commit();
      return result;
    });
  }
  static useCLS(ns) {
    if (!ns || typeof ns !== "object" || typeof ns.bind !== "function" || typeof ns.run !== "function")
      throw new Error("Must provide CLS namespace");
    Sequelize._cls = ns;
    return this;
  }
  static _clsRun(fn) {
    const ns = Sequelize._cls;
    if (!ns)
      return fn();
    let res;
    ns.run((context) => res = fn(context));
    return res;
  }
  log(...args) {
    let options;
    const last = _.last(args);
    if (last && _.isPlainObject(last) && Object.prototype.hasOwnProperty.call(last, "logging")) {
      options = last;
      if (options.logging === console.log) {
        args.splice(args.length - 1, 1);
      }
    } else {
      options = this.options;
    }
    if (options.logging) {
      if (options.logging === true) {
        deprecations.noTrueLogging();
        options.logging = console.log;
      }
      if ((this.options.benchmark || options.benchmark) && options.logging === console.log) {
        args = [`${args[0]} Elapsed time: ${args[1]}ms`];
      }
      options.logging(...args);
    }
  }
  close() {
    return this.connectionManager.close();
  }
  normalizeDataType(Type) {
    let type = typeof Type === "function" ? new Type() : Type;
    const dialectTypes = this.dialect.DataTypes || {};
    if (dialectTypes[type.key]) {
      type = dialectTypes[type.key].extend(type);
    }
    if (type instanceof DataTypes.ARRAY) {
      if (!type.type) {
        throw new Error("ARRAY is missing type definition for its values.");
      }
      if (dialectTypes[type.type.key]) {
        type.type = dialectTypes[type.type.key].extend(type.type);
      }
    }
    return type;
  }
  normalizeAttribute(attribute) {
    if (!_.isPlainObject(attribute)) {
      attribute = { type: attribute };
    }
    if (!attribute.type)
      return attribute;
    attribute.type = this.normalizeDataType(attribute.type);
    if (Object.prototype.hasOwnProperty.call(attribute, "defaultValue")) {
      if (typeof attribute.defaultValue === "function" && [DataTypes.NOW, DataTypes.UUIDV1, DataTypes.UUIDV4].includes(attribute.defaultValue)) {
        attribute.defaultValue = new attribute.defaultValue();
      }
    }
    if (attribute.type instanceof DataTypes.ENUM) {
      if (attribute.values) {
        attribute.type.values = attribute.type.options.values = attribute.values;
      } else {
        attribute.values = attribute.type.values;
      }
      if (!attribute.values.length) {
        throw new Error("Values for ENUM have not been defined.");
      }
    }
    return attribute;
  }
}
Sequelize.prototype.fn = Sequelize.fn;
Sequelize.prototype.col = Sequelize.col;
Sequelize.prototype.cast = Sequelize.cast;
Sequelize.prototype.literal = Sequelize.literal;
Sequelize.prototype.and = Sequelize.and;
Sequelize.prototype.or = Sequelize.or;
Sequelize.prototype.json = Sequelize.json;
Sequelize.prototype.where = Sequelize.where;
Sequelize.prototype.validate = Sequelize.prototype.authenticate;
Object.defineProperty(Sequelize, "version", {
  enumerable: true,
  get() {
    return require("../package.json").version;
  }
});
Sequelize.options = { hooks: {} };
Sequelize.Utils = Utils;
Sequelize.Op = Op;
Sequelize.TableHints = TableHints;
Sequelize.IndexHints = IndexHints;
Sequelize.Transaction = Transaction;
Sequelize.prototype.Sequelize = Sequelize;
Sequelize.prototype.QueryTypes = Sequelize.QueryTypes = QueryTypes;
Sequelize.prototype.Validator = Sequelize.Validator = Validator;
Sequelize.Model = Model;
Sequelize.QueryInterface = QueryInterface;
Sequelize.BelongsTo = BelongsTo;
Sequelize.HasOne = HasOne;
Sequelize.HasMany = HasMany;
Sequelize.BelongsToMany = BelongsToMany;
Sequelize.DataTypes = DataTypes;
for (const dataType in DataTypes) {
  Sequelize[dataType] = DataTypes[dataType];
}
Sequelize.Deferrable = Deferrable;
Sequelize.prototype.Association = Sequelize.Association = Association;
Sequelize.useInflection = Utils.useInflection;
Hooks.applyTo(Sequelize);
Hooks.applyTo(Sequelize.prototype);
Sequelize.Error = sequelizeErrors.BaseError;
for (const error of Object.keys(sequelizeErrors)) {
  Sequelize[error] = sequelizeErrors[error];
}
module.exports = Sequelize;
module.exports.Sequelize = Sequelize;
module.exports.default = Sequelize;
//# sourceMappingURL=sequelize.js.map

cmd: