oak-domain 5.1.16 → 5.1.18

package/lib/compiler/schemalBuilder.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildSchema = exports.analyzeEntities = exports.registerDeducedRelationMap = exports.registerFixedDestinationPathMap = exports.registerIgnoredRelationPathMap = exports.registerFreeEntities = exports.registerIgnoredForeignKeyMap = void 0;
+exports.buildSchema = exports.buildSchemaBackup = exports.analyzeEntities = exports.registerDeducedRelationMap = exports.registerFixedDestinationPathMap = exports.registerIgnoredRelationPathMap = exports.registerFreeEntities = exports.registerIgnoredForeignKeyMap = void 0;
 const tslib_1 = require("tslib");
 const path_1 = tslib_1.__importDefault(require("path"));
 const assert_1 = tslib_1.__importDefault(require("assert"));
@@ -83,6 +83,9 @@ function createForeignRef(entity, foreignKey, ref) {
     }
     return factory.createQualifiedName(factory.createIdentifier(foreignKey), factory.createIdentifier(ref));
 }
+function createIndexedForeignRef(foreignEntity, ref) {
+    return factory.createIndexedAccessTypeNode(factory.createTypeReferenceNode(factory.createIdentifier(foreignEntity), undefined), factory.createLiteralTypeNode(factory.createStringLiteral(ref)));
+}
 function pushStatementIntoActionAst(moduleName, node, sourceFile) {
     // let actionNames;
     let actionDefName;
@@ -169,7 +172,7 @@ function checkActionDefNameConsistent(filename, actionDefNode) {
     (0, assert_1.default)(ts.isTypeReferenceNode(actionNode) && ts.isTypeReferenceNode(stateNode), `文件${filename}中的ActionDef${name.text}类型声明中的action和state非法`);
     (0, assert_1.default)(ts.isIdentifier(actionNode.typeName) && ts.isIdentifier(stateNode.typeName));
     (0, assert_1.default)(actionNode.typeName.text.endsWith('Action'), `文件${filename}中的ActionDef${name.text}所引用的Action${actionNode.typeName}未以Action结尾`);
-    (0, assert_1.default)(stateNode.typeName.text.endsWith('State'), `文件${filename}中的ActionDef${name.text}所引用的Action${stateNode.typeName}未以Action结尾`);
+    (0, assert_1.default)(stateNode.typeName.text.endsWith('State'), `文件${filename}中的ActionDef${name.text}所引用的State${stateNode.typeName}未以State结尾`);
     const adfName = name.text.slice(0, name.text.length - 9);
     const aName = actionNode.typeName.text.slice(0, actionNode.typeName.text.length - 6);
     const sName = stateNode.typeName.text.slice(0, stateNode.typeName.text.length - 5);
@@ -913,24 +916,29 @@ function analyzeEntity(filename, path, program, relativePath) {
                 toLog = result.toLog;
                 extendsFrom = result.extendsFrom;
                 // 对于不是Modi和Oper的对象，全部建立和ModiEntity的反指关系
-                if (!['Modi', 'Oper', 'OperEntity', 'ModiEntity'].includes(moduleName) && !toModi) {
-                    if (ReversePointerRelations['ModiEntity'] && !ReversePointerRelations['ModiEntity'].includes(moduleName)) {
-                        ReversePointerRelations['ModiEntity'].push(moduleName);
+                /* if (!['Modi', 'Oper', 'OperEntity', 'ModiEntity'].includes(moduleName) && !toModi) {
+                    if (ReversePointerRelations['ModiEntity']) {
+                        if (!ReversePointerRelations['ModiEntity'].includes(moduleName)) {
+                            ReversePointerRelations['ModiEntity'].push(moduleName);
+                        }
                     }
                     else {
-                        (0, lodash_1.assign)(ReversePointerRelations, {
+                        assign(ReversePointerRelations, {
                             ['ModiEntity']: [moduleName],
                         });
                     }
-                    if (ReversePointerRelations['OperEntity'] && !ReversePointerRelations['OperEntity'].includes(moduleName)) {
-                        ReversePointerRelations['OperEntity'].push(moduleName);
+
+                    if (ReversePointerRelations['OperEntity']) {
+                        if (!ReversePointerRelations['OperEntity'].includes(moduleName)) {
+                            ReversePointerRelations['OperEntity'].push(moduleName);
+                        }
                     }
                     else {
-                        (0, lodash_1.assign)(ReversePointerRelations, {
+                        assign(ReversePointerRelations, {
                             ['OperEntity']: [moduleName],
                         });
                     }
-                }
+                } */
             }
             else if (beforeSchema) {
                 // 本地规定的一些形状定义，直接使用
@@ -1526,6 +1534,85 @@ function constructSchema(statements, entity) {
         ...otmAggrMappedNodes,
     ])));
 }
+function _constructOpSchema(statements, entity) {
+    const { schemaAttrs } = Schema[entity];
+    const members = [];
+    const members2 = [];
+    const { [entity]: manyToOneSet } = ManyToOne;
+    const { [entity]: oneToManySet } = OneToMany;
+    const referenceEntities = [];
+    for (const attr of schemaAttrs) {
+        const { type, name, questionToken } = attr;
+        const attrName = name.text;
+        if (ts.isTypeReferenceNode(type)) {
+            const { typeName } = type;
+            if (ts.isIdentifier(typeName)) {
+                const { text } = typeName;
+                const text2 = text === 'Schema' ? entity : text;
+                const manyToOneItem = manyToOneSet && manyToOneSet.find(([refEntity, attrName2]) => refEntity === text2 && attrName2 === attrName);
+                if (manyToOneItem) {
+                    referenceEntities.push(text2);
+                    members2.push(factory.createPropertySignature(undefined, name, questionToken, questionToken ? factory.createUnionTypeNode([
+                        factory.createTypeReferenceNode(createForeignRef(entity, text2, 'Schema')),
+                        factory.createLiteralTypeNode(factory.createNull())
+                    ]) : factory.createTypeReferenceNode(createForeignRef(entity, text2, 'Schema'))));
+                    const foreignKey = `${attrName}Id`;
+                    members.push(factory.createPropertySignature(undefined, factory.createIdentifier(foreignKey), questionToken, questionToken ? factory.createUnionTypeNode([
+                        factory.createTypeReferenceNode(factory.createIdentifier('ForeignKey'), [
+                            factory.createLiteralTypeNode(factory.createStringLiteral((0, string_1.firstLetterLowerCase)(text2)))
+                        ]),
+                        factory.createLiteralTypeNode(factory.createNull())
+                    ]) : factory.createTypeReferenceNode(factory.createIdentifier('ForeignKey'), [
+                        factory.createLiteralTypeNode(factory.createStringLiteral((0, string_1.firstLetterLowerCase)(text2)))
+                    ])));
+                }
+                else {
+                    // assert(types.includes(text), `${entity}中的属性${name.toString()}有非法的属性类型定义`);
+                    // 处理entity这种特殊情况
+                    if (ReversePointerRelations[entity] && attrName === 'entity') {
+                        const entityUnionTypeNode = ReversePointerRelations[entity].map(ele => factory.createLiteralTypeNode(factory.createStringLiteral((0, string_1.firstLetterLowerCase)(ele))));
+                        if (process.env.COMPLING_AS_LIB) {
+                            // 如果是建立 base-domain，还要容纳可能的其它对象引用
+                            entityUnionTypeNode.push(factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword));
+                        }
+                        members.push(factory.createPropertySignature(undefined, name, questionToken, questionToken ? factory.createUnionTypeNode([
+                            factory.createUnionTypeNode(entityUnionTypeNode),
+                            factory.createLiteralTypeNode(factory.createNull())
+                        ]) : factory.createUnionTypeNode(entityUnionTypeNode)));
+                    }
+                    else {
+                        members.push(factory.createPropertySignature(undefined, name, questionToken, questionToken ? factory.createUnionTypeNode([
+                            type,
+                            factory.createLiteralTypeNode(factory.createNull())
+                        ]) : type));
+                    }
+                }
+            }
+            else {
+                (0, assert_1.default)(false); // 这是什么case，不确定
+                members.push(attr);
+            }
+        }
+        else {
+            // assert(ts.isUnionTypeNode(type!) || ts.isLiteralTypeNode(type!), `${entity}有非法的属性类型定义${(<ts.Identifier>name).text}`);
+            members.push(factory.createPropertySignature(undefined, name, questionToken, questionToken ? factory.createUnionTypeNode([
+                type,
+                factory.createLiteralTypeNode(factory.createNull())
+            ]) : type));
+        }
+    }
+    // 在这里把需要直接拷贝过来的语句写入
+    if (SchemaAsts[entity]) {
+        statements.push(...SchemaAsts[entity].statements);
+    }
+    statements.push(factory.createTypeAliasDeclaration([
+        factory.createModifier(ts.SyntaxKind.ExportKeyword)
+    ], factory.createIdentifier('OpSchema'), undefined, factory.createIntersectionTypeNode([
+        factory.createTypeReferenceNode('EntityShape'),
+        factory.createTypeLiteralNode(members),
+        factory.createMappedTypeNode(undefined, factory.createTypeParameterDeclaration(undefined, factory.createIdentifier("A"), factory.createTypeReferenceNode(factory.createIdentifier("ExpressionKey"), undefined), undefined), undefined, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword), undefined),
+    ])), factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("OpAttr"), undefined, factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, factory.createTypeReferenceNode(factory.createIdentifier("OpSchema"), undefined))));
+}
 /**
  * 生成Query
  * @param statements
@@ -1703,6 +1790,137 @@ function constructFilter(statements, entity) {
     }
     statements.push(factory.createTypeAliasDeclaration([factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("Filter"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("MakeFilter"), [factory.createIntersectionTypeNode(types)])));
 }
+function _constructOpFilter(statements, entity) {
+    const { schemaAttrs, fulltextIndex, enumAttributes } = Schema[entity];
+    const members = [
+        // id: Q_StringValue
+        factory.createPropertySignature(undefined, factory.createIdentifier('id'), undefined, factory.createUnionTypeNode([
+            factory.createTypeReferenceNode(factory.createIdentifier('Q_StringValue')),
+            /* factory.createTypeReferenceNode(
+                factory.createQualifiedName(
+                    factory.createIdentifier("SubQuery"),
+                    factory.createIdentifier(`${entity}IdSubQuery`)
+                )
+            ) */
+        ])),
+        // $$createAt$$: Q_DateValue
+        factory.createPropertySignature(undefined, factory.createIdentifier('$$createAt$$'), undefined, factory.createTypeReferenceNode(factory.createIdentifier('Q_DateValue'))),
+        // $$seq$$: Q_StringValue
+        factory.createPropertySignature(undefined, factory.createIdentifier('$$seq$$'), undefined, factory.createTypeReferenceNode(factory.createIdentifier('Q_NumberValue'))),
+        // $$updateAt$$: Q_DateValue
+        factory.createPropertySignature(undefined, factory.createIdentifier('$$updateAt$$'), undefined, factory.createTypeReferenceNode(factory.createIdentifier('Q_DateValue')))
+    ];
+    const entityUnionTypeNodes = ReversePointerRelations[entity] && ReversePointerRelations[entity].map(ele => factory.createLiteralTypeNode(factory.createStringLiteral((0, string_1.firstLetterLowerCase)(ele))));
+    if (process.env.COMPLING_AS_LIB) {
+        entityUnionTypeNodes && entityUnionTypeNodes.push(factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword));
+    }
+    const { [entity]: manyToOneSet } = ManyToOne;
+    for (const attr of schemaAttrs) {
+        const { type, name } = attr;
+        const attrName = name.text;
+        if (ts.isTypeReferenceNode(type)) {
+            const { typeName } = type;
+            if (ts.isIdentifier(typeName)) {
+                const { text } = typeName;
+                let type2;
+                switch (text) {
+                    case 'String':
+                    case 'Text':
+                    case 'Image':
+                    case 'File': {
+                        if (ReversePointerRelations[entity] && attrName === 'entity') {
+                            type2 = factory.createTypeReferenceNode(factory.createIdentifier('Q_EnumValue'), [
+                                factory.createUnionTypeNode(entityUnionTypeNodes)
+                            ]);
+                        }
+                        else {
+                            type2 = factory.createTypeReferenceNode(factory.createIdentifier('Q_StringValue'));
+                        }
+                        break;
+                    }
+                    case 'Int':
+                    case 'Uint':
+                    case 'Float':
+                    case 'Double':
+                    case 'Price':
+                    case 'Decimal': {
+                        type2 = factory.createTypeReferenceNode(factory.createIdentifier('Q_NumberValue'));
+                        break;
+                    }
+                    case 'Boolean': {
+                        type2 = factory.createTypeReferenceNode(factory.createIdentifier('Q_BooleanValue'));
+                        break;
+                    }
+                    case 'Datetime': {
+                        type2 = factory.createTypeReferenceNode(factory.createIdentifier('Q_DateValue'));
+                        break;
+                    }
+                    case 'SingleGeo':
+                    case 'Geo': {
+                        // geo类型暂时只支持通过expr查询
+                        break;
+                    }
+                    case 'Object': {
+                        type2 = factory.createTypeReferenceNode(factory.createIdentifier('Object'));
+                        break;
+                    }
+                    default: {
+                        const text2 = text === 'Schema' ? entity : text;
+                        const manyToOneItem = manyToOneSet && manyToOneSet.find(([refEntity]) => refEntity === text2);
+                        if (manyToOneItem) {
+                            // 外键可能落到相应的子查询中
+                            members.push(factory.createPropertySignature(undefined, `${name.text}Id`, undefined, factory.createTypeReferenceNode(factory.createIdentifier('Q_StringValue'))));
+                        }
+                        else if (enumAttributes && enumAttributes[attrName] || ts.isUnionTypeNode(type)) {
+                            // 这里应该都是引用某个UnionType类型的定义了，如何判断？
+                            // const words = getStringTextFromUnionStringLiterals();
+                            type2 = factory.createTypeReferenceNode(factory.createIdentifier('Q_EnumValue'), [
+                                factory.createTypeReferenceNode(factory.createIdentifier(text), undefined)
+                            ]);
+                        }
+                        else {
+                            // 非枚举类型的非结构化属性，用JSONFilter来形式化
+                            type2 = factory.createTypeReferenceNode(factory.createIdentifier('JsonFilter'), [
+                                factory.createTypeReferenceNode(factory.createIdentifier(text), undefined)
+                            ]);
+                        }
+                    }
+                }
+                if (type2) {
+                    members.push(factory.createPropertySignature(undefined, name, undefined, type2));
+                }
+            }
+        }
+        else if (ts.isUnionTypeNode(type) && ts.isLiteralTypeNode(type.types[0]) || ts.isLiteralTypeNode(type)) {
+            members.push(factory.createPropertySignature(undefined, name, undefined, factory.createTypeReferenceNode(factory.createIdentifier('Q_EnumValue'), [
+                type
+            ])));
+        }
+        else {
+            // 此时应当是引用本地定义的shape
+            (0, assert_1.default)(type, `${entity}中的属性${name.toString()}有非法的属性类型定义`);
+            members.push(factory.createPropertySignature(undefined, name, undefined, factory.createTypeReferenceNode(factory.createIdentifier('JsonFilter'), [
+                type
+            ])));
+        }
+    }
+    const types = [
+        factory.createTypeLiteralNode(members),
+        factory.createTypeReferenceNode(factory.createIdentifier("ExprOp"), [
+            process.env.COMPLING_AS_LIB ?
+                factory.createUnionTypeNode([
+                    factory.createTypeReferenceNode(factory.createIdentifier('OpAttr')),
+                    factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+                ]) :
+                factory.createTypeReferenceNode(factory.createIdentifier('OpAttr'))
+        ]),
+    ];
+    // 如果还有其它类型的查询如全文，则加在types数组中
+    if (fulltextIndex) {
+        types.push(factory.createTypeReferenceNode('FulltextFilter'));
+    }
+    statements.push(factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("OpFilter"), undefined, factory.createIntersectionTypeNode(types)));
+}
 /**
  * 构造Projection和OneAttrProjection
  * @param statements
@@ -1931,52 +2149,159 @@ function constructProjection(statements, entity) {
         ])));
     }
 }
-/**
- * 构造Query
- * @param statements
- * @param entity
- */
-function constructQuery(statements, entity) {
-    const entityLc = (0, string_1.firstLetterLowerCase)(entity);
-    /* statements.push(
-        factory.createTypeAliasDeclaration(
-            undefined,
-            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-            factory.createIdentifier("Query"),
-            undefined,
-            factory.createIntersectionTypeNode([
-                factory.createTypeLiteralNode([
-                    // 这里可以不写entity了
-                    factory.createPropertySignature(
-                        undefined,
-                        factory.createIdentifier("projection"),
-                        undefined,
-                        factory.createTypeReferenceNode(
-                            factory.createIdentifier("Projection"),
-                            undefined
-                        )
-                    ),
-                    factory.createPropertySignature(
-                        undefined,
-                        factory.createIdentifier("sort"),
-                        factory.createToken(ts.SyntaxKind.QuestionToken),
-                        factory.createTypeReferenceNode(
-                            factory.createIdentifier("Sorter"),
-                            undefined
-                        )
-                    )
-                ]),
-                factory.createTypeReferenceNode(
-                    factory.createIdentifier("OakFilter"),
-                    [
-                        factory.createLiteralTypeNode(factory.createStringLiteral("select")),
-                        factory.createTypeReferenceNode(
-                            factory.createIdentifier("Filter"),
-                            undefined
-                        )
-                    ]
-                ),
-                factory.createTypeReferenceNode(
+function _constructOpProjection(statements, entity) {
+    const { schemaAttrs, enumAttributes } = Schema[entity];
+    const properties = [
+        ['id', false],
+        ['$$createAt$$', false],
+        ['$$updateAt$$', false],
+        ['$$seq$$', false],
+    ];
+    const { [entity]: manyToOneSet } = ManyToOne;
+    for (const attr of schemaAttrs) {
+        const { type, name } = attr;
+        const attrName = name.text;
+        if (ts.isTypeReferenceNode(type)) {
+            const { typeName } = type;
+            if (ts.isIdentifier(typeName)) {
+                const { text } = typeName;
+                switch (text) {
+                    case 'String':
+                    case 'Text':
+                    case 'Int':
+                    case 'Uint':
+                    case 'Float':
+                    case 'Double':
+                    case 'Boolean':
+                    case 'Datetime':
+                    case 'Image':
+                    case 'File':
+                    case 'SingleGeo':
+                    case 'Geo':
+                    case 'Price':
+                    case 'Decimal': {
+                        properties.push([name, false]);
+                        break;
+                    }
+                    case 'Object': {
+                        properties.push([name, false, factory.createUnionTypeNode([
+                                factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+                                factory.createTypeReferenceNode(factory.createIdentifier("Object"), undefined)
+                            ])]);
+                        break;
+                    }
+                    default: {
+                        const text2 = text === 'Schema' ? entity : text;
+                        const manyToOneItem = manyToOneSet && manyToOneSet.find(([refEntity]) => refEntity === text2);
+                        if (manyToOneItem) {
+                            // 外键投影
+                            properties.push([`${attrName}Id`, false, undefined]);
+                        }
+                        else {
+                            if (!enumAttributes || !enumAttributes[attrName]) {
+                                // 引用的非enum类型shape
+                                properties.push([name, false, factory.createUnionTypeNode([
+                                        factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+                                        factory.createTypeReferenceNode(factory.createIdentifier("JsonProjection"), [type])
+                                    ])]);
+                            }
+                            else {
+                                // 引用的enum类型shape
+                                properties.push([name, false, undefined]);
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                (0, assert_1.default)(false);
+            }
+        }
+        else {
+            // 增加了本身object的shape定义
+            // assert(ts.isUnionTypeNode(type!) && ts.isLiteralTypeNode(type.types[0]) || ts.isLiteralTypeNode(type!));
+            if (enumAttributes && enumAttributes[attrName] || ts.isUnionTypeNode(type) && ts.isLiteralTypeNode(type.types[0])) {
+                properties.push([name, false, undefined]);
+            }
+            else {
+                // 如果是非枚举类型的其它对象的union定义，加上JsonProjection
+                properties.push([name, false, factory.createUnionTypeNode([
+                        factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+                        factory.createTypeReferenceNode(factory.createIdentifier("JsonProjection"), [type])
+                    ])]);
+            }
+        }
+    }
+    const exprNode = factory.createTypeReferenceNode(factory.createIdentifier("Partial"), [
+        factory.createTypeReferenceNode(factory.createIdentifier("ExprOp"), [
+            process.env.COMPLING_AS_LIB ?
+                factory.createUnionTypeNode([
+                    factory.createTypeReferenceNode(factory.createIdentifier('OpAttr')),
+                    factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+                ]) :
+                factory.createTypeReferenceNode(factory.createIdentifier('OpAttr'))
+        ])
+    ]);
+    const MetaPropertySignatures = [
+        factory.createPropertySignature(undefined, factory.createStringLiteral("#id"), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode('NodeId'))
+    ];
+    if (process.env.COMPLING_AS_LIB) {
+        MetaPropertySignatures.push(factory.createIndexSignature(undefined, [factory.createParameterDeclaration(undefined, undefined, factory.createIdentifier("k"), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), undefined)], factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)));
+    }
+    // OpProjection，原始属性投影
+    statements.push(factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("OpProjection"), undefined, factory.createIntersectionTypeNode([
+        factory.createTypeLiteralNode(MetaPropertySignatures.concat(properties.map(([n, q, v]) => {
+            return factory.createPropertySignature(undefined, n, q ? undefined : factory.createToken(ts.SyntaxKind.QuestionToken), v || factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword));
+        }))),
+        exprNode,
+    ])));
+}
+/**
+ * 构造Query
+ * @param statements
+ * @param entity
+ */
+function constructQuery(statements, entity) {
+    const entityLc = (0, string_1.firstLetterLowerCase)(entity);
+    /* statements.push(
+        factory.createTypeAliasDeclaration(
+            undefined,
+            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+            factory.createIdentifier("Query"),
+            undefined,
+            factory.createIntersectionTypeNode([
+                factory.createTypeLiteralNode([
+                    // 这里可以不写entity了
+                    factory.createPropertySignature(
+                        undefined,
+                        factory.createIdentifier("projection"),
+                        undefined,
+                        factory.createTypeReferenceNode(
+                            factory.createIdentifier("Projection"),
+                            undefined
+                        )
+                    ),
+                    factory.createPropertySignature(
+                        undefined,
+                        factory.createIdentifier("sort"),
+                        factory.createToken(ts.SyntaxKind.QuestionToken),
+                        factory.createTypeReferenceNode(
+                            factory.createIdentifier("Sorter"),
+                            undefined
+                        )
+                    )
+                ]),
+                factory.createTypeReferenceNode(
+                    factory.createIdentifier("OakFilter"),
+                    [
+                        factory.createLiteralTypeNode(factory.createStringLiteral("select")),
+                        factory.createTypeReferenceNode(
+                            factory.createIdentifier("Filter"),
+                            undefined
+                        )
+                    ]
+                ),
+                factory.createTypeReferenceNode(
                     factory.createIdentifier("OakOperation"),
                     [
                         factory.createTypeReferenceNode(
@@ -2169,72 +2494,80 @@ function constructSorter(statements, entity) {
      */
     statements.push(factory.createTypeAliasDeclaration([factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("Sorter"), undefined, factory.createArrayTypeNode(factory.createTypeReferenceNode(factory.createIdentifier("SortNode"), undefined))));
 }
-function constructFullAttrs(statements, entity) {
+function _constructOpSortAttr(statements, entity) {
+    const { schemaAttrs } = Schema[entity];
+    const members = [
+        // id: 1
+        factory.createPropertySignature(undefined, factory.createIdentifier("id"), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)),
+        // $$createAt$$: 1
+        factory.createPropertySignature(undefined, factory.createIdentifier("$$createAt$$"), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)),
+        // $$seq$$: 1
+        factory.createPropertySignature(undefined, factory.createIdentifier("$$seq$$"), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)),
+        // $$updateAt$$: 1
+        factory.createPropertySignature(undefined, factory.createIdentifier("$$updateAt$$"), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)),
+    ];
     const { [entity]: manyToOneSet } = ManyToOne;
-    const { [entity]: oneToManySet } = OneToMany;
-    if (manyToOneSet && manyToOneSet.length) {
-        const mtoAttrs = [];
-        for (const item of manyToOneSet) {
-            const [one, key] = item;
-            if (one === entity) {
-                // 递归引用自身，因为typescript本身不支持递归，因此这里做一个显式的三层递归应该够用了
-                mtoAttrs.push(factory.createTemplateLiteralType(factory.createTemplateHead(`${key}.`, `${key}.`), [factory.createTemplateLiteralTypeSpan(factory.createTypeReferenceNode(factory.createIdentifier("OpAttr"), undefined), factory.createTemplateTail("", ""))]), factory.createTemplateLiteralType(factory.createTemplateHead(`${key}.${key}.`, `${key}.${key}.`), [factory.createTemplateLiteralTypeSpan(factory.createTypeReferenceNode(factory.createIdentifier("OpAttr"), undefined), factory.createTemplateTail("", ""))]), factory.createTemplateLiteralType(factory.createTemplateHead(`${key}.${key}.${key}.`, `${key}.${key}.${key}.`), [factory.createTemplateLiteralTypeSpan(factory.createTypeReferenceNode(factory.createIdentifier("OpAttr"), undefined), factory.createTemplateTail("", ""))]));
-            }
-            else {
-                mtoAttrs.push(factory.createTemplateLiteralType(factory.createTemplateHead(`${key}.`, `${key}.`), [factory.createTemplateLiteralTypeSpan(factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(one), factory.createIdentifier("NativeAttr")), undefined), factory.createTemplateTail("", ""))
-                ]));
+    for (const attr of schemaAttrs) {
+        const { type, name, questionToken } = attr;
+        if (ts.isTypeReferenceNode(type)) {
+            const { typeName } = type;
+            if (ts.isIdentifier(typeName)) {
+                const { text } = typeName;
+                let type2;
+                switch (text) {
+                    case 'String':
+                    case 'Text':
+                    case 'Int':
+                    case 'Float':
+                    case 'Double':
+                    case 'Boolean':
+                    case 'Datetime':
+                    case 'Image':
+                    case 'File':
+                    case 'Price': {
+                        type2 = factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
+                        break;
+                    }
+                    default: {
+                        const text2 = text === 'Schema' ? entity : text;
+                        const manyToOneItem = manyToOneSet && manyToOneSet.find(([refEntity]) => refEntity === text2);
+                        if (manyToOneItem) {
+                            factory.createPropertySignature(undefined, factory.createIdentifier(`${name.text}Id`), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword));
+                        }
+                        else if (!['Object'].includes(text)) {
+                            // todo 对State的专门处理
+                            type2 = factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
+                        }
+                    }
+                }
+                if (type2) {
+                    members.push(factory.createPropertySignature(undefined, name, undefined, type2));
+                }
             }
         }
-        statements.push(factory.createTypeAliasDeclaration([factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("NativeAttr"), undefined, factory.createUnionTypeNode([
-            factory.createTypeReferenceNode(factory.createIdentifier("OpAttr"), undefined),
-            ...mtoAttrs
-        ])));
-    }
-    else {
-        statements.push(factory.createTypeAliasDeclaration([factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("NativeAttr"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("OpAttr"), undefined)));
-    }
-    const foreignKeySet = {};
-    if (oneToManySet && oneToManySet.length > 0) {
-        for (const oneToManyItem of oneToManySet) {
-            const [entityName, foreignKey] = oneToManyItem;
-            if (foreignKeySet.hasOwnProperty(entityName)) {
-                foreignKeySet[entityName].push(foreignKey);
-            }
-            else {
-                foreignKeySet[entityName] = [foreignKey];
-            }
+        else if (ts.isUnionTypeNode(type) && ts.isLiteralTypeNode(type.types[0]) || ts.isLiteralTypeNode(type)) {
+            members.push(factory.createPropertySignature(undefined, name, undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)));
         }
-        const otmAttrs = [];
-        for (const entityName in foreignKeySet) {
-            const entityNameLc = (0, string_1.firstLetterLowerCase)(entityName);
-            if (foreignKeySet[entityName].length > 1) {
-                foreignKeySet[entityName].forEach((foreignKey) => {
-                    const head = `${entityNameLc}s$${foreignKey}`;
-                    otmAttrs.push(factory.createTemplateLiteralType(factory.createTemplateHead(`${head}$`, `${head}$`), [
-                        factory.createTemplateLiteralTypeSpan(factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword), factory.createTemplateMiddle(".", ".")),
-                        factory.createTemplateLiteralTypeSpan(factory.createTypeReferenceNode(entityName === entity
-                            ? factory.createIdentifier("NativeAttr")
-                            : factory.createQualifiedName(factory.createIdentifier(entityName), factory.createIdentifier("NativeAttr")), undefined), factory.createTemplateTail("", ""))
-                    ]));
-                });
-            }
-            else {
-                otmAttrs.push(factory.createTemplateLiteralType(factory.createTemplateHead(`${entityNameLc}s$`, `${entityNameLc}s$`), [
-                    factory.createTemplateLiteralTypeSpan(factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword), factory.createTemplateMiddle(".", ".")),
-                    factory.createTemplateLiteralTypeSpan(factory.createTypeReferenceNode(entityName === entity
-                        ? factory.createIdentifier("NativeAttr")
-                        : factory.createQualifiedName(factory.createIdentifier(entityName), factory.createIdentifier("NativeAttr")), undefined), factory.createTemplateTail("", ""))
-                ]));
-            }
+        else {
+            // 本地规定的shape，非结构化属性不参与排序
         }
-        statements.push(factory.createTypeAliasDeclaration([factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("FullAttr"), undefined, factory.createUnionTypeNode([
-            factory.createTypeReferenceNode(factory.createIdentifier("NativeAttr"), undefined),
-            ...otmAttrs
-        ])));
     }
-    else {
-        statements.push(factory.createTypeAliasDeclaration([factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("FullAttr"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("NativeAttr"), undefined)));
+    if (process.env.COMPLING_AS_LIB) {
+        members.push(factory.createIndexSignature(undefined, [factory.createParameterDeclaration(undefined, undefined, factory.createIdentifier("k"), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), undefined)], factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)));
     }
+    statements.push(factory.createTypeAliasDeclaration([factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("OpSortAttr"), undefined, factory.createTypeReferenceNode('Partial', [
+        factory.createUnionTypeNode([
+            factory.createTypeLiteralNode(members),
+            factory.createTypeReferenceNode(factory.createIdentifier("ExprOp"), [
+                process.env.COMPLING_AS_LIB ?
+                    factory.createUnionTypeNode([
+                        factory.createTypeReferenceNode(factory.createIdentifier('OpAttr')),
+                        factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+                    ]) :
+                    factory.createTypeReferenceNode(factory.createIdentifier('OpAttr'))
+            ])
+        ])
+    ])));
 }
 function constructOperations(statements, entity) {
     // Selection
@@ -3020,13 +3353,13 @@ function constructOperations(statements, entity) {
         factory.createTypeReferenceNode(factory.createIdentifier("RemoveOperation"), undefined)
     ])));
 }
-const initialStatements = () => [
+const initialStatements = (level) => [
     // import { String, Text, Int, SpecificKey } from 'oak-domain/types/DataType';
     factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
         factory.createImportSpecifier(false, undefined, factory.createIdentifier('PrimaryKey')),
         factory.createImportSpecifier(false, undefined, factory.createIdentifier('ForeignKey')),
         factory.createImportSpecifier(false, undefined, factory.createIdentifier('JsonProjection'))
-    ])), factory.createStringLiteral(`${(0, env_1.TYPE_PATH_IN_OAK_DOMAIN)()}DataType`)),
+    ])), factory.createStringLiteral(`${(0, env_1.TYPE_PATH_IN_OAK_DOMAIN)(level)}DataType`)),
     /* import {
         Q_DateValue, Q_LogicKey, Q_NumberValue, FnCallKey, FnCallValue,
         Q_StringValue, Q_FullTextKey, Q_FullTextValue, FnCallValueAs,
@@ -3045,11 +3378,11 @@ const initialStatements = () => [
         factory.createImportSpecifier(false, undefined, factory.createIdentifier('ExpressionKey')),
         factory.createImportSpecifier(false, undefined, factory.createIdentifier('JsonFilter')),
         factory.createImportSpecifier(false, undefined, factory.createIdentifier('SubQueryPredicateMetadata')),
-    ])), factory.createStringLiteral(`${(0, env_1.TYPE_PATH_IN_OAK_DOMAIN)()}Demand`)),
+    ])), factory.createStringLiteral(`${(0, env_1.TYPE_PATH_IN_OAK_DOMAIN)(level)}Demand`)),
     factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
         factory.createImportSpecifier(false, undefined, factory.createIdentifier("OneOf")),
         factory.createImportSpecifier(false, undefined, factory.createIdentifier("ValueOf"))
-    ])), factory.createStringLiteral(`${(0, env_1.TYPE_PATH_IN_OAK_DOMAIN)()}Polyfill`)),
+    ])), factory.createStringLiteral(`${(0, env_1.TYPE_PATH_IN_OAK_DOMAIN)(level)}Polyfill`)),
     // import * as SubQuery from '../_SubQuery';
     /* factory.createImportDeclaration(
         undefined,
@@ -3071,8 +3404,67 @@ const initialStatements = () => [
         factory.createImportSpecifier(false, factory.createIdentifier("MakeAction"), factory.createIdentifier("OakMakeAction")),
         factory.createImportSpecifier(false, undefined, factory.createIdentifier("AggregationResult")),
         factory.createImportSpecifier(false, undefined, factory.createIdentifier("EntityShape")),
+    ])), factory.createStringLiteral(`${(0, env_1.TYPE_PATH_IN_OAK_DOMAIN)(level)}Entity`), undefined)
+];
+const initialStatements2 = () => [
+    // import { String, Text, Int, SpecificKey } from 'oak-domain/types/DataType';
+    factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('PrimaryKey')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('ForeignKey')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('JsonProjection'))
+    ])), factory.createStringLiteral(`${(0, env_1.TYPE_PATH_IN_OAK_DOMAIN)()}DataType`)),
+    /* import {
+        Q_DateValue, Q_LogicKey, Q_NumberValue, FnCallKey, FnCallValue,
+        Q_StringValue, Q_FullTextKey, Q_FullTextValue, FnCallValueAs,
+        Q_BooleanValue,
+    } from 'oak-domain/types/Demand'; */
+    factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('Q_DateValue')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('Q_BooleanValue')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('Q_NumberValue')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('Q_StringValue')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('Q_EnumValue')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('NodeId')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('MakeFilter')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('FulltextFilter')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('ExprOp')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('ExpressionKey')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('JsonFilter')),
+    ])), factory.createStringLiteral(`${(0, env_1.TYPE_PATH_IN_OAK_DOMAIN)()}Demand`)),
+    factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
+        factory.createImportSpecifier(false, factory.createIdentifier("MakeAction"), factory.createIdentifier("OakMakeAction")),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier("EntityShape")),
     ])), factory.createStringLiteral(`${(0, env_1.TYPE_PATH_IN_OAK_DOMAIN)()}Entity`), undefined)
 ];
+const initialStatements3 = (level) => [
+    // import { String, Text, Int, SpecificKey } from 'oak-domain/types/DataType';
+    factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('PrimaryKey')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('ForeignKey')),
+    ])), factory.createStringLiteral(`${(0, env_1.TYPE_PATH_IN_OAK_DOMAIN)(level)}DataType`)),
+    /* import {
+        Q_DateValue, Q_LogicKey, Q_NumberValue, FnCallKey, FnCallValue,
+        Q_StringValue, Q_FullTextKey, Q_FullTextValue, FnCallValueAs,
+        Q_BooleanValue,
+    } from 'oak-domain/types/Demand'; */
+    factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('NodeId')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('MakeFilter')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('FulltextFilter')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('ExprOp')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('ExpressionKey')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('JsonFilter')),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier('SubQueryPredicateMetadata')),
+    ])), factory.createStringLiteral(`${(0, env_1.TYPE_PATH_IN_OAK_DOMAIN)(level)}Demand`)),
+    factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier("FormCreateData")),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier("FormUpdateData")),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier("DeduceAggregation")),
+        factory.createImportSpecifier(false, factory.createIdentifier("Operation"), factory.createIdentifier("OakOperation")),
+        factory.createImportSpecifier(false, factory.createIdentifier("Selection"), factory.createIdentifier("OakSelection")),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier("AggregationResult")),
+    ])), factory.createStringLiteral(`${(0, env_1.TYPE_PATH_IN_OAK_DOMAIN)(level)}Entity`), undefined)
+];
 function outputSubQuery(outputDir, printer) {
     const statements = [];
     if (process.env.COMPLING_AS_LIB) {
@@ -3128,15 +3520,145 @@ function outputEntityDict(outputDir, printer) {
     else {
         statements.push(factory.createTypeAliasDeclaration([factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("EntityDict"), undefined, factory.createTypeLiteralNode(propertySignatures)));
     }
-    const resultFile = ts.createSourceFile("someFileName.ts", "", ts.ScriptTarget.Latest, /*setParentNodes*/ false, ts.ScriptKind.TS);
-    const result = printer.printNode(ts.EmitHint.Unspecified, factory.createSourceFile(statements, factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None), resultFile);
-    const fileName = path_1.default.join(outputDir, 'EntityDict.ts');
-    (0, fs_1.writeFileSync)(fileName, result, { flag: 'w' });
+    const resultFile = ts.createSourceFile("someFileName.ts", "", ts.ScriptTarget.Latest, /*setParentNodes*/ false, ts.ScriptKind.TS);
+    const result = printer.printNode(ts.EmitHint.Unspecified, factory.createSourceFile(statements, factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None), resultFile);
+    const fileName = path_1.default.join(outputDir, 'EntityDict.ts');
+    (0, fs_1.writeFileSync)(fileName, result, { flag: 'w' });
+}
+function outputSchema(outputDir, printer) {
+    for (const entity in Schema) {
+        const { importAttrFrom } = Schema[entity];
+        const statements = initialStatements();
+        if (ActionAsts[entity]) {
+            const { importStateFrom } = ActionAsts[entity];
+            const fromLocalActionSpecifiers = ['Action', 'ParticularAction'];
+            const fromExtenalStates = {};
+            for (const state in importStateFrom) {
+                (0, assert_1.default)(state.endsWith('State'), `${state} should end with State`);
+                if (importStateFrom[state][0] === './') {
+                    // 本地定义的State从 ./Action 中获取
+                    fromLocalActionSpecifiers.push(state);
+                }
+                else {
+                    // 否则从原来的import specifiers当中获取
+                    // todo 在additionalImports中如果有则去重
+                    const [from, propertyName] = importStateFrom[state];
+                    if (fromExtenalStates[from]) {
+                        fromExtenalStates[from].push([state, propertyName]);
+                    }
+                    else {
+                        fromExtenalStates[from] = [[state, propertyName]];
+                    }
+                }
+            }
+            statements.push(factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports(fromLocalActionSpecifiers.map(ele => factory.createImportSpecifier(false, undefined, factory.createIdentifier(ele))))), factory.createStringLiteral('./Action'), undefined), factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
+                factory.createImportSpecifier(false, undefined, factory.createIdentifier("RelationAction")),
+            ])), factory.createStringLiteral((0, env_1.ACTION_CONSTANT_IN_OAK_DOMAIN)()), undefined));
+            for (const external in fromExtenalStates) {
+                statements.push(factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports(fromExtenalStates[external].map(ele => factory.createImportSpecifier(false, ele[1] === undefined ? undefined : factory.createIdentifier(ele[1]), factory.createIdentifier(ele[0]))))), factory.createStringLiteral(external), undefined));
+            }
+        }
+        else {
+            statements.push(factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
+                factory.createImportSpecifier(false, undefined, factory.createIdentifier("GenericAction")),
+                factory.createImportSpecifier(false, undefined, factory.createIdentifier("AppendOnlyAction")),
+                factory.createImportSpecifier(false, undefined, factory.createIdentifier("ReadOnlyAction")),
+                factory.createImportSpecifier(false, undefined, factory.createIdentifier("ExcludeUpdateAction")),
+                factory.createImportSpecifier(false, undefined, factory.createIdentifier("ExcludeRemoveAction")),
+                factory.createImportSpecifier(false, undefined, factory.createIdentifier("RelationAction")),
+            ])), factory.createStringLiteral((0, env_1.ACTION_CONSTANT_IN_OAK_DOMAIN)()), undefined));
+        }
+        // 从外部引入的属性
+        const fromExternalImportAttrs = {};
+        for (const attr in importAttrFrom) {
+            const [from, propertyName] = importAttrFrom[attr];
+            if (fromExternalImportAttrs[from]) {
+                fromExternalImportAttrs[from].push([attr, propertyName]);
+            }
+            else {
+                fromExternalImportAttrs[from] = [[attr, propertyName]];
+            }
+        }
+        for (const external in fromExternalImportAttrs) {
+            statements.push(factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports(fromExternalImportAttrs[external].map(ele => factory.createImportSpecifier(false, ele[1] === undefined ? undefined : factory.createIdentifier(ele[1]), factory.createIdentifier(ele[0]))))), factory.createStringLiteral(external), undefined));
+        }
+        // Relation定义加入
+        /* if (typeof Schema[entity].hasRelationDef === 'object' && ts.isTypeAliasDeclaration(Schema[entity].hasRelationDef as ts.Node)) {
+            const node = Schema[entity].hasRelationDef as ts.TypeAliasDeclaration;
+            statements.push(
+                factory.updateTypeAliasDeclaration(
+                    node,
+                    undefined,
+                    [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+                    node.name,
+                    node.typeParameters,
+                    node.type
+                )
+            );
+        } */
+        constructSchema(statements, entity);
+        constructFilter(statements, entity);
+        constructProjection(statements, entity);
+        constructSorter(statements, entity);
+        constructOperations(statements, entity);
+        constructQuery(statements, entity);
+        // 现在FullAttrs和NativeAttrs似乎没什么用，还会引起递归
+        // constructFullAttrs(statements, entity);
+        const makeActionArguments = [];
+        if (ActionAsts[entity]) {
+            makeActionArguments.push(factory.createTypeReferenceNode('Action'));
+        }
+        else {
+            makeActionArguments.push(factory.createTypeReferenceNode(OriginActionDict[Schema[entity].actionType]));
+        }
+        if (Schema[entity].relations || entity === 'User') {
+            makeActionArguments.push(factory.createTypeReferenceNode('RelationAction'));
+        }
+        const actionTypeNode = factory.createTypeReferenceNode(factory.createIdentifier('OakMakeAction'), makeActionArguments.length === 1 ? makeActionArguments : [factory.createUnionTypeNode(makeActionArguments)]);
+        const EntityDefAttrs = [
+            factory.createPropertySignature(undefined, factory.createIdentifier("Schema"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("Schema"), undefined)),
+            factory.createPropertySignature(undefined, factory.createIdentifier("OpSchema"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("OpSchema"), undefined)),
+            factory.createPropertySignature(undefined, factory.createIdentifier("Action"), undefined, process.env.COMPLING_AS_LIB ?
+                factory.createUnionTypeNode([
+                    actionTypeNode,
+                    factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+                ]) : actionTypeNode),
+            factory.createPropertySignature(undefined, factory.createIdentifier("Selection"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("Selection"), undefined)),
+            factory.createPropertySignature(undefined, factory.createIdentifier("Aggregation"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("Aggregation"), undefined)),
+            factory.createPropertySignature(undefined, factory.createIdentifier("Operation"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("Operation"), undefined)),
+            factory.createPropertySignature(undefined, factory.createIdentifier("Create"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("CreateOperation"), undefined)),
+            factory.createPropertySignature(undefined, factory.createIdentifier("Update"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("UpdateOperation"), undefined)),
+            factory.createPropertySignature(undefined, factory.createIdentifier("Remove"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("RemoveOperation"), undefined)),
+            factory.createPropertySignature(undefined, factory.createIdentifier("CreateSingle"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("CreateSingleOperation"), undefined)),
+            factory.createPropertySignature(undefined, factory.createIdentifier("CreateMulti"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("CreateMultipleOperation"), undefined)),
+        ];
+        if (ActionAsts[entity]) {
+            EntityDefAttrs.push(factory.createPropertySignature(undefined, factory.createIdentifier("ParticularAction"), undefined, factory.createTypeReferenceNode(factory.createIdentifier('ParticularAction'), undefined)));
+        }
+        /* if (typeof Schema[entity].hasRelationDef === 'object' && ts.isTypeAliasDeclaration(Schema[entity].hasRelationDef as ts.Node)) {
+            EntityDefAttrs.push(
+                factory.createPropertySignature(
+                    undefined,
+                    factory.createIdentifier("Relation"),
+                    undefined,
+                    factory.createTypeReferenceNode(
+                        factory.createIdentifier('Relation'),
+                        undefined
+                    )
+                )
+            );
+        } */
+        statements.push(factory.createTypeAliasDeclaration([factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("EntityDef"), undefined, factory.createTypeLiteralNode(EntityDefAttrs)));
+        // 现在支持Schema extends，其继承的对象解析来自另一个文件，故不能再用原sourceFile来生成，否则printer会用sourceFile中的originText去取stringLiteral
+        const result = printer.printList(ts.ListFormat.SourceFileStatements, factory.createNodeArray(statements), undefined);
+        const fileName = path_1.default.join(outputDir, entity, 'Schema.ts');
+        (0, fs_1.writeFileSync)(fileName, result, { flag: 'w' });
+    }
 }
-function outputSchema(outputDir, printer) {
+function _outputBaseSchema(outputDir, printer) {
     for (const entity in Schema) {
         const { importAttrFrom } = Schema[entity];
-        const statements = initialStatements();
+        const statements = initialStatements2();
         if (ActionAsts[entity]) {
             const { importStateFrom } = ActionAsts[entity];
             const fromLocalActionSpecifiers = ['Action', 'ParticularAction'];
@@ -3190,31 +3712,15 @@ function outputSchema(outputDir, printer) {
         for (const external in fromExternalImportAttrs) {
             statements.push(factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports(fromExternalImportAttrs[external].map(ele => factory.createImportSpecifier(false, ele[1] === undefined ? undefined : factory.createIdentifier(ele[1]), factory.createIdentifier(ele[0]))))), factory.createStringLiteral(external), undefined));
         }
-        // Relation定义加入
-        /* if (typeof Schema[entity].hasRelationDef === 'object' && ts.isTypeAliasDeclaration(Schema[entity].hasRelationDef as ts.Node)) {
-            const node = Schema[entity].hasRelationDef as ts.TypeAliasDeclaration;
-            statements.push(
-                factory.updateTypeAliasDeclaration(
-                    node,
-                    undefined,
-                    [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-                    node.name,
-                    node.typeParameters,
-                    node.type
-                )
-            );
-        } */
-        constructSchema(statements, entity);
-        constructFilter(statements, entity);
-        constructProjection(statements, entity);
-        constructSorter(statements, entity);
-        constructOperations(statements, entity);
-        constructQuery(statements, entity);
-        // 现在FullAttrs和NativeAttrs似乎没什么用，还会引起递归
-        // constructFullAttrs(statements, entity);
+        _constructOpSchema(statements, entity);
+        _constructOpFilter(statements, entity);
+        _constructOpProjection(statements, entity);
+        _constructOpSortAttr(statements, entity);
         const makeActionArguments = [];
+        const makeUpdateActionArguments = [factory.createLiteralTypeNode(factory.createStringLiteral('update'))];
         if (ActionAsts[entity]) {
             makeActionArguments.push(factory.createTypeReferenceNode('Action'));
+            makeUpdateActionArguments.push(factory.createTypeReferenceNode('ParticularAction'));
         }
         else {
             makeActionArguments.push(factory.createTypeReferenceNode(OriginActionDict[Schema[entity].actionType]));
@@ -3222,44 +3728,14 @@ function outputSchema(outputDir, printer) {
         if (Schema[entity].relations || entity === 'User') {
             makeActionArguments.push(factory.createTypeReferenceNode('RelationAction'));
         }
-        const actionTypeNode = factory.createTypeReferenceNode(factory.createIdentifier('OakMakeAction'), makeActionArguments.length === 1 ? makeActionArguments : [factory.createUnionTypeNode(makeActionArguments)]);
-        const EntityDefAttrs = [
-            factory.createPropertySignature(undefined, factory.createIdentifier("Schema"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("Schema"), undefined)),
-            factory.createPropertySignature(undefined, factory.createIdentifier("OpSchema"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("OpSchema"), undefined)),
-            factory.createPropertySignature(undefined, factory.createIdentifier("Action"), undefined, process.env.COMPLING_AS_LIB ?
-                factory.createUnionTypeNode([
-                    actionTypeNode,
-                    factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
-                ]) : actionTypeNode),
-            factory.createPropertySignature(undefined, factory.createIdentifier("Selection"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("Selection"), undefined)),
-            factory.createPropertySignature(undefined, factory.createIdentifier("Aggregation"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("Aggregation"), undefined)),
-            factory.createPropertySignature(undefined, factory.createIdentifier("Operation"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("Operation"), undefined)),
-            factory.createPropertySignature(undefined, factory.createIdentifier("Create"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("CreateOperation"), undefined)),
-            factory.createPropertySignature(undefined, factory.createIdentifier("Update"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("UpdateOperation"), undefined)),
-            factory.createPropertySignature(undefined, factory.createIdentifier("Remove"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("RemoveOperation"), undefined)),
-            factory.createPropertySignature(undefined, factory.createIdentifier("CreateSingle"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("CreateSingleOperation"), undefined)),
-            factory.createPropertySignature(undefined, factory.createIdentifier("CreateMulti"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("CreateMultipleOperation"), undefined)),
-        ];
-        if (ActionAsts[entity]) {
-            EntityDefAttrs.push(factory.createPropertySignature(undefined, factory.createIdentifier("ParticularAction"), undefined, factory.createTypeReferenceNode(factory.createIdentifier('ParticularAction'), undefined)));
+        if (process.env.COMPLING_AS_LIB) {
+            makeActionArguments.push(factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword));
+            makeUpdateActionArguments.push(factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword));
         }
-        /* if (typeof Schema[entity].hasRelationDef === 'object' && ts.isTypeAliasDeclaration(Schema[entity].hasRelationDef as ts.Node)) {
-            EntityDefAttrs.push(
-                factory.createPropertySignature(
-                    undefined,
-                    factory.createIdentifier("Relation"),
-                    undefined,
-                    factory.createTypeReferenceNode(
-                        factory.createIdentifier('Relation'),
-                        undefined
-                    )
-                )
-            );
-        } */
-        statements.push(factory.createTypeAliasDeclaration([factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("EntityDef"), undefined, factory.createTypeLiteralNode(EntityDefAttrs)));
+        statements.push(factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("OpAction"), undefined, factory.createTypeReferenceNode(factory.createIdentifier('OakMakeAction'), [factory.createUnionTypeNode(makeActionArguments)])), factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("OpUpdateAction"), undefined, factory.createUnionTypeNode(makeUpdateActionArguments)));
         // 现在支持Schema extends，其继承的对象解析来自另一个文件，故不能再用原sourceFile来生成，否则printer会用sourceFile中的originText去取stringLiteral
         const result = printer.printList(ts.ListFormat.SourceFileStatements, factory.createNodeArray(statements), undefined);
-        const fileName = path_1.default.join(outputDir, entity, 'Schema.ts');
+        const fileName = path_1.default.join(outputDir, entity, '_baseSchema.ts');
         (0, fs_1.writeFileSync)(fileName, result, { flag: 'w' });
     }
 }
@@ -4266,12 +4742,13 @@ function outputStyleDict(outputDir, printer) {
     for (const entity in StyleAsts) {
         const stmts = [
             factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
-                factory.createImportSpecifier(false, undefined, factory.createIdentifier("EntityDef"))
+                factory.createImportSpecifier(false, undefined, factory.createIdentifier("Action")),
+                factory.createImportSpecifier(false, undefined, factory.createIdentifier("OpSchema"))
             ])), factory.createStringLiteral("./Schema"), undefined),
             factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier("StyleDef"))])), factory.createStringLiteral(`${(0, env_1.TYPE_PATH_IN_OAK_DOMAIN)()}Style`), undefined),
             factory.createVariableStatement([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier("style"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("StyleDef"), [
-                    factory.createIndexedAccessTypeNode(factory.createTypeReferenceNode(factory.createIdentifier("EntityDef"), undefined), factory.createLiteralTypeNode(factory.createStringLiteral("OpSchema"))),
-                    factory.createIndexedAccessTypeNode(factory.createTypeReferenceNode(factory.createIdentifier("EntityDef"), undefined), factory.createLiteralTypeNode(factory.createStringLiteral("Action")))
+                    factory.createTypeReferenceNode('OpSchema'),
+                    factory.createTypeReferenceNode('Action')
                 ]), StyleAsts[entity])], ts.NodeFlags.Const))
         ];
         const { sourceFile } = Schema[entity];
@@ -4308,7 +4785,7 @@ function analyzeEntities(inputDir, relativePath) {
     uniqRelationships();
 }
 exports.analyzeEntities = analyzeEntities;
-function buildSchema(outputDir) {
+function buildSchemaBackup(outputDir) {
     addReverseRelationship();
     // setRelationEntities();
     const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
@@ -4326,4 +4803,709 @@ function buildSchema(outputDir) {
         outputPackageJson(outputDir);
     }
 }
+exports.buildSchemaBackup = buildSchemaBackup;
+function _getAggrKey(entity, foreignKey) {
+    const aggrKey = `${entity}$${foreignKey}`;
+    if (process.env.COMPLING_AS_LIB) {
+        return `${aggrKey}$$aggr`;
+    }
+    return factory.createUnionTypeNode([
+        factory.createLiteralTypeNode(factory.createStringLiteral(`${aggrKey}$$aggr`)),
+        factory.createTemplateLiteralType(factory.createTemplateHead(`${aggrKey}$$`, `${aggrKey}$$`), [factory.createTemplateLiteralTypeSpan(factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword), factory.createTemplateTail("$$aggr", "$$aggr"))])
+    ]);
+}
+function _outputEntityDict(outputDir, printer) {
+    const statements = initialStatements3(1);
+    for (const entity in Schema) {
+        statements.push(factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamespaceImport(factory.createIdentifier(`Base${entity}`))), factory.createStringLiteral(`./${entity}/_baseSchema`), undefined));
+    }
+    for (const entity in Schema) {
+        const entityLc = (0, string_1.firstLetterLowerCase)(entity);
+        const getSchema = () => {
+            const { schemaAttrs } = Schema[entity];
+            const { [entity]: manyToOneSet } = ManyToOne;
+            const { [entity]: oneToManySet } = OneToMany;
+            const members = [];
+            for (const attr of schemaAttrs) {
+                const { type, name, questionToken } = attr;
+                const attrName = name.text;
+                if (ts.isTypeReferenceNode(type)) {
+                    const { typeName } = type;
+                    if (ts.isIdentifier(typeName)) {
+                        const { text } = typeName;
+                        const text2 = text === 'Schema' ? entity : text;
+                        const manyToOneItem = manyToOneSet && manyToOneSet.find(([refEntity, attrName2]) => refEntity === text2 && attrName2 === attrName);
+                        if (manyToOneItem) {
+                            const foreignKeyNode = createIndexedForeignRef(text2, 'Schema');
+                            members.push(factory.createPropertySignature(undefined, name, questionToken, foreignKeyNode));
+                        }
+                    }
+                    else {
+                        (0, assert_1.default)(false); // 这是什么case，不确定
+                    }
+                }
+            }
+            // 处理reverserPointer
+            const reverseOnes = ReversePointerRelations[entity];
+            if (reverseOnes) {
+                reverseOnes.forEach((one) => {
+                    members.push(factory.createPropertySignature(undefined, (0, string_1.firstLetterLowerCase)(one), factory.createToken(ts.SyntaxKind.QuestionToken), createIndexedForeignRef(one, 'Schema')));
+                });
+            }
+            const foreignKeySet = {};
+            if (oneToManySet) {
+                for (const oneToManyItem of oneToManySet) {
+                    const [entityName, foreignKey] = oneToManyItem;
+                    if (foreignKeySet.hasOwnProperty(entityName)) {
+                        foreignKeySet[entityName].push(foreignKey);
+                    }
+                    else {
+                        foreignKeySet[entityName] = [foreignKey];
+                    }
+                }
+                for (const entityName in foreignKeySet) {
+                    const entityNameLc = (0, string_1.firstLetterLowerCase)(entityName);
+                    foreignKeySet[entityName].forEach((foreignKey) => {
+                        const identifier = `${entityNameLc}$${foreignKey}`;
+                        members.push(factory.createPropertySignature(undefined, identifier, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode(factory.createIdentifier("Array"), [
+                            factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [
+                                createIndexedForeignRef(entityName, 'Schema'),
+                                factory.createLiteralTypeNode(factory.createStringLiteral(foreignKey))
+                            ])
+                        ])));
+                    });
+                }
+            }
+            const otmAggrMappedNodes = [];
+            for (const entityName in foreignKeySet) {
+                const entityNameLc = (0, string_1.firstLetterLowerCase)(entityName);
+                foreignKeySet[entityName].forEach((foreignKey) => {
+                    const aggrKeyNode = _getAggrKey(entityNameLc, foreignKey);
+                    const aggrNode = factory.createTypeReferenceNode(factory.createIdentifier("AggregationResult"), [factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [
+                            createIndexedForeignRef(entityName, 'Schema'),
+                            factory.createLiteralTypeNode(factory.createStringLiteral(foreignKey))
+                        ])]);
+                    if (typeof aggrKeyNode === 'string') {
+                        members.push(factory.createPropertySignature(undefined, aggrKeyNode, factory.createToken(ts.SyntaxKind.QuestionToken), aggrNode));
+                    }
+                    else {
+                        otmAggrMappedNodes.push(factory.createMappedTypeNode(undefined, factory.createTypeParameterDeclaration(undefined, factory.createIdentifier("A"), aggrKeyNode, undefined), undefined, factory.createToken(ts.SyntaxKind.QuestionToken), aggrNode, undefined));
+                    }
+                });
+            }
+            return factory.createIntersectionTypeNode([
+                factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(`Base${entity}`), factory.createIdentifier("OpSchema"))),
+                factory.createTypeLiteralNode(members),
+                ...otmAggrMappedNodes,
+            ]);
+        };
+        const getProjection = () => {
+            const { schemaAttrs, enumAttributes } = Schema[entity];
+            const properties = [];
+            const { [entity]: manyToOneSet } = ManyToOne;
+            for (const attr of schemaAttrs) {
+                const { type, name } = attr;
+                const attrName = name.text;
+                if (ts.isTypeReferenceNode(type)) {
+                    const { typeName } = type;
+                    if (ts.isIdentifier(typeName)) {
+                        const { text } = typeName;
+                        switch (text) {
+                            case 'String':
+                            case 'Text':
+                            case 'Int':
+                            case 'Uint':
+                            case 'Float':
+                            case 'Double':
+                            case 'Boolean':
+                            case 'Datetime':
+                            case 'Image':
+                            case 'File':
+                            case 'SingleGeo':
+                            case 'Geo':
+                            case 'Price':
+                            case 'Decimal':
+                            case 'Object': {
+                                break;
+                            }
+                            default: {
+                                const text2 = text === 'Schema' ? entity : text;
+                                const manyToOneItem = manyToOneSet && manyToOneSet.find(([refEntity]) => refEntity === text2);
+                                if (manyToOneItem) {
+                                    // 外键投影
+                                    properties.push([name, false, createIndexedForeignRef(text2, 'Projection')]);
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        (0, assert_1.default)(false);
+                    }
+                }
+            }
+            if (ReversePointerRelations[entity]) {
+                ReversePointerRelations[entity].forEach((one) => {
+                    const text2 = one === 'Schema' ? entity : one;
+                    properties.push([(0, string_1.firstLetterLowerCase)(one), false, createIndexedForeignRef(text2, 'Projection')]);
+                });
+            }
+            // 一对多的projection
+            const otmAggrMappedNodes = [];
+            const { [entity]: oneToManySet } = OneToMany;
+            if (oneToManySet) {
+                const foreignKeySet = {};
+                for (const oneToManyItem of oneToManySet) {
+                    const [entityName, foreignKey] = oneToManyItem;
+                    if (foreignKeySet.hasOwnProperty(entityName)) {
+                        foreignKeySet[entityName].push(foreignKey);
+                    }
+                    else {
+                        foreignKeySet[entityName] = [foreignKey];
+                    }
+                }
+                for (const entityName in foreignKeySet) {
+                    const entityNameLc = (0, string_1.firstLetterLowerCase)(entityName);
+                    foreignKeySet[entityName].forEach((foreignKey) => {
+                        const identifier = `${entityNameLc}$${foreignKey}`;
+                        const aggrKey = _getAggrKey(entityNameLc, foreignKey);
+                        properties.push([identifier, false,
+                            factory.createIntersectionTypeNode([
+                                factory.createTypeReferenceNode(factory.createIdentifier("OakSelection"), [
+                                    factory.createLiteralTypeNode(factory.createStringLiteral("select")),
+                                    factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [
+                                        createIndexedForeignRef(entityName, 'Projection'),
+                                        factory.createLiteralTypeNode(factory.createStringLiteral(entityLc))
+                                    ]),
+                                    factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [
+                                        createIndexedForeignRef(entityName, 'Filter'),
+                                        factory.createLiteralTypeNode(factory.createStringLiteral(entityLc))
+                                    ]),
+                                    createIndexedForeignRef(entityName, 'Sorter')
+                                ]),
+                                factory.createTypeLiteralNode([
+                                    factory.createPropertySignature(undefined, factory.createIdentifier("$entity"), undefined, factory.createLiteralTypeNode(factory.createStringLiteral((0, string_1.firstLetterLowerCase)(entityName))))
+                                ])
+                            ])
+                        ]);
+                        const otmAggrNode = factory.createIntersectionTypeNode([
+                            factory.createTypeReferenceNode(factory.createIdentifier("DeduceAggregation"), [
+                                factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [
+                                    createIndexedForeignRef(entityName, 'Projection'),
+                                    factory.createLiteralTypeNode(factory.createStringLiteral(entityLc))
+                                ]),
+                                factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [
+                                    createIndexedForeignRef(entityName, 'Filter'),
+                                    factory.createLiteralTypeNode(factory.createStringLiteral(entityLc))
+                                ]),
+                                createIndexedForeignRef(entityName, 'Sorter')
+                            ]),
+                            factory.createTypeLiteralNode([
+                                factory.createPropertySignature(undefined, factory.createIdentifier("$entity"), undefined, factory.createLiteralTypeNode(factory.createStringLiteral((0, string_1.firstLetterLowerCase)(entityName))))
+                            ])
+                        ]);
+                        if (typeof aggrKey === 'string') {
+                            properties.push([
+                                aggrKey,
+                                false,
+                                otmAggrNode
+                            ]);
+                        }
+                        else {
+                            otmAggrMappedNodes.push(factory.createMappedTypeNode(undefined, factory.createTypeParameterDeclaration(undefined, factory.createIdentifier("A"), aggrKey, undefined), undefined, factory.createToken(ts.SyntaxKind.QuestionToken), otmAggrNode, undefined));
+                        }
+                    });
+                }
+            }
+            return factory.createIntersectionTypeNode([
+                factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(`Base${entity}`), factory.createIdentifier("OpProjection"))),
+                factory.createTypeLiteralNode(properties.map(([n, q, v]) => {
+                    return factory.createPropertySignature(undefined, n, q ? undefined : factory.createToken(ts.SyntaxKind.QuestionToken), v || factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword));
+                })),
+                ...otmAggrMappedNodes,
+            ]);
+        };
+        const getFilterUnit = () => {
+            const { schemaAttrs, fulltextIndex } = Schema[entity];
+            const members = [];
+            const { [entity]: manyToOneSet } = ManyToOne;
+            const entityUnionTypeNodes = ReversePointerRelations[entity] && ReversePointerRelations[entity].map(ele => factory.createLiteralTypeNode(factory.createStringLiteral((0, string_1.firstLetterLowerCase)(ele))));
+            if (process.env.COMPLING_AS_LIB) {
+                entityUnionTypeNodes && entityUnionTypeNodes.push(factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword));
+            }
+            for (const attr of schemaAttrs) {
+                const { type, name } = attr;
+                const attrName = name.text;
+                if (ts.isTypeReferenceNode(type)) {
+                    const { typeName } = type;
+                    if (ts.isIdentifier(typeName)) {
+                        const { text } = typeName;
+                        let type2;
+                        switch (text) {
+                            case 'String':
+                            case 'Text':
+                            case 'Image':
+                            case 'File':
+                            case 'Int':
+                            case 'Uint':
+                            case 'Float':
+                            case 'Double':
+                            case 'Price':
+                            case 'Decimal':
+                            case 'Boolean':
+                            case 'Datetime':
+                            case 'SingleGeo':
+                            case 'Geo':
+                            case 'Object': {
+                                break;
+                            }
+                            default: {
+                                const text2 = text === 'Schema' ? entity : text;
+                                const manyToOneItem = manyToOneSet && manyToOneSet.find(([refEntity]) => refEntity === text2);
+                                if (manyToOneItem) {
+                                    type2 = factory.createTypeReferenceNode('MakeFilter', [
+                                        createIndexedForeignRef(text2, 'FilterUnit')
+                                    ]);
+                                }
+                            }
+                        }
+                        if (type2) {
+                            members.push(factory.createPropertySignature(undefined, name, undefined, type2));
+                        }
+                    }
+                }
+            }
+            // type AttrFilter = {};
+            if (ReversePointerRelations[entity]) {
+                // 有反向指针，将反向指针关联的对象的Filter也注入
+                ReversePointerRelations[entity].forEach(ele => members.push(factory.createPropertySignature(undefined, (0, string_1.firstLetterLowerCase)(ele), undefined, factory.createTypeReferenceNode('MakeFilter', [
+                    createIndexedForeignRef(ele, 'FilterUnit')
+                ]))));
+            }
+            // 一对多的生成子查询
+            const { [entity]: oneToManySet } = OneToMany;
+            if (oneToManySet) {
+                const foreignKeySet = {};
+                for (const oneToManyItem of oneToManySet) {
+                    const [entityName, foreignKey] = oneToManyItem;
+                    if (foreignKeySet.hasOwnProperty(entityName)) {
+                        foreignKeySet[entityName].push(foreignKey);
+                    }
+                    else {
+                        foreignKeySet[entityName] = [foreignKey];
+                    }
+                }
+                for (const entityName in foreignKeySet) {
+                    const entityNameLc = (0, string_1.firstLetterLowerCase)(entityName);
+                    foreignKeySet[entityName].forEach((foreignKey) => {
+                        const identifier = `${entityNameLc}$${foreignKey}`;
+                        members.push(factory.createPropertySignature(undefined, identifier, undefined, factory.createIntersectionTypeNode([
+                            factory.createTypeReferenceNode('MakeFilter', [
+                                factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [
+                                    createIndexedForeignRef(entityName, 'FilterUnit'),
+                                    factory.createLiteralTypeNode(factory.createStringLiteral(foreignKey))
+                                ])
+                            ]),
+                            factory.createTypeReferenceNode('SubQueryPredicateMetadata')
+                        ])));
+                    });
+                }
+            }
+            const types = [
+                factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(`Base${entity}`), factory.createIdentifier("OpFilter"))),
+                factory.createTypeLiteralNode(members)
+            ];
+            // 如果还有其它类型的查询如全文，则加在types数组中
+            if (fulltextIndex) {
+                types.push(factory.createTypeReferenceNode('FulltextFilter'));
+            }
+            return factory.createIntersectionTypeNode(types);
+        };
+        const getSortAttr = () => {
+            const { schemaAttrs } = Schema[entity];
+            const members = [];
+            const { [entity]: manyToOneSet } = ManyToOne;
+            for (const attr of schemaAttrs) {
+                const { type, name, questionToken } = attr;
+                if (ts.isTypeReferenceNode(type)) {
+                    const { typeName } = type;
+                    if (ts.isIdentifier(typeName)) {
+                        const { text } = typeName;
+                        let type2;
+                        switch (text) {
+                            case 'String':
+                            case 'Text':
+                            case 'Int':
+                            case 'Float':
+                            case 'Double':
+                            case 'Boolean':
+                            case 'Datetime':
+                            case 'Image':
+                            case 'File':
+                            case 'Price': {
+                                break;
+                            }
+                            default: {
+                                const text2 = text === 'Schema' ? entity : text;
+                                const manyToOneItem = manyToOneSet && manyToOneSet.find(([refEntity]) => refEntity === text2);
+                                if (manyToOneItem) {
+                                    type2 = createIndexedForeignRef(text2, 'SortAttr');
+                                }
+                            }
+                        }
+                        if (type2) {
+                            members.push(factory.createPropertySignature(undefined, name, undefined, type2));
+                        }
+                    }
+                }
+            }
+            if (ReversePointerRelations[entity]) {
+                ReversePointerRelations[entity].forEach((one) => {
+                    members.push(factory.createPropertySignature(undefined, (0, string_1.firstLetterLowerCase)(one), undefined, createIndexedForeignRef(one, 'SortAttr')));
+                });
+            }
+            return factory.createTypeReferenceNode('Partial', [
+                factory.createUnionTypeNode([
+                    factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(`Base${entity}`), factory.createIdentifier("OpSortAttr"))),
+                    factory.createTypeLiteralNode(members),
+                ])
+            ]);
+        };
+        const getOperations = () => {
+            const { [entity]: manyToOneSet } = ManyToOne;
+            const { [entity]: oneToManySet } = OneToMany;
+            const foreignKeySet = {};
+            if (oneToManySet) {
+                for (const oneToManyItem of oneToManySet) {
+                    const [entityName, foreignKey] = oneToManyItem;
+                    if (foreignKeySet.hasOwnProperty(entityName)) {
+                        foreignKeySet[entityName].push(foreignKey);
+                    }
+                    else {
+                        foreignKeySet[entityName] = [foreignKey];
+                    }
+                }
+            }
+            const cascadeCreateElements = [];
+            const cascadeUpdateElements = [];
+            {
+                const addManyToOneCascade = (foreignEntity, foreignKey) => {
+                    // 切断modiEntity和其它对象的关联（太多了）
+                    if (entity === 'ModiEntity' && foreignEntity !== 'Modi') {
+                        return;
+                    }
+                    if (entity === 'OperEntity' && foreignEntity !== 'Oper') {
+                        return;
+                    }
+                    const propertyName = foreignKey === 'entity' ? (0, string_1.firstLetterLowerCase)(foreignEntity) : foreignKey;
+                    const createCasNode = factory.createTypeReferenceNode('OakOperation', [
+                        factory.createLiteralTypeNode(factory.createStringLiteral('create')),
+                        createIndexedForeignRef(foreignEntity, 'CreateOperationData')
+                    ]);
+                    const updateCasNode = factory.createTypeReferenceNode('OakOperation', [
+                        factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(`Base${foreignEntity}`), factory.createIdentifier("OpUpdateAction"))),
+                        createIndexedForeignRef(foreignEntity, 'UpdateOperationData'),
+                        createIndexedForeignRef(foreignEntity, 'Filter'),
+                    ]);
+                    const removeCasNode = factory.createTypeReferenceNode('OakOperation', [
+                        factory.createLiteralTypeNode(factory.createStringLiteral('remove')),
+                        createIndexedForeignRef(foreignEntity, 'RemoveOperationData'),
+                        createIndexedForeignRef(foreignEntity, 'Filter')
+                    ]);
+                    if (!Schema[foreignEntity].static) {
+                        switch (Schema[foreignEntity].actionType) {
+                            case 'crud': {
+                                cascadeCreateElements.push(factory.createPropertySignature(undefined, propertyName, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
+                                    createCasNode,
+                                    updateCasNode
+                                ])));
+                                cascadeUpdateElements.push(factory.createPropertySignature(undefined, propertyName, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
+                                    createCasNode,
+                                    updateCasNode,
+                                    removeCasNode,
+                                ])));
+                                break;
+                            }
+                            case 'excludeRemove': {
+                                cascadeCreateElements.push(factory.createPropertySignature(undefined, propertyName, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
+                                    createCasNode,
+                                    updateCasNode
+                                ])));
+                                cascadeUpdateElements.push(factory.createPropertySignature(undefined, propertyName, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
+                                    createCasNode,
+                                    updateCasNode,
+                                ])));
+                                break;
+                            }
+                            case 'excludeUpdate': {
+                                cascadeCreateElements.push(factory.createPropertySignature(undefined, propertyName, factory.createToken(ts.SyntaxKind.QuestionToken), createCasNode));
+                                cascadeUpdateElements.push(factory.createPropertySignature(undefined, propertyName, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
+                                    createCasNode,
+                                    removeCasNode,
+                                ])));
+                                break;
+                            }
+                            case 'appendOnly': {
+                                cascadeCreateElements.push(factory.createPropertySignature(undefined, propertyName, factory.createToken(ts.SyntaxKind.QuestionToken), createCasNode));
+                                cascadeUpdateElements.push(factory.createPropertySignature(undefined, propertyName, factory.createToken(ts.SyntaxKind.QuestionToken), createCasNode));
+                                break;
+                            }
+                            case 'readOnly': {
+                                break;
+                            }
+                            default: {
+                                (0, assert_1.default)(false);
+                            }
+                        }
+                    }
+                };
+                // 多对一
+                if (manyToOneSet) {
+                    for (const one of manyToOneSet) {
+                        addManyToOneCascade(one[0], one[1]);
+                    }
+                }
+                // 一对多
+                const addOneToManyCascade = (foreignEntity, foreignKey) => {
+                    // 切断modiEntity和其它对象的关联（太多了）
+                    if (foreignEntity === 'ModiEntity' && entity !== 'Modi') {
+                        return;
+                    }
+                    if (foreignEntity === 'OperEntity' && entity !== 'Oper') {
+                        return;
+                    }
+                    const foreignEntityLc = (0, string_1.firstLetterLowerCase)(foreignEntity);
+                    const otmKey = `${foreignEntityLc}$${foreignKey}`;
+                    const mtoKey = foreignKey === 'entity' ? (0, string_1.firstLetterLowerCase)(entity) : foreignKey;
+                    const otmCreateData = factory.createTypeReferenceNode('Omit', [
+                        createIndexedForeignRef(foreignEntity, 'CreateOperationData'),
+                        factory.createLiteralTypeNode(factory.createStringLiteral(mtoKey))
+                    ]);
+                    const otmUpdateData = factory.createTypeReferenceNode('Omit', [
+                        createIndexedForeignRef(foreignEntity, 'UpdateOperationData'),
+                        factory.createLiteralTypeNode(factory.createStringLiteral(mtoKey))
+                    ]);
+                    const createCasNode = factory.createTypeReferenceNode('OakOperation', [
+                        factory.createLiteralTypeNode(factory.createStringLiteral('create')),
+                        factory.createUnionTypeNode([
+                            otmCreateData,
+                            factory.createArrayTypeNode(otmCreateData)
+                        ])
+                    ]);
+                    const updateCasNode = factory.createTypeReferenceNode('OakOperation', [
+                        factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(`Base${foreignEntity}`), factory.createIdentifier("OpUpdateAction"))),
+                        otmUpdateData,
+                        createIndexedForeignRef(foreignEntity, 'Filter'),
+                    ]);
+                    const removeCasNode = factory.createTypeReferenceNode('OakOperation', [
+                        factory.createLiteralTypeNode(factory.createStringLiteral('remove')),
+                        createIndexedForeignRef(foreignEntity, 'RemoveOperationData'),
+                        createIndexedForeignRef(foreignEntity, 'Filter')
+                    ]);
+                    if (!Schema[foreignEntity].static) {
+                        switch (Schema[foreignEntity].actionType) {
+                            case 'crud': {
+                                cascadeCreateElements.push(factory.createPropertySignature(undefined, otmKey, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createArrayTypeNode(factory.createUnionTypeNode([
+                                    createCasNode,
+                                    updateCasNode
+                                ]))));
+                                cascadeUpdateElements.push(factory.createPropertySignature(undefined, otmKey, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createArrayTypeNode(factory.createUnionTypeNode([
+                                    createCasNode,
+                                    updateCasNode,
+                                    removeCasNode,
+                                ]))));
+                                break;
+                            }
+                            case 'excludeRemove': {
+                                cascadeCreateElements.push(factory.createPropertySignature(undefined, otmKey, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createArrayTypeNode(factory.createUnionTypeNode([
+                                    createCasNode,
+                                    updateCasNode
+                                ]))));
+                                cascadeUpdateElements.push(factory.createPropertySignature(undefined, otmKey, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createArrayTypeNode(factory.createUnionTypeNode([
+                                    createCasNode,
+                                    updateCasNode,
+                                ]))));
+                                break;
+                            }
+                            case 'excludeUpdate': {
+                                cascadeCreateElements.push(factory.createPropertySignature(undefined, otmKey, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createArrayTypeNode(createCasNode)));
+                                cascadeUpdateElements.push(factory.createPropertySignature(undefined, otmKey, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createArrayTypeNode(factory.createUnionTypeNode([
+                                    createCasNode,
+                                    removeCasNode,
+                                ]))));
+                                break;
+                            }
+                            case 'appendOnly': {
+                                cascadeCreateElements.push(factory.createPropertySignature(undefined, otmKey, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createArrayTypeNode(createCasNode)));
+                                cascadeUpdateElements.push(factory.createPropertySignature(undefined, otmKey, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createArrayTypeNode(createCasNode)));
+                                break;
+                            }
+                            case 'readOnly': {
+                                break;
+                            }
+                            default: {
+                                (0, assert_1.default)(false);
+                            }
+                        }
+                    }
+                };
+                if (oneToManySet) {
+                    for (const entityName in foreignKeySet) {
+                        foreignKeySet[entityName].forEach((foreignKey) => {
+                            addOneToManyCascade(entityName, foreignKey);
+                        });
+                    }
+                }
+                if (process.env.COMPLING_AS_LIB) {
+                    // 如果是base，要包容更多可能的反指
+                    /* cascadeCreateElements.push(
+                        factory.createIndexSignature(
+                            undefined,
+                            [factory.createParameterDeclaration(
+                                undefined,
+                                undefined,
+                                factory.createIdentifier("K"),
+                                undefined,
+                                factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+                                undefined
+                            )],
+                            factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+                        )
+                    );
+                    cascadeUpdateElements.push(
+                        factory.createIndexSignature(
+                            undefined,
+                            [factory.createParameterDeclaration(
+                                undefined,
+                                undefined,
+                                factory.createIdentifier("K"),
+                                undefined,
+                                factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+                                undefined
+                            )],
+                            factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+                        )
+                    ); */
+                }
+            }
+            return {
+                CreateOperationData: factory.createTypeReferenceNode('FormCreateData', [
+                    cascadeCreateElements.length ? factory.createIntersectionTypeNode([
+                        factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(`Base${entity}`), factory.createIdentifier("OpSchema"))),
+                        factory.createTypeLiteralNode(cascadeCreateElements),
+                    ]) : factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(`Base${entity}`), factory.createIdentifier("OpSchema")))
+                ]),
+                UpdateOperationData: factory.createTypeReferenceNode('FormUpdateData', [
+                    cascadeUpdateElements.length ? factory.createIntersectionTypeNode([
+                        factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(`Base${entity}`), factory.createIdentifier("OpSchema"))),
+                        factory.createTypeLiteralNode(cascadeUpdateElements),
+                    ]) : factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(`Base${entity}`), factory.createIdentifier("OpSchema")))
+                ]),
+                RemoveOperationData: factory.createTypeLiteralNode([]), // RemoveOperate暂时不支持Cascade
+            };
+        };
+        const { CreateOperationData, UpdateOperationData, RemoveOperationData, } = getOperations();
+        statements.push(factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(entity), undefined, factory.createTypeLiteralNode([
+            factory.createPropertySignature(undefined, 'OpSchema', undefined, factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(`Base${entity}`), factory.createIdentifier("OpSchema")))),
+            factory.createPropertySignature(undefined, 'Action', undefined, factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(`Base${entity}`), factory.createIdentifier("OpAction")))),
+            factory.createPropertySignature(undefined, factory.createIdentifier("Schema"), undefined, getSchema()),
+            factory.createPropertySignature(undefined, factory.createIdentifier("Projection"), undefined, getProjection()),
+            factory.createPropertySignature(undefined, factory.createIdentifier("FilterUnit"), undefined, getFilterUnit()),
+            factory.createPropertySignature(undefined, factory.createIdentifier("Filter"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("MakeFilter"), [
+                createIndexedForeignRef(entity, 'FilterUnit')
+            ])),
+            factory.createPropertySignature(undefined, factory.createIdentifier("SortAttr"), undefined, getSortAttr()),
+            factory.createPropertySignature(undefined, factory.createIdentifier("SortNode"), undefined, factory.createTypeLiteralNode([
+                factory.createPropertySignature(undefined, factory.createIdentifier("$attr"), undefined, createIndexedForeignRef(entity, 'SortAttr')),
+                factory.createPropertySignature(undefined, factory.createIdentifier("$direction"), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
+                    factory.createLiteralTypeNode(factory.createStringLiteral("asc")),
+                    factory.createLiteralTypeNode(factory.createStringLiteral("desc"))
+                ]))
+            ])),
+            factory.createPropertySignature(undefined, factory.createIdentifier("Sorter"), undefined, factory.createArrayTypeNode(createIndexedForeignRef(entity, 'SortNode'))),
+            factory.createPropertySignature(undefined, factory.createIdentifier("Selection"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("OakSelection"), [
+                factory.createLiteralTypeNode(factory.createStringLiteral("select")),
+                createIndexedForeignRef(entity, 'Projection'),
+                createIndexedForeignRef(entity, 'Filter'),
+                createIndexedForeignRef(entity, 'Sorter')
+            ])),
+            factory.createPropertySignature(undefined, factory.createIdentifier("Aggregation"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("DeduceAggregation"), [
+                createIndexedForeignRef(entity, 'Projection'),
+                createIndexedForeignRef(entity, 'Filter'),
+                createIndexedForeignRef(entity, 'Sorter')
+            ])),
+            factory.createPropertySignature(undefined, factory.createIdentifier("CreateOperationData"), undefined, CreateOperationData),
+            factory.createPropertySignature(undefined, factory.createIdentifier("CreateSingle"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("OakOperation"), [
+                factory.createLiteralTypeNode(factory.createStringLiteral('create')),
+                createIndexedForeignRef(entity, 'CreateOperationData')
+            ])),
+            factory.createPropertySignature(undefined, factory.createIdentifier("CreateMulti"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("OakOperation"), [
+                factory.createLiteralTypeNode(factory.createStringLiteral('create')),
+                factory.createTypeReferenceNode(factory.createIdentifier("Array"), [
+                    createIndexedForeignRef(entity, 'CreateOperationData')
+                ])
+            ])),
+            factory.createPropertySignature(undefined, factory.createIdentifier("Create"), undefined, factory.createUnionTypeNode([
+                createIndexedForeignRef(entity, 'CreateSingle'),
+                createIndexedForeignRef(entity, 'CreateMulti')
+            ])),
+            factory.createPropertySignature(undefined, factory.createIdentifier("UpdateOperationData"), undefined, UpdateOperationData),
+            factory.createPropertySignature(undefined, factory.createIdentifier("Update"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("OakOperation"), [
+                factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(`Base${entity}`), factory.createIdentifier("OpUpdateAction"))),
+                createIndexedForeignRef(entity, 'UpdateOperationData'),
+                createIndexedForeignRef(entity, 'Filter'),
+                createIndexedForeignRef(entity, 'Sorter'),
+            ])),
+            factory.createPropertySignature(undefined, factory.createIdentifier("RemoveOperationData"), undefined, RemoveOperationData),
+            factory.createPropertySignature(undefined, factory.createIdentifier("Remove"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("OakOperation"), [
+                factory.createLiteralTypeNode(factory.createStringLiteral('remove')),
+                createIndexedForeignRef(entity, 'RemoveOperationData'),
+                createIndexedForeignRef(entity, 'Filter'),
+                createIndexedForeignRef(entity, 'Sorter'),
+            ])),
+            factory.createPropertySignature(undefined, factory.createIdentifier("Operation"), undefined, factory.createUnionTypeNode([
+                createIndexedForeignRef(entity, 'Create'),
+                createIndexedForeignRef(entity, 'Update'),
+                createIndexedForeignRef(entity, 'Remove'),
+            ])),
+        ])));
+    }
+    statements.push(factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("EntityDict"), undefined, factory.createTypeLiteralNode(Object.keys(Schema).map((ele) => factory.createPropertySignature(undefined, (0, string_1.firstLetterLowerCase)(ele), undefined, factory.createTypeReferenceNode(factory.createIdentifier(ele)))))));
+    const result = printer.printList(ts.ListFormat.SourceFileStatements, factory.createNodeArray(statements), undefined);
+    const fileName = path_1.default.join(outputDir, 'EntityDict.ts');
+    (0, fs_1.writeFileSync)(fileName, result, { flag: 'w' });
+}
+function _outputSchema(outputDir, printer) {
+    for (const entity in Schema) {
+        const statements = [
+            factory.createExportDeclaration(undefined, false, undefined, factory.createStringLiteral("./_baseSchema"), undefined),
+            factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
+                factory.createImportSpecifier(false, undefined, factory.createIdentifier(entity))
+            ])), factory.createStringLiteral("../EntityDict"), undefined),
+        ];
+        const keys = [
+            'Schema', 'Action', 'Projection', 'Filter', 'SortNode', 'Sorter', 'Selection',
+            'Aggregation', 'CreateOperationData', 'CreateSingle', 'CreateMulti', 'Create',
+            'UpdateOperationData', 'Update', 'RemoveOperationData', 'Remove', 'Operation'
+        ];
+        statements.push(...keys.map((ele) => factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(ele), undefined, factory.createIndexedAccessTypeNode(factory.createTypeReferenceNode(factory.createIdentifier(entity), undefined), factory.createLiteralTypeNode(factory.createStringLiteral(ele))))));
+        const result = printer.printList(ts.ListFormat.SourceFileStatements, factory.createNodeArray(statements), undefined);
+        const fileName = path_1.default.join(outputDir, entity, 'Schema.ts');
+        (0, fs_1.writeFileSync)(fileName, result, { flag: 'w' });
+    }
+}
+function buildSchema(outputDir) {
+    addReverseRelationship();
+    // setRelationEntities();
+    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+    resetOutputDir(outputDir);
+    outputAction(outputDir, printer);
+    _outputBaseSchema(outputDir, printer);
+    outputLocale(outputDir, printer);
+    _outputEntityDict(outputDir, printer);
+    _outputSchema(outputDir, printer);
+    outputStorage(outputDir, printer);
+    outputRelation2(outputDir, printer);
+    outputStyleDict(outputDir, printer);
+    outputIndexTs(outputDir);
+}
 exports.buildSchema = buildSchema;