309 lines
14 KiB
JavaScript
309 lines
14 KiB
JavaScript
"use strict";
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.makeIntrinsicCheckers = void 0;
|
||
const types_1 = require("../types");
|
||
const lodash_1 = require("../utils/lodash");
|
||
const filter_1 = require("./filter");
|
||
const modi_1 = require("./modi");
|
||
const checker_1 = require("./checker");
|
||
const action_1 = require("../actions/action");
|
||
function checkUniqueBetweenRows(rows, uniqAttrs) {
|
||
// 先检查这些行本身之间有无unique冲突
|
||
const dict = {};
|
||
for (const row of rows) {
|
||
let s = '';
|
||
for (const a of uniqAttrs) {
|
||
if (row[a] === null || row[a] === undefined) {
|
||
s + row.id;
|
||
}
|
||
else {
|
||
s + `-${row[a]}`;
|
||
}
|
||
}
|
||
if (dict[s]) {
|
||
throw new types_1.OakUniqueViolationException([{
|
||
id: row.id,
|
||
attrs: uniqAttrs,
|
||
}]);
|
||
}
|
||
else {
|
||
dict[s] = 1;
|
||
}
|
||
}
|
||
}
|
||
function checkCountLessThan(count, uniqAttrs, than = 0, id) {
|
||
if (count instanceof Promise) {
|
||
return count.then((count2) => {
|
||
if (count2 > than) {
|
||
throw new types_1.OakUniqueViolationException([{
|
||
id,
|
||
attrs: uniqAttrs,
|
||
}]);
|
||
}
|
||
});
|
||
}
|
||
if (count > than) {
|
||
throw new types_1.OakUniqueViolationException([{
|
||
id,
|
||
attrs: uniqAttrs,
|
||
}]);
|
||
}
|
||
}
|
||
function checkUnique(entity, row, context, uniqAttrs, extraFilter) {
|
||
const filter = (0, lodash_1.pick)(row, uniqAttrs);
|
||
for (const a in filter) {
|
||
if (filter[a] === null || filter[a] === undefined) {
|
||
delete filter[a];
|
||
}
|
||
}
|
||
if (Object.keys(filter).length < uniqAttrs.length) {
|
||
// 说明有null值，不需要检查约束
|
||
return;
|
||
}
|
||
const filter2 = extraFilter ? (0, filter_1.combineFilters)(entity, context.getSchema(), [filter, extraFilter]) : filter;
|
||
const count = context.count(entity, { filter: filter2 }, { dontCollect: true });
|
||
return checkCountLessThan(count, uniqAttrs, 0, row.id);
|
||
}
|
||
function createUniqueCheckers(schema) {
|
||
const checkers = [];
|
||
for (const entity in schema) {
|
||
const { indexes } = schema[entity];
|
||
if (indexes) {
|
||
for (const index of indexes) {
|
||
if (index.config?.unique) {
|
||
const { attributes } = index;
|
||
const uniqAttrs = attributes.map(ele => ele.name);
|
||
checkers.push({
|
||
entity,
|
||
action: 'create',
|
||
type: 'logicalData',
|
||
priority: types_1.CHECKER_MAX_PRIORITY,
|
||
checker: (operation, context) => {
|
||
const { data } = operation;
|
||
if (data instanceof Array) {
|
||
checkUniqueBetweenRows(data, uniqAttrs);
|
||
const checkResult = data.map(ele => checkUnique(entity, ele, context, uniqAttrs));
|
||
if (checkResult[0] instanceof Promise) {
|
||
return Promise.all(checkResult).then(() => undefined);
|
||
}
|
||
}
|
||
else if (data) {
|
||
return checkUnique(entity, data, context, uniqAttrs);
|
||
}
|
||
}
|
||
}, {
|
||
entity,
|
||
action: 'update',
|
||
type: 'logicalData',
|
||
priority: types_1.CHECKER_MAX_PRIORITY,
|
||
checker: (operation, context) => {
|
||
const { data, filter: operationFilter } = operation;
|
||
if (data) {
|
||
const attrs = Object.keys(data);
|
||
const refAttrs = (0, lodash_1.intersection)(attrs, uniqAttrs);
|
||
if (refAttrs.length === 0) {
|
||
// 如果本次更新和unique约束的属性之间没有交集则直接返回
|
||
return;
|
||
}
|
||
for (const attr of refAttrs) {
|
||
// 如果有更新为null值，不用再检查约束
|
||
if (data[attr] === null || data[attr] === undefined) {
|
||
return;
|
||
}
|
||
}
|
||
if (refAttrs.length === uniqAttrs.length) {
|
||
// 如果更新了全部属性，直接检查
|
||
const filter = (0, lodash_1.pick)(data, refAttrs);
|
||
// 在这些行以外的行不和更新后的键值冲突
|
||
const count = context.count(entity, {
|
||
filter: (0, filter_1.combineFilters)(entity, context.getSchema(), [filter, {
|
||
$not: operationFilter,
|
||
}]),
|
||
}, { dontCollect: true });
|
||
const checkCount = checkCountLessThan(count, uniqAttrs, 0, operationFilter?.id);
|
||
// 更新的行只能有一行
|
||
const rowCount = context.count(entity, {
|
||
filter: operationFilter,
|
||
}, { dontCollect: true });
|
||
const checkRowCount = checkCountLessThan(rowCount, uniqAttrs, 1, operationFilter?.id);
|
||
// 如果更新的行数为零似乎也可以，但这应该不可能出现吧，by Xc 20230131
|
||
if (checkRowCount instanceof Promise) {
|
||
return Promise.all([checkCount, checkRowCount]).then(() => undefined);
|
||
}
|
||
}
|
||
// 否则需要结合本行现有的属性来进行检查
|
||
const projection = { id: 1 };
|
||
for (const attr of uniqAttrs) {
|
||
Object.assign(projection, {
|
||
[attr]: 1,
|
||
});
|
||
}
|
||
const checkWithRows = (rows2) => {
|
||
const rows22 = rows2.map(ele => Object.assign(ele, data));
|
||
// 先检查这些行本身之间是否冲突
|
||
checkUniqueBetweenRows(rows22, uniqAttrs);
|
||
const checkResults = rows22.map((row) => checkUnique(entity, row, context, uniqAttrs, {
|
||
$not: operationFilter
|
||
}));
|
||
if (checkResults[0] instanceof Promise) {
|
||
return Promise.all(checkResults).then(() => undefined);
|
||
}
|
||
};
|
||
const currentRows = context.select(entity, {
|
||
data: projection,
|
||
filter: operationFilter,
|
||
}, { dontCollect: true });
|
||
if (currentRows instanceof Promise) {
|
||
return currentRows.then((row2) => checkWithRows(row2));
|
||
}
|
||
return checkWithRows(currentRows);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return checkers;
|
||
}
|
||
function createActionTransformerCheckers(actionDefDict) {
|
||
const checkers = [];
|
||
for (const entity in actionDefDict) {
|
||
for (const attr in actionDefDict[entity]) {
|
||
const def = actionDefDict[entity][attr];
|
||
const { stm, is } = def;
|
||
for (const action in stm) {
|
||
const actionStm = stm[action];
|
||
const conditionalFilter = typeof actionStm[0] === 'string' ? {
|
||
[attr]: actionStm[0],
|
||
} : {
|
||
[attr]: {
|
||
$in: actionStm[0],
|
||
},
|
||
};
|
||
checkers.push({
|
||
action: action,
|
||
type: 'row',
|
||
entity,
|
||
filter: conditionalFilter,
|
||
errMsg: '',
|
||
});
|
||
// 这里用data类型的checker改数据了不太好，先这样
|
||
checkers.push({
|
||
action: action,
|
||
type: 'logicalData',
|
||
entity,
|
||
checker: (operation) => {
|
||
const { data } = operation;
|
||
if (data instanceof Array) {
|
||
data.forEach((d) => Object.assign(d, {
|
||
[attr]: stm[action][1],
|
||
}));
|
||
}
|
||
else {
|
||
Object.assign(data, {
|
||
[attr]: stm[action][1],
|
||
});
|
||
}
|
||
}
|
||
});
|
||
}
|
||
if (is) {
|
||
checkers.push({
|
||
action: 'create',
|
||
type: 'logicalData',
|
||
entity,
|
||
priority: 10,
|
||
checker: (operation) => {
|
||
const { data } = operation;
|
||
if (data instanceof Array) {
|
||
data.forEach(ele => {
|
||
if (!ele[attr]) {
|
||
Object.assign(ele, {
|
||
[attr]: is,
|
||
});
|
||
}
|
||
});
|
||
}
|
||
else {
|
||
if (!data[attr]) {
|
||
Object.assign(data, {
|
||
[attr]: is,
|
||
});
|
||
}
|
||
}
|
||
}
|
||
});
|
||
}
|
||
}
|
||
}
|
||
return checkers;
|
||
}
|
||
function createAttrUpdateCheckers(schema, attrUpdateMatrix) {
|
||
const checkers = [];
|
||
for (const entity in attrUpdateMatrix) {
|
||
const matrix = attrUpdateMatrix[entity];
|
||
const updateAttrs = Object.keys(matrix);
|
||
const { actions } = schema[entity];
|
||
const updateActions = actions.filter((a) => !action_1.readOnlyActions.concat(['create', 'remove']).includes(a));
|
||
/**
|
||
* 如果一个entity定义了attrUpdateMatrix，则必须严格遵循定义，未出现在matrix中的属性不允许更新
|
||
*/
|
||
const updateChecker = {
|
||
entity,
|
||
action: updateActions,
|
||
type: 'logicalData',
|
||
checker({ data, filter, action }, context) {
|
||
const attrs = Object.keys(data);
|
||
const extras = (0, lodash_1.difference)(attrs, updateAttrs);
|
||
if (extras.length > 0) {
|
||
throw new types_1.OakAttrCantUpdateException(entity, extras, '更新了不允许的属性');
|
||
}
|
||
const condition = attrs.map(ele => matrix[ele]);
|
||
const actions = condition.map(ele => ele.actions).filter(ele => !!ele);
|
||
const filters = condition.map(ele => ele.filter).filter(ele => !!ele);
|
||
const a = actions.length > 0 && (0, lodash_1.intersection)(actions.flat());
|
||
const f = filters.length > 0 && (0, filter_1.combineFilters)(entity, schema, filters);
|
||
if (a) {
|
||
if (!a.includes(action)) {
|
||
// 找到不满足的那个attr
|
||
const attrsIllegal = attrs.filter((attr) => matrix[attr]?.actions && !matrix[attr]?.actions?.includes(action));
|
||
throw new types_1.OakAttrCantUpdateException(entity, attrsIllegal, `${attrsIllegal}不允许被${action}动作更新`);
|
||
}
|
||
}
|
||
if (f) {
|
||
const result = (0, filter_1.checkFilterContains)(entity, context, f, filter, true);
|
||
if (result instanceof Promise) {
|
||
return result.then((v) => {
|
||
if (!v) {
|
||
throw new types_1.OakAttrCantUpdateException(entity, attrs, '更新的行当前属性不满足约束，请仔细检查数据');
|
||
}
|
||
});
|
||
}
|
||
if (!result) {
|
||
throw new types_1.OakAttrCantUpdateException(entity, attrs, '更新的行当前属性不满足约束，请仔细检查数据');
|
||
}
|
||
}
|
||
}
|
||
};
|
||
checkers.push(updateChecker);
|
||
}
|
||
return checkers;
|
||
}
|
||
function makeIntrinsicCheckers(schema, actionDefDict, attrUpdateMatrix) {
|
||
const checkers = [];
|
||
checkers.push(...(0, modi_1.createModiRelatedCheckers)(schema));
|
||
checkers.push(...(0, checker_1.createRemoveCheckers)(schema));
|
||
checkers.push(...(0, checker_1.createCreateCheckers)(schema));
|
||
// action状态转换矩阵相应的checker
|
||
checkers.push(...createActionTransformerCheckers(actionDefDict));
|
||
// unique索引相应的checker
|
||
checkers.push(...createUniqueCheckers(schema));
|
||
if (attrUpdateMatrix) {
|
||
// attrUpdateMatrix相应的checker
|
||
checkers.push(...createAttrUpdateCheckers(schema, attrUpdateMatrix));
|
||
}
|
||
return checkers;
|
||
}
|
||
exports.makeIntrinsicCheckers = makeIntrinsicCheckers;
|