Oak-Team
/
oak-domain
13
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 33 Wiki Activity

schema支持static

This commit is contained in:
Xu Chang 2022-09-02 14:27:11 +08:00
parent bf448dbe38
commit 38f7e12339
13 changed files with 738 additions and 626 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

484
lib/compiler/schemalBuilder.js
View File

@ -328,6 +328,7 @@ function analyzeEntity(filename, path, program) {
var hasActionOrStateDef = false;
var toModi = false;
var actionType = 'crud';
var _static = false;
var enumStringAttrs = [];
var states = [];
var localEnumStringTypes = [];
@ -750,13 +751,21 @@ function analyzeEntity(filename, path, program) {
}
localeDef = initializer;
}
else if (ts.isTypeReferenceNode(declaration.type) && ts.isIdentifier(declaration.type.typeName) && declaration.type.typeName.text === 'ActionType') {
(0, assert_1.default)(!hasActionDef, "".concat(moduleName, "\u4E2D\u7684actionType\u5B9A\u4E49\u5728Action\u4E4B\u540E"));
(0, assert_1.default)(ts.isStringLiteral(declaration.initializer));
actionType = declaration.initializer.text;
else if (ts.isTypeReferenceNode(declaration.type) && ts.isIdentifier(declaration.type.typeName) && declaration.type.typeName.text === 'Configuration') {
(0, assert_1.default)(!hasActionDef, "".concat(moduleName, "\u4E2D\u7684Configuration\u5B9A\u4E49\u5728Action\u4E4B\u540E"));
(0, assert_1.default)(ts.isObjectLiteralExpression(declaration.initializer));
var properties = declaration.initializer.properties;
var atProperty = properties.find(function (ele) { return ts.isPropertyAssignment(ele) && ts.isIdentifier(ele.name) && ele.name.text === 'actionType'; });
var staticProperty = properties.find(function (ele) { return ts.isPropertyAssignment(ele) && ts.isIdentifier(ele.name) && ele.name.text === 'static'; });
if (atProperty) {
actionType = atProperty.initializer.text;
}
if (staticProperty) {
_static = true; // static如果有值只能为true
}
}
else {
throw new Error("\u4E0D\u80FD\u7406\u89E3\u7684\u5B9A\u4E49\u5185\u5BB9".concat(declaration.name.getText()));
throw new Error("".concat(moduleName, "\uFF1A\u4E0D\u80FD\u7406\u89E3\u7684\u5B9A\u4E49\u5185\u5BB9").concat(declaration.name.getText()));
}
});
}
@ -773,6 +782,7 @@ function analyzeEntity(filename, path, program) {
sourceFile: sourceFile,
toModi: toModi,
actionType: actionType,
static: _static,
};
if (hasFulltextIndex) {
(0, lodash_1.assign)(schema, {
@ -1766,23 +1776,28 @@ function constructActions(statements, entity) {
var noCascadeNode = factory.createTypeLiteralNode([
factory.createPropertySignature(undefined, factory.createIdentifier("".concat(one[1], "Id")), one[2] ? factory.createToken(ts.SyntaxKind.QuestionToken) : undefined, factory.createTypeReferenceNode(factory.createIdentifier("String"), [factory.createLiteralTypeNode(factory.createNumericLiteral("64"))]))
]);
switch (Schema[oneEntity].actionType) {
case 'crud':
case 'excludeRemove': {
upsertOneNodes.push(factory.createUnionTypeNode([cascadeCreateNode, cascadeUpdateNode, noCascadeNode]));
break;
}
case 'excludeUpdate':
case 'appendOnly': {
upsertOneNodes.push(factory.createUnionTypeNode([cascadeCreateNode, noCascadeNode]));
break;
}
case 'readOnly': {
upsertOneNodes.push(noCascadeNode);
break;
}
default: {
(0, assert_1.default)(false);
if (Schema[oneEntity].static) {
upsertOneNodes.push(noCascadeNode);
}
else {
switch (Schema[oneEntity].actionType) {
case 'crud':
case 'excludeRemove': {
upsertOneNodes.push(factory.createUnionTypeNode([cascadeCreateNode, cascadeUpdateNode, noCascadeNode]));
break;
}
case 'excludeUpdate':
case 'appendOnly': {
upsertOneNodes.push(factory.createUnionTypeNode([cascadeCreateNode, noCascadeNode]));
break;
}
case 'readOnly': {
upsertOneNodes.push(noCascadeNode);
break;
}
default: {
(0, assert_1.default)(false);
}
}
}
}
@ -1824,23 +1839,28 @@ function constructActions(statements, entity) {
factory.createPropertySignature(undefined, factory.createIdentifier('entityId'), undefined, // 反向指针好像不能为空，以后或许会有特例 by Xc
factory.createTypeReferenceNode(factory.createIdentifier("String"), [factory.createLiteralTypeNode(factory.createNumericLiteral("64"))]))
]);
switch (Schema[one].actionType) {
case 'crud':
case 'excludeRemove': {
reverseOneNodes.push(cascadeCreateNode, cascadeUpdateNode, noCascadeNode);
break;
}
case 'appendOnly':
case 'excludeUpdate': {
reverseOneNodes.push(cascadeCreateNode, noCascadeNode);
break;
}
case 'readOnly': {
reverseOneNodes.push(noCascadeNode);
break;
}
default: {
(0, assert_1.default)(false);
if (Schema[one].static) {
reverseOneNodes.push(noCascadeNode);
}
else {
switch (Schema[one].actionType) {
case 'crud':
case 'excludeRemove': {
reverseOneNodes.push(cascadeCreateNode, cascadeUpdateNode, noCascadeNode);
break;
}
case 'appendOnly':
case 'excludeUpdate': {
reverseOneNodes.push(cascadeCreateNode, noCascadeNode);
break;
}
case 'readOnly': {
reverseOneNodes.push(noCascadeNode);
break;
}
default: {
(0, assert_1.default)(false);
}
}
}
}
@ -1904,31 +1924,33 @@ function constructActions(statements, entity) {
]),
factory.createTypeReferenceNode(createForeignRef(entity, entityName, 'Filter'), undefined)
]);
switch (Schema[entityName].actionType) {
case 'crud': {
propertySignatures.push(factory.createPropertySignature(undefined, factory.createIdentifier(identifier), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
otmUpdateOperationNode,
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(factory.createIdentifier("Array"), [factory.createUnionTypeNode([
otmCreateSingleOperationNode,
otmUpdateOperationNode
])])
])));
break;
}
case 'appendOnly':
case 'excludeUpdate': {
propertySignatures.push(factory.createPropertySignature(undefined, factory.createIdentifier(identifier), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(factory.createIdentifier("Array"), [otmCreateSingleOperationNode])
])));
break;
}
case 'readOnly': {
break;
}
default: {
(0, assert_1.default)(false);
if (!Schema[entityName].static) {
switch (Schema[entityName].actionType) {
case 'crud': {
propertySignatures.push(factory.createPropertySignature(undefined, factory.createIdentifier(identifier), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
otmUpdateOperationNode,
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(factory.createIdentifier("Array"), [factory.createUnionTypeNode([
otmCreateSingleOperationNode,
otmUpdateOperationNode
])])
])));
break;
}
case 'appendOnly':
case 'excludeUpdate': {
propertySignatures.push(factory.createPropertySignature(undefined, factory.createIdentifier(identifier), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(factory.createIdentifier("Array"), [otmCreateSingleOperationNode])
])));
break;
}
case 'readOnly': {
break;
}
default: {
(0, assert_1.default)(false);
}
}
}
});
@ -2013,29 +2035,34 @@ function constructActions(statements, entity) {
factory.createLiteralTypeNode(factory.createNull())
])),
]);
switch (Schema[one[0]].actionType) {
case 'crud': {
upsertOneNodes.push(factory.createUnionTypeNode([cascadeCreateNode, cascadeUpdateNode, cascadeRemoveNode, noCascadeNode]));
break;
}
case 'excludeUpdate': {
upsertOneNodes.push(factory.createUnionTypeNode([cascadeCreateNode, cascadeRemoveNode, noCascadeNode]));
break;
}
case 'appendOnly': {
upsertOneNodes.push(factory.createUnionTypeNode([cascadeCreateNode, noCascadeNode]));
break;
}
case 'readOnly': {
upsertOneNodes.push(noCascadeNode);
break;
}
case 'excludeRemove': {
upsertOneNodes.push(factory.createUnionTypeNode([cascadeCreateNode, cascadeUpdateNode, noCascadeNode]));
break;
}
default: {
(0, assert_1.default)(false);
if (Schema[one[0]].static) {
upsertOneNodes.push(noCascadeNode);
}
else {
switch (Schema[one[0]].actionType) {
case 'crud': {
upsertOneNodes.push(factory.createUnionTypeNode([cascadeCreateNode, cascadeUpdateNode, cascadeRemoveNode, noCascadeNode]));
break;
}
case 'excludeUpdate': {
upsertOneNodes.push(factory.createUnionTypeNode([cascadeCreateNode, cascadeRemoveNode, noCascadeNode]));
break;
}
case 'appendOnly': {
upsertOneNodes.push(factory.createUnionTypeNode([cascadeCreateNode, noCascadeNode]));
break;
}
case 'readOnly': {
upsertOneNodes.push(noCascadeNode);
break;
}
case 'excludeRemove': {
upsertOneNodes.push(factory.createUnionTypeNode([cascadeCreateNode, cascadeUpdateNode, noCascadeNode]));
break;
}
default: {
(0, assert_1.default)(false);
}
}
}
}
@ -2059,28 +2086,30 @@ function constructActions(statements, entity) {
var one = _t.value;
refEntityLitrals.push(factory.createLiteralTypeNode(factory.createStringLiteral("".concat((0, string_1.firstLetterLowerCase)(one)))));
var actionNodes = [];
switch (Schema[one].actionType) {
case 'crud': {
actionNodes.push(factory.createTypeReferenceNode(createForeignRef(entity, one, 'CreateSingleOperation')), factory.createTypeReferenceNode(createForeignRef(entity, one, 'UpdateOperation')), factory.createTypeReferenceNode(createForeignRef(entity, one, 'RemoveOperation')));
break;
}
case 'excludeUpdate': {
actionNodes.push(factory.createTypeReferenceNode(createForeignRef(entity, one, 'CreateSingleOperation')), factory.createTypeReferenceNode(createForeignRef(entity, one, 'RemoveOperation')));
break;
}
case 'excludeRemove': {
actionNodes.push(factory.createTypeReferenceNode(createForeignRef(entity, one, 'CreateSingleOperation')), factory.createTypeReferenceNode(createForeignRef(entity, one, 'UpdateOperation')));
break;
}
case 'appendOnly': {
actionNodes.push(factory.createTypeReferenceNode(createForeignRef(entity, one, 'CreateSingleOperation')));
break;
}
case 'readOnly': {
break;
}
default: {
(0, assert_1.default)(false);
if (!Schema[one].static) {
switch (Schema[one].actionType) {
case 'crud': {
actionNodes.push(factory.createTypeReferenceNode(createForeignRef(entity, one, 'CreateSingleOperation')), factory.createTypeReferenceNode(createForeignRef(entity, one, 'UpdateOperation')), factory.createTypeReferenceNode(createForeignRef(entity, one, 'RemoveOperation')));
break;
}
case 'excludeUpdate': {
actionNodes.push(factory.createTypeReferenceNode(createForeignRef(entity, one, 'CreateSingleOperation')), factory.createTypeReferenceNode(createForeignRef(entity, one, 'RemoveOperation')));
break;
}
case 'excludeRemove': {
actionNodes.push(factory.createTypeReferenceNode(createForeignRef(entity, one, 'CreateSingleOperation')), factory.createTypeReferenceNode(createForeignRef(entity, one, 'UpdateOperation')));
break;
}
case 'appendOnly': {
actionNodes.push(factory.createTypeReferenceNode(createForeignRef(entity, one, 'CreateSingleOperation')));
break;
}
case 'readOnly': {
break;
}
default: {
(0, assert_1.default)(false);
}
}
}
if (actionNodes.length > 0) {
@ -2147,56 +2176,58 @@ function constructActions(statements, entity) {
]);
var otmUpdateOperationNode = factory.createTypeReferenceNode(createForeignRef(entity, entityName, 'UpdateOperation'), undefined);
var otmRemoveOperationNode = factory.createTypeReferenceNode(createForeignRef(entity, entityName, 'RemoveOperation'), undefined);
switch (Schema[entityName].actionType) {
case 'crud': {
propertySignatures2.push(factory.createPropertySignature(undefined, factory.createIdentifier(identifier), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
otmUpdateOperationNode,
otmRemoveOperationNode,
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(factory.createIdentifier("Array"), [factory.createUnionTypeNode([
otmCreateSingleOperationNode,
otmUpdateOperationNode,
otmRemoveOperationNode
])])
])));
break;
}
case 'excludeUpdate': {
propertySignatures2.push(factory.createPropertySignature(undefined, factory.createIdentifier(identifier), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
otmRemoveOperationNode,
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(factory.createIdentifier("Array"), [factory.createUnionTypeNode([
otmCreateSingleOperationNode,
otmRemoveOperationNode
])])
])));
break;
}
case 'excludeRemove': {
propertySignatures2.push(factory.createPropertySignature(undefined, factory.createIdentifier(identifier), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
otmUpdateOperationNode,
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(factory.createIdentifier("Array"), [factory.createUnionTypeNode([
otmCreateSingleOperationNode,
otmUpdateOperationNode
])])
])));
break;
}
case 'appendOnly': {
propertySignatures2.push(factory.createPropertySignature(undefined, factory.createIdentifier(identifier), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(factory.createIdentifier("Array"), [factory.createUnionTypeNode([
otmCreateSingleOperationNode
])])
])));
break;
}
case 'readOnly': {
break;
}
default: {
(0, assert_1.default)(false);
if (!Schema[entityName].static) {
switch (Schema[entityName].actionType) {
case 'crud': {
propertySignatures2.push(factory.createPropertySignature(undefined, factory.createIdentifier(identifier), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
otmUpdateOperationNode,
otmRemoveOperationNode,
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(factory.createIdentifier("Array"), [factory.createUnionTypeNode([
otmCreateSingleOperationNode,
otmUpdateOperationNode,
otmRemoveOperationNode
])])
])));
break;
}
case 'excludeUpdate': {
propertySignatures2.push(factory.createPropertySignature(undefined, factory.createIdentifier(identifier), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
otmRemoveOperationNode,
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(factory.createIdentifier("Array"), [factory.createUnionTypeNode([
otmCreateSingleOperationNode,
otmRemoveOperationNode
])])
])));
break;
}
case 'excludeRemove': {
propertySignatures2.push(factory.createPropertySignature(undefined, factory.createIdentifier(identifier), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
otmUpdateOperationNode,
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(factory.createIdentifier("Array"), [factory.createUnionTypeNode([
otmCreateSingleOperationNode,
otmUpdateOperationNode
])])
])));
break;
}
case 'appendOnly': {
propertySignatures2.push(factory.createPropertySignature(undefined, factory.createIdentifier(identifier), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(factory.createIdentifier("Array"), [factory.createUnionTypeNode([
otmCreateSingleOperationNode
])])
])));
break;
}
case 'readOnly': {
break;
}
default: {
(0, assert_1.default)(false);
}
}
}
});
@ -2240,40 +2271,42 @@ function constructActions(statements, entity) {
for (var manyToOneSet_6 = tslib_1.__values(manyToOneSet), manyToOneSet_6_1 = manyToOneSet_6.next(); !manyToOneSet_6_1.done; manyToOneSet_6_1 = manyToOneSet_6.next()) {
var one = manyToOneSet_6_1.value;
if (!ReversePointerRelations[entity] || !ReversePointerRelations[entity].includes(one[0])) {
switch (Schema[one[0]].actionType) {
case 'crud': {
upsertOneNodes.push(factory.createUnionTypeNode([
factory.createTypeLiteralNode([
factory.createPropertySignature(undefined, factory.createIdentifier(one[1]), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
factory.createTypeReferenceNode(createForeignRef(entity, one[0], 'UpdateOperation')),
factory.createTypeReferenceNode(createForeignRef(entity, one[0], 'RemoveOperation'))
]))
])
]));
break;
}
case 'excludeUpdate': {
upsertOneNodes.push(factory.createUnionTypeNode([
factory.createTypeLiteralNode([
factory.createPropertySignature(undefined, factory.createIdentifier(one[1]), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode(createForeignRef(entity, one[0], 'RemoveOperation')))
])
]));
break;
}
case 'excludeRemove': {
upsertOneNodes.push(factory.createUnionTypeNode([
factory.createTypeLiteralNode([
factory.createPropertySignature(undefined, factory.createIdentifier(one[1]), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode(createForeignRef(entity, one[0], 'UpdateOperation')))
])
]));
break;
}
case 'appendOnly':
case 'readOnly': {
break;
}
default: {
(0, assert_1.default)(false);
if (!Schema[one[0]].static) {
switch (Schema[one[0]].actionType) {
case 'crud': {
upsertOneNodes.push(factory.createUnionTypeNode([
factory.createTypeLiteralNode([
factory.createPropertySignature(undefined, factory.createIdentifier(one[1]), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
factory.createTypeReferenceNode(createForeignRef(entity, one[0], 'UpdateOperation')),
factory.createTypeReferenceNode(createForeignRef(entity, one[0], 'RemoveOperation'))
]))
])
]));
break;
}
case 'excludeUpdate': {
upsertOneNodes.push(factory.createUnionTypeNode([
factory.createTypeLiteralNode([
factory.createPropertySignature(undefined, factory.createIdentifier(one[1]), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode(createForeignRef(entity, one[0], 'RemoveOperation')))
])
]));
break;
}
case 'excludeRemove': {
upsertOneNodes.push(factory.createUnionTypeNode([
factory.createTypeLiteralNode([
factory.createPropertySignature(undefined, factory.createIdentifier(one[1]), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode(createForeignRef(entity, one[0], 'UpdateOperation')))
])
]));
break;
}
case 'appendOnly':
case 'readOnly': {
break;
}
default: {
(0, assert_1.default)(false);
}
}
}
}
@ -2293,34 +2326,36 @@ function constructActions(statements, entity) {
for (var _u = tslib_1.__values(ReversePointerRelations[entity]), _v = _u.next(); !_v.done; _v = _u.next()) {
var one = _v.value;
refEntityLitrals.push(factory.createLiteralTypeNode(factory.createStringLiteral("".concat((0, string_1.firstLetterLowerCase)(one)))));
switch (Schema[one].actionType) {
case 'crud': {
reverseOneNodes_2.push(factory.createTypeLiteralNode([
factory.createPropertySignature(undefined, factory.createIdentifier((0, string_1.firstLetterLowerCase)(one)), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
factory.createTypeReferenceNode(createForeignRef(entity, one, 'UpdateOperation')),
factory.createTypeReferenceNode(createForeignRef(entity, one, 'RemoveOperation'))
]))
]));
break;
}
case 'excludeUpdate': {
reverseOneNodes_2.push(factory.createTypeLiteralNode([
factory.createPropertySignature(undefined, factory.createIdentifier((0, string_1.firstLetterLowerCase)(one)), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode(createForeignRef(entity, one, 'RemoveOperation')))
]));
break;
}
case 'excludeRemove': {
reverseOneNodes_2.push(factory.createTypeLiteralNode([
factory.createPropertySignature(undefined, factory.createIdentifier((0, string_1.firstLetterLowerCase)(one)), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode(createForeignRef(entity, one, 'UpdateOperation')))
]));
break;
}
case 'appendOnly':
case 'readOnly': {
break;
}
default: {
(0, assert_1.default)(false);
if (!Schema[one].static) {
switch (Schema[one].actionType) {
case 'crud': {
reverseOneNodes_2.push(factory.createTypeLiteralNode([
factory.createPropertySignature(undefined, factory.createIdentifier((0, string_1.firstLetterLowerCase)(one)), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
factory.createTypeReferenceNode(createForeignRef(entity, one, 'UpdateOperation')),
factory.createTypeReferenceNode(createForeignRef(entity, one, 'RemoveOperation'))
]))
]));
break;
}
case 'excludeUpdate': {
reverseOneNodes_2.push(factory.createTypeLiteralNode([
factory.createPropertySignature(undefined, factory.createIdentifier((0, string_1.firstLetterLowerCase)(one)), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode(createForeignRef(entity, one, 'RemoveOperation')))
]));
break;
}
case 'excludeRemove': {
reverseOneNodes_2.push(factory.createTypeLiteralNode([
factory.createPropertySignature(undefined, factory.createIdentifier((0, string_1.firstLetterLowerCase)(one)), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode(createForeignRef(entity, one, 'UpdateOperation')))
]));
break;
}
case 'appendOnly':
case 'readOnly': {
break;
}
default: {
(0, assert_1.default)(false);
}
}
}
}
@ -2863,7 +2898,7 @@ function outputStorage(outputDir, printer) {
var entityAssignments = [];
for (var entity in Schema) {
var indexExpressions = [];
var _a = Schema[entity], sourceFile = _a.sourceFile, inModi = _a.inModi, indexes = _a.indexes, toModi = _a.toModi, actionType = _a.actionType;
var _a = Schema[entity], sourceFile = _a.sourceFile, inModi = _a.inModi, indexes = _a.indexes, toModi = _a.toModi, actionType = _a.actionType, _static = _a.static;
var statements = [
factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier("StorageDesc"))])), factory.createStringLiteral("".concat((0, env_1.TYPE_PATH_IN_OAK_DOMAIN)(), "Storage")), undefined),
factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier("OpSchema"))])), factory.createStringLiteral("./Schema"), undefined)
@ -2902,6 +2937,9 @@ function outputStorage(outputDir, printer) {
if (inModi) {
propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("inModi"), factory.createTrue()));
}
if (_static || actionType === 'readOnly') {
propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("static"), factory.createTrue()));
}
propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("actionType"), factory.createStringLiteral(actionType)), factory.createShorthandPropertyAssignment(factory.createIdentifier("actions"), undefined));
if (indexExpressions.length > 0) {
propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("indexes"), factory.createArrayLiteralExpression(indexExpressions, true)));
@ -2986,7 +3024,7 @@ function analyzeInModi() {
return;
}
var schema = Schema[entity];
if (schema.toModi || schema.inModi || schema.actionType === 'readOnly') {
if (schema.toModi || schema.inModi || schema.actionType === 'readOnly' || schema.static) {
return;
}
schema.inModi = true;

4
lib/entities/ModiEntity.js
View File

@ -1,7 +1,9 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
;
var actionType = 'appendOnly';
var config = {
actionType: 'appendOnly',
};
var locale = {
zh_CN: {
attr: {

4
lib/entities/Oper.js
View File

@ -1,7 +1,9 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
;
var actionType = 'appendOnly';
var configuration = {
actionType: 'appendOnly',
};
var locale = {
zh_CN: {
attr: {

4
lib/entities/OperEntity.js
View File

@ -1,7 +1,9 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
;
var actionType = 'appendOnly';
var config = {
actionType: 'appendOnly',
};
var locale = {
zh_CN: {
attr: {

4
lib/store/modi.js
View File

@ -87,8 +87,8 @@ function createModiRelatedCheckers(schema) {
var _this = this;
var checkers = [];
var _loop_1 = function (entity) {
var _a = schema[entity], actionType = _a.actionType, actions = _a.actions;
if (['modi', 'modiEntity', 'oper', 'operEntity'].includes(entity) || ['readOnly', 'appendOnly'].includes(actionType)) {
var _a = schema[entity], actionType = _a.actionType, actions = _a.actions, inModi = _a.inModi;
if (!inModi || ['readOnly', 'appendOnly'].includes(actionType)) {
return "continue";
}
var restActions = (0, lodash_1.difference)(actions, action_1.appendOnlyActions);

4
lib/types/Entity.d.ts vendored
View File

@ -144,4 +144,8 @@ export declare type SelectionResult<E extends GeneralEntityShape, P extends Dedu
result: Array<SelectRowShape<E, P>>;
};
export declare type ActionType = 'readOnly' | 'appendOnly' | 'excludeUpdate' | 'excludeRemove' | 'crud';
export declare type Configuration = {
actionType?: ActionType;
static?: boolean;
};
export {};

1
lib/types/Storage.d.ts vendored
View File

@ -44,6 +44,7 @@ export interface StorageDesc<SH extends EntityShape> {
config?: EntityConfig;
toModi?: true;
inModi?: true;
static?: true;
actions: string[];
actionType: ActionType;
view?: true;

835
src/compiler/schemalBuilder.ts
View File

@ -28,6 +28,7 @@ const Schema: Record<string, {
locale: ts.ObjectLiteralExpression;
toModi: boolean;
actionType: string;
static: boolean;
inModi: boolean;
}> = {};
const OneToMany: Record<string, Array<[string, string, boolean]>> = {};
@ -480,6 +481,7 @@ function analyzeEntity(filename: string, path: string, program: ts.Program) {
let hasActionOrStateDef = false;
let toModi = false;
let actionType = 'crud';
let _static = false;
const enumStringAttrs: string[] = [];
const states: string[] = [];
const localEnumStringTypes: string[] = [];
@ -1023,13 +1025,25 @@ function analyzeEntity(filename: string, path: string, program: ts.Program) {
localeDef = initializer;
}
else if (ts.isTypeReferenceNode(declaration.type!) && ts.isIdentifier(declaration.type.typeName) && declaration.type.typeName.text === 'ActionType') {
assert(!hasActionDef, `${moduleName}中的actionType定义在Action之后`);
assert(ts.isStringLiteral(declaration.initializer!));
actionType = declaration.initializer.text;
else if (ts.isTypeReferenceNode(declaration.type!) && ts.isIdentifier(declaration.type.typeName) && declaration.type.typeName.text === 'Configuration') {
assert(!hasActionDef, `${moduleName}中的Configuration定义在Action之后`);
assert(ts.isObjectLiteralExpression(declaration.initializer!));
const { properties } = declaration.initializer;
const atProperty = properties.find(
ele => ts.isPropertyAssignment(ele) && ts.isIdentifier(ele.name) && ele.name.text === 'actionType'
);
const staticProperty = properties.find(
ele => ts.isPropertyAssignment(ele) && ts.isIdentifier(ele.name) && ele.name.text === 'static'
);
if (atProperty) {
actionType = (<ts.StringLiteral>(<ts.PropertyAssignment>atProperty).initializer).text;
}
if (staticProperty) {
_static = true; // static如果有值只能为true
}
}
else {
throw new Error(`不能理解的定义内容${declaration.name.getText()}`);
throw new Error(`${moduleName}：不能理解的定义内容${declaration.name.getText()}`);
}
}
);
@ -1048,6 +1062,7 @@ function analyzeEntity(filename: string, path: string, program: ts.Program) {
sourceFile,
toModi,
actionType,
static: _static,
};
if (hasFulltextIndex) {
assign(schema, {
@ -2859,27 +2874,32 @@ function constructActions(statements: Array<ts.Statement>, entity: string) {
)
]
);
switch (Schema[oneEntity].actionType) {
case 'crud':
case 'excludeRemove': {
upsertOneNodes.push(
factory.createUnionTypeNode([cascadeCreateNode, cascadeUpdateNode, noCascadeNode])
);
break;
}
case 'excludeUpdate':
case 'appendOnly': {
upsertOneNodes.push(
factory.createUnionTypeNode([cascadeCreateNode, noCascadeNode])
);
break;
}
case 'readOnly': {
upsertOneNodes.push(noCascadeNode);
break;
}
default: {
assert(false);
if (Schema[oneEntity].static) {
upsertOneNodes.push(noCascadeNode);
}
else {
switch (Schema[oneEntity].actionType) {
case 'crud':
case 'excludeRemove': {
upsertOneNodes.push(
factory.createUnionTypeNode([cascadeCreateNode, cascadeUpdateNode, noCascadeNode])
);
break;
}
case 'excludeUpdate':
case 'appendOnly': {
upsertOneNodes.push(
factory.createUnionTypeNode([cascadeCreateNode, noCascadeNode])
);
break;
}
case 'readOnly': {
upsertOneNodes.push(noCascadeNode);
break;
}
default: {
assert(false);
}
}
}
}
@ -2969,23 +2989,28 @@ function constructActions(statements: Array<ts.Statement>, entity: string) {
)
]
);
switch (Schema[one].actionType) {
case 'crud':
case 'excludeRemove': {
reverseOneNodes.push(cascadeCreateNode, cascadeUpdateNode, noCascadeNode);
break;
}
case 'appendOnly':
case 'excludeUpdate': {
reverseOneNodes.push(cascadeCreateNode, noCascadeNode);
break;
}
case 'readOnly': {
reverseOneNodes.push(noCascadeNode);
break;
}
default: {
assert(false);
if (Schema[one].static) {
reverseOneNodes.push(noCascadeNode);
}
else {
switch (Schema[one].actionType) {
case 'crud':
case 'excludeRemove': {
reverseOneNodes.push(cascadeCreateNode, cascadeUpdateNode, noCascadeNode);
break;
}
case 'appendOnly':
case 'excludeUpdate': {
reverseOneNodes.push(cascadeCreateNode, noCascadeNode);
break;
}
case 'readOnly': {
reverseOneNodes.push(noCascadeNode);
break;
}
default: {
assert(false);
}
}
}
}
@ -3110,51 +3135,53 @@ function constructActions(statements: Array<ts.Statement>, entity: string) {
]
);
switch (Schema[entityName].actionType) {
case 'crud': {
propertySignatures.push(
factory.createPropertySignature(
undefined,
factory.createIdentifier(identifier),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createUnionTypeNode([
otmUpdateOperationNode,
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(
factory.createIdentifier("Array"),
[factory.createUnionTypeNode([
otmCreateSingleOperationNode,
otmUpdateOperationNode
])]
)
])
)
);
break;
}
case 'appendOnly':
case 'excludeUpdate': {
propertySignatures.push(
factory.createPropertySignature(
undefined,
factory.createIdentifier(identifier),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createUnionTypeNode([
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(
factory.createIdentifier("Array"),
[otmCreateSingleOperationNode]
)
])
)
);
break;
}
case 'readOnly': {
break;
}
default: {
assert(false);
if (!Schema[entityName].static) {
switch (Schema[entityName].actionType) {
case 'crud': {
propertySignatures.push(
factory.createPropertySignature(
undefined,
factory.createIdentifier(identifier),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createUnionTypeNode([
otmUpdateOperationNode,
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(
factory.createIdentifier("Array"),
[factory.createUnionTypeNode([
otmCreateSingleOperationNode,
otmUpdateOperationNode
])]
)
])
)
);
break;
}
case 'appendOnly':
case 'excludeUpdate': {
propertySignatures.push(
factory.createPropertySignature(
undefined,
factory.createIdentifier(identifier),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createUnionTypeNode([
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(
factory.createIdentifier("Array"),
[otmCreateSingleOperationNode]
)
])
)
);
break;
}
case 'readOnly': {
break;
}
default: {
assert(false);
}
}
}
}
@ -3351,39 +3378,46 @@ function constructActions(statements: Array<ts.Statement>, entity: string) {
),
]
);
switch (Schema[one[0]].actionType) {
case 'crud': {
upsertOneNodes.push(
factory.createUnionTypeNode([cascadeCreateNode, cascadeUpdateNode, cascadeRemoveNode, noCascadeNode])
);
break;
}
case 'excludeUpdate': {
upsertOneNodes.push(
factory.createUnionTypeNode([cascadeCreateNode, cascadeRemoveNode, noCascadeNode])
);
break;
}
case 'appendOnly': {
upsertOneNodes.push(
factory.createUnionTypeNode([cascadeCreateNode, noCascadeNode])
);
break;
}
case 'readOnly': {
upsertOneNodes.push(
noCascadeNode
);
break;
}
case 'excludeRemove': {
upsertOneNodes.push(
factory.createUnionTypeNode([cascadeCreateNode, cascadeUpdateNode, noCascadeNode])
);
break;
}
default: {
assert(false);
if (Schema[one[0]].static) {
upsertOneNodes.push(
noCascadeNode
);
}
else {
switch (Schema[one[0]].actionType) {
case 'crud': {
upsertOneNodes.push(
factory.createUnionTypeNode([cascadeCreateNode, cascadeUpdateNode, cascadeRemoveNode, noCascadeNode])
);
break;
}
case 'excludeUpdate': {
upsertOneNodes.push(
factory.createUnionTypeNode([cascadeCreateNode, cascadeRemoveNode, noCascadeNode])
);
break;
}
case 'appendOnly': {
upsertOneNodes.push(
factory.createUnionTypeNode([cascadeCreateNode, noCascadeNode])
);
break;
}
case 'readOnly': {
upsertOneNodes.push(
noCascadeNode
);
break;
}
case 'excludeRemove': {
upsertOneNodes.push(
factory.createUnionTypeNode([cascadeCreateNode, cascadeUpdateNode, noCascadeNode])
);
break;
}
default: {
assert(false);
}
}
}
}
@ -3402,56 +3436,58 @@ function constructActions(statements: Array<ts.Statement>, entity: string) {
for (const one of ReversePointerRelations[entity]) {
refEntityLitrals.push(factory.createLiteralTypeNode(factory.createStringLiteral(`${firstLetterLowerCase(one)}`)));
const actionNodes: ts.TypeNode[] = [];
switch (Schema[one].actionType) {
case 'crud': {
actionNodes.push(
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'CreateSingleOperation')
),
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'UpdateOperation')
),
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'RemoveOperation')
)
);
break;
}
case 'excludeUpdate': {
actionNodes.push(
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'CreateSingleOperation')
),
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'RemoveOperation')
)
);
break;
}
case 'excludeRemove': {
actionNodes.push(
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'CreateSingleOperation')
),
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'UpdateOperation')
)
);
break;
}
case 'appendOnly': {
actionNodes.push(
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'CreateSingleOperation')
)
);
break;
}
case 'readOnly': {
break;
}
default: {
assert(false);
if (!Schema[one].static) {
switch (Schema[one].actionType) {
case 'crud': {
actionNodes.push(
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'CreateSingleOperation')
),
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'UpdateOperation')
),
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'RemoveOperation')
)
);
break;
}
case 'excludeUpdate': {
actionNodes.push(
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'CreateSingleOperation')
),
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'RemoveOperation')
)
);
break;
}
case 'excludeRemove': {
actionNodes.push(
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'CreateSingleOperation')
),
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'UpdateOperation')
)
);
break;
}
case 'appendOnly': {
actionNodes.push(
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'CreateSingleOperation')
)
);
break;
}
case 'readOnly': {
break;
}
default: {
assert(false);
}
}
}
if (actionNodes.length > 0) {
@ -3597,99 +3633,100 @@ function constructActions(statements: Array<ts.Statement>, entity: string) {
createForeignRef(entity, entityName, 'RemoveOperation'),
undefined
);
switch (Schema[entityName].actionType) {
case 'crud': {
propertySignatures2.push(
factory.createPropertySignature(
undefined,
factory.createIdentifier(identifier),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createUnionTypeNode([
otmUpdateOperationNode,
otmRemoveOperationNode,
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(
factory.createIdentifier("Array"),
[factory.createUnionTypeNode([
otmCreateSingleOperationNode,
otmUpdateOperationNode,
otmRemoveOperationNode
])]
)
])
)
);
break;
}
case 'excludeUpdate': {
propertySignatures2.push(
factory.createPropertySignature(
undefined,
factory.createIdentifier(identifier),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createUnionTypeNode([
otmRemoveOperationNode,
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(
factory.createIdentifier("Array"),
[factory.createUnionTypeNode([
otmCreateSingleOperationNode,
otmRemoveOperationNode
])]
)
])
)
);
break;
}
case 'excludeRemove': {
propertySignatures2.push(
factory.createPropertySignature(
undefined,
factory.createIdentifier(identifier),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createUnionTypeNode([
otmUpdateOperationNode,
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(
factory.createIdentifier("Array"),
[factory.createUnionTypeNode([
otmCreateSingleOperationNode,
otmUpdateOperationNode
])]
)
])
)
);
break;
}
case 'appendOnly': {
propertySignatures2.push(
factory.createPropertySignature(
undefined,
factory.createIdentifier(identifier),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createUnionTypeNode([
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(
factory.createIdentifier("Array"),
[factory.createUnionTypeNode([
otmCreateSingleOperationNode
])]
)
])
)
);
break;
}
case 'readOnly': {
break;
}
default: {
assert(false);
if (!Schema[entityName].static) {
switch (Schema[entityName].actionType) {
case 'crud': {
propertySignatures2.push(
factory.createPropertySignature(
undefined,
factory.createIdentifier(identifier),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createUnionTypeNode([
otmUpdateOperationNode,
otmRemoveOperationNode,
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(
factory.createIdentifier("Array"),
[factory.createUnionTypeNode([
otmCreateSingleOperationNode,
otmUpdateOperationNode,
otmRemoveOperationNode
])]
)
])
)
);
break;
}
case 'excludeUpdate': {
propertySignatures2.push(
factory.createPropertySignature(
undefined,
factory.createIdentifier(identifier),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createUnionTypeNode([
otmRemoveOperationNode,
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(
factory.createIdentifier("Array"),
[factory.createUnionTypeNode([
otmCreateSingleOperationNode,
otmRemoveOperationNode
])]
)
])
)
);
break;
}
case 'excludeRemove': {
propertySignatures2.push(
factory.createPropertySignature(
undefined,
factory.createIdentifier(identifier),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createUnionTypeNode([
otmUpdateOperationNode,
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(
factory.createIdentifier("Array"),
[factory.createUnionTypeNode([
otmCreateSingleOperationNode,
otmUpdateOperationNode
])]
)
])
)
);
break;
}
case 'appendOnly': {
propertySignatures2.push(
factory.createPropertySignature(
undefined,
factory.createIdentifier(identifier),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createUnionTypeNode([
otmCreateMultipleOperationNode,
factory.createTypeReferenceNode(
factory.createIdentifier("Array"),
[factory.createUnionTypeNode([
otmCreateSingleOperationNode
])]
)
])
)
);
break;
}
case 'readOnly': {
break;
}
default: {
assert(false);
}
}
}
}
);
}
@ -3762,81 +3799,83 @@ function constructActions(statements: Array<ts.Statement>, entity: string) {
const upsertOneNodes: ts.TypeNode[] = [];
for (const one of manyToOneSet) {
if (!ReversePointerRelations[entity] || !ReversePointerRelations[entity].includes(one[0])) {
switch (Schema[one[0]].actionType) {
case 'crud': {
upsertOneNodes.push(
factory.createUnionTypeNode(
[
factory.createTypeLiteralNode(
[
factory.createPropertySignature(
undefined,
factory.createIdentifier(one[1]),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createUnionTypeNode([
factory.createTypeReferenceNode(
createForeignRef(entity, one[0], 'UpdateOperation')
),
if (!Schema[one[0]].static) {
switch (Schema[one[0]].actionType) {
case 'crud': {
upsertOneNodes.push(
factory.createUnionTypeNode(
[
factory.createTypeLiteralNode(
[
factory.createPropertySignature(
undefined,
factory.createIdentifier(one[1]),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createUnionTypeNode([
factory.createTypeReferenceNode(
createForeignRef(entity, one[0], 'UpdateOperation')
),
factory.createTypeReferenceNode(
createForeignRef(entity, one[0], 'RemoveOperation')
)
])
)
]
)
]
)
);
break;
}
case 'excludeUpdate': {
upsertOneNodes.push(
factory.createUnionTypeNode(
[
factory.createTypeLiteralNode(
[
factory.createPropertySignature(
undefined,
factory.createIdentifier(one[1]),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createTypeReferenceNode(
createForeignRef(entity, one[0], 'RemoveOperation')
)
])
)
]
)
]
)
);
break;
}
case 'excludeUpdate': {
upsertOneNodes.push(
factory.createUnionTypeNode(
[
factory.createTypeLiteralNode(
[
factory.createPropertySignature(
undefined,
factory.createIdentifier(one[1]),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createTypeReferenceNode(
createForeignRef(entity, one[0], 'RemoveOperation')
)
)
]
)
]
)
);
break;
}
case 'excludeRemove': {
upsertOneNodes.push(
factory.createUnionTypeNode(
[
factory.createTypeLiteralNode(
[
factory.createPropertySignature(
undefined,
factory.createIdentifier(one[1]),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createTypeReferenceNode(
createForeignRef(entity, one[0], 'UpdateOperation')
]
)
]
)
);
break;
}
case 'excludeRemove': {
upsertOneNodes.push(
factory.createUnionTypeNode(
[
factory.createTypeLiteralNode(
[
factory.createPropertySignature(
undefined,
factory.createIdentifier(one[1]),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createTypeReferenceNode(
createForeignRef(entity, one[0], 'UpdateOperation')
)
)
)
]
)
]
)
);
break;
}
case 'appendOnly':
case 'readOnly': {
break;
}
default: {
assert(false);
]
)
]
)
);
break;
}
case 'appendOnly':
case 'readOnly': {
break;
}
default: {
assert(false);
}
}
}
}
@ -3847,69 +3886,71 @@ function constructActions(statements: Array<ts.Statement>, entity: string) {
const refEntityLitrals: (ts.TypeNode)[] = [];
for (const one of ReversePointerRelations[entity]) {
refEntityLitrals.push(factory.createLiteralTypeNode(factory.createStringLiteral(`${firstLetterLowerCase(one)}`)));
switch (Schema[one].actionType) {
case 'crud': {
reverseOneNodes.push(
factory.createTypeLiteralNode(
[
factory.createPropertySignature(
undefined,
factory.createIdentifier(firstLetterLowerCase(one)),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createUnionTypeNode([
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'UpdateOperation')
),
if (!Schema[one].static) {
switch (Schema[one].actionType) {
case 'crud': {
reverseOneNodes.push(
factory.createTypeLiteralNode(
[
factory.createPropertySignature(
undefined,
factory.createIdentifier(firstLetterLowerCase(one)),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createUnionTypeNode([
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'UpdateOperation')
),
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'RemoveOperation')
)
])
)
]
),
);
break;
}
case 'excludeUpdate': {
reverseOneNodes.push(
factory.createTypeLiteralNode(
[
factory.createPropertySignature(
undefined,
factory.createIdentifier(firstLetterLowerCase(one)),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'RemoveOperation')
)
])
)
]
),
);
break;
}
case 'excludeUpdate': {
reverseOneNodes.push(
factory.createTypeLiteralNode(
[
factory.createPropertySignature(
undefined,
factory.createIdentifier(firstLetterLowerCase(one)),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'RemoveOperation')
)
)
]
),
);
break;
}
case 'excludeRemove': {
reverseOneNodes.push(
factory.createTypeLiteralNode(
[
factory.createPropertySignature(
undefined,
factory.createIdentifier(firstLetterLowerCase(one)),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'UpdateOperation')
]
),
);
break;
}
case 'excludeRemove': {
reverseOneNodes.push(
factory.createTypeLiteralNode(
[
factory.createPropertySignature(
undefined,
factory.createIdentifier(firstLetterLowerCase(one)),
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createTypeReferenceNode(
createForeignRef(entity, one, 'UpdateOperation')
)
)
)
]
),
);
break;
}
case 'appendOnly':
case 'readOnly': {
break;
}
default: {
assert(false);
]
),
);
break;
}
case 'appendOnly':
case 'readOnly': {
break;
}
default: {
assert(false);
}
}
}
@ -5351,7 +5392,7 @@ function outputStorage(outputDir: string, printer: ts.Printer) {
for (const entity in Schema) {
const indexExpressions: ts.Expression[] = [];
const { sourceFile, inModi, indexes, toModi, actionType } = Schema[entity];
const { sourceFile, inModi, indexes, toModi, actionType, static: _static } = Schema[entity];
const statements: ts.Statement[] = [
factory.createImportDeclaration(
undefined,
@ -5522,6 +5563,15 @@ function outputStorage(outputDir: string, printer: ts.Printer) {
);
}
if (_static || actionType === 'readOnly') {
propertyAssignments.push(
factory.createPropertyAssignment(
factory.createIdentifier("static"),
factory.createTrue()
)
);
}
propertyAssignments.push(
factory.createPropertyAssignment(
factory.createIdentifier("actionType"),
@ -5701,9 +5751,10 @@ function analyzeInModi() {
return;
}
const schema = Schema[entity];
if (schema.toModi || schema.inModi || schema.actionType === 'readOnly') {
if (schema.toModi || schema.inModi || schema.actionType === 'readOnly' || schema.static) {
return;
}
console.log('setInModi', entity);
schema.inModi = true;
const related = getRelateEntities(entity);
related.forEach(

6
src/entities/ModiEntity.ts
View File

@ -1,5 +1,5 @@
import { String } from '../types/DataType';
import { EntityShape, ActionType } from '../types/Entity';
import { EntityShape, Configuration } from '../types/Entity';
import { LocaleDef } from '../types/Locale';
import { Schema as Modi } from './Modi';
@ -9,7 +9,9 @@ export interface Schema extends EntityShape {
entityId: String<64>;
};
const actionType: ActionType = 'appendOnly';
const config: Configuration = {
actionType: 'appendOnly',
};
const locale: LocaleDef<Schema, '', '', {}> = {
zh_CN: {

6
src/entities/Oper.ts
View File

@ -1,5 +1,5 @@
import { String, Int, Datetime, Image, Boolean, Text } from '../types/DataType';
import { EntityShape, ActionType } from '../types/Entity';
import { EntityShape, Configuration } from '../types/Entity';
import { LocaleDef } from '../types/Locale';
import { Schema as User } from './User';
@ -11,7 +11,9 @@ export interface Schema extends EntityShape {
operator?: User;
};
const actionType: ActionType = 'appendOnly';
const configuration: Configuration = {
actionType: 'appendOnly',
}
const locale: LocaleDef<Schema, '', '', {}> = {
zh_CN: {

6
src/entities/OperEntity.ts
View File

@ -1,5 +1,5 @@
import { String } from '../types/DataType';
import { EntityShape, ActionType } from '../types/Entity';
import { EntityShape, Configuration } from '../types/Entity';
import { LocaleDef } from '../types/Locale';
import { Schema as Oper } from './Oper';
@ -9,7 +9,9 @@ export interface Schema extends EntityShape {
entityId: String<64>;
};
const actionType: ActionType = 'appendOnly';
const config: Configuration = {
actionType: 'appendOnly',
};
const locale: LocaleDef<Schema, '', '', {}> = {
zh_CN: {

5
src/types/Entity.ts
View File

@ -206,3 +206,8 @@ export type SelectionResult<E extends GeneralEntityShape, P extends DeduceProjec
}
export type ActionType = 'readOnly' | 'appendOnly' | 'excludeUpdate' | 'excludeRemove' | 'crud'; // 只读型、只插入型、没有更新型、没有删除型、所有型
export type Configuration = {
actionType?: ActionType;
static?: boolean; // 标识是维表（变动较小，相对独立）
};

1
src/types/Storage.ts
View File

@ -55,6 +55,7 @@ export interface StorageDesc<SH extends EntityShape> {
config?: EntityConfig;
toModi?: true; // 标识是否有一对多的modi关联关系（业务层的申请）
inModi?: true; // 标识是否可能被modi所指向（编译器根据toModi对象进行的推断，主要用于对这些对象的update/remove时检查有无modi的存在）
static?: true; // 标识是维表（变动较小，相对独立）
actions: string[];
actionType: ActionType;
// view 相关