You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

644 lines
23 KiB

"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 "oracle":
Dialect = require("./dialects/oracle");
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, oracle, 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(this.dialect.queryGenerator.authTestQuery(), 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