506 lines
16 KiB
JavaScript
506 lines
16 KiB
JavaScript
import _ from 'lodash/fp';
|
|
import DatabaseError from '../errors/database.mjs';
|
|
import { transactionCtx } from '../transaction-context.mjs';
|
|
import { isKnexQuery } from '../utils/knex.mjs';
|
|
import { applySearch } from './helpers/search.mjs';
|
|
import { processOrderBy, wrapWithDeepSort } from './helpers/order-by.mjs';
|
|
import { createJoin, applyJoins } from './helpers/join.mjs';
|
|
import applyPopulate from './helpers/populate/apply.mjs';
|
|
import processPopulate from './helpers/populate/process.mjs';
|
|
import { processWhere, applyWhere } from './helpers/where.mjs';
|
|
import { toColumnName, toRow, fromRow } from './helpers/transform.mjs';
|
|
import ReadableStrapiQuery from './helpers/streams/readable.mjs';
|
|
|
|
const createQueryBuilder = (uid, db, initialState = {})=>{
|
|
const meta = db.metadata.get(uid);
|
|
const { tableName } = meta;
|
|
const state = _.defaults({
|
|
type: 'select',
|
|
select: [],
|
|
count: null,
|
|
max: null,
|
|
first: false,
|
|
data: null,
|
|
where: [],
|
|
joins: [],
|
|
populate: null,
|
|
limit: null,
|
|
offset: null,
|
|
transaction: null,
|
|
forUpdate: false,
|
|
onConflict: null,
|
|
merge: null,
|
|
ignore: false,
|
|
orderBy: [],
|
|
groupBy: [],
|
|
increments: [],
|
|
decrements: [],
|
|
aliasCounter: 0,
|
|
filters: null,
|
|
search: null,
|
|
processed: false
|
|
}, initialState);
|
|
const getAlias = ()=>{
|
|
const alias = `t${state.aliasCounter}`;
|
|
state.aliasCounter += 1;
|
|
return alias;
|
|
};
|
|
return {
|
|
alias: getAlias(),
|
|
getAlias,
|
|
state,
|
|
clone () {
|
|
return createQueryBuilder(uid, db, state);
|
|
},
|
|
select (args) {
|
|
state.type = 'select';
|
|
state.select = _.uniq(_.castArray(args));
|
|
return this;
|
|
},
|
|
addSelect (args) {
|
|
state.select = _.uniq([
|
|
...state.select,
|
|
..._.castArray(args)
|
|
]);
|
|
return this;
|
|
},
|
|
insert (data) {
|
|
state.type = 'insert';
|
|
state.data = data;
|
|
return this;
|
|
},
|
|
onConflict (args) {
|
|
state.onConflict = args;
|
|
return this;
|
|
},
|
|
merge (args) {
|
|
state.merge = args;
|
|
return this;
|
|
},
|
|
ignore () {
|
|
state.ignore = true;
|
|
return this;
|
|
},
|
|
delete () {
|
|
state.type = 'delete';
|
|
return this;
|
|
},
|
|
ref (name) {
|
|
return db.connection.ref(toColumnName(meta, name));
|
|
},
|
|
update (data) {
|
|
state.type = 'update';
|
|
state.data = data;
|
|
return this;
|
|
},
|
|
increment (column, amount = 1) {
|
|
state.type = 'update';
|
|
state.increments.push({
|
|
column,
|
|
amount
|
|
});
|
|
return this;
|
|
},
|
|
decrement (column, amount = 1) {
|
|
state.type = 'update';
|
|
state.decrements.push({
|
|
column,
|
|
amount
|
|
});
|
|
return this;
|
|
},
|
|
count (count = 'id') {
|
|
state.type = 'count';
|
|
state.count = count;
|
|
return this;
|
|
},
|
|
max (column) {
|
|
state.type = 'max';
|
|
state.max = column;
|
|
return this;
|
|
},
|
|
where (where = {}) {
|
|
if (!_.isPlainObject(where)) {
|
|
throw new Error('Where must be an object');
|
|
}
|
|
state.where.push(where);
|
|
return this;
|
|
},
|
|
limit (limit) {
|
|
state.limit = limit;
|
|
return this;
|
|
},
|
|
offset (offset) {
|
|
state.offset = offset;
|
|
return this;
|
|
},
|
|
orderBy (orderBy) {
|
|
state.orderBy = orderBy;
|
|
return this;
|
|
},
|
|
groupBy (groupBy) {
|
|
state.groupBy = groupBy;
|
|
return this;
|
|
},
|
|
populate (populate) {
|
|
state.populate = populate;
|
|
return this;
|
|
},
|
|
search (query) {
|
|
state.search = query;
|
|
return this;
|
|
},
|
|
transacting (transaction) {
|
|
state.transaction = transaction;
|
|
return this;
|
|
},
|
|
forUpdate () {
|
|
state.forUpdate = true;
|
|
return this;
|
|
},
|
|
init (params = {}) {
|
|
const { _q, filters, where, select, limit, offset, orderBy, groupBy, populate } = params;
|
|
if (!_.isNil(where)) {
|
|
this.where(where);
|
|
}
|
|
if (!_.isNil(_q)) {
|
|
this.search(_q);
|
|
}
|
|
if (!_.isNil(select)) {
|
|
this.select(select);
|
|
} else {
|
|
this.select('*');
|
|
}
|
|
if (!_.isNil(limit)) {
|
|
this.limit(limit);
|
|
}
|
|
if (!_.isNil(offset)) {
|
|
this.offset(offset);
|
|
}
|
|
if (!_.isNil(orderBy)) {
|
|
this.orderBy(orderBy);
|
|
}
|
|
if (!_.isNil(groupBy)) {
|
|
this.groupBy(groupBy);
|
|
}
|
|
if (!_.isNil(populate)) {
|
|
this.populate(populate);
|
|
}
|
|
if (!_.isNil(filters)) {
|
|
this.filters(filters);
|
|
}
|
|
return this;
|
|
},
|
|
filters (filters) {
|
|
state.filters = filters;
|
|
},
|
|
first () {
|
|
state.first = true;
|
|
return this;
|
|
},
|
|
join (join) {
|
|
if (!join.targetField) {
|
|
state.joins.push(join);
|
|
return this;
|
|
}
|
|
const model = db.metadata.get(uid);
|
|
const attribute = model.attributes[join.targetField];
|
|
createJoin({
|
|
db,
|
|
qb: this,
|
|
uid
|
|
}, {
|
|
alias: this.alias,
|
|
refAlias: join.alias,
|
|
attributeName: join.targetField,
|
|
attribute
|
|
});
|
|
return this;
|
|
},
|
|
mustUseAlias () {
|
|
return [
|
|
'select',
|
|
'count'
|
|
].includes(state.type);
|
|
},
|
|
aliasColumn (key, alias) {
|
|
if (typeof key !== 'string') {
|
|
return key;
|
|
}
|
|
if (key.indexOf('.') >= 0) {
|
|
return key;
|
|
}
|
|
if (!_.isNil(alias)) {
|
|
return `${alias}.${key}`;
|
|
}
|
|
return this.mustUseAlias() ? `${this.alias}.${key}` : key;
|
|
},
|
|
raw: db.connection.raw.bind(db.connection),
|
|
shouldUseSubQuery () {
|
|
return [
|
|
'delete',
|
|
'update'
|
|
].includes(state.type) && state.joins.length > 0;
|
|
},
|
|
runSubQuery () {
|
|
const originalType = state.type;
|
|
this.select('id');
|
|
const subQB = this.getKnexQuery();
|
|
const nestedSubQuery = db.getConnection().select('id').from(subQB.as('subQuery'));
|
|
const connection = db.getConnection(tableName);
|
|
return connection[originalType]().whereIn('id', nestedSubQuery);
|
|
},
|
|
processState () {
|
|
if (this.state.processed) {
|
|
return;
|
|
}
|
|
state.orderBy = processOrderBy(state.orderBy, {
|
|
qb: this,
|
|
uid,
|
|
db
|
|
});
|
|
if (!_.isNil(state.filters)) {
|
|
if (_.isFunction(state.filters)) {
|
|
const filters = state.filters({
|
|
qb: this,
|
|
uid,
|
|
meta,
|
|
db
|
|
});
|
|
if (!_.isNil(filters)) {
|
|
state.where.push(filters);
|
|
}
|
|
} else {
|
|
state.where.push(state.filters);
|
|
}
|
|
}
|
|
state.where = processWhere(state.where, {
|
|
qb: this,
|
|
uid,
|
|
db
|
|
});
|
|
state.populate = processPopulate(state.populate, {
|
|
qb: this,
|
|
uid,
|
|
db
|
|
});
|
|
state.data = toRow(meta, state.data);
|
|
this.processSelect();
|
|
this.state.processed = true;
|
|
},
|
|
shouldUseDistinct () {
|
|
return state.joins.length > 0 && _.isEmpty(state.groupBy);
|
|
},
|
|
shouldUseDeepSort () {
|
|
return state.orderBy.filter(({ column })=>column.indexOf('.') >= 0).filter(({ column })=>{
|
|
const col = column.split('.');
|
|
for(let i = 0; i < col.length - 1; i += 1){
|
|
const el = col[i];
|
|
// order by "rel"."xxx"
|
|
const isRelationAttribute = meta.attributes[el]?.type === 'relation';
|
|
// order by "t2"."xxx"
|
|
const isAliasedRelation = Object.values(state.joins).map((join)=>join.alias).includes(el);
|
|
if (isRelationAttribute || isAliasedRelation) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}).length > 0;
|
|
},
|
|
processSelect () {
|
|
state.select = state.select.map((field)=>{
|
|
if (isKnexQuery(field)) {
|
|
return field;
|
|
}
|
|
return toColumnName(meta, field);
|
|
});
|
|
if (this.shouldUseDistinct()) {
|
|
const joinsOrderByColumns = state.joins.flatMap((join)=>{
|
|
return _.keys(join.orderBy).map((key)=>this.aliasColumn(key, join.alias));
|
|
});
|
|
const orderByColumns = state.orderBy.map(({ column })=>column);
|
|
state.select = _.uniq([
|
|
...joinsOrderByColumns,
|
|
...orderByColumns,
|
|
...state.select
|
|
]);
|
|
}
|
|
},
|
|
getKnexQuery () {
|
|
if (!state.type) {
|
|
this.select('*');
|
|
}
|
|
const aliasedTableName = this.mustUseAlias() ? `${tableName} as ${this.alias}` : tableName;
|
|
const qb = db.getConnection(aliasedTableName);
|
|
// The state should always be processed before calling shouldUseSubQuery as it
|
|
// relies on the presence or absence of joins to determine the need of a subquery
|
|
this.processState();
|
|
if (this.shouldUseSubQuery()) {
|
|
return this.runSubQuery();
|
|
}
|
|
switch(state.type){
|
|
case 'select':
|
|
{
|
|
qb.select(state.select.map((column)=>this.aliasColumn(column)));
|
|
if (this.shouldUseDistinct()) {
|
|
qb.distinct();
|
|
}
|
|
break;
|
|
}
|
|
case 'count':
|
|
{
|
|
const dbColumnName = this.aliasColumn(toColumnName(meta, state.count));
|
|
if (this.shouldUseDistinct()) {
|
|
qb.countDistinct({
|
|
count: dbColumnName
|
|
});
|
|
} else {
|
|
qb.count({
|
|
count: dbColumnName
|
|
});
|
|
}
|
|
break;
|
|
}
|
|
case 'max':
|
|
{
|
|
const dbColumnName = this.aliasColumn(toColumnName(meta, state.max));
|
|
qb.max({
|
|
max: dbColumnName
|
|
});
|
|
break;
|
|
}
|
|
case 'insert':
|
|
{
|
|
qb.insert(state.data);
|
|
if (db.dialect.useReturning() && _.has('id', meta.attributes)) {
|
|
qb.returning('id');
|
|
}
|
|
break;
|
|
}
|
|
case 'update':
|
|
{
|
|
if (state.data) {
|
|
qb.update(state.data);
|
|
}
|
|
break;
|
|
}
|
|
case 'delete':
|
|
{
|
|
qb.delete();
|
|
break;
|
|
}
|
|
case 'truncate':
|
|
{
|
|
qb.truncate();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
throw new Error('Unknown query type');
|
|
}
|
|
}
|
|
if (state.transaction) {
|
|
qb.transacting(state.transaction);
|
|
}
|
|
if (state.forUpdate) {
|
|
qb.forUpdate();
|
|
}
|
|
if (!_.isEmpty(state.increments)) {
|
|
state.increments.forEach((incr)=>qb.increment(incr.column, incr.amount));
|
|
}
|
|
if (!_.isEmpty(state.decrements)) {
|
|
state.decrements.forEach((decr)=>qb.decrement(decr.column, decr.amount));
|
|
}
|
|
if (state.onConflict) {
|
|
if (state.merge) {
|
|
qb.onConflict(state.onConflict).merge(state.merge);
|
|
} else if (state.ignore) {
|
|
qb.onConflict(state.onConflict).ignore();
|
|
}
|
|
}
|
|
if (state.limit) {
|
|
qb.limit(state.limit);
|
|
}
|
|
if (state.offset) {
|
|
qb.offset(state.offset);
|
|
}
|
|
if (state.orderBy.length > 0) {
|
|
qb.orderBy(state.orderBy);
|
|
}
|
|
if (state.first) {
|
|
qb.first();
|
|
}
|
|
if (state.groupBy.length > 0) {
|
|
qb.groupBy(state.groupBy);
|
|
}
|
|
// if there are joins and it is a delete or update use a sub query
|
|
if (state.where) {
|
|
applyWhere(qb, state.where);
|
|
}
|
|
// if there are joins and it is a delete or update use a sub query
|
|
if (state.search) {
|
|
qb.where((subQb)=>{
|
|
applySearch(subQb, state.search, {
|
|
qb: this,
|
|
db,
|
|
uid
|
|
});
|
|
});
|
|
}
|
|
if (state.joins.length > 0) {
|
|
applyJoins(qb, state.joins);
|
|
}
|
|
if (this.shouldUseDeepSort()) {
|
|
return wrapWithDeepSort(qb, {
|
|
qb: this,
|
|
db,
|
|
uid
|
|
});
|
|
}
|
|
return qb;
|
|
},
|
|
async execute ({ mapResults = true } = {}) {
|
|
try {
|
|
const qb = this.getKnexQuery();
|
|
const transaction = transactionCtx.get();
|
|
if (transaction) {
|
|
qb.transacting(transaction);
|
|
}
|
|
const rows = await qb;
|
|
if (state.populate && !_.isNil(rows)) {
|
|
await applyPopulate(_.castArray(rows), state.populate, {
|
|
qb: this,
|
|
uid,
|
|
db
|
|
});
|
|
}
|
|
let results = rows;
|
|
if (mapResults && state.type === 'select') {
|
|
results = fromRow(meta, rows);
|
|
}
|
|
return results;
|
|
} catch (error) {
|
|
if (error instanceof Error) {
|
|
db.dialect.transformErrors(error);
|
|
} else {
|
|
throw error;
|
|
}
|
|
}
|
|
},
|
|
stream ({ mapResults = true } = {}) {
|
|
if (state.type === 'select') {
|
|
return new ReadableStrapiQuery({
|
|
qb: this,
|
|
db,
|
|
uid,
|
|
mapResults
|
|
});
|
|
}
|
|
throw new DatabaseError(`query-builder.stream() has been called with an unsupported query type: "${state.type}"`);
|
|
}
|
|
};
|
|
};
|
|
|
|
export { createQueryBuilder as default };
|
|
//# sourceMappingURL=query-builder.mjs.map
|