import PathLib from 'path';
import assert from 'assert';
import { writeFileSync, readdirSync, mkdirSync, fstat } from 'fs';
import { emptydirSync } from 'fs-extra';
import { assign, cloneDeep, difference, identity, intersection, keys, pull, uniq, uniqBy } from 'lodash';
import * as ts from 'typescript';
const { factory } = ts;
import {
    ACTION_CONSTANT_IN_OAK_DOMAIN,
    TYPE_PATH_IN_OAK_DOMAIN,
    RESERVED_ENTITIES,
    STRING_LITERAL_MAX_LENGTH,
    NUMERICAL_LITERL_DEFAULT_PRECISION,
    NUMERICAL_LITERL_DEFAULT_SCALE,
    INT_LITERL_DEFAULT_WIDTH,
    LIB_OAK_DOMAIN,
} from './env';
import { firstLetterLowerCase, firstLetterUpperCase } from '../utils/string';

const Schema: Record<string, {
    schemaAttrs: Array<ts.PropertySignature>;
    fulltextIndex?: true;
    indexes?: ts.ArrayLiteralExpression;
    states: string[];
    sourceFile: ts.SourceFile;
    locale: ts.ObjectLiteralExpression;
    // relationHierarchy?: ts.ObjectLiteralExpression;
    // reverseCascadeRelationHierarchy?: ts.ObjectLiteralExpression;
    toModi: boolean;
    actionType: string;
    static: boolean;
    inModi: boolean;
    hasRelationDef: false | ts.TypeAliasDeclaration;
    enumStringAttrs: string[],
    additionalImports: ts.ImportDeclaration[],
}> = {};
const OneToMany: Record<string, Array<[string, string, boolean]>> = {};
const ManyToOne: Record<string, Array<[string, string, boolean]>> = {};
const ReversePointerEntities: Record<string, 1> = {};
const ReversePointerRelations: Record<string, string[]> = {};

const ActionImportStatements = () => [
    factory.createImportDeclaration(
        undefined,
        undefined,
        factory.createImportClause(
            false,
            undefined,
            factory.createNamedImports([factory.createImportSpecifier(
                false,
                undefined,
                factory.createIdentifier("ActionDef")
            )])
        ),
        factory.createStringLiteral(`${TYPE_PATH_IN_OAK_DOMAIN()}Action`),
        undefined
    ),
    factory.createImportDeclaration(
        undefined,
        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(ACTION_CONSTANT_IN_OAK_DOMAIN()),
        undefined
    )
];

const ActionAsts: {
    [module: string]: {
        statements: Array<ts.Statement>;
        sourceFile: ts.SourceFile;
        importedFrom: Record<string, ts.ImportDeclaration | 'local'>;
        // actionNames: string[];
        actionDefNames: string[];
    };
} = {};

const SchemaAsts: {
    [module: string]: {
        statements: Array<ts.Statement>;
        sourceFile: ts.SourceFile;
    };
} = {};

function addRelationship(many: string, one: string, key: string, notNull: boolean) {
    const { [many]: manySet } = ManyToOne;
    const one2 = one === 'Schema' ? many : one;
    if (manySet) {
        manySet.push([one2, key, notNull]);
    }
    else {
        assign(ManyToOne, {
            [many]: [[one2, key, notNull]],
        });
    }

    const { [one2]: oneSet } = OneToMany;
    if (oneSet) {
        oneSet.push([many, key, notNull]);
    }
    else {
        assign(OneToMany, {
            [one2]: [[many, key, notNull]],
        });
    }
}

/**
 * 对relationship去重。一旦发生对象重定义这里就有可能重复
 */
function uniqRelationships() {
    for (const entity in ManyToOne) {
        ManyToOne[entity] = uniqBy(ManyToOne[entity], (ele) => `${ele[0]}-${ele[1]}`);
    }
    for (const entity in OneToMany) {
        OneToMany[entity] = uniqBy(OneToMany[entity], (ele) => `${ele[0]}-${ele[1]}`);
    }
    for (const entity in ReversePointerRelations) {
        OneToMany[entity] = uniq(OneToMany[entity]);
    }
}


function createForeignRef(entity: string, foreignKey: string, ref: string) {
    if (entity === foreignKey) {
        return factory.createIdentifier(ref)
    }
    return factory.createQualifiedName(
        factory.createIdentifier(foreignKey),
        factory.createIdentifier(ref)
    );
}

function pushStatementIntoActionAst(
    moduleName: string,
    node: ts.Statement,
    sourceFile: ts.SourceFile) {

    // let actionNames;
    let actionDefName;
    /* if (ts.isTypeAliasDeclaration(node) && node.name.text === 'ParticularAction') {
        const { type } = node;
        if (ts.isUnionTypeNode(type)) {
            actionNames = type.types.map(
                (ele) => {
                    assert(ts.isTypeReferenceNode(ele));
                    const text = (<ts.Identifier>ele.typeName).text;
                    assert(text.endsWith('Action'));
                    return firstLetterLowerCase(text.slice(0, text.length - 6));
                }
            )
        }
        else {
            assert(ts.isTypeReferenceNode(type));
            const text = (<ts.Identifier>type.typeName).text;
            assert(text.endsWith('Action'));
            actionNames = [firstLetterLowerCase(text.slice(0, text.length - 6))];
        }
    } */

    if (ts.isVariableStatement(node)) {
        const { declarationList: { declarations } } = node;
        declarations.forEach(
            (declaration) => {
                if (ts.isIdentifier(declaration.name) && declaration.name.text.endsWith('ActionDef')) {
                    const { text } = declaration.name;
                    actionDefName = firstLetterLowerCase(text.slice(0, text.length - 9));
                }
            }
        );
    }

    if (ActionAsts[moduleName]) {
        ActionAsts[moduleName].statements.push(node);
        /* if (actionNames) {
            ActionAsts[moduleName].actionNames = actionNames;
        } */
        if (actionDefName) {
            ActionAsts[moduleName].actionDefNames.push(actionDefName);
        }
    }
    else {
        assign(ActionAsts, {
            [moduleName]: {
                statements: [...ActionImportStatements(), node],
                sourceFile,
                importedFrom: {},
                // actionNames,
                actionDefNames: actionDefName ? [actionDefName] : [],
            }
        });
    }
}

function pushStatementIntoSchemaAst(moduleName: string, statement: ts.Statement, sourceFile: ts.SourceFile) {
    if (SchemaAsts[moduleName]) {
        SchemaAsts[moduleName].statements.push(statement);
    }
    else {
        assign(SchemaAsts, {
            [moduleName]: {
                statements: [statement],
                sourceFile,
            }
        });
    }
}

/**
 * 检查ActionDef是否满足合法的定义
 * 1、ActionDef, Action, State三者命名是否一致
 * @param actionDefNode 
 */
function checkActionDefNameConsistent(filename: string, actionDefNode: ts.VariableDeclaration) {
    const { name, type } = actionDefNode;
    assert(ts.isTypeReferenceNode(type!));
    const { typeArguments } = type!;
    assert(typeArguments!.length === 2);
    const [actionNode, stateNode] = typeArguments!;

    assert(ts.isIdentifier(name), `文件${filename}中的ActionDef${(<ts.Identifier>name).text}不是一个有效的变量`);
    assert(name.text.endsWith('ActionDef'), `文件${filename}中的ActionDef${name.text}未以ActionDef结尾`);
    assert(ts.isTypeReferenceNode(actionNode) && ts.isTypeReferenceNode(stateNode), `文件${filename}中的ActionDef${name.text}类型声明中的action和state非法`);
    assert(ts.isIdentifier(actionNode.typeName) && ts.isIdentifier(stateNode.typeName));
    assert(actionNode.typeName.text.endsWith('Action'), `文件${filename}中的ActionDef${name.text}所引用的Action${actionNode.typeName}未以Action结尾`);
    assert(stateNode.typeName.text.endsWith('State'), `文件${filename}中的ActionDef${name.text}所引用的Action${stateNode.typeName}未以Action结尾`);
    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);

    assert(adfName === aName && aName === sName, `文件${filename}中的ActionDef${name.text}中ActionDef, Action和State的命名规则不一致`);
}

function addActionSource(moduleName: string, name: ts.Identifier, node: ts.ImportDeclaration) {
    const ast = ActionAsts[moduleName];
    const { moduleSpecifier } = node;

    // todo 目前应该只会引用oak-domain/src/actions/action里的公共action，未来如果有交叉引用这里代码要修正（如果domain中也有引用action_constants这里应该也会错）
    assert(ts.isStringLiteral(moduleSpecifier) && moduleSpecifier.text === ACTION_CONSTANT_IN_OAK_DOMAIN());
    assign(ast.importedFrom, {
        [name.text]: node,
    });
}

function getStringTextFromUnionStringLiterals(moduleName: string, filename: string, node: ts.TypeReferenceNode, program: ts.Program) {
    const checker = program.getTypeChecker();
    const symbol = checker.getSymbolAtLocation(node.typeName);
    let declaration = symbol?.getDeclarations()![0]!;
    let isImport = false;
    /* const typee = checker.getDeclaredTypeOfSymbol(symbol!);

    const declaration = typee.aliasSymbol!.getDeclarations()![0]; */
    if (ts.isImportSpecifier(declaration)) {
        isImport = true;
        const typee = checker.getDeclaredTypeOfSymbol(symbol!);
        declaration = typee.aliasSymbol!.getDeclarations()![0];
    }

    assert(ts.isTypeAliasDeclaration(declaration));
    const { type, name } = declaration;
    // assert(ts.isUnionTypeNode(type!) || ts.isLiteralTypeNode(type!), `${filename}中引用的action「${(<ts.Identifier>name).text}」的定义不是union和stringLiteral类型`);

    // 如果这个action是从外部导入的，在这里要记下来此entity和这个导入之间的关系
    if (isImport) {
        const importDeclartion = symbol!.getDeclarations()![0]!.parent.parent.parent;

        assert(ts.isImportDeclaration(importDeclartion));
        addActionSource(moduleName, name, importDeclartion);
    }
    else {
        const ast = ActionAsts[moduleName];
        assign(ast.importedFrom, {
            [name.text]: 'local',
        });
    }

    const getStringLiteral = (ele: ts.TypeNode) => {
        assert(ts.isLiteralTypeNode(ele) && ts.isStringLiteral(ele.literal), `${filename}中引用的action${(<ts.Identifier>name).text}中存在不是stringliteral的类型`);
        assert(!ele.literal.text.includes('$'), `${filename}中引用的action${(<ts.Identifier>name).text}中的action「${ele.literal.text}」包含非法字符$`);
        assert(ele.literal.text.length > 0, `${filename}中引用的action${(<ts.Identifier>name).text}中的action「${ele.literal.text}」长度非法`);
        assert(ele.literal.text.length < STRING_LITERAL_MAX_LENGTH, `${filename}中引用的action${(<ts.Identifier>name).text}中的action「${ele.literal.text}」长度过长`);
        return ele.literal.text;
    }

    if (ts.isUnionTypeNode(type)) {
        const actions = type.types!.map(
            ele => getStringLiteral(ele)
        );

        return actions;
    }
    else {
        assert(ts.isLiteralTypeNode(type!), `${filename}中引用的action「${(<ts.Identifier>name).text}」的定义不是union和stringLiteral类型`);
        const action = getStringLiteral(type);
        return [action];
    }
}

const RESERVED_ACTION_NAMES = ['GenericAction', 'ParticularAction', 'ExcludeRemoveAction', 'ExcludeUpdateAction', 'ReadOnlyAction', 'AppendOnlyAction', 'RelationAction'];
import { genericActions, relationActions } from '../actions/action';
import { unIndexedTypes } from '../types/DataType';
import { initinctiveAttributes } from '../types/Entity';

const OriginActionDict = {
    'crud': 'GenericAction',
    'excludeUpdate': 'ExcludeUpdateAction',
    'excludeRemove': 'ExcludeRemoveAction',
    'appendOnly': 'AppendOnlyAction',
    'readOnly': 'ReadOnlyAction',
};
function dealWithActions(moduleName: string, filename: string, node: ts.TypeNode, program: ts.Program, sourceFile: ts.SourceFile, hasRelationDef?: boolean) {
    const actionTexts = genericActions.map(
        ele => ele
    );
    if (hasRelationDef) {
        actionTexts.push(...relationActions);
    }
    if (ts.isUnionTypeNode(node)) {
        const actionNames = node.types.map(
            ele => {
                if (ts.isTypeReferenceNode(ele) && ts.isIdentifier(ele.typeName)) {
                    return ele.typeName.text;
                }
            }
        ).filter(
            ele => !!ele
        );
        assert(intersection(actionNames, RESERVED_ENTITIES).length === 0,
            `${filename}中的Action命名不能是「${RESERVED_ACTION_NAMES.join(',')}」之一`);

        node.types.forEach(
            ele => {
                if (ts.isTypeReferenceNode(ele)) {
                    actionTexts.push(...getStringTextFromUnionStringLiterals(moduleName, filename, ele, program));
                }
                else {
                    assert(ts.isLiteralTypeNode(ele) && ts.isStringLiteral(ele.literal), `【${moduleName}】action的定义既非Type也不是string`);
                    actionTexts.push(ele.literal.text);
                }
            }
        );
    }
    else if (ts.isTypeReferenceNode(node)) {
        if (ts.isIdentifier(node.typeName)) {
            assert(!RESERVED_ACTION_NAMES.includes(node.typeName.text),
                `${filename}中的Action命名不能是「${RESERVED_ACTION_NAMES.join(',')}」之一`);
        }
        actionTexts.push(...getStringTextFromUnionStringLiterals(moduleName, filename, node, program));
    }
    else {
        assert(ts.isLiteralTypeNode(node) && ts.isStringLiteral(node.literal), `【${moduleName}】action的定义既非Type也不是string`);
        actionTexts.push(node.literal.text);
    }

    // 所有的action定义不能有重名
    const ActionDict = {};
    actionTexts.forEach(
        (action) => {
            assert(action.length <= STRING_LITERAL_MAX_LENGTH, `${filename}中的Action「${action}」命名长度大于${STRING_LITERAL_MAX_LENGTH}`);
            assert(/^[a-z][a-z|A-Z]+$/.test(action), `${filename}中的Action「${action}」命名不合法，必须以小字字母开头且只能包含字母`)
            if (ActionDict.hasOwnProperty(action)) {
                throw new Error(`文件${filename}中，Action定义上的【${action}】动作存在同名`);
            }
            else {
                assign(ActionDict, {
                    [action]: 1,
                });
            }
        }
    );

    pushStatementIntoActionAst(moduleName,
        factory.createVariableStatement(
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createVariableDeclarationList(
                [factory.createVariableDeclaration(
                    factory.createIdentifier("actions"),
                    undefined,
                    undefined,
                    factory.createArrayLiteralExpression(
                        actionTexts.map(
                            ele => factory.createStringLiteral(ele)
                        ),
                        false
                    )
                )],
                ts.NodeFlags.Const
            )
        ),
        sourceFile
    );
}

/**
 * entity的引用一定要以 import { Schema as XXX } from '..../XXX'这种形式
 * @param declaration 
 * @param filename 
 * @returns 
 */
function getEntityImported(declaration: ts.ImportDeclaration) {
    const { moduleSpecifier, importClause } = declaration;
    let entityImported: string | undefined;

    if (ts.isStringLiteral(moduleSpecifier)) {
        const { name: importedFileName } = PathLib.parse(moduleSpecifier.text);
        const { namedBindings } = importClause!;
        if (namedBindings && ts.isNamedImports(namedBindings)) {
            const { elements } = namedBindings;
            if (elements.find(
                ele => ts.isImportSpecifier(ele) && ele.name.text === importedFileName && ele.propertyName?.text === 'Schema'
            )) {
                entityImported = importedFileName;
            }
        }
    }
    return entityImported;
}

function checkLocaleEnumAttrs(node: ts.TypeLiteralNode, attrs: string[], filename: string) {
    const { members } = node;
    const memberKeys = members.map(
        (ele) => {
            assert(ts.isPropertySignature(ele) && ts.isIdentifier(ele.name));
            return ele.name.text;
        }
    );

    const lack = difference(attrs, memberKeys);
    if (lack.length > 0) {
        throw new Error(`${filename}中缺少了对${lack.join(',')}属性的locale定义`);
    }
}

function checkLocaleExpressionPropertyExists(root: ts.ObjectLiteralExpression, attr: string, exists: boolean, filename: string) {
    const { properties } = root;
    properties.forEach(
        (ele) => {
            assert(ts.isPropertyAssignment(ele) && (ts.isIdentifier(ele.name) || ts.isStringLiteral(ele.name)) && ts.isObjectLiteralExpression(ele.initializer));
            const { properties: p2 } = ele.initializer;
            const pp = p2.find(
                (ele2) => {
                    assert(ts.isPropertyAssignment(ele2) && ts.isIdentifier(ele2.name));
                    return ele2.name.text === attr;
                }
            );
            if (exists && !pp) {
                throw new Error(`${filename}中的locale定义中的${ele.name.text}中缺少了${attr}的定义`);
            }
            else if (!exists && pp) {
                throw new Error(`${filename}中的locale定义中的${ele.name.text}中有多余的${attr}定义`);
            }
        }
    )
}

function analyzeEntity(filename: string, path: string, program: ts.Program, relativePath?: string) {
    const fullPath = `${path}/${filename}`;
    const sourceFile = program.getSourceFile(fullPath);
    const moduleName = filename.split('.')[0];

    if (Schema.hasOwnProperty(moduleName)) {
        delete ActionAsts[moduleName];
        delete SchemaAsts[moduleName];
        // removeFromRelationShip(moduleName);
        console.warn(`出现了同名的Entity定义「${moduleName}」，将使用${fullPath}取代掉默认对象，请检查新的对象结构及相关常量定义与原有的兼容，否则原有对象的相关逻辑会出现不可知异常`);
    }
    const referencedSchemas: string[] = [];
    const schemaAttrs: ts.TypeElement[] = [];
    let hasFulltextIndex: boolean = false;
    let indexes: ts.ArrayLiteralExpression;
    let beforeSchema = true;
    let hasActionDef = false;
    let hasRelationDef: boolean | ts.TypeAliasDeclaration = false;
    let hasActionOrStateDef = false;
    let toModi = false;
    let actionType = 'crud';
    let _static = false;
    const enumStringAttrs: string[] = [];
    const states: string[] = [];
    const localEnumStringTypes: string[] = [];
    const additionalImports: ts.ImportDeclaration[] = [];
    let localeDef: ts.ObjectLiteralExpression | undefined = undefined;
    // let relationHierarchy: ts.ObjectLiteralExpression | undefined = undefined;
    // let reverseCascadeRelationHierarchy: ts.ObjectLiteralExpression | undefined = undefined;
    ts.forEachChild(sourceFile!, (node) => {
        if (ts.isImportDeclaration(node)) {
            const entityImported = getEntityImported(node);
            if (entityImported) {
                referencedSchemas.push(entityImported);
            }
            else if (!process.env.COMPLING_IN_DOMAIN && !relativePath?.startsWith(LIB_OAK_DOMAIN)) {
                /**import了domain以外的其它定义类型，需要被复制到生成的Schema文件中
                 * 这里必须注意，1、假设了domain当中定义的几个entity不会引用其它文件上的定义（除了type里的那些通用类型，默认都会被输出到文件中）
                 * 2、假设了其它项目文件不会引用domain当中除了type通用类型之外的其它内容，否则不会被输出到文件中
                 * 这里主要是对import的处理比较粗略，日后有需要的时候再精修
                */
                const { moduleSpecifier, importClause } = node;
                if (ts.isStringLiteral(moduleSpecifier) && !moduleSpecifier.text.startsWith(LIB_OAK_DOMAIN)) {
                    // 编译后的路径默认要深一层
                    const moduleSpecifier2Text = relativePath
                        ? PathLib.join(
                            relativePath,
                            moduleSpecifier.text
                        ).replace(/\\/g, '/')
                        : PathLib.join('..', moduleSpecifier.text).replace(
                            /\\/g,
                            '/'
                        );
                    additionalImports.push(
                        factory.updateImportDeclaration(
                            node,
                            undefined,
                            undefined,
                            importClause,
                            factory.createStringLiteral(moduleSpecifier2Text),
                            undefined
                        )
                    );
                }
            }
        }

        if (ts.isInterfaceDeclaration(node)) {
            // schema 定义
            if (node.name.text === 'Schema') {
                assert(!localeDef, `【${filename}】locale定义须在Schema之后`);
                let hasEntityAttr = false;
                let hasEntityIdAttr = false;
                const { members, heritageClauses } = node;
                assert(['EntityShape'].includes((<ts.Identifier>heritageClauses![0].types![0].expression).text), moduleName);
                members.forEach(
                    (attrNode) => {
                        const { type, name, questionToken } = <ts.PropertySignature>attrNode;
                        const attrName = (<ts.Identifier>name).text;
                        if (ts.isTypeReferenceNode(type!)
                            && ts.isIdentifier(type.typeName)) {
                            if ((referencedSchemas.includes(type.typeName.text) || type.typeName.text === 'Schema')) {
                                addRelationship(moduleName, type.typeName.text, attrName, !!questionToken);
                                schemaAttrs.push(attrNode);
                            }
                            else if (type.typeName.text === 'Array') {
                                // 这是一对多的反向指针的引用，需要特殊处理
                                const { typeArguments } = type;
                                assert(typeArguments!.length === 1
                                    && ts.isTypeReferenceNode(typeArguments![0])
                                    && ts.isIdentifier(typeArguments![0].typeName)
                                    && referencedSchemas.includes(typeArguments![0].typeName.text),
                                    `「${filename}」非法的属性定义「${attrName}」`);
                                const reverseEntity = typeArguments![0].typeName.text;
                                if (ReversePointerRelations[reverseEntity]) {
                                    if (!ReversePointerRelations[reverseEntity].includes(moduleName)) {
                                        ReversePointerRelations[reverseEntity].push(moduleName);
                                    }
                                }
                                else {
                                    assign(ReversePointerRelations, {
                                        [reverseEntity]: [moduleName],
                                    });
                                }

                                if (reverseEntity === 'Modi') {
                                    toModi = true;
                                }
                            }
                            else {
                                schemaAttrs.push(attrNode);
                                if (localEnumStringTypes.includes(type.typeName.text)) {
                                    enumStringAttrs.push((<ts.Identifier>name).text);
                                }
                            }
                        }
                        else if (ts.isArrayTypeNode(type!) && ts.isTypeReferenceNode(type.elementType) && ts.isIdentifier(type.elementType.typeName)) {
                            const { typeName } = type.elementType;

                            if (referencedSchemas.includes(typeName.text)) {
                                // 这也是一对多的反指定义 
                                const reverseEntity = typeName.text;
                                if (ReversePointerRelations[reverseEntity]) {
                                    ReversePointerRelations[reverseEntity].push(moduleName);
                                }
                                else {
                                    assign(ReversePointerRelations, {
                                        [reverseEntity]: [moduleName],
                                    });
                                }

                                if (reverseEntity === 'Modi') {
                                    toModi = true;
                                }
                            }
                            else {
                                throw new Error(`对象${moduleName}中定义的属性${attrName}是不可识别的数组类别`);
                            }
                        }
                        else {
                            schemaAttrs.push(attrNode);
                            if (ts.isUnionTypeNode(type!)) {
                                const { types } = type;
                                if (ts.isLiteralTypeNode(types[0]) && ts.isStringLiteral(types[0].literal)) {
                                    enumStringAttrs.push((<ts.Identifier>name).text);
                                    types.forEach(
                                        (ele) => {
                                            assert(ts.isLiteralTypeNode(ele) && ts.isStringLiteral(ele.literal), `「${filename}」不支持混合型的枚举属性定义「${attrName}」`);
                                            assert(ele.literal.text.length < STRING_LITERAL_MAX_LENGTH, `「${filename}」中定义的属性枚举「${attrName}」的字符串长度应小于${STRING_LITERAL_MAX_LENGTH}`);
                                        }
                                    )
                                }
                            }
                        }

                        if (attrName === 'entity') {
                            assert(ts.isTypeReferenceNode(type!) && ts.isIdentifier(type.typeName), `「${moduleName}」中entity属性的定义不是String<32>类型，entity是系统用于表示反指指针的保留属性，请勿他用`);
                            const { typeArguments } = type;
                            assert(type.typeName.text === 'String'
                                && typeArguments
                                && typeArguments.length === 1, `「${moduleName}」中entity属性的定义不是String<32>类型，entity是系统用于表示反指指针的保留属性，请勿他用`);
                            const [node] = typeArguments;
                            if (ts.isLiteralTypeNode(node) && ts.isNumericLiteral(node.literal)) {
                                if (parseInt(node.literal.text) > 32) {
                                    assert(false, `「${moduleName}」中entity属性的定义不是String<32>类型，entity是系统用于表示反指指针的保留属性，请勿他用`);
                                }
                                else {
                                    hasEntityAttr = true;
                                }
                            }
                        }

                        if (attrName === 'entityId') {
                            assert(ts.isTypeReferenceNode(type!) && ts.isIdentifier(type.typeName), `「${moduleName}」中entityId属性的定义不是String<64>类型，entityId是系统用于表示反指指针的保留属性，请勿他用`);
                            const { typeArguments } = type;
                            assert(type.typeName.text === 'String' && typeArguments && typeArguments.length === 1, `「${moduleName}」中entityId属性的定义不是String<64>类型，entityId是系统用于表示反指指针的保留属性，请勿他用`);

                            const [node] = typeArguments;
                            if (ts.isLiteralTypeNode(node) && ts.isNumericLiteral(node.literal)) {
                                if (parseInt(node.literal.text) !== 64) {
                                    assert(false, `「${moduleName}」中entityId属性的定义不是String<64>类型，entityId是系统用于表示反指指针的保留属性，请勿他用`);
                                }
                                else {
                                    hasEntityIdAttr = true;
                                }
                            }
                        }
                    }
                );
                if (hasEntityAttr && hasEntityIdAttr) {
                    assign(ReversePointerEntities, {
                        [moduleName]: 1,
                    });
                }
                beforeSchema = false;

                // 对于不是Oper的对象，全部建立和OperEntity的反指关系
                if (!['Oper', 'OperEntity', 'ModiEntity'].includes(moduleName)) {
                    if (ReversePointerRelations['OperEntity'] && !ReversePointerRelations['OperEntity'].includes(moduleName)) {
                        ReversePointerRelations['OperEntity'].push(moduleName);
                    }
                    else {
                        assign(ReversePointerRelations, {
                            ['OperEntity']: [moduleName],
                        });
                    }

                    // 对于不是Modi的对象，全部建立和ModiEntity的反指关系
                    if (!['Modi'].includes(moduleName) && !toModi) {
                        if (ReversePointerRelations['ModiEntity'] && !ReversePointerRelations['ModiEntity'].includes(moduleName)) {
                            ReversePointerRelations['ModiEntity'].push(moduleName);
                        }
                        else {
                            assign(ReversePointerRelations, {
                                ['ModiEntity']: [moduleName],
                            });
                        }
                    }
                }
            }
            else if (beforeSchema) {
                // 本地规定的一些形状定义，直接使用
                pushStatementIntoSchemaAst(moduleName, node, sourceFile!);
            }
        }

        if (ts.isTypeAliasDeclaration(node)) {
            // action 定义
            if (node.name.text === 'Action') {
                assert(!localeDef, `【${filename}】locale定义须在Action之后`);
                hasActionDef = true;
                const modifiers = [factory.createModifier(ts.SyntaxKind.ExportKeyword)];
                pushStatementIntoActionAst(
                    moduleName,
                    factory.updateTypeAliasDeclaration(
                        node,
                        node.decorators,
                        modifiers,
                        factory.createIdentifier('ParticularAction'),
                        node.typeParameters,
                        node.type
                    ),
                    sourceFile!
                );
                const actionDefNodes = [
                    factory.createTypeReferenceNode(
                        OriginActionDict[actionType as keyof typeof OriginActionDict],
                        undefined
                    ),
                    factory.createTypeReferenceNode(
                        'ParticularAction',
                        undefined
                    )
                ] as ts.TypeNode[];
                if (hasRelationDef || moduleName === 'User') {
                    actionDefNodes.push(
                        factory.createTypeReferenceNode(
                            'RelationAction',
                            undefined
                        )
                    );
                }
                if (process.env.COMPLING_AS_LIB) {
                    actionDefNodes.push(
                        factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
                    );
                }
                pushStatementIntoActionAst(
                    moduleName,
                    factory.createTypeAliasDeclaration(
                        undefined,
                        [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
                        factory.createIdentifier("Action"),
                        undefined,
                        factory.createUnionTypeNode(actionDefNodes)
                    ),
                    sourceFile!
                );
                dealWithActions(moduleName, filename, node.type, program, sourceFile!, !!hasRelationDef || moduleName === 'User');
            }
            else if (node.name.text === 'Relation') {
                assert(!hasActionDef, `【${filename}】action定义须在Relation之后`);
                assert(!localeDef, `【${filename}】locale定义须在Relation之后`);
                // 增加userXXX对象的描述
                if (ts.isLiteralTypeNode(node.type)) {
                    assert(ts.isStringLiteral(node.type.literal));
                    assert(node.type.literal.text.length < STRING_LITERAL_MAX_LENGTH, `Relation定义的字符串长度不长于${STRING_LITERAL_MAX_LENGTH}（${filename}，${node.type.literal.text}）`);
                }
                else {
                    assert(ts.isUnionTypeNode(node.type), `Relation的定义只能是string类型（${filename}）`);
                    node.type.types.forEach(
                        (ele) => {
                            assert(ts.isLiteralTypeNode(ele) && ts.isStringLiteral(ele.literal), `Relation的定义只能是string类型（${filename}）`);
                            assert(ele.literal.text.length < STRING_LITERAL_MAX_LENGTH, `Relation定义的字符串长度不长于${STRING_LITERAL_MAX_LENGTH}（${filename}，${ele.literal.text}）`);
                        }
                    );
                }
                const entityLc = firstLetterLowerCase(moduleName);
                const relationEntityName = `User${moduleName}`;
                const relationSchemaAttrs: ts.TypeElement[] = [
                    factory.createPropertySignature(
                        undefined,
                        factory.createIdentifier("user"),
                        undefined,
                        factory.createTypeReferenceNode(
                            factory.createIdentifier("User"),
                            undefined
                        )
                    ),
                    factory.createPropertySignature(
                        undefined,
                        factory.createIdentifier(entityLc),
                        undefined,
                        factory.createTypeReferenceNode(
                            factory.createIdentifier(moduleName),
                            undefined
                        )
                    ),
                    factory.createPropertySignature(
                        undefined,
                        factory.createIdentifier('relation'),
                        undefined,
                        factory.createTypeReferenceNode(
                            factory.createIdentifier("Relation"),
                            undefined
                        )
                    ),
                ];
                assign(Schema, {
                    [relationEntityName]: {
                        schemaAttrs: relationSchemaAttrs,
                        sourceFile,
                        enumStringAttrs: ['relation'],
                        actionType: 'excludeUpdate',
                        additionalImports: [
                            factory.createImportDeclaration(
                                undefined,
                                undefined,
                                factory.createImportClause(
                                    false,
                                    undefined,
                                    factory.createNamedImports([factory.createImportSpecifier(
                                        false,
                                        undefined,
                                        factory.createIdentifier("Relation")
                                    )])
                                ),
                                factory.createStringLiteral(`../${moduleName}/Schema`),
                                undefined
                            )
                        ],
                    },
                });
                addRelationship(relationEntityName, 'User', 'user', true);
                addRelationship(relationEntityName, moduleName, entityLc, true);

                // 对UserEntityGrant对象，建立相应的反指关系
                if (ReversePointerRelations['UserEntityGrant']) {
                    if (!ReversePointerRelations['UserEntityGrant'].includes(moduleName)) {
                        ReversePointerRelations['UserEntityGrant'].push(moduleName);
                    }
                }
                else {
                    assign(ReversePointerRelations, {
                        ['UserEntityGrant']: [moduleName],
                    });
                }

                hasRelationDef = node;
            }
            else if (node.name.text.endsWith('Action') || node.name.text.endsWith('State')) {
                assert(!localeDef, `【${filename}】locale定义须在Action/State之后`);
                hasActionOrStateDef = true;
                const { type } = node;
                if (ts.isUnionTypeNode(type)) {
                    pushStatementIntoActionAst(moduleName,
                        factory.updateTypeAliasDeclaration(
                            node,
                            node.decorators,
                            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
                            node.name,
                            node.typeParameters,
                            process.env.COMPLING_AS_LIB ? factory.createUnionTypeNode([
                                ...type.types,
                                factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
                            ]) : type
                        ),
                        sourceFile!);
                }
                else {
                    assert(ts.isLiteralTypeNode(type) || ts.isTypeReferenceNode(type), `${moduleName} - ${node.name}`);
                    pushStatementIntoActionAst(moduleName,
                        factory.updateTypeAliasDeclaration(
                            node,
                            node.decorators,
                            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
                            node.name,
                            node.typeParameters,
                            process.env.COMPLING_AS_LIB ? factory.createUnionTypeNode([
                                type,
                                factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
                            ]) : type
                        ),
                        sourceFile!);
                }
            }
            else if (beforeSchema) {
                // 本地规定的一些形状定义，直接使用
                pushStatementIntoSchemaAst(moduleName, node, sourceFile!);

                if (ts.isUnionTypeNode(node.type) && ts.isLiteralTypeNode(node.type.types[0]) && ts.isStringLiteral(node.type.types[0].literal)) {
                    // 本文件内定义的枚举类型
                    localEnumStringTypes.push(node.name.text);

                    node.type.types.forEach(
                        (ele) => {
                            assert(ts.isLiteralTypeNode(ele) && ts.isStringLiteral(ele.literal), `「${filename}」不支持混合型的常量定义「${node.name.text}」`);
                            assert(ele.literal.text.length < STRING_LITERAL_MAX_LENGTH, `「${filename}」中定义的常量枚举「${node.name.text}」的字符串长度应小于${STRING_LITERAL_MAX_LENGTH}`);
                        }
                    )
                }
            }
        }

        if (ts.isVariableStatement(node)) {
            const { declarationList: { declarations } } = node;
            declarations.forEach(
                (declaration) => {
                    if (ts.isIdentifier(declaration.name) && declaration.name.text.endsWith('ActionDef')) {
                        if (declaration.type && ts.isTypeReferenceNode(declaration.type) && ts.isIdentifier(declaration.type.typeName) && declaration.type.typeName.text === 'ActionDef') {
                            // 是显示的actionDef定义
                            checkActionDefNameConsistent(filename, declaration);
                            const { typeArguments } = declaration.type;
                            assert(typeArguments!.length === 2);
                            const [actionNode, stateNode] = typeArguments!;

                            const checker = program.getTypeChecker();
                            let symbol = checker.getSymbolAtLocation((<ts.TypeReferenceNode>actionNode).typeName);

                            let declaration2 = symbol!.getDeclarations()![0];
                            if (declaration2.getSourceFile() === sourceFile) {
                                // pushStatementIntoActionAst(moduleName, <ts.TypeAliasDeclaration>declaration2, sourceFile);
                            }

                            symbol = checker.getSymbolAtLocation((<ts.TypeReferenceNode>stateNode).typeName);

                            declaration2 = symbol!.getDeclarations()![0];
                            if (declaration2.getSourceFile() === sourceFile) {
                                // 检查state的定义合法
                                assert(ts.isTypeAliasDeclaration(declaration2) && ts.isUnionTypeNode(declaration2.type), `「${filename}」State「${(<ts.TypeAliasDeclaration>declaration2).name}」的定义只能是或结点`);
                                declaration2.type.types.forEach(
                                    (type) => {
                                        assert(ts.isLiteralTypeNode(type) && ts.isStringLiteral(type.literal), `「${filename}」State「${(<ts.TypeAliasDeclaration>declaration2).name}」的定义只能是字符串`);
                                        assert(type.literal.text.length < STRING_LITERAL_MAX_LENGTH, `「${filename}」State「${type.literal.text}」的长度大于「${STRING_LITERAL_MAX_LENGTH}」`);
                                    }
                                );
                                /* pushStatementIntoActionAst(moduleName,
                                    factory.updateTypeAliasDeclaration(
                                        declaration2,
                                        declaration2.decorators,
                                        [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
                                        declaration2.name,
                                        declaration2.typeParameters,
                                        declaration2.type
                                    ),
                                    sourceFile); */
                            }
                        }

                        pushStatementIntoActionAst(moduleName, node, sourceFile!);

                        const adName = declaration.name.text.slice(0, declaration.name.text.length - 9);
                        const attr = adName.concat('State');
                        schemaAttrs.push(
                            factory.createPropertySignature(
                                undefined,
                                factory.createIdentifier(firstLetterLowerCase(attr)),
                                factory.createToken(ts.SyntaxKind.QuestionToken),
                                factory.createTypeReferenceNode(
                                    factory.createIdentifier(attr),
                                )
                            )
                        );
                        states.push(firstLetterLowerCase(attr));
                    }
                    else if (declaration.type && (ts.isArrayTypeNode(declaration.type!)
                        && ts.isTypeReferenceNode(declaration.type.elementType)
                        && ts.isIdentifier(declaration.type.elementType.typeName)
                        && declaration.type.elementType.typeName.text === 'Index'
                        || ts.isTypeReferenceNode(declaration.type!)
                        && ts.isIdentifier(declaration.type.typeName)
                        && declaration.type.typeName.text === 'Array'
                        && ts.isTypeReferenceNode(declaration.type.typeArguments![0])
                        && ts.isIdentifier(declaration.type.typeArguments![0].typeName)
                        && declaration.type.typeArguments![0].typeName.text === 'Index')) {
                        // 对索引Index的定义
                        const indexNameDict: Record<string, true> = {};
                        assert(ts.isArrayLiteralExpression(declaration.initializer!), `「${filename}」Index「${declaration.name.getText()}」的定义必须符合规范`);

                        // todo 这里应该先做一个类型检查的，但不知道怎么写  by Xc
                        // 检查索引的属性是否合法
                        const { elements } = declaration.initializer;
                        elements.forEach(
                            (ele) => {
                                let isFulltextIndex = false;
                                assert(ts.isObjectLiteralExpression(ele));
                                const { properties } = ele;
                                const attrProperty = properties.find(
                                    (ele2) => {
                                        assert(ts.isPropertyAssignment(ele2));
                                        return ele2.name.getText() === 'attributes';
                                    }
                                ) as ts.PropertyAssignment;
                                assert(ts.isArrayLiteralExpression(attrProperty.initializer));

                                const nameProperty = properties.find(
                                    (ele2) => {
                                        assert(ts.isPropertyAssignment(ele2));
                                        return ele2.name.getText() === 'name';
                                    }
                                ) as ts.PropertyAssignment;
                                assert(ts.isStringLiteral(nameProperty.initializer));
                                const nameText = nameProperty.initializer.text;
                                if (indexNameDict[nameText]) {
                                    throw new Error(`「${filename}」索引定义重名「${nameText}」`);
                                }
                                assign(indexNameDict, {
                                    [nameText]: true,
                                });

                                const configProperty = properties.find(
                                    (ele2) => {
                                        assert(ts.isPropertyAssignment(ele2));
                                        return ele2.name.getText() === 'config';
                                    }
                                ) as ts.PropertyAssignment;
                                if (configProperty) {
                                    assert(ts.isObjectLiteralExpression(configProperty.initializer));
                                    const { properties: properties2 } = configProperty.initializer;
                                    const typeProperty = properties2.find(
                                        (ele2) => {
                                            assert(ts.isPropertyAssignment(ele2));
                                            return ele2.name.getText() === 'type';
                                        }
                                    ) as ts.PropertyAssignment;

                                    if (typeProperty && (<ts.Identifier>typeProperty.initializer!).text === 'fulltext') {
                                        // 定义了全文索引
                                        if (hasFulltextIndex) {
                                            throw new Error(`「${filename}」只能定义一个全文索引`);
                                        }
                                        hasFulltextIndex = true;
                                        isFulltextIndex = true;
                                    }
                                }

                                const { elements } = attrProperty.initializer;

                                // 每个属性都应该在schema中有值，且对象类型是可索引值
                                elements.forEach(
                                    (ele2) => {
                                        assert(ts.isObjectLiteralExpression(ele2));
                                        const { properties: properties2 } = ele2;

                                        const nameProperty = properties2.find(
                                            (ele3) => {
                                                assert(ts.isPropertyAssignment(ele3));
                                                return ele3.name.getText() === 'name';
                                            }
                                        ) as ts.PropertyAssignment;

                                        const indexAttrName = (<ts.Identifier>nameProperty.initializer!).text;
                                        if (!initinctiveAttributes.includes(indexAttrName)) {
                                            const schemaNode = schemaAttrs.find(
                                                (ele3) => {
                                                    assert(ts.isPropertySignature(ele3));
                                                    return (<ts.Identifier>ele3.name).text === indexAttrName;
                                                }
                                            ) as ts.PropertySignature;
                                            if (!schemaNode) {
                                                throw new Error(`「${filename}」中索引「${nameText}」的属性「${indexAttrName}」定义非法`);
                                            }

                                            const { type, name } = schemaNode;
                                            const entity = moduleName;
                                            const { [entity]: manyToOneSet } = ManyToOne;
                                            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, attrName]) => refEntity === text2 && attrName === (<ts.Identifier>name).text
                                                    );
                                                    if (!manyToOneItem) {
                                                        // 如果不是外键，则不能是Text, File 
                                                        if (isFulltextIndex) {
                                                            assert(['Text', 'String'].includes(text2), `「${filename}」中全文索引「${nameText}」定义的属性「${indexAttrName}」类型非法，只能是Text/String`);
                                                        }
                                                        else {
                                                            assert(!unIndexedTypes.includes(text2), `「${filename}」中索引「${nameText}」的属性「${indexAttrName}」的类型为「${text2}」，不可索引`);
                                                        }
                                                    }
                                                    else {
                                                        assert(!isFulltextIndex, `「${filename}」中全文索引「${nameText}」的属性「${indexAttrName}」类型非法，只能为Text/String`);
                                                        // 在这里把外键加上Id，这样storageSchema才能正常通过
                                                        // 这里的写法不太好，未来TS版本高了可能会有问题。by Xc 20230131
                                                        Object.assign(nameProperty, {
                                                            initializer: factory.createStringLiteral(`${indexAttrName}Id`),
                                                        });
                                                    }
                                                }
                                                else {
                                                    assert(false);          // 这是什么case，不确定
                                                }
                                            }
                                            else {
                                                assert(!isFulltextIndex, `「${filename}」中全文索引「${nameText}」的属性「${indexAttrName}」类型只能为Text/String`);
                                                assert(ts.isUnionTypeNode(type!) || ts.isLiteralTypeNode(type!), `${entity}中索引「${nameText}」的属性${(<ts.Identifier>name).text}有定义非法`);
                                            }
                                        }
                                    }
                                );
                            }
                        );

                        indexes = declaration.initializer;
                    }
                    else if (ts.isTypeReferenceNode(declaration.type!) && ts.isIdentifier(declaration.type.typeName) && declaration.type.typeName.text === 'LocaleDef') {
                        // locale定义
                        const { type, initializer } = declaration;

                        assert(ts.isObjectLiteralExpression(initializer!));
                        const { properties } = initializer;
                        assert(properties.length > 0, `${filename}至少需要有一种locale定义`);


                        const allEnumStringAttrs = enumStringAttrs.concat(states);
                        const { typeArguments } = type;
                        assert(typeArguments &&
                            ts.isTypeReferenceNode(typeArguments[0])
                            && ts.isIdentifier(typeArguments[0].typeName) && typeArguments[0].typeName.text === 'Schema', `${filename}中缺少locale定义，或者locale类型定义的第一个参数不是Schema`);

                        if (hasActionDef) {
                            assert(ts.isTypeReferenceNode(typeArguments[1])
                                && ts.isIdentifier(typeArguments[1].typeName) && typeArguments[1].typeName.text === 'Action', `${filename}中locale类型定义的第二个参数不是Action`);
                            // 检查每种locale定义中都应该有'action'域
                            checkLocaleExpressionPropertyExists(initializer, 'action', true, filename);
                        }
                        else {
                            assert(ts.isLiteralTypeNode(typeArguments[1])
                                && ts.isStringLiteral(typeArguments[1].literal), `${filename}中locale类型定义的第二个参数不是字符串`);
                            checkLocaleExpressionPropertyExists(initializer, 'action', false, filename);
                        }

                        if (hasRelationDef) {
                            assert(ts.isTypeReferenceNode(typeArguments[2])
                                && ts.isIdentifier(typeArguments[2].typeName)
                                && typeArguments[2].typeName.text === 'Relation', `${filename}中的locale类型定义的第三个参数不是Relation`);
                            // 检查每种locale定义中都应该有'r'域
                            checkLocaleExpressionPropertyExists(initializer, 'r', true, filename);
                        }
                        else {
                            assert(ts.isLiteralTypeNode(typeArguments[2])
                                && ts.isStringLiteral(typeArguments[2].literal), `${filename}中locale类型定义的第三个参数不是空字符串`);
                            checkLocaleExpressionPropertyExists(initializer, 'r', false, filename);
                        }

                        if (allEnumStringAttrs.length > 0) {
                            assert(ts.isTypeLiteralNode(typeArguments[3]), `${filename}中的locale类型定义的第四个参数不是{}`);
                            checkLocaleEnumAttrs(typeArguments[3], allEnumStringAttrs, filename);
                            // 检查每种locale定义中都应该有'v'域
                            checkLocaleExpressionPropertyExists(initializer, 'v', true, filename);
                        }
                        else {
                            assert(ts.isTypeLiteralNode(typeArguments[3]), `${filename}中的locale类型定义的第四个参数不是{}`);
                            assert(typeArguments[3].members.length == 0, `${filename}中locale类型定义的第四个参数不应存在相应的v定义`)
                            // 检查每种locale定义中都应该有'v'域
                            checkLocaleExpressionPropertyExists(initializer, 'v', false, filename);
                        }

                        localeDef = initializer;
                    }
                    else if (ts.isTypeReferenceNode(declaration.type!) && ts.isIdentifier(declaration.type.typeName) && declaration.type.typeName.text === 'Configuration') {
                        assert(!hasActionDef, `${moduleName}中的Configuration定义在Action之后`);
                        assert(ts.isObjectLiteralExpression(declaration.initializer!));
                        const { properties } = declaration.initializer;
                        const atProperty = properties.find(
                            ele => ts.isPropertyAssignment(ele) && ts.isIdentifier(ele.name) && ele.name.text === 'actionType'
                        );
                        const staticProperty = properties.find(
                            ele => ts.isPropertyAssignment(ele) && ts.isIdentifier(ele.name) && ele.name.text === 'static'
                        );
                        if (atProperty) {
                            actionType = (<ts.StringLiteral>(<ts.PropertyAssignment>atProperty).initializer).text;
                        }
                        if (staticProperty) {
                            _static = true;     // static如果有值只能为true
                        }
                    }
                    /* else if (ts.isTypeReferenceNode(declaration.type!) && ts.isIdentifier(declaration.type.typeName) && declaration.type.typeName.text === 'RelationHierarchy') {
                        // RelationHierary
                        assert(hasRelationDef, `${moduleName}中的Relation定义在RelationHierarchy之后`);
                        const { initializer } = declaration;
                        assert(ts.isObjectLiteralExpression(initializer!), `${moduleName}中的RelationHierarchy的定义必须是初始化为ObjectLiteralExpress`);
                        relationHierarchy = initializer;
                    }
                    else if (ts.isTypeReferenceNode(declaration.type!) && ts.isIdentifier(declaration.type.typeName) && declaration.type.typeName.text === 'ReverseCascadeRelationHierarchy') {
                        // ReverseCascadeRelationHierarchy
                        assert(hasRelationDef, `${moduleName}中的Relation定义在ReverseCascadeRelationHierarchy之后`);
                        const { initializer } = declaration;
                        assert(ts.isObjectLiteralExpression(initializer!), `${moduleName}中的RelationHierarchy的定义必须是初始化为ObjectLiteralExpress`);
                        reverseCascadeRelationHierarchy = initializer;
                    } */
                    else {
                        throw new Error(`${moduleName}：不能理解的定义内容${(declaration.name as ts.Identifier).text}`);
                    }
                }
            );
        }
    });

    if (!hasActionDef && hasActionOrStateDef) {
        throw new Error(`${filename}中有Action或State定义，但没有定义完整的Action类型`);
    }
    if (hasActionDef && actionType !== 'crud') {
        throw new Error(`${filename}中有Action定义，但却定义了actionType不是crud`);
    }
    assert(schemaAttrs.length > 0, `对象${moduleName}没有任何属性定义`);
    const schema = {
        schemaAttrs,
        sourceFile,
        toModi,
        actionType,
        static: _static,
        hasRelationDef,
        enumStringAttrs: enumStringAttrs.concat(states),
        additionalImports,
    };
    if (hasFulltextIndex) {
        assign(schema, {
            fulltextIndex: true,
        });
    }
    if (indexes!) {
        assign(schema, {
            indexes,
        });
    }
    if (!localeDef) {
        throw new Error(`${filename}中缺少了locale定义`);
    }
    else {
        assign(schema, {
            locale: localeDef,
        });
    }
    /* if (hasRelationDef) {
        if(!relationHierarchy && !reverseCascadeRelationHierarchy){
            console.warn(`${filename}中定义了Relation,但并没有relationHierarchy或reverseCascadeRelationHierarchy的定义，请注意自主编写权限分配的checker`);
        }
        if (relationHierarchy) {
            assign(schema, {
                relationHierarchy,
            });
        }
        if (reverseCascadeRelationHierarchy) {
            assign(schema, {
                reverseCascadeRelationHierarchy,
            });
        }
    }
    else {
        assert(!relationHierarchy, `${filename}中具有relationHierarchy定义但没有Relation定义`);
        assert(!reverseCascadeRelationHierarchy, `${filename}中具有reverseCascadeRelationHierarchy定义但没有Relation定义`)
    } */

    assign(Schema, {
        [moduleName]: schema,
    });
}

/**
 * 生成Schema
 * @param statements 
 * @param schemaAttrs 
 * @param entity 
 */
function constructSchema(statements: Array<ts.Statement>, entity: string) {
    const { schemaAttrs } = Schema[entity];
    const members: Array<ts.TypeElement> = [
    ];
    const members2: Array<ts.TypeElement> = [];

    const { [entity]: manyToOneSet } = ManyToOne;
    const { [entity]: oneToManySet } = OneToMany;
    const referenceEntities: string[] = [];
    for (const attr of schemaAttrs) {
        const { type, name, questionToken } = attr;
        const attrName = (<ts.Identifier>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, attrName]) => refEntity === text2 && attrName === 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(firstLetterLowerCase(text2))
                                        )
                                    ]
                                ),
                                factory.createLiteralTypeNode(factory.createNull())
                            ]) : factory.createTypeReferenceNode(
                                factory.createIdentifier('ForeignKey'),
                                [
                                    factory.createLiteralTypeNode(
                                        factory.createStringLiteral(firstLetterLowerCase(text2))
                                    )
                                ]
                            )
                        )
                    );
                }
                else {
                    // assert(types.includes(text), `${entity}中的属性${name.toString()}有非法的属性类型定义`);
                    // 处理entity这种特殊情况
                    if (ReversePointerRelations[entity] && attrName === 'entity') {
                        const entityUnionTypeNode: ts.TypeNode[] = ReversePointerRelations[entity].map(
                            ele => factory.createLiteralTypeNode(
                                factory.createStringLiteral(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 {
                assert(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
                )
            );
        }
    }
    // 处理reverserPointer
    const reverseOnes = ReversePointerRelations[entity];
    if (reverseOnes) {
        reverseOnes.forEach(
            (one) => {
                referenceEntities.push(one);
                members2.push(
                    factory.createPropertySignature(
                        undefined,
                        firstLetterLowerCase(one),
                        factory.createToken(ts.SyntaxKind.QuestionToken),
                        factory.createTypeReferenceNode(
                            createForeignRef(entity, one, 'Schema')
                        )
                    )
                );
            }
        )
    }

    const foreignKeySet: Record<string, string[]> = {};
    if (oneToManySet) {
        for (const oneToManyItem of oneToManySet) {
            const [entityName, foreignKey] = oneToManyItem;
            if (referenceEntities.indexOf(entityName) === -1) {
                referenceEntities.push(entityName);
            }

            if (foreignKeySet.hasOwnProperty(entityName)) {
                foreignKeySet[entityName].push(foreignKey);
            }
            else {
                foreignKeySet[entityName] = [foreignKey];
            }
        }
        for (const entityName in foreignKeySet) {
            const entityNameLc = firstLetterLowerCase(entityName);
            foreignKeySet[entityName].forEach(
                (foreignKey) => {
                    const identifier = `${entityNameLc}$${foreignKey}`;
                    members2.push(
                        factory.createPropertySignature(
                            undefined,
                            identifier,
                            factory.createToken(ts.SyntaxKind.QuestionToken),
                            factory.createTypeReferenceNode(
                                factory.createIdentifier("Array"),
                                [factory.createTypeReferenceNode(
                                    createForeignRef(entity, entityName, 'Schema'),
                                    undefined
                                )]
                            ),
                        )
                    );
                    const aggrIdentifier = `${entityNameLc}$${foreignKey}$$aggr`;
                    members2.push(
                        factory.createPropertySignature(
                            undefined,
                            aggrIdentifier,
                            factory.createToken(ts.SyntaxKind.QuestionToken),
                            factory.createTypeReferenceNode(
                                factory.createIdentifier("AggregationResult"),
                                [factory.createTypeReferenceNode(
                                    createForeignRef(entity, entityName, 'Schema'),
                                    undefined
                                )]
                            )
                        )
                    )
                }
            );
        }
    }


    uniq(referenceEntities).forEach(
        (ele) => {
            if (ele !== entity) {
                statements.push(factory.createImportDeclaration(
                    undefined,
                    undefined,
                    factory.createImportClause(
                        false,
                        undefined,
                        factory.createNamespaceImport(
                            factory.createIdentifier(ele)
                        )
                    ),
                    factory.createStringLiteral(`../${ele}/Schema`)
                ));
            }
        }
    );

    // 在这里把需要直接拷贝过来的语句写入
    if (SchemaAsts[entity]) {
        statements.push(...SchemaAsts[entity].statements);
    }


    statements.push(
        factory.createTypeAliasDeclaration(
            undefined,
            [
                factory.createModifier(ts.SyntaxKind.ExportKeyword)
            ],
            factory.createIdentifier('OpSchema'),
            undefined,
            factory.createIntersectionTypeNode([
                factory.createTypeReferenceNode('EntityShape'),
                factory.createTypeLiteralNode(members)
            ])
        ),
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("OpAttr"),
            undefined,
            factory.createTypeOperatorNode(
                ts.SyntaxKind.KeyOfKeyword,
                factory.createTypeReferenceNode(
                    factory.createIdentifier("OpSchema"),
                    undefined
                )
            )
        )
    );

    statements.push(
        factory.createTypeAliasDeclaration(
            undefined,
            [
                factory.createModifier(ts.SyntaxKind.ExportKeyword)
            ],
            factory.createIdentifier('Schema'),
            undefined,
            factory.createIntersectionTypeNode(
                [
                    factory.createTypeReferenceNode('EntityShape'),
                    factory.createTypeLiteralNode(members.concat(members2)),
                    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
                    )
                ]
            )
        )
    );
}

/**
 * 生成Query
 * @param statements 
 * @param schemaAttrs 
 * @param entity 
 */
function constructFilter(statements: Array<ts.Statement>, entity: string) {
    const { schemaAttrs, fulltextIndex } = Schema[entity];
    const members: Array<ts.TypeElement> = [
        // 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_StringValue'),
            )
        ),
        // $$updateAt$$: Q_DateValue
        factory.createPropertySignature(
            undefined,
            factory.createIdentifier('$$updateAt$$'),
            undefined,
            factory.createTypeReferenceNode(
                factory.createIdentifier('Q_DateValue'),
            )
        )
    ];

    const { [entity]: manyToOneSet } = ManyToOne;

    for (const attr of schemaAttrs) {
        const { type, name } = <ts.PropertySignature>attr;
        const attrName = (<ts.Identifier>name).text;
        if (ts.isTypeReferenceNode(type!)) {
            const { typeName } = type;
            if (ts.isIdentifier(typeName)) {
                const { text } = typeName;
                let type2: ts.TypeNode;
                switch (text) {
                    case 'String':
                    case 'Text':
                    case 'Image':
                    case 'File': {
                        if (ReversePointerRelations[entity] && attrName === 'entity') {
                            type2 = factory.createTypeReferenceNode('E');
                        }
                        else {
                            type2 = factory.createTypeReferenceNode(
                                factory.createIdentifier('Q_StringValue'),
                            );
                        }
                        break;
                    }
                    case 'Int':
                    case 'Uint':
                    case 'Float':
                    case 'Double': {
                        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,
                                    `${(<ts.Identifier>name).text}Id`,
                                    undefined,
                                    factory.createUnionTypeNode([
                                        factory.createTypeReferenceNode(
                                            factory.createIdentifier('Q_StringValue'),
                                        ),
                                        factory.createTypeReferenceNode(
                                            factory.createQualifiedName(
                                                factory.createIdentifier("SubQuery"),
                                                factory.createIdentifier(`${text2}IdSubQuery`)
                                            ),
                                            undefined
                                        )
                                    ])
                                )
                            );
                            type2 = factory.createTypeReferenceNode(
                                createForeignRef(entity, text2, 'Filter')
                            );
                        }
                        else {
                            // 这里应该都是引用某个UnionType类型的定义了，如何判断？
                            // const words = getStringTextFromUnionStringLiterals();
                            type2 = factory.createTypeReferenceNode(
                                factory.createIdentifier('Q_EnumValue'),
                                [
                                    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
        }
    }

    // type AttrFilter = {};
    if (ReversePointerRelations[entity]) {
        // 有反向指针，将反向指针关联的对象的Filter也注入
        ReversePointerRelations[entity].forEach(
            ele =>
                members.push(
                    factory.createPropertySignature(
                        undefined,
                        firstLetterLowerCase(ele),
                        undefined,
                        factory.createTypeReferenceNode(
                            createForeignRef(entity, ele, 'Filter')
                        )
                    )
                )
        );
    }
    const eumUnionTypeNode: ts.TypeNode[] = ReversePointerRelations[entity] && ReversePointerRelations[entity].map(
        ele => factory.createLiteralTypeNode(
            factory.createStringLiteral(firstLetterLowerCase(ele))
        )
    );
    if (process.env.COMPLING_AS_LIB) {
        eumUnionTypeNode && eumUnionTypeNode.push(
            factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
        );
    }
    statements.push(
        factory.createTypeAliasDeclaration(
            undefined,
            undefined,
            factory.createIdentifier('AttrFilter'),
            ReversePointerRelations[entity] ? [
                factory.createTypeParameterDeclaration(
                    undefined,
                    factory.createIdentifier("E"),
                    undefined,
                )
            ] : undefined,
            factory.createTypeLiteralNode(members)
        )
    );

    /**
     * 
    export type Filter = AttrFilter | Partial<ExprOp<OpSchema> | {
            [F in Q_LogicKey]: Filter[];
        } | {
            [F in Q_FullTextKey]: Q_FullTextValue;
        }>;

     */
    const types: ts.TypeNode[] = [
        factory.createTypeReferenceNode(
            factory.createIdentifier("AttrFilter"),
            ReversePointerRelations[entity] ? [factory.createTypeReferenceNode('E')] : undefined
        ),
        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(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("Filter"),
            ReversePointerRelations[entity] ? [
                factory.createTypeParameterDeclaration(
                    undefined,
                    factory.createIdentifier("E"),
                    undefined,
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("Q_EnumValue"),
                        [
                            factory.createUnionTypeNode(
                                eumUnionTypeNode
                            )
                        ]
                    )
                )
            ] : undefined,
            factory.createTypeReferenceNode(
                factory.createIdentifier("MakeFilter"),
                [factory.createIntersectionTypeNode(types)]
            )
        )
    );
}

/**
 * 构造Projection和OneAttrProjection
 * @param statements 
 * @param entity 
 */
function constructProjection(statements: Array<ts.Statement>, entity: string) {
    const { schemaAttrs } = Schema[entity];
    const properties: Array<[string | ts.PropertyName, boolean, ts.TypeNode?/* , ts.TypeNode? */]> = [
        ['id', false],
        ['$$createAt$$', false],
        ['$$updateAt$$', false],
        ['$$seq$$', false],
    ];
    const foreignKeyProperties: {
        [k: string]: [string]
    } = {
        [entity]: [''],
    };

    const { [entity]: manyToOneSet } = ManyToOne;

    for (const attr of schemaAttrs) {
        const { type, name } = <ts.PropertySignature>attr;
        const attrName = (<ts.Identifier>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 'Float':
                    case 'Double':
                    case 'Boolean':
                    case 'Datetime':
                    case 'Image':
                    case 'File':
                    case 'SingleGeo':
                    case 'Geo':
                    case 'Object': {
                        properties.push(
                            [name, false]
                        )
                        break;
                    }
                    default: {
                        const text2 = text === 'Schema' ? entity : text;
                        const manyToOneItem = manyToOneSet && manyToOneSet.find(
                            ([refEntity]) => refEntity === text2
                        );
                        if (manyToOneItem) {
                            // 外键投影
                            properties.push(
                                [`${attrName}Id`, false, undefined],
                                [name, false, factory.createTypeReferenceNode(
                                    createForeignRef(entity, text2, 'Projection')
                                )/* , factory.createTypeReferenceNode(
                                    createForeignRef(entity, text2, 'ExportProjection')
                                ) */]
                            );
                            if (foreignKeyProperties.hasOwnProperty(text2)) {
                                foreignKeyProperties[text2].push(attrName);
                            }
                            else {
                                assign(foreignKeyProperties, {
                                    [text2]: [attrName],
                                });
                            }
                        }
                        else {
                            // todo 此处是对State的专门处理
                            if (text.endsWith('State')) {
                                properties.push(
                                    [name, false, undefined]
                                );
                            }
                            else {
                                // 引用的shape
                                properties.push(
                                    [name, false, undefined]
                                );
                            }
                        }
                    }
                }
            }
            else {
                assert(false);
            }
        }
        else {
            // 增加了本身object的shape定义
            // assert(ts.isUnionTypeNode(type!) && ts.isLiteralTypeNode(type.types[0]) || ts.isLiteralTypeNode(type!));
            properties.push(
                [name, false, undefined]
            )
        }
    }

    if (ReversePointerRelations[entity]) {
        ReversePointerRelations[entity].forEach(
            (one) => {
                const text2 = one === 'Schema' ? entity : one;
                properties.push(
                    [firstLetterLowerCase(one), false, factory.createTypeReferenceNode(
                        createForeignRef(entity, one, 'Projection')
                    )/* , factory.createTypeReferenceNode(
                        createForeignRef(entity, one, 'ExportProjection')
                    ) */]
                );
                if (foreignKeyProperties.hasOwnProperty(one)) {
                    foreignKeyProperties[text2].push('entity');
                }
                else {
                    assign(foreignKeyProperties, {
                        [text2]: ['entity'],
                    });
                }
            }
        )
    }

    // 一对多的projection
    const { [entity]: oneToManySet } = OneToMany;
    if (oneToManySet) {
        const foreignKeySet: Record<string, string[]> = {};
        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 = firstLetterLowerCase(entityName);
            foreignKeySet[entityName].forEach(
                (foreignKey) => {
                    const identifier = `${entityNameLc}$${foreignKey}`;
                    const aggrIdentifier = `${entityNameLc}$${foreignKey}$$aggr`;
                    properties.push(
                        [identifier, false,
                            factory.createIntersectionTypeNode([
                                factory.createTypeReferenceNode(
                                    createForeignRef(entity, entityName, 'Selection'),
                                    undefined
                                ),
                                factory.createTypeLiteralNode([
                                    factory.createPropertySignature(
                                        undefined,
                                        factory.createIdentifier("$entity"),
                                        undefined,
                                        factory.createLiteralTypeNode(factory.createStringLiteral(firstLetterLowerCase(entityName)))
                                    )
                                ])
                            ])/* ,
                            factory.createIntersectionTypeNode([
                                factory.createTypeReferenceNode(
                                    createForeignRef(entity, entityName, 'Exportation'),
                                    undefined
                                ),
                                factory.createTypeLiteralNode([
                                    factory.createPropertySignature(
                                        undefined,
                                        factory.createIdentifier("$entity"),
                                        undefined,
                                        factory.createLiteralTypeNode(factory.createStringLiteral(firstLetterLowerCase(entityName)))
                                    )
                                ])
                            ]) */
                        ],
                        [aggrIdentifier, false,
                            factory.createIntersectionTypeNode([
                                factory.createTypeReferenceNode(
                                    createForeignRef(entity, entityName, 'Aggregation'),
                                    undefined
                                ),
                                factory.createTypeLiteralNode([
                                    factory.createPropertySignature(
                                        undefined,
                                        factory.createIdentifier("$entity"),
                                        undefined,
                                        factory.createLiteralTypeNode(factory.createStringLiteral(firstLetterLowerCase(entityName)))
                                    )
                                ])
                            ])
                        ]
                    );
                }
            );
        }
    }

    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: ts.TypeElement[] = [
        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,
                undefined,
                [factory.createParameterDeclaration(
                    undefined,
                    undefined,
                    undefined,
                    factory.createIdentifier("k"),
                    undefined,
                    factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
                    undefined
                )],
                factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
            )
        )
    }
    // Projection，正常查询的投影
    statements.push(
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("Projection"),
            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,
            ])
        )
    );

    // ExportProjection，下载查询的投影 
    // 已经废弃。By Xc 2023.01.08
    /* statements.push(
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("ExportProjection"),
            undefined,
            factory.createIntersectionTypeNode([
                factory.createTypeLiteralNode(
                    MetaPropertySignaturs.concat(
                        properties.map(
                            ([n, q, v, v2]) => {
                                return factory.createPropertySignature(
                                    undefined,
                                    n,
                                    factory.createToken(ts.SyntaxKind.QuestionToken),
                                    v2 || factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
                                )
                            }
                        )
                    )
                ),
                exprNode,
            ])
        )
    ); */

    // ${Entity}Projection，外键查询的专用投影
    for (const foreignKey in foreignKeyProperties) {
        const identifier = `${foreignKey}IdProjection`;
        statements.push(
            factory.createTypeAliasDeclaration(
                undefined,
                undefined,
                factory.createIdentifier(identifier),
                undefined,
                factory.createTypeReferenceNode(
                    factory.createIdentifier("OneOf"),
                    [
                        factory.createTypeLiteralNode(
                            foreignKeyProperties[foreignKey].map(
                                (attr) => factory.createPropertySignature(
                                    undefined,
                                    attr ? factory.createIdentifier(`${attr}Id`) : 'id',
                                    undefined,
                                    factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
                                )
                            )
                        )
                    ]
                )
            )
        );
    }
}

/**
 * 构造Query
 * @param statements 
 * @param entity 
 */
function constructQuery(statements: Array<ts.Statement>, entity: string) {
    const entityLc = 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(
                            factory.createIdentifier("Operation"),
                            undefined
                        )
                    ]
                )
            ])
        )
    ); */

    /**
      * export type ExportQuery = {
         entity: 'user';
         projection: ExportProjection;
         filter?: Filter;
         sort?: Sorter;
         indexFrom?: number;
         count?: number;
     };
      */
    /* statements.push(
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("ExportQuery"),
            undefined,
            factory.createIntersectionTypeNode([
                factory.createTypeLiteralNode([
                    factory.createPropertySignature(
                        undefined,
                        factory.createIdentifier("projection"),
                        undefined,
                        factory.createTypeReferenceNode(
                            factory.createIdentifier("ExportProjection"),
                            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
                        )
                    ]
                )
            ])
        )
    ); */

    // 对每个可能的外键的子查询，建立相应的${Entity}IdSubQuery    
    const { [entity]: manyToOneSet } = ManyToOne;
    let manyToSelf = false;
    if (manyToOneSet) {
        uniqBy(manyToOneSet, ([a]) => a).forEach(
            ([oneEntity, foreignKey]) => {
                statements.push(
                    factory.createTypeAliasDeclaration(
                        undefined,
                        [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
                        factory.createIdentifier(`${oneEntity}IdSubQuery`),
                        undefined,
                        factory.createTypeReferenceNode(
                            factory.createIdentifier("Selection"),
                            [factory.createTypeReferenceNode(
                                factory.createIdentifier(`${oneEntity}IdProjection`),
                                undefined
                            )]
                        )
                    )
                );

                if (oneEntity === entity) {
                    manyToSelf = true;
                }
            }
        );
    }

    // 主键可能产生的子查询
    if (!manyToSelf) {
        statements.push(
            factory.createTypeAliasDeclaration(
                undefined,
                [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
                factory.createIdentifier(`${entity}IdSubQuery`),
                undefined,
                factory.createTypeReferenceNode(
                    factory.createIdentifier("Selection"),
                    [factory.createTypeReferenceNode(
                        factory.createIdentifier(`${entity}IdProjection`),
                        undefined
                    )]
                )
            )
        );
    }
}

/**
 * 构造Sort
 * @param statements 
 * @param entity 
 */
function constructSorter(statements: Array<ts.Statement>, entity: string) {
    const { schemaAttrs } = Schema[entity];
    const members: Array<ts.TypeNode> = [
        // id: 1
        factory.createTypeLiteralNode(
            [factory.createPropertySignature(
                undefined,
                factory.createIdentifier("id"),
                undefined,
                factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
            )]
        ),
        // $$createAt$$: 1
        factory.createTypeLiteralNode(
            [factory.createPropertySignature(
                undefined,
                factory.createIdentifier("$$createAt$$"),
                undefined,
                factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
            )]
        ),
        // $$seq$$: 1
        factory.createTypeLiteralNode(
            [factory.createPropertySignature(
                undefined,
                factory.createIdentifier("$$seq$$"),
                undefined,
                factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
            )]
        ),
        // $$updateAt$$: 1
        factory.createTypeLiteralNode(
            [factory.createPropertySignature(
                undefined,
                factory.createIdentifier("$$updateAt$$"),
                undefined,
                factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
            )]
        ),
    ];

    const { [entity]: manyToOneSet } = ManyToOne;

    for (const attr of schemaAttrs) {
        const { type, name, questionToken } = <ts.PropertySignature>attr;
        if (ts.isTypeReferenceNode(type!)) {
            const { typeName } = type;
            if (ts.isIdentifier(typeName)) {
                const { text } = typeName;
                let type2: ts.TypeNode;
                switch (text) {
                    case 'String':
                    case 'Text':
                    case 'Int':
                    case 'Float':
                    case 'Double':
                    case 'Boolean':
                    case 'Datetime':
                    case 'Image':
                    case 'File': {
                        type2 = factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
                        break;
                    }
                    default: {
                        const text2 = text === 'Schema' ? entity : text;
                        const manyToOneItem = manyToOneSet && manyToOneSet.find(
                            ([refEntity]) => refEntity === text2
                        );
                        if (manyToOneItem) {
                            type2 = factory.createTypeReferenceNode(
                                <ts.EntityName>createForeignRef(entity, text2, 'SortAttr')
                            );

                            members.push(
                                factory.createTypeLiteralNode(
                                    [factory.createPropertySignature(
                                        undefined,
                                        factory.createIdentifier(`${(<ts.Identifier>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.createTypeLiteralNode(
                            [factory.createPropertySignature(
                                undefined,
                                name,
                                undefined,
                                type2
                            )]
                        )
                    );
                }
            }
        }
        else if (ts.isUnionTypeNode(type!) && ts.isLiteralTypeNode(type.types[0]) || ts.isLiteralTypeNode(type!)) {
            members.push(
                factory.createTypeLiteralNode(
                    [factory.createPropertySignature(
                        undefined,
                        name,
                        undefined,
                        factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
                    )]
                )
            );
        }
        else {
            // 本地规定的shape，非结构化属性不参与排序
        }
    }

    if (ReversePointerRelations[entity]) {
        ReversePointerRelations[entity].forEach(
            (one) => {
                members.push(
                    factory.createTypeLiteralNode(
                        [factory.createPropertySignature(
                            undefined,
                            firstLetterLowerCase(one),
                            undefined,
                            factory.createTypeReferenceNode(
                                <ts.EntityName>createForeignRef(entity, one, 'SortAttr')
                            )
                        )]
                    )
                );
            }
        );
    }

    if (process.env.COMPLING_AS_LIB) {
        members.push(
            factory.createTypeLiteralNode([factory.createIndexSignature(
                undefined,
                undefined,
                [factory.createParameterDeclaration(
                    undefined,
                    undefined,
                    undefined,
                    factory.createIdentifier("k"),
                    undefined,
                    factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
                    undefined
                )],
                factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
            )])
        );
    }

    members.push(
        factory.createTypeReferenceNode(
            factory.createIdentifier("OneOf"),
            [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')
                        )
                ]
            )]
        )
    );
    /**
     * 
        export type SortAttr = {
            id: 1;
        } | {
            $$createAt$$: 1;
        } | {
            $$updateAt$$: 1;
        } | {
            modiId: 1;
        } | {
            modi: Modi.SortAttr;
        } | {
            [k: string]: any;
        } | OneOf<ExprOp<OpAttr>>
     */
    statements.push(
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("SortAttr"),
            undefined,
            factory.createUnionTypeNode(members)
        )
    );

    /**
     * export type SortNode = {
        $attr: SortAttr;
        $direction?: 'asc' | 'desc';
    };
     */
    statements.push(
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("SortNode"),
            undefined,
            factory.createTypeLiteralNode([
                factory.createPropertySignature(
                    undefined,
                    factory.createIdentifier("$attr"),
                    undefined,
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("SortAttr"),
                        undefined
                    )
                ),
                factory.createPropertySignature(
                    undefined,
                    factory.createIdentifier("$direction"),
                    factory.createToken(ts.SyntaxKind.QuestionToken),
                    factory.createUnionTypeNode([
                        factory.createLiteralTypeNode(factory.createStringLiteral("asc")),
                        factory.createLiteralTypeNode(factory.createStringLiteral("desc"))
                    ])
                )
            ])
        )
    );

    /**
     * export type Sorter = SortNode[];
     */
    statements.push(
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("Sorter"),
            undefined,
            factory.createArrayTypeNode(factory.createTypeReferenceNode(
                factory.createIdentifier("SortNode"),
                undefined
            ))
        )
    )
}

function constructFullAttrs(statements: Array<ts.Statement>, entity: string) {
    const { [entity]: manyToOneSet } = ManyToOne;
    const { [entity]: oneToManySet } = OneToMany;

    if (manyToOneSet && manyToOneSet.length) {
        const mtoAttrs: ts.TypeNode[] = [];
        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(
                                "",
                                ""
                            )
                        )
                        ]
                    )
                );
            }
        }
        statements.push(
            factory.createTypeAliasDeclaration(
                undefined,
                [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
                factory.createIdentifier("NativeAttr"),
                undefined,
                factory.createUnionTypeNode(
                    [
                        factory.createTypeReferenceNode(
                            factory.createIdentifier("OpAttr"),
                            undefined
                        )
                        ,
                        ...mtoAttrs
                    ]
                )
            )
        );
    }
    else {
        statements.push(factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("NativeAttr"),
            undefined,
            factory.createTypeReferenceNode(
                factory.createIdentifier("OpAttr"),
                undefined
            )
        ));
    }

    const foreignKeySet: Record<string, string[]> = {};
    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];
            }
        }
        const otmAttrs: ts.TemplateLiteralTypeNode[] = [];
        for (const entityName in foreignKeySet) {
            const entityNameLc = 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(
                                    "",
                                    ""
                                )
                            )
                        ]
                    )
                );
            }
        }

        statements.push(
            factory.createTypeAliasDeclaration(
                undefined,
                [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
                factory.createIdentifier("FullAttr"),
                undefined,
                factory.createUnionTypeNode([
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("NativeAttr"),
                        undefined
                    ),
                    ...otmAttrs
                ])
            )
        );
    }
    else {
        statements.push(factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("FullAttr"),
            undefined,
            factory.createTypeReferenceNode(
                factory.createIdentifier("NativeAttr"),
                undefined
            )
        ));
    }

}

function constructActions(statements: Array<ts.Statement>, entity: string) {
    // Selection
    statements.push(
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("SelectOperation"),
            [
                factory.createTypeParameterDeclaration(
                    undefined,
                    factory.createIdentifier("P"),
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("Object"),
                        undefined
                    ),
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("Projection"),
                        undefined
                    )
                )
            ],
            factory.createTypeReferenceNode(
                factory.createIdentifier("OakSelection"),
                [
                    factory.createLiteralTypeNode(factory.createStringLiteral("select")),
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("P"),
                        undefined
                    ),
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("Filter"),
                        undefined
                    ),
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("Sorter"),
                        undefined
                    )
                ]
            )
        ),
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("Selection"),
            [
                factory.createTypeParameterDeclaration(
                    undefined,
                    factory.createIdentifier("P"),
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("Object"),
                        undefined
                    ),
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("Projection"),
                        undefined
                    )
                )
            ],
            factory.createTypeReferenceNode(
                factory.createIdentifier("Omit"),
                [
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("SelectOperation"),
                        [
                            factory.createTypeReferenceNode(
                                factory.createIdentifier("P"),
                                undefined
                            )
                        ]
                    ),
                    factory.createLiteralTypeNode(factory.createStringLiteral("action"))
                ]
            )
        ),
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createToken(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("Aggregation"),
            undefined,
            factory.createTypeReferenceNode(
                factory.createIdentifier("DeduceAggregation"),
                [
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("Projection"),
                        undefined
                    ),
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("Filter"),
                        undefined
                    ),
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("Sorter"),
                        undefined
                    )
                ]
            )
        )
    );

    // Exportation
    // 已经废弃，by Xc 2023.01.08
    /*  statements.push(
         factory.createTypeAliasDeclaration(
             undefined,
             [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
             factory.createIdentifier("Exportation"),
             undefined,
             factory.createTypeReferenceNode(
                 factory.createIdentifier("OakOperation"),
                 [
                     factory.createLiteralTypeNode(factory.createStringLiteral("export")),
                     factory.createTypeReferenceNode(
                         factory.createIdentifier("ExportProjection"),
                         undefined
                     ),
                     factory.createTypeReferenceNode(
                         factory.createIdentifier("Filter"),
                         undefined
                     ),
                     factory.createTypeReferenceNode(
                         factory.createIdentifier("Sorter"),
                         undefined
                     )
                 ]
             )
         )
     ); */

    const { [entity]: manyToOneSet } = ManyToOne;
    const { [entity]: oneToManySet } = OneToMany;
    const foreignKeySet: Record<string, string[]> = {};
    if (oneToManySet) {
        for (const oneToManyItem of oneToManySet) {
            const [entityName, foreignKey] = oneToManyItem;

            if (foreignKeySet.hasOwnProperty(entityName)) {
                foreignKeySet[entityName].push(foreignKey);
            }
            else {
                foreignKeySet[entityName] = [foreignKey];
            }
        }
    }
    // CreateOperationData
    let foreignKeyAttr: string[] = [];

    if (ReversePointerEntities[entity]) {
        foreignKeyAttr.push(
            'entity', 'entityId'
        );
    }
    if (manyToOneSet) {
        for (const one of manyToOneSet) {
            if (!ReversePointerRelations[entity] || !ReversePointerRelations[entity].includes(one[1])) {
                foreignKeyAttr.push(`${one[1]}Id`);
            }
        }
    }
    let adNodes: ts.TypeNode[] = [
        factory.createTypeReferenceNode(
            factory.createIdentifier("FormCreateData"),
            [
                foreignKeyAttr.length > 0
                    ? factory.createTypeReferenceNode(
                        factory.createIdentifier("Omit"),
                        [
                            factory.createTypeReferenceNode(
                                factory.createIdentifier("OpSchema"),
                                undefined
                            ),
                            factory.createUnionTypeNode(uniq(foreignKeyAttr).map(
                                ele => factory.createLiteralTypeNode(factory.createStringLiteral(ele))
                            ))
                        ]
                    )
                    : factory.createTypeReferenceNode(
                        factory.createIdentifier("OpSchema"),
                        undefined
                    )
            ]
        )
    ];


    if (manyToOneSet) {
        /**
         * create的多对一有两种case
         * 如果关联对象是create，则对象的外键由关联对象的id决定
         * 如果关联对象是update，则关联对象的filter由对象决定其主键
         * 见cascadeStore
         */
        const upsertOneNodes: ts.TypeNode[] = [];
        for (const one of manyToOneSet) {
            if (!ReversePointerRelations[entity] || !ReversePointerRelations[entity].includes(one[0])) {
                const oneEntity = one[0];
                const cascadeCreateNode = factory.createTypeLiteralNode(
                    [
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier(`${one[1]}Id`),
                            factory.createToken(ts.SyntaxKind.QuestionToken),
                            factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)
                        ),
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier(one[1]),
                            one[2] ? factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
                            factory.createTypeReferenceNode(
                                createForeignRef(entity, one[0], 'CreateSingleOperation')
                            )
                        )
                    ]
                );
                const cascadeUpdateNode = factory.createTypeLiteralNode(
                    [
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier(`${one[1]}Id`),
                            undefined,
                            factory.createTypeReferenceNode(
                                factory.createIdentifier("String"),
                                [factory.createLiteralTypeNode(factory.createNumericLiteral("64"))]
                            )
                        ),
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier(one[1]),
                            factory.createToken(ts.SyntaxKind.QuestionToken),
                            factory.createTypeReferenceNode(
                                createForeignRef(entity, one[0], 'UpdateOperation')
                            )
                        )
                    ]
                );
                const noCascadeNode = factory.createTypeLiteralNode(
                    [
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier(`${one[1]}Id`),
                            one[2] ? factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
                            factory.createTypeReferenceNode(
                                factory.createIdentifier("String"),
                                [factory.createLiteralTypeNode(factory.createNumericLiteral("64"))]
                            )
                        )
                    ]
                );
                if (Schema[oneEntity].static) {
                    upsertOneNodes.push(noCascadeNode);
                }
                else {
                    switch (Schema[oneEntity].actionType) {
                        case 'crud':
                        case 'excludeRemove': {
                            upsertOneNodes.push(
                                factory.createUnionTypeNode([cascadeCreateNode, cascadeUpdateNode, noCascadeNode])
                            );
                            break;
                        }
                        case 'excludeUpdate':
                        case 'appendOnly': {
                            upsertOneNodes.push(
                                factory.createUnionTypeNode([cascadeCreateNode, noCascadeNode])
                            );
                            break;
                        }
                        case 'readOnly': {
                            upsertOneNodes.push(noCascadeNode);
                            break;
                        }
                        default: {
                            assert(false);
                        }
                    }
                }
            }
        }

        if (upsertOneNodes.length > 0) {
            adNodes.push(
                factory.createIntersectionTypeNode(
                    upsertOneNodes
                )
            );
        }
    }
    const reverseOneNodes: ts.TypeNode[] = [];
    if (ReversePointerEntities[entity]) {
        if (ReversePointerRelations[entity]) {
            const { schemaAttrs } = Schema[entity];
            const { questionToken } = schemaAttrs.find(
                ele => {
                    const { name } = ele;
                    return (<ts.Identifier>name).text === 'entity'
                }
            )!;
            for (const one of ReversePointerRelations[entity]) {
                const cascadeCreateNode = factory.createTypeLiteralNode(
                    [
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier('entity'),
                            factory.createToken(ts.SyntaxKind.QuestionToken),
                            factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)
                        ),
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier('entityId'),
                            factory.createToken(ts.SyntaxKind.QuestionToken),
                            factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)
                        ),
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier(firstLetterLowerCase(one)),
                            undefined,          // 反向指针好像不能为空，以后或许会有特例  by Xc
                            factory.createTypeReferenceNode(
                                createForeignRef(entity, one, 'CreateSingleOperation')
                            )
                        )
                    ]
                );
                const cascadeUpdateNode = factory.createTypeLiteralNode(
                    [
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier('entity'),
                            undefined,          // 反向指针好像不能为空，以后或许会有特例  by Xc
                            factory.createLiteralTypeNode(factory.createStringLiteral(`${firstLetterLowerCase(one)}`)
                            )
                        ),
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier('entityId'),
                            undefined,           // 反向指针好像不能为空，以后或许会有特例  by Xc
                            factory.createTypeReferenceNode(
                                factory.createIdentifier("String"),
                                [factory.createLiteralTypeNode(factory.createNumericLiteral("64"))]
                            )
                        ),
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier(firstLetterLowerCase(one)),
                            undefined,
                            factory.createTypeReferenceNode(
                                createForeignRef(entity, one, 'UpdateOperation')
                            )
                        )
                    ]
                );
                const noCascadeNode = factory.createTypeLiteralNode(
                    [
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier('entity'),
                            questionToken,
                            factory.createLiteralTypeNode(factory.createStringLiteral(`${firstLetterLowerCase(one)}`)
                            )
                        ),
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier('entityId'),
                            questionToken,
                            factory.createTypeReferenceNode(
                                factory.createIdentifier("String"),
                                [factory.createLiteralTypeNode(factory.createNumericLiteral("64"))]
                            )
                        )
                    ]
                );
                if (Schema[one].static) {
                    reverseOneNodes.push(noCascadeNode);
                }
                else {
                    switch (Schema[one].actionType) {
                        case 'crud':
                        case 'excludeRemove': {
                            reverseOneNodes.push(cascadeCreateNode, cascadeUpdateNode, noCascadeNode);
                            break;
                        }
                        case 'appendOnly':
                        case 'excludeUpdate': {
                            reverseOneNodes.push(cascadeCreateNode, noCascadeNode);
                            break;
                        }
                        case 'readOnly': {
                            reverseOneNodes.push(noCascadeNode);
                            break;
                        }
                        default: {
                            assert(false);
                        }
                    }
                }
            }
        }

        if (process.env.COMPLING_AS_LIB) {
            // 如果是base，要包容更多可能的反指
            reverseOneNodes.push(
                factory.createTypeLiteralNode(
                    [
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier('entity'),
                            factory.createToken(ts.SyntaxKind.QuestionToken),
                            factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
                        ),
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier('entityId'),
                            factory.createToken(ts.SyntaxKind.QuestionToken),
                            factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
                        ),
                        factory.createIndexSignature(
                            undefined,
                            undefined,
                            [factory.createParameterDeclaration(
                                undefined,
                                undefined,
                                undefined,
                                factory.createIdentifier("K"),
                                undefined,
                                factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
                                undefined
                            )],
                            factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
                        )
                    ]
                )
            );
        }

        if (reverseOneNodes.length > 0) {
            adNodes.push(
                factory.createUnionTypeNode(
                    reverseOneNodes
                )
            );
        }
    }

    // 一对多
    const propertySignatures: ts.TypeElement[] = [];

    if (oneToManySet) {
        for (const entityName in foreignKeySet) {
            const entityNameLc = firstLetterLowerCase(entityName);
            foreignKeySet[entityName].forEach(
                (foreignKey) => {
                    const identifier = `${entityNameLc}$${foreignKey}`;
                    const otmCreateOperationDataNode = factory.createTypeReferenceNode(
                        factory.createIdentifier("Omit"),
                        [
                            factory.createTypeReferenceNode(
                                createForeignRef(entity, entityName, 'CreateOperationData'),
                                undefined
                            ),
                            factory.createUnionTypeNode(foreignKey === 'entity' ? [
                                factory.createLiteralTypeNode(factory.createStringLiteral("entity")),
                                factory.createLiteralTypeNode(factory.createStringLiteral("entityId"))
                            ] : [
                                factory.createLiteralTypeNode(factory.createStringLiteral(foreignKey)),
                                factory.createLiteralTypeNode(factory.createStringLiteral(`${foreignKey}Id`))
                            ])
                        ]
                    );
                    const otmCreateSingleOperationNode = factory.createTypeReferenceNode(
                        factory.createIdentifier("OakOperation"),
                        [
                            factory.createLiteralTypeNode(factory.createStringLiteral("create")),
                            otmCreateOperationDataNode
                        ]
                    );
                    const otmCreateMultipleOperationNode = factory.createTypeReferenceNode(
                        factory.createIdentifier("OakOperation"),
                        [
                            factory.createLiteralTypeNode(factory.createStringLiteral("create")),
                            factory.createArrayTypeNode(
                                otmCreateOperationDataNode
                            )
                        ]
                    );
                    const otmUpdateOperationNode = factory.createTypeReferenceNode(
                        factory.createIdentifier("OakOperation"),
                        [
                            factory.createIndexedAccessTypeNode(
                                factory.createTypeReferenceNode(
                                    createForeignRef(entity, entityName, 'UpdateOperation'),
                                    undefined
                                ),
                                factory.createLiteralTypeNode(factory.createStringLiteral("action"))
                            ),
                            factory.createTypeReferenceNode(
                                factory.createIdentifier("Omit"),
                                [
                                    factory.createTypeReferenceNode(
                                        createForeignRef(entity, entityName, 'UpdateOperationData'),
                                        undefined
                                    ),
                                    factory.createUnionTypeNode(foreignKey === 'entity' ? [
                                        factory.createLiteralTypeNode(factory.createStringLiteral("entity")),
                                        factory.createLiteralTypeNode(factory.createStringLiteral("entityId"))
                                    ] : [
                                        factory.createLiteralTypeNode(factory.createStringLiteral(foreignKey)),
                                        factory.createLiteralTypeNode(factory.createStringLiteral(`${foreignKey}Id`))
                                    ])
                                ]
                            ),
                            factory.createTypeReferenceNode(
                                createForeignRef(entity, entityName, 'Filter'),
                                undefined
                            )
                        ]
                    );

                    if (!Schema[entityName].static) {
                        switch (Schema[entityName].actionType) {
                            case 'crud': {
                                propertySignatures.push(
                                    factory.createPropertySignature(
                                        undefined,
                                        factory.createIdentifier(identifier),
                                        factory.createToken(ts.SyntaxKind.QuestionToken),
                                        factory.createUnionTypeNode([
                                            otmUpdateOperationNode,
                                            otmCreateMultipleOperationNode,
                                            factory.createTypeReferenceNode(
                                                factory.createIdentifier("Array"),
                                                [factory.createUnionTypeNode([
                                                    otmCreateSingleOperationNode,
                                                    otmUpdateOperationNode
                                                ])]
                                            )
                                        ])
                                    )
                                );
                                break;
                            }
                            case 'appendOnly':
                            case 'excludeUpdate': {
                                propertySignatures.push(
                                    factory.createPropertySignature(
                                        undefined,
                                        factory.createIdentifier(identifier),
                                        factory.createToken(ts.SyntaxKind.QuestionToken),
                                        factory.createUnionTypeNode([
                                            otmCreateMultipleOperationNode,
                                            factory.createTypeReferenceNode(
                                                factory.createIdentifier("Array"),
                                                [otmCreateSingleOperationNode]
                                            )
                                        ])
                                    )
                                );
                                break;
                            }
                            case 'readOnly': {
                                break;
                            }
                            default: {
                                assert(false);
                            }
                        }
                    }
                }
            );
        }
    }
    if (propertySignatures.length > 0) {
        adNodes.push(
            factory.createTypeLiteralNode(
                propertySignatures
            )
        );
    }
    statements.push(
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("CreateOperationData"),
            undefined,
            factory.createIntersectionTypeNode(adNodes)
        )
    );

    // CreateOperation
    statements.push(
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("CreateSingleOperation"),
            undefined,
            factory.createTypeReferenceNode(
                factory.createIdentifier("OakOperation"),
                [
                    factory.createLiteralTypeNode(factory.createStringLiteral("create")),
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("CreateOperationData")
                    )
                ]
            )
        ),
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("CreateMultipleOperation"),
            undefined,
            factory.createTypeReferenceNode(
                factory.createIdentifier("OakOperation"),
                [
                    factory.createLiteralTypeNode(factory.createStringLiteral("create")),
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("Array"),
                        [factory.createTypeReferenceNode(
                            factory.createIdentifier("CreateOperationData")
                        )]
                    )
                ]
            )
        ),
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("CreateOperation"),
            undefined,
            factory.createUnionTypeNode([
                factory.createTypeReferenceNode(
                    factory.createIdentifier("CreateSingleOperation")
                ),
                factory.createTypeReferenceNode(
                    factory.createIdentifier("CreateMultipleOperation")
                )
            ])
        )
    );

    // UpdateOperationData
    foreignKeyAttr = [];
    if (ReversePointerRelations[entity]) {
        foreignKeyAttr.push('entity', 'entityId');
    }
    if (manyToOneSet) {
        for (const one of manyToOneSet) {
            if (!ReversePointerRelations[entity] || !ReversePointerRelations[entity].includes(one[1])) {
                foreignKeyAttr.push(`${one[1]}Id`);
            }
        }
    }
    adNodes = [
        factory.createTypeReferenceNode(
            factory.createIdentifier("FormUpdateData"),
            [
                foreignKeyAttr.length > 0 ? factory.createTypeReferenceNode(
                    factory.createIdentifier("Omit"),
                    [
                        factory.createTypeReferenceNode(
                            factory.createIdentifier("OpSchema"),
                            undefined
                        ),
                        factory.createUnionTypeNode(uniq(foreignKeyAttr).map(
                            ele => factory.createLiteralTypeNode(factory.createStringLiteral(ele))
                        ))
                    ]
                ) : factory.createTypeReferenceNode(
                    factory.createIdentifier("OpSchema"),
                    undefined
                )
            ]
        )
    ];
    if (manyToOneSet) {
        /**
         * update的多对一有三种case
         * 如果关联对象是create，则对象的外键由关联对象的id决定
         * 如果关联对象是update或者remove，则关联对象的filter由对象(的原行！注意这里的外键是不能变的!)决定其主键
         * 见cascadeStore
         */
        const upsertOneNodes: ts.TypeNode[] = [];
        for (const one of manyToOneSet) {
            if (!ReversePointerRelations[entity] || !ReversePointerRelations[entity].includes(one[0])) {
                const cascadeCreateNode = factory.createTypeLiteralNode(
                    [
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier(one[1]),
                            undefined,
                            factory.createTypeReferenceNode(
                                createForeignRef(entity, one[0], 'CreateSingleOperation')
                            )
                        ),
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier(`${one[1]}Id`),
                            factory.createToken(ts.SyntaxKind.QuestionToken),
                            factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)
                        ),
                    ]
                );
                const cascadeUpdateNode = factory.createTypeLiteralNode(
                    [
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier(one[1]),
                            undefined,
                            factory.createTypeReferenceNode(
                                createForeignRef(entity, one[0], 'UpdateOperation')
                            ),
                        ),
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier(`${one[1]}Id`),
                            factory.createToken(ts.SyntaxKind.QuestionToken),
                            factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)
                        ),
                    ]
                );
                const cascadeRemoveNode = factory.createTypeLiteralNode(
                    [
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier(one[1]),
                            undefined,
                            factory.createTypeReferenceNode(
                                createForeignRef(entity, one[0], 'RemoveOperation')
                            )
                        ),
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier(`${one[1]}Id`),
                            factory.createToken(ts.SyntaxKind.QuestionToken),
                            factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)
                        ),
                    ]
                );
                const noCascadeNode = factory.createTypeLiteralNode(
                    [
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier(one[1]),
                            factory.createToken(ts.SyntaxKind.QuestionToken),
                            factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)
                        ),
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier(`${one[1]}Id`),
                            factory.createToken(ts.SyntaxKind.QuestionToken),
                            factory.createUnionTypeNode(
                                [
                                    factory.createTypeReferenceNode(
                                        factory.createIdentifier("String"),
                                        [factory.createLiteralTypeNode(factory.createNumericLiteral("64"))]
                                    ),
                                    factory.createLiteralTypeNode(factory.createNull())
                                ]
                            )
                        ),
                    ]
                );
                if (Schema[one[0]].static) {
                    upsertOneNodes.push(
                        noCascadeNode
                    );
                }
                else {
                    switch (Schema[one[0]].actionType) {
                        case 'crud': {
                            upsertOneNodes.push(
                                factory.createUnionTypeNode([cascadeCreateNode, cascadeUpdateNode, cascadeRemoveNode, noCascadeNode])
                            );
                            break;
                        }
                        case 'excludeUpdate': {
                            upsertOneNodes.push(
                                factory.createUnionTypeNode([cascadeCreateNode, cascadeRemoveNode, noCascadeNode])
                            );
                            break;
                        }
                        case 'appendOnly': {
                            upsertOneNodes.push(
                                factory.createUnionTypeNode([cascadeCreateNode, noCascadeNode])
                            );
                            break;
                        }
                        case 'readOnly': {
                            upsertOneNodes.push(
                                noCascadeNode
                            );
                            break;
                        }
                        case 'excludeRemove': {
                            upsertOneNodes.push(
                                factory.createUnionTypeNode([cascadeCreateNode, cascadeUpdateNode, noCascadeNode])
                            );
                            break;
                        }
                        default: {
                            assert(false);
                        }
                    }
                }
            }
        }
        if (upsertOneNodes.length > 0) {
            adNodes.push(
                factory.createIntersectionTypeNode(
                    upsertOneNodes
                )
            );
        }

        const reverseOneNodes: ts.TypeNode[] = [];
        if (ReversePointerRelations[entity]) {
            const refEntityLitrals: (ts.TypeNode)[] = [];
            for (const one of ReversePointerRelations[entity]) {
                refEntityLitrals.push(factory.createLiteralTypeNode(factory.createStringLiteral(`${firstLetterLowerCase(one)}`)));
                const actionNodes: ts.TypeNode[] = [];
                if (!Schema[one].static) {
                    switch (Schema[one].actionType) {
                        case 'crud': {
                            actionNodes.push(
                                factory.createTypeReferenceNode(
                                    createForeignRef(entity, one, 'CreateSingleOperation')
                                ),
                                factory.createTypeReferenceNode(
                                    createForeignRef(entity, one, 'UpdateOperation')
                                ),
                                factory.createTypeReferenceNode(
                                    createForeignRef(entity, one, 'RemoveOperation')
                                )
                            );
                            break;
                        }
                        case 'excludeUpdate': {
                            actionNodes.push(
                                factory.createTypeReferenceNode(
                                    createForeignRef(entity, one, 'CreateSingleOperation')
                                ),
                                factory.createTypeReferenceNode(
                                    createForeignRef(entity, one, 'RemoveOperation')
                                )
                            );
                            break;
                        }
                        case 'excludeRemove': {
                            actionNodes.push(
                                factory.createTypeReferenceNode(
                                    createForeignRef(entity, one, 'CreateSingleOperation')
                                ),
                                factory.createTypeReferenceNode(
                                    createForeignRef(entity, one, 'UpdateOperation')
                                )
                            );
                            break;
                        }
                        case 'appendOnly': {
                            actionNodes.push(
                                factory.createTypeReferenceNode(
                                    createForeignRef(entity, one, 'CreateSingleOperation')
                                )
                            );
                            break;
                        }
                        case 'readOnly': {
                            break;
                        }
                        default: {
                            assert(false);
                        }
                    }
                }
                if (actionNodes.length > 0) {
                    reverseOneNodes.push(
                        factory.createTypeLiteralNode(
                            [
                                factory.createPropertySignature(
                                    undefined,
                                    factory.createIdentifier(firstLetterLowerCase(one)),
                                    factory.createToken(ts.SyntaxKind.QuestionToken),
                                    factory.createUnionTypeNode(actionNodes)
                                ),
                                factory.createPropertySignature(
                                    undefined,
                                    factory.createIdentifier('entityId'),
                                    factory.createToken(ts.SyntaxKind.QuestionToken),
                                    factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)
                                ),
                                factory.createPropertySignature(
                                    undefined,
                                    factory.createIdentifier('entity'),
                                    factory.createToken(ts.SyntaxKind.QuestionToken),
                                    factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)
                                )
                            ]
                        ),
                    );
                }
            }
            if (process.env.COMPLING_AS_LIB) {
                // 如果是base，要包容更多可能的反指
                refEntityLitrals.push(
                    factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
                );
            }

            reverseOneNodes.push(
                factory.createTypeLiteralNode(
                    [
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier('entity'),
                            factory.createToken(ts.SyntaxKind.QuestionToken),
                            factory.createUnionTypeNode(
                                [
                                    factory.createUnionTypeNode(refEntityLitrals),
                                    factory.createLiteralTypeNode(factory.createNull())
                                ]
                            )
                        ),
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier('entityId'),
                            factory.createToken(ts.SyntaxKind.QuestionToken),
                            factory.createUnionTypeNode(
                                [
                                    factory.createTypeReferenceNode(
                                        factory.createIdentifier("String"),
                                        [factory.createLiteralTypeNode(factory.createNumericLiteral("64"))]
                                    ),
                                    factory.createLiteralTypeNode(factory.createNull())
                                ]
                            )
                        )
                    ]
                )
            );
        }

        if (reverseOneNodes.length > 0) {
            adNodes.push(
                factory.createUnionTypeNode(
                    reverseOneNodes
                )
            );
        }
    }


    const propertySignatures2: ts.TypeElement[] = [];
    if (process.env.COMPLING_AS_LIB) {
        propertySignatures2.push(
            factory.createIndexSignature(
                undefined,
                undefined,
                [factory.createParameterDeclaration(
                    undefined,
                    undefined,
                    undefined,
                    factory.createIdentifier("k"),
                    undefined,
                    factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
                    undefined
                )],
                factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
            )
        );
    }
    if (oneToManySet) {
        for (const entityName in foreignKeySet) {
            const entityNameLc = firstLetterLowerCase(entityName);
            foreignKeySet[entityName].forEach(
                (foreignKey) => {
                    const identifier = `${entityNameLc}$${foreignKey}`;

                    const otmCreateOperationDataNode = factory.createTypeReferenceNode(
                        factory.createIdentifier("Omit"),
                        [
                            factory.createTypeReferenceNode(
                                createForeignRef(entity, entityName, 'CreateOperationData'),
                                undefined
                            ),
                            factory.createUnionTypeNode(foreignKey === 'entity' ? [
                                factory.createLiteralTypeNode(factory.createStringLiteral("entity")),
                                factory.createLiteralTypeNode(factory.createStringLiteral("entityId"))
                            ] : [
                                factory.createLiteralTypeNode(factory.createStringLiteral(foreignKey)),
                                factory.createLiteralTypeNode(factory.createStringLiteral(`${foreignKey}Id`))
                            ])
                        ]
                    );
                    const otmCreateSingleOperationNode = factory.createTypeReferenceNode(
                        factory.createIdentifier("OakOperation"),
                        [
                            factory.createLiteralTypeNode(factory.createStringLiteral("create")),
                            otmCreateOperationDataNode
                        ]
                    )
                    const otmCreateMultipleOperationNode = factory.createTypeReferenceNode(
                        factory.createIdentifier("OakOperation"),
                        [
                            factory.createLiteralTypeNode(factory.createStringLiteral("create")),
                            factory.createArrayTypeNode(
                                otmCreateOperationDataNode
                            )
                        ]
                    );
                    const otmUpdateOperationNode = factory.createTypeReferenceNode(
                        createForeignRef(entity, entityName, 'UpdateOperation'),
                        undefined
                    );
                    const otmRemoveOperationNode = factory.createTypeReferenceNode(
                        createForeignRef(entity, entityName, 'RemoveOperation'),
                        undefined
                    );
                    if (!Schema[entityName].static) {
                        switch (Schema[entityName].actionType) {
                            case 'crud': {
                                propertySignatures2.push(
                                    factory.createPropertySignature(
                                        undefined,
                                        factory.createIdentifier(identifier),
                                        factory.createToken(ts.SyntaxKind.QuestionToken),
                                        factory.createUnionTypeNode([
                                            otmUpdateOperationNode,
                                            otmRemoveOperationNode,
                                            otmCreateMultipleOperationNode,
                                            factory.createTypeReferenceNode(
                                                factory.createIdentifier("Array"),
                                                [factory.createUnionTypeNode([
                                                    otmCreateSingleOperationNode,
                                                    otmUpdateOperationNode,
                                                    otmRemoveOperationNode
                                                ])]
                                            )
                                        ])
                                    )
                                );
                                break;
                            }
                            case 'excludeUpdate': {
                                propertySignatures2.push(
                                    factory.createPropertySignature(
                                        undefined,
                                        factory.createIdentifier(identifier),
                                        factory.createToken(ts.SyntaxKind.QuestionToken),
                                        factory.createUnionTypeNode([
                                            otmRemoveOperationNode,
                                            otmCreateMultipleOperationNode,
                                            factory.createTypeReferenceNode(
                                                factory.createIdentifier("Array"),
                                                [factory.createUnionTypeNode([
                                                    otmCreateSingleOperationNode,
                                                    otmRemoveOperationNode
                                                ])]
                                            )
                                        ])
                                    )
                                );
                                break;
                            }
                            case 'excludeRemove': {
                                propertySignatures2.push(
                                    factory.createPropertySignature(
                                        undefined,
                                        factory.createIdentifier(identifier),
                                        factory.createToken(ts.SyntaxKind.QuestionToken),
                                        factory.createUnionTypeNode([
                                            otmUpdateOperationNode,
                                            otmCreateMultipleOperationNode,
                                            factory.createTypeReferenceNode(
                                                factory.createIdentifier("Array"),
                                                [factory.createUnionTypeNode([
                                                    otmCreateSingleOperationNode,
                                                    otmUpdateOperationNode
                                                ])]
                                            )
                                        ])
                                    )
                                );
                                break;
                            }
                            case 'appendOnly': {
                                propertySignatures2.push(
                                    factory.createPropertySignature(
                                        undefined,
                                        factory.createIdentifier(identifier),
                                        factory.createToken(ts.SyntaxKind.QuestionToken),
                                        factory.createUnionTypeNode([
                                            otmCreateMultipleOperationNode,
                                            factory.createTypeReferenceNode(
                                                factory.createIdentifier("Array"),
                                                [factory.createUnionTypeNode([
                                                    otmCreateSingleOperationNode
                                                ])]
                                            )
                                        ])
                                    )
                                );
                                break;
                            }
                            case 'readOnly': {
                                break;
                            }
                            default: {
                                assert(false);
                            }
                        }
                    }
                }
            );
        }
    }
    if (propertySignatures2.length > 0) {
        adNodes.push(
            factory.createTypeLiteralNode(
                propertySignatures2
            )
        );
    }
    statements.push(
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("UpdateOperationData"),
            undefined,
            factory.createIntersectionTypeNode(adNodes)
        )
    );

    // UpdateOperation
    const actionTypeNodes: ts.TypeNode[] = [factory.createLiteralTypeNode(factory.createStringLiteral("update"))];

    if (ActionAsts[entity]) {
        actionTypeNodes.push(
            factory.createTypeReferenceNode('ParticularAction')
        );
    }
    if (Schema[entity].hasRelationDef || entity === 'User') {
        actionTypeNodes.push(
            factory.createTypeReferenceNode('RelationAction')
        );
    }
    if (process.env.COMPLING_AS_LIB) {
        actionTypeNodes.push(
            factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
        );
    }

    statements.push(
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("UpdateOperation"),
            undefined,
            factory.createTypeReferenceNode(
                factory.createIdentifier("OakOperation"),
                [
                    factory.createUnionTypeNode(actionTypeNodes),
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("UpdateOperationData")
                    ),
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("Filter"),
                        undefined
                    ),
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("Sorter"),
                        undefined
                    )
                ]
            )
        )
    );

    // RemoveOperationData
    adNodes = [
        factory.createTypeLiteralNode([])
    ];
    if (manyToOneSet) {
        /**
         * remove的多对一有两种case         
         * 如果关联对象动作是update或者remove，则关联对象的filter由对象(的原行！注意这里的外键是不能变的!)决定其主键
         * 见cascadeStore
         */
        const upsertOneNodes: ts.TypeNode[] = [];
        for (const one of manyToOneSet) {
            if (!ReversePointerRelations[entity] || !ReversePointerRelations[entity].includes(one[0])) {
                if (!Schema[one[0]].static) {
                    switch (Schema[one[0]].actionType) {
                        case 'crud': {
                            upsertOneNodes.push(
                                factory.createUnionTypeNode(
                                    [
                                        factory.createTypeLiteralNode(
                                            [
                                                factory.createPropertySignature(
                                                    undefined,
                                                    factory.createIdentifier(one[1]),
                                                    factory.createToken(ts.SyntaxKind.QuestionToken),
                                                    factory.createUnionTypeNode([
                                                        factory.createTypeReferenceNode(
                                                            createForeignRef(entity, one[0], 'UpdateOperation')
                                                        ),
                                                        factory.createTypeReferenceNode(
                                                            createForeignRef(entity, one[0], 'RemoveOperation')
                                                        )
                                                    ])
                                                )
                                            ]
                                        )
                                    ]
                                )
                            );
                            break;
                        }
                        case 'excludeUpdate': {
                            upsertOneNodes.push(
                                factory.createUnionTypeNode(
                                    [
                                        factory.createTypeLiteralNode(
                                            [
                                                factory.createPropertySignature(
                                                    undefined,
                                                    factory.createIdentifier(one[1]),
                                                    factory.createToken(ts.SyntaxKind.QuestionToken),
                                                    factory.createTypeReferenceNode(
                                                        createForeignRef(entity, one[0], 'RemoveOperation')
                                                    )
                                                )
                                            ]
                                        )
                                    ]
                                )
                            );
                            break;
                        }
                        case 'excludeRemove': {
                            upsertOneNodes.push(
                                factory.createUnionTypeNode(
                                    [
                                        factory.createTypeLiteralNode(
                                            [
                                                factory.createPropertySignature(
                                                    undefined,
                                                    factory.createIdentifier(one[1]),
                                                    factory.createToken(ts.SyntaxKind.QuestionToken),
                                                    factory.createTypeReferenceNode(
                                                        createForeignRef(entity, one[0], 'UpdateOperation')
                                                    )
                                                )
                                            ]
                                        )
                                    ]
                                )
                            );
                            break;
                        }
                        case 'appendOnly':
                        case 'readOnly': {
                            break;
                        }
                        default: {
                            assert(false);
                        }
                    }
                }
            }
        }

        const reverseOneNodes: ts.TypeNode[] = [];
        if (ReversePointerRelations[entity]) {
            const refEntityLitrals: (ts.TypeNode)[] = [];
            for (const one of ReversePointerRelations[entity]) {
                refEntityLitrals.push(factory.createLiteralTypeNode(factory.createStringLiteral(`${firstLetterLowerCase(one)}`)));
                if (!Schema[one].static) {
                    switch (Schema[one].actionType) {
                        case 'crud': {
                            reverseOneNodes.push(
                                factory.createTypeLiteralNode(
                                    [
                                        factory.createPropertySignature(
                                            undefined,
                                            factory.createIdentifier(firstLetterLowerCase(one)),
                                            factory.createToken(ts.SyntaxKind.QuestionToken),
                                            factory.createUnionTypeNode([
                                                factory.createTypeReferenceNode(
                                                    createForeignRef(entity, one, 'UpdateOperation')
                                                ),
                                                factory.createTypeReferenceNode(
                                                    createForeignRef(entity, one, 'RemoveOperation')
                                                )
                                            ])
                                        )
                                    ]
                                ),
                            );
                            break;
                        }
                        case 'excludeUpdate': {
                            reverseOneNodes.push(
                                factory.createTypeLiteralNode(
                                    [
                                        factory.createPropertySignature(
                                            undefined,
                                            factory.createIdentifier(firstLetterLowerCase(one)),
                                            factory.createToken(ts.SyntaxKind.QuestionToken),
                                            factory.createTypeReferenceNode(
                                                createForeignRef(entity, one, 'RemoveOperation')
                                            )
                                        )
                                    ]
                                ),
                            );
                            break;
                        }
                        case 'excludeRemove': {
                            reverseOneNodes.push(
                                factory.createTypeLiteralNode(
                                    [
                                        factory.createPropertySignature(
                                            undefined,
                                            factory.createIdentifier(firstLetterLowerCase(one)),
                                            factory.createToken(ts.SyntaxKind.QuestionToken),
                                            factory.createTypeReferenceNode(
                                                createForeignRef(entity, one, 'UpdateOperation')
                                            )
                                        )
                                    ]
                                ),
                            );
                            break;
                        }
                        case 'appendOnly':
                        case 'readOnly': {
                            break;
                        }
                        default: {
                            assert(false);
                        }
                    }
                }

            }
            if (process.env.COMPLING_AS_LIB) {
                reverseOneNodes.push(
                    factory.createTypeLiteralNode(
                        [
                            factory.createIndexSignature(
                                undefined,
                                undefined,
                                [factory.createParameterDeclaration(
                                    undefined,
                                    undefined,
                                    undefined,
                                    factory.createIdentifier("k"),
                                    undefined,
                                    factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
                                    undefined
                                )],
                                factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
                            )
                        ]
                    )
                )
            }
        }

        if (upsertOneNodes.length > 0) {
            adNodes.push(
                factory.createIntersectionTypeNode(
                    upsertOneNodes
                )
            );
        }
        if (reverseOneNodes.length > 0) {
            adNodes.push(
                factory.createUnionTypeNode(
                    reverseOneNodes
                )
            );
        }
    }

    /**
     *  remove的同时进行cascade update或者cascade remove，感觉用触发器会更自然，因为在用户界面上似乎不会有对应的操作。
     *  这部分代码暂时封闭 by Xc 20220501
     **/

    /* const propertySignatures3: ts.TypeElement[] = [];
    if (process.env.COMPLING_AS_LIB) {
        propertySignatures3.push(
            factory.createIndexSignature(
                undefined,
                undefined,
                [factory.createParameterDeclaration(
                    undefined,
                    undefined,
                    undefined,
                    factory.createIdentifier("k"),
                    undefined,
                    factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
                    undefined
                )],
                factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
            )
        );
    }
    if (oneToManySet) {
        for (const entityName in foreignKeySet) {
            const entityNameLc = firstLetterLowerCase(entityName);
            foreignKeySet[entityName].forEach(
                (foreignKey) => {
                    const identifier = `${entityNameLc}s$${foreignKey}`;
                    propertySignatures3.push(
                        factory.createPropertySignature(
                            undefined,
                            factory.createIdentifier(identifier),
                            factory.createToken(ts.SyntaxKind.QuestionToken),
                            factory.createUnionTypeNode([
                                factory.createTypeReferenceNode(
                                    createForeignRef(entity, entityName, 'UpdateOperation'),
                                    undefined
                                ),
                                factory.createTypeReferenceNode(
                                    createForeignRef(entity, entityName, 'RemoveOperation'),
                                    undefined
                                ),
                                factory.createTypeReferenceNode(
                                    factory.createIdentifier("Array"),
                                    [factory.createUnionTypeNode([
                                        factory.createTypeReferenceNode(
                                            createForeignRef(entity, entityName, 'UpdateOperation'),
                                            undefined
                                        ),
                                        factory.createTypeReferenceNode(
                                            createForeignRef(entity, entityName, 'RemoveOperation'),
                                            undefined
                                        )
                                    ])]
                                )
                            ])
                        )
                    );
                }
            );
        }
    }
    if (propertySignatures3.length > 0) {
        adNodes.push(
            factory.createTypeLiteralNode(
                propertySignatures3
            )
        );
    } */

    statements.push(
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("RemoveOperationData"),
            undefined,
            factory.createIntersectionTypeNode(adNodes)
        )
    );

    // RemoveOperation
    statements.push(
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("RemoveOperation"),
            undefined,
            factory.createTypeReferenceNode(
                factory.createIdentifier("OakOperation"),
                [
                    factory.createLiteralTypeNode(factory.createStringLiteral("remove")),
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("RemoveOperationData"),
                        undefined
                    ),
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("Filter"),
                        undefined
                    ),
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("Sorter"),
                        undefined
                    )
                ]
            )
        )
    );

    statements.push(
        factory.createTypeAliasDeclaration(
            undefined,
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createIdentifier("Operation"),
            undefined,
            factory.createUnionTypeNode([
                factory.createTypeReferenceNode(
                    factory.createIdentifier("CreateOperation"),
                    undefined
                ),
                factory.createTypeReferenceNode(
                    factory.createIdentifier("UpdateOperation"),
                    undefined
                ),
                factory.createTypeReferenceNode(
                    factory.createIdentifier("RemoveOperation"),
                    undefined
                )
            ])
        )
    );
}

const initialStatements = () => [
    // import { String, Text, Int, SpecificKey } from 'oak-domain/types/DataType';
    factory.createImportDeclaration(
        undefined,
        undefined,
        factory.createImportClause(
            false,
            undefined,
            factory.createNamedImports(
                [
                    factory.createImportSpecifier(
                        false,
                        undefined,
                        factory.createIdentifier('String')
                    ),
                    factory.createImportSpecifier(
                        false,
                        undefined,
                        factory.createIdentifier('Int')
                    ),
                    factory.createImportSpecifier(
                        false,
                        undefined,
                        factory.createIdentifier('Uint')
                    ),
                    factory.createImportSpecifier(
                        false,
                        undefined,
                        factory.createIdentifier('Float')
                    ),
                    factory.createImportSpecifier(
                        false,
                        undefined,
                        factory.createIdentifier('Double')
                    ),
                    factory.createImportSpecifier(
                        false,
                        undefined,
                        factory.createIdentifier('Boolean')
                    ),
                    factory.createImportSpecifier(
                        false,
                        undefined,
                        factory.createIdentifier('Text')
                    ),
                    factory.createImportSpecifier(
                        false,
                        undefined,
                        factory.createIdentifier('Datetime')
                    ),
                    factory.createImportSpecifier(
                        false,
                        undefined,
                        factory.createIdentifier('File')
                    ),
                    factory.createImportSpecifier(
                        false,
                        undefined,
                        factory.createIdentifier('Image')
                    ),
                    factory.createImportSpecifier(
                        false,
                        undefined,
                        factory.createIdentifier('PrimaryKey')
                    ),
                    factory.createImportSpecifier(
                        false,
                        undefined,
                        factory.createIdentifier('ForeignKey')
                    ),
                    factory.createImportSpecifier(
                        false,
                        undefined,
                        factory.createIdentifier('Geo')
                    ),
                    factory.createImportSpecifier(
                        false,
                        undefined,
                        factory.createIdentifier('SingleGeo')
                    )
                ]
            )
        ),
        factory.createStringLiteral(`${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,
        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.createStringLiteral(`${TYPE_PATH_IN_OAK_DOMAIN()}Demand`)
    ),
    factory.createImportDeclaration(
        undefined,
        undefined,
        factory.createImportClause(
            false,
            undefined,
            factory.createNamedImports([
                factory.createImportSpecifier(
                    false,
                    undefined,
                    factory.createIdentifier("OneOf")
                ),
                factory.createImportSpecifier(
                    false,
                    undefined,
                    factory.createIdentifier("ValueOf")
                )
            ])
        ),
        factory.createStringLiteral(`${TYPE_PATH_IN_OAK_DOMAIN()}Polyfill`)
    ),
    // import * as SubQuery from '../_SubQuery';
    factory.createImportDeclaration(
        undefined,
        undefined,
        factory.createImportClause(
            false,
            undefined,
            factory.createNamespaceImport(factory.createIdentifier("SubQuery"))
        ),
        factory.createStringLiteral("../_SubQuery")
    ),
    // import { Filter as OakFilter } from 'oak-domain/src/types/Entity';
    factory.createImportDeclaration(
        undefined,
        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,
                    factory.createIdentifier("MakeAction"),
                    factory.createIdentifier("OakMakeAction")
                ),
                factory.createImportSpecifier(
                    false,
                    undefined,
                    factory.createIdentifier("EntityShape")
                ),
                factory.createImportSpecifier(
                    false,
                    undefined,
                    factory.createIdentifier("AggregationResult")
                ),
            ])
        ),
        factory.createStringLiteral(`${TYPE_PATH_IN_OAK_DOMAIN()}Entity`),
        undefined
    )
];

function outputSubQuery(outputDir: string, printer: ts.Printer) {
    const statements: ts.Statement[] = [];
    if (process.env.COMPLING_AS_LIB) {
    }
    for (const entity in Schema) {
        // import * as User from '../User/Schema';
        statements.push(
            factory.createImportDeclaration(
                undefined,
                undefined,
                factory.createImportClause(
                    false,
                    undefined,
                    factory.createNamespaceImport(factory.createIdentifier(entity))
                ),
                factory.createStringLiteral(`./${entity}/Schema`)
            )
        );
    }
    const entities = keys(Schema);

    // 每个有manyToOne的Entity都会输出${One}IdSubQuery
    for (const one in Schema) {
        const identifier = `${one}IdSubQuery`;
        const fromEntites = OneToMany[one] ? uniq(OneToMany[one]
            .filter(
                ([e, f]) => f !== 'entity'
            ).map(
                ([e]) => e
            )) : [];
        fromEntites.push(one);

        const inUnionTypeNode: ts.TypeNode[] = fromEntites.map(
            ele => factory.createIntersectionTypeNode(
                [
                    factory.createTypeReferenceNode(
                        factory.createQualifiedName(
                            factory.createIdentifier(ele),
                            factory.createIdentifier(identifier)
                        ),
                        undefined
                    ),
                    factory.createTypeLiteralNode([factory.createPropertySignature(
                        undefined,
                        factory.createIdentifier("entity"),
                        undefined,
                        factory.createLiteralTypeNode(factory.createStringLiteral(firstLetterLowerCase(ele)))
                    )])
                ]
            )
        );

        if (process.env.COMPLING_AS_LIB) {
            // 如果是建立 base，这里要加上额外可能的对象信息
            inUnionTypeNode.push(
                factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
            );
        }
        statements.push(
            factory.createTypeAliasDeclaration(
                undefined,
                [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
                factory.createIdentifier(identifier),
                undefined,
                factory.createMappedTypeNode(
                    undefined,
                    factory.createTypeParameterDeclaration(
                        undefined,
                        factory.createIdentifier("K"),
                        factory.createUnionTypeNode([
                            factory.createLiteralTypeNode(factory.createStringLiteral("$in")),
                            factory.createLiteralTypeNode(factory.createStringLiteral("$nin"))
                        ]),
                        undefined
                    ),
                    undefined,
                    factory.createToken(ts.SyntaxKind.QuestionToken),
                    factory.createUnionTypeNode(
                        inUnionTypeNode
                    ),
                    undefined
                )

            )
        );
    }

    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 = PathLib.join(outputDir, '_SubQuery.ts');
    writeFileSync(fileName, result, { flag: 'w' });
}

function outputEntityDict(outputDir: string, printer: ts.Printer) {
    const statements: ts.Statement[] = [];
    const propertySignatures: ts.PropertySignature[] = [];
    for (const entity in Schema) {
        // import * as User from '../User/Schema';
        statements.push(
            factory.createImportDeclaration(
                undefined,
                undefined,
                factory.createImportClause(
                    false,
                    undefined,
                    factory.createNamedImports([factory.createImportSpecifier(
                        false,
                        factory.createIdentifier("EntityDef"),
                        factory.createIdentifier(entity)
                    )])
                ),
                factory.createStringLiteral(`./${entity}/Schema`)
            )
        );

        const entityLc = firstLetterLowerCase(entity);
        propertySignatures.push(
            factory.createPropertySignature(
                undefined,
                factory.createIdentifier(entityLc),
                undefined,
                factory.createTypeReferenceNode(entity)
            )
        );
    }

    if (/* process.env.COMPLING_AS_LIB */false) {
        statements.push(
            factory.createImportDeclaration(
                undefined,
                undefined,
                factory.createImportClause(
                    false,
                    undefined,
                    factory.createNamedImports([factory.createImportSpecifier(
                        false,
                        undefined,
                        factory.createIdentifier("EntityDef")
                    )])
                ),
                factory.createStringLiteral("../types/Entity"),
                undefined
            ),
            factory.createTypeAliasDeclaration(
                undefined,
                [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
                factory.createIdentifier("EntityDict"),
                undefined,
                factory.createIntersectionTypeNode([
                    factory.createTypeLiteralNode(
                        propertySignatures
                    ),
                    factory.createTypeLiteralNode([
                        factory.createIndexSignature(
                            undefined,
                            undefined,
                            [factory.createParameterDeclaration(
                                undefined,
                                undefined,
                                undefined,
                                factory.createIdentifier("E"),
                                undefined,
                                factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
                                undefined
                            )],
                            factory.createTypeReferenceNode(
                                factory.createIdentifier("EntityDef"),
                                undefined
                            )
                        )
                    ])
                ])
            )
        );
    }
    else {
        statements.push(
            factory.createTypeAliasDeclaration(
                undefined,
                [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 = PathLib.join(outputDir, 'EntityDict.ts');
    writeFileSync(fileName, result, { flag: 'w' });
}

function outputSchema(outputDir: string, printer: ts.Printer) {
    for (const entity in Schema) {
        const statements: ts.Statement[] = initialStatements();
        if (ActionAsts[entity]) {
            const { importedFrom, actionDefNames } = ActionAsts[entity];
            const localActions: string[] = ['Action', 'ParticularAction'];
            for (const a in importedFrom) {
                assert(a.endsWith('Action'));
                const s = a.slice(0, a.length - 6).concat('State');
                if (importedFrom[a] === 'local' && actionDefNames.includes(firstLetterLowerCase(a.slice(0, a.length - 6)))) {
                    localActions.push(s);
                }
                else if (actionDefNames.includes(firstLetterLowerCase(a.slice(0, a.length - 6)))) {
                    const { moduleSpecifier } = importedFrom[a] as ts.ImportDeclaration;
                    statements.push(
                        factory.createImportDeclaration(
                            undefined,
                            undefined,
                            factory.createImportClause(
                                false,
                                undefined,
                                factory.createNamedImports(
                                    [
                                        factory.createImportSpecifier(
                                            false,
                                            undefined,
                                            factory.createIdentifier(s)
                                        )
                                    ]
                                )
                            ),
                            moduleSpecifier,
                            undefined
                        )
                    );
                }
            }
            statements.push(
                factory.createImportDeclaration(
                    undefined,
                    undefined,
                    factory.createImportClause(
                        false,
                        undefined,
                        factory.createNamedImports(localActions.map(
                            ele => factory.createImportSpecifier(
                                false,
                                undefined,
                                factory.createIdentifier(ele)
                            )
                        ))
                    ),
                    factory.createStringLiteral('./Action'),
                    undefined
                ),
                factory.createImportDeclaration(
                    undefined,
                    undefined,
                    factory.createImportClause(
                        false,
                        undefined,
                        factory.createNamedImports([
                            factory.createImportSpecifier(
                                false,
                                undefined,
                                factory.createIdentifier("RelationAction")
                            ),
                        ])
                    ),
                    factory.createStringLiteral(ACTION_CONSTANT_IN_OAK_DOMAIN()),
                    undefined
                )
            );
        }
        else {
            statements.push(
                factory.createImportDeclaration(
                    undefined,
                    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(ACTION_CONSTANT_IN_OAK_DOMAIN()),
                    undefined
                )
            );
        }
        const { additionalImports } = Schema[entity];
        if (additionalImports?.length > 0) {
            statements.push(...additionalImports);
        }

        // 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);
        constructActions(statements, entity);
        constructQuery(statements, entity);
        // 现在FullAttrs和NativeAttrs似乎没什么用，还会引起递归
        // constructFullAttrs(statements, entity);

        const makeActionArguments: ts.TypeNode[] = [];
        if (ActionAsts[entity]) {
            makeActionArguments.push(factory.createTypeReferenceNode('Action'));
        }
        else {
            makeActionArguments.push(
                factory.createTypeReferenceNode(
                    OriginActionDict[Schema[entity].actionType as keyof typeof OriginActionDict],
                )
            );
        }
        if (Schema[entity].hasRelationDef || entity === 'User') {
            makeActionArguments.push(
                factory.createTypeReferenceNode('RelationAction')
            );
        }
        const actionTypeNode: ts.TypeNode = 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(
                undefined,
                [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
                factory.createIdentifier("EntityDef"),
                undefined,
                factory.createTypeLiteralNode(EntityDefAttrs)
            )
        )

        const result = printer.printList(ts.ListFormat.SourceFileStatements, factory.createNodeArray(statements), Schema[entity].sourceFile);
        const fileName = PathLib.join(outputDir, entity, 'Schema.ts');
        writeFileSync(fileName, result, { flag: 'w' });
    }
}

function outputAction(outputDir: string, printer: ts.Printer) {
    const actionDictStatements: ts.Statement[] = [];
    const propertyAssignments: ts.PropertyAssignment[] = [];
    for (const entity in ActionAsts) {
        const { sourceFile, statements, importedFrom, actionDefNames } = ActionAsts[entity];
        const importStatements: ts.Statement[] = [];
        for (const k in importedFrom) {
            assert(k.endsWith('Action'));
            if (importedFrom[k] !== 'local') {
                importStatements.push(
                    importedFrom[k] as ts.ImportDeclaration
                );
            }
        }
        /* const actionDiff = difference(actionNames, actionDefNames);
        if (actionDiff.length > 0) {
            throw new Error(`action not conform to actionDef: ${actionDiff.join(',')}, entity: ${entity}`);
        } */
        statements.push(
            factory.createVariableStatement(
                [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
                factory.createVariableDeclarationList(
                    [factory.createVariableDeclaration(
                        factory.createIdentifier("ActionDefDict"),
                        undefined,
                        undefined,
                        factory.createObjectLiteralExpression(
                            actionDefNames.map(
                                ele => factory.createPropertyAssignment(
                                    factory.createIdentifier(`${ele}State`),
                                    factory.createIdentifier(`${firstLetterUpperCase(ele)}ActionDef`)
                                )
                            ),
                            true
                        )
                    )],
                    ts.NodeFlags.Const
                )
            )
        );
        /*  const result = printer.printNode(
             ts.EmitHint.Unspecified,
             factory.createSourceFile(statements,
                 factory.createToken(ts.SyntaxKind.EndOfFileToken),
                 ts.NodeFlags.None),
             sourceFile
         ); */
        // 这里如果用printNode，stringLiteral的输出始终有个bug不知道如何处理
        const result = printer.printList(
            ts.ListFormat.SourceFileStatements,
            factory.createNodeArray(importStatements.concat(statements)),
            sourceFile);
        const filename = PathLib.join(outputDir, entity, 'Action.ts');
        writeFileSync(filename, result, { flag: 'w' });

        actionDictStatements.push(
            factory.createImportDeclaration(
                undefined,
                undefined,
                factory.createImportClause(
                    false,
                    undefined,
                    factory.createNamedImports([factory.createImportSpecifier(
                        false,
                        factory.createIdentifier("ActionDefDict"),
                        factory.createIdentifier(entity)
                    )])
                ),
                factory.createStringLiteral(`./${entity}/Action`)
            )
        );
        propertyAssignments.push(
            factory.createPropertyAssignment(
                factory.createIdentifier(firstLetterLowerCase(entity)),
                factory.createIdentifier(entity)
            )
        );
    }

    actionDictStatements.push(
        factory.createVariableStatement(
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createVariableDeclarationList(
                [factory.createVariableDeclaration(
                    factory.createIdentifier("ActionDefDict"),
                    undefined,
                    undefined,
                    factory.createObjectLiteralExpression(
                        propertyAssignments,
                        true
                    )
                )],
                ts.NodeFlags.Const
            )
        )
    );

    const resultFile = ts.createSourceFile("someFileName.ts", "", ts.ScriptTarget.Latest, /*setParentNodes*/ false, ts.ScriptKind.TS);
    const result = printer.printNode(
        ts.EmitHint.Unspecified,
        factory.createSourceFile(actionDictStatements, factory.createToken(ts.SyntaxKind.EndOfFileToken),
            ts.NodeFlags.None),
        resultFile
    );

    const fileName = PathLib.join(outputDir, 'ActionDefDict.ts');
    writeFileSync(fileName, result, { flag: 'w' });
}

function constructAttributes(entity: string): ts.PropertyAssignment[] {
    const { schemaAttrs, enumStringAttrs } = Schema[entity];
    const { [entity]: manyToOneSet } = ManyToOne;
    const result: ts.PropertyAssignment[] = [];

    schemaAttrs.forEach(
        (attr) => {
            const attrAssignments: ts.PropertyAssignment[] = [];
            const { name, type } = attr;
            let name2 = name;

            if (ts.isTypeReferenceNode(type!)) {
                const { typeName, typeArguments } = type;
                if (ts.isIdentifier(typeName)) {
                    const { text } = typeName;
                    switch (text) {
                        case 'String': {
                            attrAssignments.push(
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("type"),
                                    factory.createStringLiteral("varchar")
                                ),
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("params"),
                                    factory.createObjectLiteralExpression(
                                        [
                                            factory.createPropertyAssignment(
                                                factory.createIdentifier("length"),
                                                factory.createNumericLiteral(
                                                    (<ts.NumericLiteral>(<ts.LiteralTypeNode>typeArguments![0]).literal).text
                                                )
                                            ),
                                        ],
                                        true
                                    )
                                )
                            );
                            // 如果是entity，在这里处理一下ref
                            if (ts.isIdentifier(name) && name.text === 'entity') {
                                const mtoRelations = ReversePointerRelations[entity];
                                if (mtoRelations) {
                                    const mtoEntities = mtoRelations.map(
                                        ele => firstLetterLowerCase(ele)
                                    );
                                    attrAssignments.push(
                                        factory.createPropertyAssignment(
                                            factory.createIdentifier("ref"),
                                            factory.createArrayLiteralExpression(
                                                mtoEntities.map(
                                                    ele => factory.createStringLiteral(ele)
                                                ),
                                                false
                                            )
                                        )
                                    );
                                }
                            }
                            break;
                        }
                        case 'Text':
                        case 'Image':
                        case 'File': {
                            attrAssignments.push(
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("type"),
                                    factory.createStringLiteral("text")
                                ),
                            );
                            break;
                        }
                        case 'Int':
                        case 'Uint': {
                            attrAssignments.push(
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("type"),
                                    factory.createStringLiteral("int")
                                ),
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("params"),
                                    factory.createObjectLiteralExpression(
                                        [
                                            factory.createPropertyAssignment(
                                                factory.createIdentifier("width"),
                                                factory.createNumericLiteral(
                                                    (<ts.NumericLiteral>(<ts.LiteralTypeNode>typeArguments![0]).literal).text
                                                )
                                            ),
                                            factory.createPropertyAssignment(
                                                factory.createIdentifier("signed"),
                                                text === 'Uint' ? factory.createFalse() : factory.createTrue()
                                            )
                                        ],
                                        true
                                    )
                                )
                            );
                            break;
                        }
                        case 'Float': {
                            attrAssignments.push(
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("type"),
                                    factory.createStringLiteral("float")
                                ),
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("params"),
                                    factory.createObjectLiteralExpression(
                                        [
                                            factory.createPropertyAssignment(
                                                factory.createIdentifier("precision"),
                                                factory.createNumericLiteral(
                                                    (<ts.NumericLiteral>(<ts.LiteralTypeNode>typeArguments![0]).literal).text
                                                )
                                            ),
                                            factory.createPropertyAssignment(
                                                factory.createIdentifier("scale"),
                                                factory.createNumericLiteral(
                                                    (<ts.NumericLiteral>(<ts.LiteralTypeNode>typeArguments![1]).literal).text
                                                )
                                            )
                                        ],
                                        true
                                    )
                                )
                            );
                            break;
                        }
                        case 'Double': {
                            attrAssignments.push(
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("type"),
                                    factory.createStringLiteral("double")
                                ),
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("params"),
                                    factory.createObjectLiteralExpression(
                                        [
                                            factory.createPropertyAssignment(
                                                factory.createIdentifier("precision"),
                                                factory.createNumericLiteral(
                                                    (<ts.NumericLiteral>(<ts.LiteralTypeNode>typeArguments![0]).literal).text
                                                )
                                            ),
                                            factory.createPropertyAssignment(
                                                factory.createIdentifier("scale"),
                                                factory.createNumericLiteral(
                                                    (<ts.NumericLiteral>(<ts.LiteralTypeNode>typeArguments![1]).literal).text
                                                )
                                            )
                                        ],
                                        true
                                    )
                                )
                            );
                            break;
                        }
                        case 'Boolean': {
                            attrAssignments.push(
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("type"),
                                    factory.createStringLiteral("boolean")
                                )
                            );
                            break;
                        }
                        case 'Datetime': {
                            attrAssignments.push(
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("type"),
                                    factory.createStringLiteral("datetime")
                                ),
                            );
                            break;
                        }
                        case 'SingleGeo':
                        case 'Geo': {
                            // object类型暂不支持查询
                            attrAssignments.push(
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("type"),
                                    factory.createStringLiteral("geometry")
                                ),
                            );
                            break;
                        }
                        case 'Object': {
                            // object类型暂不支持查询
                            attrAssignments.push(
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("type"),
                                    factory.createStringLiteral("object")
                                ),
                            );
                            break;
                        }
                        default: {
                            const text2 = text === 'Schema' ? entity : text;
                            const manyToOneItem = manyToOneSet && manyToOneSet.find(
                                ([refEntity, attrName]) => refEntity === text2 && attrName === attrName
                            );
                            if (manyToOneItem) {
                                // 外键
                                name2 = factory.createIdentifier(`${(<ts.Identifier>name).text}Id`);
                                attrAssignments.push(
                                    factory.createPropertyAssignment(
                                        factory.createIdentifier("type"),
                                        factory.createStringLiteral("ref")
                                    ),
                                    factory.createPropertyAssignment(
                                        factory.createIdentifier("ref"),
                                        factory.createStringLiteral(firstLetterLowerCase(text2))
                                    )
                                );
                            }
                            else {
                                if (enumStringAttrs && enumStringAttrs.includes((<ts.Identifier>name).text)) {
                                    attrAssignments.push(
                                        factory.createPropertyAssignment(
                                            factory.createIdentifier("type"),
                                            factory.createStringLiteral("varchar")
                                        ),
                                        factory.createPropertyAssignment(
                                            factory.createIdentifier("params"),
                                            factory.createObjectLiteralExpression(
                                                [factory.createPropertyAssignment(
                                                    factory.createIdentifier("length"),
                                                    factory.createNumericLiteral(STRING_LITERAL_MAX_LENGTH)
                                                )],
                                                true
                                            )
                                        )
                                    );
                                }
                                else {
                                    // todo 引用的非string定义，目前没有处理int类型的引用，等遇到了再处理
                                    attrAssignments.push(
                                        factory.createPropertyAssignment(
                                            factory.createIdentifier("type"),
                                            factory.createStringLiteral("object")
                                        ),
                                    );
                                }
                            }
                        }
                    }
                }
                else {
                    assert(false);
                }
            }
            else {
                if (ts.isUnionTypeNode(type!)) {
                    if (ts.isLiteralTypeNode(type.types[0])) {
                        if (ts.isStringLiteral(type.types[0].literal)) {
                            attrAssignments.push(
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("type"),
                                    factory.createStringLiteral("varchar")
                                ),
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("params"),
                                    factory.createObjectLiteralExpression(
                                        [factory.createPropertyAssignment(
                                            factory.createIdentifier("length"),
                                            factory.createNumericLiteral(STRING_LITERAL_MAX_LENGTH)
                                        )],
                                        true
                                    )
                                )
                            );
                        }
                        else {
                            assert(ts.isNumericLiteral(type.types[0].literal));
                            attrAssignments.push(
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("type"),
                                    factory.createStringLiteral("int")
                                ),
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("params"),
                                    factory.createObjectLiteralExpression(
                                        [
                                            factory.createPropertyAssignment(
                                                factory.createIdentifier("width"),
                                                factory.createNumericLiteral(INT_LITERL_DEFAULT_WIDTH)
                                            )
                                        ],
                                        true
                                    )
                                )
                            );
                        }
                    }
                    else {
                        // 否则是本地规定的shape，直接用object
                        attrAssignments.push(
                            factory.createPropertyAssignment(
                                factory.createIdentifier("type"),
                                factory.createStringLiteral("object")
                            ),
                        );
                    }
                }
                else {
                    if (ts.isLiteralTypeNode(type!)) {
                        if (ts.isStringLiteral(type.literal)) {
                            attrAssignments.push(
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("type"),
                                    factory.createStringLiteral("varchar")
                                ),
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("params"),
                                    factory.createObjectLiteralExpression(
                                        [factory.createPropertyAssignment(
                                            factory.createIdentifier("length"),
                                            factory.createNumericLiteral(STRING_LITERAL_MAX_LENGTH)
                                        )],
                                        true
                                    )
                                )
                            );
                        }
                        else {
                            assert(ts.isNumericLiteral(type.literal));
                            attrAssignments.push(
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("type"),
                                    factory.createStringLiteral("precision")
                                ),
                                factory.createPropertyAssignment(
                                    factory.createIdentifier("params"),
                                    factory.createObjectLiteralExpression(
                                        [
                                            factory.createPropertyAssignment(
                                                factory.createIdentifier("precision"),
                                                factory.createNumericLiteral(NUMERICAL_LITERL_DEFAULT_PRECISION)
                                            ),
                                            factory.createPropertyAssignment(
                                                factory.createIdentifier("scale"),
                                                factory.createNumericLiteral(NUMERICAL_LITERL_DEFAULT_SCALE)
                                            )
                                        ],
                                        true
                                    )
                                )
                            );
                        }
                    }
                    else {
                        // 否则是本地规定的shape，直接用object
                        attrAssignments.push(
                            factory.createPropertyAssignment(
                                factory.createIdentifier("type"),
                                factory.createStringLiteral("object")
                            ),
                        );
                    }
                }
            }

            result.push(
                factory.createPropertyAssignment(
                    name2,
                    factory.createObjectLiteralExpression(attrAssignments, true)
                )
            );
        }
    );

    return result;
}

function outputLocale(outputDir: string, printer: ts.Printer) {
    const locales: Record<string, string[]> = {};
    const entities: string[] = [];
    for (const entity in Schema) {
        const { locale, sourceFile } = Schema[entity];
        if (locale) {
            const { properties } = locale;
            properties.forEach(
                (ele) => {
                    assert(ts.isPropertyAssignment(ele) && (ts.isIdentifier(ele.name) || ts.isStringLiteral(ele.name)) && ts.isObjectLiteralExpression(ele.initializer));
                    const lng = ele.name.text;

                    const result = printer.printList(
                        ts.ListFormat.SourceFileStatements,
                        factory.createNodeArray([
                            factory.createReturnStatement(
                                ele.initializer
                            )
                        ]),
                        sourceFile);
                    const data = Function(result)();
                    const filename = PathLib.join(outputDir, entity, 'locales', `${lng}.json`);
                    writeFileSync(filename, JSON.stringify(data), { flag: 'w' });

                    if (locales[lng]) {
                        locales[lng].push(entity);
                    }
                    else {
                        locales[lng] = [entity];
                    }
                }
            );
            entities.push(entity);
        }
    }

    for (const lng in locales) {
        if (locales[lng].length < entities.length) {
            const lack = difference(entities, locales[lng]);
            throw new Error(`${lng}语言定义中缺少了对象${lack.join(',')}的定义，请检查相应的定义文件`);
        }
        /* const statements: ts.Statement[] = locales[lng].map(
            (entity) => factory.createImportDeclaration(
                undefined,
                undefined,
                factory.createImportClause(
                    false,
                    factory.createIdentifier(firstLetterLowerCase(entity)),
                    undefined
                ),
                factory.createStringLiteral(`../${entity}/locales/${lng}`),
                undefined
            )
        );

        statements.push(
            factory.createExportAssignment(
                undefined,
                undefined,
                undefined,
                factory.createObjectLiteralExpression(
                    locales[lng].map(
                        ele => factory.createShorthandPropertyAssignment(
                            factory.createIdentifier(firstLetterLowerCase(ele)),
                            undefined
                        )
                    ),
                    true
                )
            )
        );

        const result = printer.printList(
            ts.ListFormat.SourceFileStatements,
            factory.createNodeArray(statements),
            ts.createSourceFile("someFileName.ts", "", ts.ScriptTarget.Latest,  false, ts.ScriptKind.TS));
        const filename = path.join(outputDir, '_locales', `${lng}.ts`);
        writeFileSync(filename, result, { flag: 'w' }); */
    }
}

function outputStorage(outputDir: string, printer: ts.Printer) {
    const importStatements: ts.Statement[] = [
        factory.createImportDeclaration(
            undefined,
            undefined,
            factory.createImportClause(
                false,
                undefined,
                factory.createNamedImports([factory.createImportSpecifier(
                    false,
                    undefined,
                    factory.createIdentifier("StorageSchema")
                )])
            ),
            factory.createStringLiteral(`${TYPE_PATH_IN_OAK_DOMAIN(1)}Storage`),
            undefined
        ),
        factory.createImportDeclaration(
            undefined,
            undefined,
            factory.createImportClause(
                false,
                undefined,
                factory.createNamedImports([factory.createImportSpecifier(
                    false,
                    undefined,
                    factory.createIdentifier("EntityDict")
                )])
            ),
            factory.createStringLiteral("./EntityDict"),
            undefined
        )
    ];
    const entityAssignments: ts.PropertyAssignment[] = [];

    for (const entity in Schema) {
        const indexExpressions: ts.Expression[] = [];
        const { sourceFile, inModi, indexes, toModi, actionType, static: _static, hasRelationDef } = Schema[entity];
        const fromSchemaSpecifiers = [
            factory.createImportSpecifier(
                false,
                undefined,
                factory.createIdentifier("OpSchema")
            )
        ];
        /* if (relationHierarchy || reverseCascadeRelationHierarchy) {
            fromSchemaSpecifiers.push(
                factory.createImportSpecifier(
                    false,
                    undefined,
                    factory.createIdentifier("Relation")
                )
            );
        } */
        const statements: ts.Statement[] = [
            factory.createImportDeclaration(
                undefined,
                undefined,
                factory.createImportClause(
                    false,
                    undefined,
                    factory.createNamedImports([factory.createImportSpecifier(
                        false,
                        undefined,
                        factory.createIdentifier("StorageDesc")
                    )])
                ),
                factory.createStringLiteral(`${TYPE_PATH_IN_OAK_DOMAIN()}Storage`),
                undefined
            ),
            factory.createImportDeclaration(
                undefined,
                undefined,
                factory.createImportClause(
                    false,
                    undefined,
                    factory.createNamedImports(fromSchemaSpecifiers)
                ),
                factory.createStringLiteral("./Schema"),
                undefined
            )
        ];

        const needImportActions: ts.ImportSpecifier[] = [];
        switch (actionType) {
            case 'readOnly': {
                needImportActions.push(
                    factory.createImportSpecifier(
                        false,
                        factory.createIdentifier("readOnlyActions"),
                        factory.createIdentifier("actions")
                    )
                );
                break;
            }
            case 'appendOnly': {
                needImportActions.push(
                    factory.createImportSpecifier(
                        false,
                        factory.createIdentifier("appendOnlyActions"),
                        factory.createIdentifier("actions")
                    )
                );
                break;
            }
            case 'excludeUpdate': {
                needImportActions.push(
                    factory.createImportSpecifier(
                        false,
                        factory.createIdentifier("excludeUpdateActions"),
                        factory.createIdentifier("actions")
                    )
                );
                break;
            }
            default: {
                if (ActionAsts[entity]) {
                    statements.push(
                        factory.createImportDeclaration(
                            undefined,
                            undefined,
                            factory.createImportClause(
                                false,
                                undefined,
                                factory.createNamedImports([factory.createImportSpecifier(
                                    false,
                                    undefined,
                                    factory.createIdentifier("actions")
                                )])
                            ),
                            factory.createStringLiteral("./Action"),
                            undefined
                        )
                    );
                }
                else {
                    needImportActions.push(
                        factory.createImportSpecifier(
                            false,
                            factory.createIdentifier("genericActions"),
                            factory.createIdentifier("actions")
                        )
                    );
                }
            }
        }

        if (Schema[entity].hasRelationDef || entity === 'User') {
            needImportActions.push(
                factory.createImportSpecifier(
                    false,
                    undefined,
                    factory.createIdentifier("relationActions"),
                )
            );
        }
        if (needImportActions.length > 0) {
            statements.push(
                factory.createImportDeclaration(
                    undefined,
                    undefined,
                    factory.createImportClause(
                        false,
                        undefined,
                        factory.createNamedImports(needImportActions)
                    ),
                    factory.createStringLiteral(ACTION_CONSTANT_IN_OAK_DOMAIN()),
                    undefined
                )
            );
        }
        const propertyAssignments: (ts.PropertyAssignment | ts.ShorthandPropertyAssignment)[] = [];
        const attributes = constructAttributes(entity);
        propertyAssignments.push(
            factory.createPropertyAssignment(
                factory.createIdentifier("attributes"),
                factory.createObjectLiteralExpression(
                    attributes,
                    true
                )
            )
        );

        if (indexes) {
            indexExpressions.push(
                ...indexes.elements
            )
        }
        if (toModi) {
            propertyAssignments.push(
                factory.createPropertyAssignment(
                    factory.createIdentifier("toModi"),
                    factory.createTrue()
                )
            );
        }

        if (inModi) {
            propertyAssignments.push(
                factory.createPropertyAssignment(
                    factory.createIdentifier("inModi"),
                    factory.createTrue()
                )
            );
        }

        if (_static || actionType === 'readOnly') {
            propertyAssignments.push(
                factory.createPropertyAssignment(
                    factory.createIdentifier("static"),
                    factory.createTrue()
                )
            );
        }

        propertyAssignments.push(
            factory.createPropertyAssignment(
                factory.createIdentifier("actionType"),
                factory.createStringLiteral(actionType)
            )
        );

        if (Schema[entity].hasRelationDef || entity === 'User') {
            propertyAssignments.push(
                factory.createPropertyAssignment(
                    factory.createIdentifier("actions"),
                    factory.createCallExpression(
                        factory.createPropertyAccessExpression(
                            factory.createIdentifier("actions"),
                            factory.createIdentifier("concat")
                        ),
                        undefined,
                        [factory.createIdentifier("relationActions")]
                    )
                )
            );
        }
        else {
            propertyAssignments.push(
                factory.createShorthandPropertyAssignment(
                    factory.createIdentifier("actions"),
                    undefined
                )
            );
        }

        if (indexExpressions.length > 0) {
            propertyAssignments.push(
                factory.createPropertyAssignment(
                    factory.createIdentifier("indexes"),
                    factory.createArrayLiteralExpression(indexExpressions, true)
                )
            );
        }
        /* if (relationHierarchy) {
            propertyAssignments.push(
                factory.createPropertyAssignment(
                    factory.createIdentifier("relationHierarchy"),
                    relationHierarchy,
                )
            );
        }
        if (reverseCascadeRelationHierarchy) {
            propertyAssignments.push(
                factory.createPropertyAssignment(
                    factory.createIdentifier("reverseCascadeRelationHierarchy"),
                    reverseCascadeRelationHierarchy,
                )
            );
        } */
        if (hasRelationDef) {
            const { type } = hasRelationDef;
            if (ts.isUnionTypeNode(type)) {
                const { types } = type;
                const relationTexts = types.map(
                    ele => {
                        assert(ts.isLiteralTypeNode(ele) && ts.isStringLiteral(ele.literal));
                        return ele.literal.text;
                    }
                )
                propertyAssignments.push(
                    factory.createPropertyAssignment(
                        factory.createIdentifier("relation"),
                        factory.createArrayLiteralExpression(relationTexts.map(
                            ele => factory.createStringLiteral(ele)
                        )),
                    )
                );
            }
            else {
                assert(ts.isLiteralTypeNode(type));
                assert(ts.isStringLiteral(type.literal));

                propertyAssignments.push(
                    factory.createPropertyAssignment(
                        factory.createIdentifier("relation"),
                        factory.createArrayLiteralExpression(
                            [
                                type.literal
                            ]
                        ),
                    )
                );
            }
        }
        const sdTypeArguments = [
            factory.createTypeReferenceNode(
                factory.createIdentifier("OpSchema"),
                undefined
            )
        ];
        statements.push(
            factory.createVariableStatement(
                [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
                factory.createVariableDeclarationList(
                    [factory.createVariableDeclaration(
                        factory.createIdentifier("desc"),
                        undefined,
                        factory.createTypeReferenceNode(
                            factory.createIdentifier("StorageDesc"),
                            sdTypeArguments
                        ),
                        factory.createObjectLiteralExpression(
                            propertyAssignments,
                            true
                        )
                    )],
                    ts.NodeFlags.Const
                )
            )
        );

        const result = printer.printList(
            ts.ListFormat.SourceFileStatements,
            factory.createNodeArray(statements),
            sourceFile);
        const filename = PathLib.join(outputDir, entity, 'Storage.ts');
        writeFileSync(filename, result, { flag: 'w' });

        importStatements.push(
            factory.createImportDeclaration(
                undefined,
                undefined,
                factory.createImportClause(
                    false,
                    undefined,
                    factory.createNamedImports([
                        factory.createImportSpecifier(
                            false,
                            factory.createIdentifier("desc"),
                            factory.createIdentifier(`${firstLetterLowerCase(entity)}Desc`)
                        )
                    ])
                ),
                factory.createStringLiteral(`./${entity}/Storage`),
                undefined
            )
        );
        entityAssignments.push(
            factory.createPropertyAssignment(
                firstLetterLowerCase(entity),
                factory.createIdentifier(`${firstLetterLowerCase(entity)}Desc`)
            )
        );
    }

    importStatements.push(
        factory.createVariableStatement(
            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
            factory.createVariableDeclarationList(
                [factory.createVariableDeclaration(
                    factory.createIdentifier("storageSchema"),
                    undefined,
                    factory.createTypeReferenceNode(
                        factory.createIdentifier("StorageSchema"),
                        [
                            factory.createTypeReferenceNode('EntityDict')
                        ]
                    ),
                    factory.createObjectLiteralExpression(
                        entityAssignments,
                        true
                    )
                )],
                ts.NodeFlags.Const
            )
        )
    );

    const result = printer.printList(
        ts.ListFormat.SourceFileStatements,
        factory.createNodeArray(importStatements),
        ts.createSourceFile("someFileName.ts", "", ts.ScriptTarget.Latest, /*setParentNodes*/ false, ts.ScriptKind.TS));
    const filename = PathLib.join(outputDir, 'Storage.ts');
    writeFileSync(filename, result, { flag: 'w' });
}

function resetOutputDir(outputDir: string) {
    emptydirSync(outputDir);

    for (const moduleName in Schema) {
        mkdirSync(PathLib.join(outputDir, moduleName));
        mkdirSync(PathLib.join(outputDir, moduleName, 'locales'));
    }
    mkdirSync(PathLib.join(outputDir, '_locales'))
}

function addReverseRelationship() {
    for (const reverseEntity in ReversePointerRelations) {
        if (!ReversePointerEntities.hasOwnProperty(reverseEntity)) {
            throw new Error(`「${reverseEntity}」被引用为一个反指对象，但其定义中的entity和entityId不符合要求`);
        }
        for (const one of ReversePointerRelations[reverseEntity]) {
            addRelationship(reverseEntity, one, 'entity', false);
        }
    }
}

function outputIndexTs(outputDir: string) {
    const indexTs = `export * from './EntityDict';
    export * from './Storage';
    export * from './ActionDefDict';
    `;
    const filename = PathLib.join(outputDir, 'index.ts');
    writeFileSync(filename, indexTs, { flag: 'w' });
}

function outputPackageJson(outputDir: string) {
    const pj = {
        "name": process.env.COMPLING_AS_LIB ? "general-app-domain" : "oak-app-domain",
        "main": "index.ts"
    };

    const filename = PathLib.join(outputDir, 'package.json');
    writeFileSync(filename, JSON.stringify(pj), { flag: 'w' });
}

/**
 * （从toModi的对象开始）分析可能被modi指向的对象
 */
function analyzeInModi() {
    const getRelateEntities = (entity: string) => {
        let result: string[] = [];
        if (ManyToOne[entity]) {
            // 用反指指针指向的对象可以忽略，因为前端不可能设计出这样的更新页面
            result = ManyToOne[entity].filter(
                ele => ele[1] !== 'entity'
            ).map(
                ele => ele[0]
            );
        }

        if (OneToMany[entity]) {
            result.push(
                ...OneToMany[entity].map(
                    ele => ele[0]
                )
            );
        }
        return uniq(result);
    };
    const setInModi = (entity: string) => {
        if (['Modi', 'ModiEntity', 'Oper', 'OperEntity', 'User'].includes(entity)) {
            return;
        }
        const schema = Schema[entity];
        if (schema.toModi || schema.inModi || schema.actionType === 'readOnly' || schema.static) {
            return;
        }
        schema.inModi = true;
        const related = getRelateEntities(entity);
        related.forEach(
            ele => setInModi(ele)
        );
    };
    for (const entity in Schema) {
        if (Schema[entity].toModi) {
            const related = getRelateEntities(entity);
            related.forEach(
                ele => setInModi(ele)
            );
        }
    }
}

export function analyzeEntities(inputDir: string, relativePath?: string) {
    const files = readdirSync(inputDir);
    const fullFilenames = files.map(
        ele => {
            const entity = ele.slice(0, ele.indexOf('.'))
            if (RESERVED_ENTITIES.includes(entity) || RESERVED_ENTITIES.find(
                ele2 => entity.startsWith(ele2)
            )) {
                throw new Error(`${ele}是系统保留字，请勿使用其当对象名或对象名前缀`);
            }
            return `${inputDir}/${ele}`;
        }
    );

    const program = ts.createProgram(fullFilenames, { allowJs: true });

    files.forEach(
        (filename) => {
            analyzeEntity(filename, inputDir, program, relativePath);
        }
    );
    analyzeInModi();
    uniqRelationships();
}

export function buildSchema(outputDir: string): void {
    addReverseRelationship();
    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
    resetOutputDir(outputDir);
    outputSchema(outputDir, printer);
    outputLocale(outputDir, printer);
    outputSubQuery(outputDir, printer);
    outputAction(outputDir, printer);
    outputEntityDict(outputDir, printer);
    outputStorage(outputDir, printer);
    outputIndexTs(outputDir);

    if (!process.env.COMPLING_AS_LIB) {
        outputPackageJson(outputDir);
    }
}