oak-domain 5.1.31 → 5.1.33

package/lib/base-app-domain/Modi/Storage.js

@@ -43,6 +43,7 @@ exports.desc = {
             type: "object"
         },
         iState: {
+            notNull: true,
             type: "enum",
             enumeration: ["active", "applied", "abandoned"]
         }

package/lib/base-app-domain/Modi/_baseSchema.d.ts

@@ -10,7 +10,7 @@ export type OpSchema = EntityShape & {
     data: Object;
     filter?: Object | null;
     extra?: Object | null;
-    iState?: IState | null;
+    iState: IState;
 } & {
     [A in ExpressionKey]?: any;
 };

package/lib/base-app-domain/Oper/Storage.js

@@ -43,6 +43,7 @@ exports.desc = {
             type: "object"
         },
         iState: {
+            notNull: true,
             type: "enum",
             enumeration: ["normal", "rollbacked"]
         }

package/lib/base-app-domain/Oper/_baseSchema.d.ts

@@ -13,7 +13,7 @@ export type OpSchema = EntityShape & {
     bornAt?: Datetime | null;
     logId?: ForeignKey<"log"> | null;
     undoData?: Object | null;
-    iState?: IState | null;
+    iState: IState;
 } & {
     [A in ExpressionKey]?: any;
 };

package/lib/compiler/identifier.d.ts

@@ -0,0 +1,9 @@
+import * as ts from 'typescript';
+/**
+ * 判断节点是否为 t 函数调用
+ * @param node ts.Node
+ * @param typeChecker ts.TypeChecker
+ * @returns boolean
+ * t: (key: string, params?: object | undefined) => string
+ */
+export declare const isTCall: (node: ts.Node, typeChecker: ts.TypeChecker, modules: string[]) => boolean;

package/lib/compiler/identifier.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTCall = void 0;
+const tslib_1 = require("tslib");
+const ts = tslib_1.__importStar(require("typescript"));
+// 缓存结构：WeakMap<Node, Map<modulesKey, boolean>>
+const isTCallCache = new WeakMap();
+/**
+ * 生成 modules 的缓存 key
+ */
+function getModulesCacheKey(modules) {
+    return modules.sort().join('|');
+}
+/**
+ * 判断节点是否为 t 函数调用
+ * @param node ts.Node
+ * @param typeChecker ts.TypeChecker
+ * @returns boolean
+ * t: (key: string, params?: object | undefined) => string
+ */
+const isTCall = (node, typeChecker, modules) => {
+    // 缓存查询
+    const modulesCacheKey = getModulesCacheKey(modules);
+    let nodeCache = isTCallCache.get(node);
+    if (nodeCache) {
+        const cachedResult = nodeCache.get(modulesCacheKey);
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
+    }
+    if (!(ts.isCallExpression(node) && ts.isIdentifier(node.expression))) {
+        // 缓存 false 结果
+        if (!nodeCache) {
+            nodeCache = new Map();
+            isTCallCache.set(node, nodeCache);
+        }
+        nodeCache.set(modulesCacheKey, false);
+        return false;
+    }
+    const result = doIsTCallDirect(node, typeChecker, modules);
+    // 缓存结果
+    if (!nodeCache) {
+        nodeCache = new Map();
+        isTCallCache.set(node, nodeCache);
+    }
+    nodeCache.set(modulesCacheKey, result);
+    return result;
+};
+exports.isTCall = isTCall;
+const doIsTCallDirect = (node, typeChecker, modules) => {
+    if (!(ts.isCallExpression(node) && ts.isIdentifier(node.expression))) {
+        return false;
+    }
+    const symbol = typeChecker.getSymbolAtLocation(node.expression);
+    if (!symbol) {
+        return false;
+    }
+    const declarations = symbol.getDeclarations();
+    if (!declarations || declarations.length === 0) {
+        return false;
+    }
+    for (const decl of declarations) {
+        const declType = typeChecker.getTypeAtLocation(decl);
+        const signatures = declType.getCallSignatures();
+        for (const sig of signatures) {
+            // 检查这个类型是否来自指定模块
+            if (!isTypeFromModules(declType, modules)) {
+                continue;
+            }
+            // 检查返回类型是否为 string
+            const returnType = typeChecker.getReturnTypeOfSignature(sig);
+            if ((returnType.flags & ts.TypeFlags.String) === 0) {
+                continue;
+            }
+            const params = sig.getParameters();
+            if (params.length === 0) {
+                continue;
+            }
+            // 检查第一个参数是否为 string
+            const firstParamType = typeChecker.getTypeOfSymbolAtLocation(params[0], decl);
+            if ((firstParamType.flags & ts.TypeFlags.String) === 0) {
+                continue;
+            }
+            // 如果只有一个参数，符合 (key: string) => string
+            if (params.length === 1) {
+                return true;
+            }
+            // 检查第二个参数
+            if (params.length >= 2) {
+                const secondParam = params[1];
+                const secondParamType = typeChecker.getTypeOfSymbolAtLocation(secondParam, decl);
+                // 检查第二个参数是否为 object 或 object | undefined
+                if (isObjectOrObjectUnion(secondParamType)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+};
+/**
+ * 检查类型是否为 object 或 object | undefined
+ * @param type ts.Type
+ * @returns boolean
+ */
+function isObjectOrObjectUnion(type) {
+    // 如果是联合类型
+    if (type.isUnion()) {
+        // 检查联合类型中是否包含 object 类型
+        // 允许 object | undefined 的组合
+        let hasObject = false;
+        let hasOnlyObjectAndUndefined = true;
+        for (const t of type.types) {
+            if ((t.flags & ts.TypeFlags.Object) !== 0 || (t.flags & ts.TypeFlags.NonPrimitive) !== 0) {
+                hasObject = true;
+            }
+            else if ((t.flags & ts.TypeFlags.Undefined) === 0) {
+                // 如果既不是 object 也不是 undefined，则不符合
+                hasOnlyObjectAndUndefined = false;
+            }
+        }
+        return hasObject && hasOnlyObjectAndUndefined;
+    }
+    // 如果是单一类型，检查是否为 object
+    return (type.flags & ts.TypeFlags.Object) !== 0 || (type.flags & ts.TypeFlags.NonPrimitive) !== 0;
+}
+/**
+ * 检查声明是否来自指定的模块
+ * @param decl ts.Declaration
+ * @param modules 模块名称列表
+ * @returns boolean
+ */
+function isFromModules(decl, modules) {
+    const sourceFile = decl.getSourceFile();
+    if (!sourceFile) {
+        return false;
+    }
+    const fileName = sourceFile.fileName;
+    // 检查文件路径是否包含指定的模块
+    return modules.some(moduleName => {
+        return fileName.includes(moduleName);
+    });
+}
+/**
+ * 检查类型是否来自指定模块
+ * @param type ts.Type
+ * @param modules 模块名称列表
+ * @returns boolean
+ */
+function isTypeFromModules(type, modules) {
+    const symbol = type.getSymbol();
+    if (!symbol) {
+        return false;
+    }
+    const declarations = symbol.getDeclarations();
+    if (!declarations || declarations.length === 0) {
+        return false;
+    }
+    return declarations.some(decl => isFromModules(decl, modules));
+}

package/lib/compiler/schemalBuilder.d.ts

@@ -44,7 +44,6 @@ export declare function registerFixedDestinationPathMap(map: Record<string, stri
 export declare function registerDeducedRelationMap(map: Record<string, string>): void;
 export declare const getAnalizedSchema: () => typeof Schema;
 export declare function analyzeEntities(inputDir: string, relativePath?: string): void;
-export declare function buildSchemaBackup(outputDir: string): void;
 export declare function getProjectionKeys(entity: string): string[];
 export declare function buildSchema(outputDir: string): void;
 export {};

package/lib/compiler/schemalBuilder.js

@@ -9,7 +9,6 @@ exports.registerIgnoredRelationPathMap = registerIgnoredRelationPathMap;
 exports.registerFixedDestinationPathMap = registerFixedDestinationPathMap;
 exports.registerDeducedRelationMap = registerDeducedRelationMap;
 exports.analyzeEntities = analyzeEntities;
-exports.buildSchemaBackup = buildSchemaBackup;
 exports.getProjectionKeys = getProjectionKeys;
 exports.buildSchema = buildSchema;
 const tslib_1 = require("tslib");
@@ -440,7 +439,7 @@ function dealWithActionTypeNode(moduleName, filename, actionTypeNode, program, s
 }
 function dealWithActionDefInitializer(moduleName, initializer, program) {
     if (ts.isIdentifier(initializer) || ts.isCallExpression(initializer)) {
-        // 是从别处的引用，注入到mportActionDefFrom
+        // 是从别处的引用，注入到importActionDefFrom
         const checker = program.getTypeChecker();
         const identifier = ts.isIdentifier(initializer) ? initializer : initializer.expression;
         (0, assert_1.default)(ts.isIdentifier(identifier), "ActionDef的initializer不是一个Identifier");
@@ -449,12 +448,131 @@ function dealWithActionDefInitializer(moduleName, initializer, program) {
         (0, assert_1.default)(ts.isImportSpecifier(declaration), "ActionDef的initializer不是一个ImportSpecifier");
         const importDeclartion = declaration.parent.parent.parent;
         addImportedFrom(moduleName, identifier.text, importDeclartion);
+        // 如果是函数调用（CallExpression），无法在编译时确定is，直接返回false
+        if (ts.isCallExpression(initializer)) {
+            return false;
+        }
+        // 如果是直接引用（Identifier），尝试分析外部引用的actionDef中的is
+        const aliasedSymbol = checker.getAliasedSymbol(symbol);
+        const aliasedDeclaration = aliasedSymbol?.getDeclarations()?.[0];
+        // 如果无法获取到声明，返回false（可能是第三方库）
+        if (!aliasedDeclaration || !ts.isVariableDeclaration(aliasedDeclaration)) {
+            return false;
+        }
+        const { initializer: aliDecInit } = aliasedDeclaration;
+        // 如果没有初始化器，可能是.d.ts声明文件，尝试从对应的.js文件读取
+        if (!aliDecInit) {
+            const sourceFile = aliasedDeclaration.getSourceFile();
+            const sourceFileName = sourceFile.fileName;
+            // 检查是否是.d.ts文件
+            if (sourceFileName.endsWith('.d.ts')) {
+                const jsFileName = sourceFileName.replace(/\.d\.ts$/, '.js');
+                // 尝试读取对应的.js文件
+                if ((0, fs_1.existsSync)(jsFileName)) {
+                    try {
+                        const jsContent = require('fs').readFileSync(jsFileName, 'utf-8');
+                        // 获取原始的导出名称（处理 as 别名的情况）
+                        // 如果有 propertyName，说明使用了 as，应该使用 propertyName
+                        // 否则使用 name
+                        const exportName = declaration.propertyName?.text || declaration.name.text;
+                        // 尝试从JS文件中解析is属性
+                        const hasIs = tryParseIsFromJsFile(jsContent, exportName);
+                        return hasIs;
+                    }
+                    catch (error) {
+                        console.warn(`无法解析JS文件 ${jsFileName}:`, error);
+                        return false;
+                    }
+                }
+            }
+            return false;
+        }
+        // 如果是对象字面量，检查is属性
+        if (ts.isObjectLiteralExpression(aliDecInit)) {
+            const { properties } = aliDecInit;
+            const isProp = properties.find((ele) => ts.isPropertyAssignment(ele) && ts.isIdentifier(ele.name) && ele.name.text === 'is' && ts.isStringLiteral(ele.initializer));
+            return !!isProp;
+        }
+        // 其他情况返回false
+        return false;
     }
     else {
         // 本地定义的actionDef，不用处理
         (0, assert_1.default)(ts.isObjectLiteralExpression(initializer), moduleName);
+        if (ts.isObjectLiteralExpression(initializer)) {
+            const { properties } = initializer;
+            // 检查is属性是否存在，并且是string literal
+            const isProp = properties.find((ele) => ts.isPropertyAssignment(ele) && ts.isIdentifier(ele.name) && ele.name.text === 'is' && ts.isStringLiteral(ele.initializer));
+            return !!isProp;
+        }
+        return false;
     }
 }
+/**
+ * 尝试从JavaScript文件内容中解析导出对象的is属性
+ * @param jsContent JavaScript文件内容
+ * @param exportName 导出的变量名
+ * @returns 是否包含is属性
+ */
+function tryParseIsFromJsFile(jsContent, exportName) {
+    // 创建一个临时的SourceFile来解析JavaScript
+    const jsSourceFile = ts.createSourceFile('temp.js', jsContent, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+    let hasIs = false;
+    // 遍历AST查找导出
+    const visit = (node) => {
+        // 处理 exports.xxx = {...} 或 module.exports.xxx = {...}
+        if (ts.isExpressionStatement(node)) {
+            const expr = node.expression;
+            if (ts.isBinaryExpression(expr) && expr.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+                const left = expr.left;
+                const right = expr.right;
+                // 检查是否是 exports.exportName 或 module.exports.exportName
+                if (ts.isPropertyAccessExpression(left)) {
+                    const propertyName = left.name.text;
+                    if (propertyName === exportName) {
+                        // 检查右侧是否是对象字面量
+                        if (ts.isObjectLiteralExpression(right)) {
+                            hasIs = checkObjectHasIsProperty(right);
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        // 处理 const xxx = {...}; exports.xxx = xxx;
+        if (ts.isVariableStatement(node)) {
+            const declarations = node.declarationList.declarations;
+            for (const decl of declarations) {
+                if (ts.isIdentifier(decl.name) && decl.name.text === exportName) {
+                    if (decl.initializer && ts.isObjectLiteralExpression(decl.initializer)) {
+                        hasIs = checkObjectHasIsProperty(decl.initializer);
+                        return;
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(jsSourceFile);
+    return hasIs;
+}
+/**
+ * 检查对象字面量是否包含is属性
+ */
+function checkObjectHasIsProperty(objLiteral) {
+    const { properties } = objLiteral;
+    const isProp = properties.find((ele) => {
+        if (ts.isPropertyAssignment(ele)) {
+            const name = ele.name;
+            if (ts.isIdentifier(name) && name.text === 'is') {
+                // 检查值是否是字符串字面量
+                return ts.isStringLiteral(ele.initializer);
+            }
+        }
+        return false;
+    });
+    return !!isProp;
+}
 /**
  * entity的引用一定要以 import { Schema as XXX } from '..../XXX'这种形式
  * @param declaration
@@ -713,7 +831,7 @@ function dealImportedFile(path, fileSpecifierPath, filename, program) {
 //     }
 //     assert(false, `「${filename}」中import路径${fileSpecifierPath}找不到对应的声明`);
 // }
-function analyzeSchemaDefinition(node, moduleName, filename, path, program, referencedSchemas, schemaAttrs, enumAttributes, importAttrFrom, relativePath) {
+function analyzeSchemaDefinition(node, moduleName, filename, path, program, referencedSchemas, schemaAttrDict, enumAttributes, importAttrFrom, relativePath) {
     let hasEntityAttr = false;
     let hasEntityIdAttr = false;
     let toModi = false;
@@ -742,7 +860,7 @@ function analyzeSchemaDefinition(node, moduleName, filename, path, program, refe
         extendsFrom.push(from);
         const [sourceFile, pathName] = dealImportedFile(path, from, filename, program);
         const relativeFilename = path_1.default.relative(process.cwd(), pathName);
-        const result = analyzeReferenceSchemaFile(moduleName, path_1.default.basename(relativeFilename), path_1.default.dirname(relativeFilename), sourceFile, program, referencedSchemas, schemaAttrs, enumAttributes, importAttrFrom, path_1.default.join(from, '..'));
+        const result = analyzeReferenceSchemaFile(moduleName, path_1.default.basename(relativeFilename), path_1.default.dirname(relativeFilename), sourceFile, program, referencedSchemas, schemaAttrDict, enumAttributes, importAttrFrom, path_1.default.join(from, '..'));
         return result;
     }).filter(ele => !!ele);
     // assert(['EntityShape'].includes((<ts.Identifier>heritageClauses![0].types![0].expression).text), moduleName);
@@ -754,7 +872,9 @@ function analyzeSchemaDefinition(node, moduleName, filename, path, program, refe
             && ts.isIdentifier(type.typeName)) {
             if ((referencedSchemas.includes(type.typeName.text) || type.typeName.text === 'Schema')) {
                 addRelationship(moduleName, type.typeName.text, attrName, !!questionToken);
-                schemaAttrs.push(attrNode);
+                // schemaAttrs.push(attrNode);
+                (0, assert_1.default)(!schemaAttrDict[attrName], `「${filename}」的属性定义「${attrName}」发生了重复`);
+                schemaAttrDict[attrName] = attrNode;
             }
             else if (type.typeName.text === 'Array') {
                 // 这是一对多的反向指针的引用，需要特殊处理
@@ -782,7 +902,9 @@ function analyzeSchemaDefinition(node, moduleName, filename, path, program, refe
                 }
             }
             else {
-                schemaAttrs.push(attrNode);
+                // schemaAttrs.push(attrNode);
+                (0, assert_1.default)(!schemaAttrDict[attrName], `「${filename}」的属性定义「${attrName}」发生了重复`);
+                schemaAttrDict[attrName] = attrNode;
                 const enumStringValues = tryGetStringLiteralValues(moduleName, filename, `attr-${attrName}`, type, program);
                 if (enumStringValues.length > 0) {
                     enumAttributes[attrName] = enumStringValues;
@@ -813,13 +935,17 @@ function analyzeSchemaDefinition(node, moduleName, filename, path, program, refe
                 }
             }
             else {
-                schemaAttrs.push(attrNode);
+                // schemaAttrs.push(attrNode);
+                (0, assert_1.default)(!schemaAttrDict[attrName], `「${filename}」的属性定义「${attrName}」发生了重复`);
+                schemaAttrDict[attrName] = attrNode;
                 analyzeExternalAttrImport(type.elementType, program, importAttrFrom, relativePath);
                 // throw new Error(`对象${moduleName}中定义的属性${attrName}是不可识别的数组类别`);
             }
         }
         else {
-            schemaAttrs.push(attrNode);
+            // schemaAttrs.push(attrNode);
+            (0, assert_1.default)(!schemaAttrDict[attrName], `「${filename}」的属性定义「${attrName}」发生了重复`);
+            schemaAttrDict[attrName] = attrNode;
             if (ts.isUnionTypeNode(type) && ts.isLiteralTypeNode(type.types[0]) && ts.isStringLiteral(type.types[0].literal)) {
                 (0, assert_1.default)(ts.isIdentifier(name), `「${filename}」中的属性定义不是String类型`);
                 const { types } = type;
@@ -893,7 +1019,7 @@ function analyzeSchemaDefinition(node, moduleName, filename, path, program, refe
         extendsFrom,
     };
 }
-function analyzeReferenceSchemaFile(moduleName, filename, path, sourceFile, program, referencedSchemas, schemaAttrs, enumAttributes, importAttrFrom, relativePath) {
+function analyzeReferenceSchemaFile(moduleName, filename, path, sourceFile, program, referencedSchemas, schemaAttrDict, enumAttributes, importAttrFrom, relativePath) {
     let result;
     ts.forEachChild(sourceFile, (node) => {
         if (ts.isImportDeclaration(node)) {
@@ -902,7 +1028,7 @@ function analyzeReferenceSchemaFile(moduleName, filename, path, sourceFile, prog
         if (ts.isInterfaceDeclaration(node)) {
             // schema 定义
             if (node.name.text === 'Schema') {
-                result = analyzeSchemaDefinition(node, moduleName, filename, path, program, referencedSchemas, schemaAttrs, enumAttributes, importAttrFrom, relativePath);
+                result = analyzeSchemaDefinition(node, moduleName, filename, path, program, referencedSchemas, schemaAttrDict, enumAttributes, importAttrFrom, relativePath);
             }
             else if (!node.name.text.endsWith('Relation') && !node.name.text.endsWith('Action') && !node.name.text.endsWith('State')) {
                 // 本地规定的一些形状定义，直接使用
@@ -933,7 +1059,8 @@ function analyzeEntity(filename, path, program, relativePath) {
     }
     checkNameLegal(filename, moduleName, true);
     const referencedSchemas = [];
-    const schemaAttrs = [];
+    // const schemaAttrs: ts.TypeElement[] = [];
+    const schemaAttrDict = {};
     let hasFulltextIndex = false;
     let indexes;
     let beforeSchema = true;
@@ -958,7 +1085,7 @@ function analyzeEntity(filename, path, program, relativePath) {
             // schema 定义
             if (node.name.text === 'Schema') {
                 beforeSchema = false;
-                const result = analyzeSchemaDefinition(node, moduleName, filename, path, program, referencedSchemas, schemaAttrs, enumAttributes, importAttrFrom, relativePath);
+                const result = analyzeSchemaDefinition(node, moduleName, filename, path, program, referencedSchemas, schemaAttrDict, enumAttributes, importAttrFrom, relativePath);
                 if (result.hasEntityAttr && result.hasEntityIdAttr) {
                     (0, lodash_1.assign)(ReversePointerEntities, {
                         [moduleName]: 1,
@@ -1112,11 +1239,12 @@ function analyzeEntity(filename, path, program, relativePath) {
                 const enumStateValues = tryGetStringLiteralValues(moduleName, filename, 'state', stateNode, program);
                 (0, assert_1.default)(enumStateValues.length > 0, `文件${filename}中的state${stateNode.typeName.text}定义不是字符串类型`);
                 pushStatementIntoActionAst(moduleName, node, sourceFile);
-                dealWithActionDefInitializer(moduleName, declaration.initializer, program);
+                const isDefined = dealWithActionDefInitializer(moduleName, declaration.initializer, program);
                 (0, assert_1.default)(ts.isIdentifier(declaration.name));
                 const adName = declaration.name.text.slice(0, declaration.name.text.length - 9);
                 const attr = adName.concat('State');
-                schemaAttrs.push(factory.createPropertySignature(undefined, (0, string_1.firstLetterLowerCase)(attr), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode(attr)));
+                (0, assert_1.default)(!schemaAttrDict[attr], `文件${filename}中的${attr}有显式定义，与ActionDef需要生成的属性冲突`);
+                schemaAttrDict[attr] = factory.createPropertySignature(undefined, (0, string_1.firstLetterLowerCase)(attr), isDefined ? undefined : factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode(attr));
                 enumAttributes[(0, string_1.firstLetterLowerCase)(attr)] = enumStateValues;
             };
             const dealWithIndexes = (declaration) => {
@@ -1175,7 +1303,7 @@ function analyzeEntity(filename, path, program, relativePath) {
                         });
                         const indexAttrName = nameProperty.initializer.text;
                         if (!Entity_1.initinctiveAttributes.includes(indexAttrName)) {
-                            const schemaNode = schemaAttrs.find((ele3) => {
+                            const schemaNode = Object.values(schemaAttrDict).find((ele3) => {
                                 (0, assert_1.default)(ts.isPropertySignature(ele3));
                                 return ele3.name.text === indexAttrName;
                             });
@@ -1390,6 +1518,7 @@ function analyzeEntity(filename, path, program, relativePath) {
     if (hasActionDef && actionType !== 'crud') {
         throw new Error(`${filename}中有Action定义，但却定义了actionType不是crud`);
     }
+    const schemaAttrs = Object.values(schemaAttrDict);
     (0, assert_1.default)(schemaAttrs.length > 0, `对象${moduleName}没有任何属性定义`);
     const schema = {
         schemaAttrs,
@@ -4933,24 +5062,6 @@ function analyzeEntities(inputDir, relativePath) {
     analyzeInModi();
     uniqRelationships();
 }
-function buildSchemaBackup(outputDir) {
-    addReverseRelationship();
-    // setRelationEntities();
-    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);
-    outputRelation2(outputDir, printer);
-    outputStyleDict(outputDir, printer);
-    outputIndexTs(outputDir);
-    if (!process.env.COMPLING_AS_LIB) {
-        outputPackageJson(outputDir);
-    }
-}
 function _getAggrKey(entity, foreignKey) {
     const aggrKey = `${entity}$${foreignKey}`;
     if (process.env.COMPLING_AS_LIB) {

package/lib/compiler/tscBuilder.d.ts

@@ -0,0 +1,47 @@
+import * as ts from 'typescript';
+export declare const OAK_IGNORE_TAGS: string[];
+interface OakBuildChecksConfig {
+    context?: {
+        checkAsyncContext?: boolean;
+        targetModules?: string[];
+        filePatterns?: string[];
+    };
+    locale?: {
+        checkI18nKeys?: boolean;
+        tFunctionModules?: string[];
+        checkTemplateLiterals?: boolean;
+        warnStringKeys?: boolean;
+    };
+}
+interface CustomDiagnostic {
+    file: ts.SourceFile;
+    start: number;
+    length: number;
+    messageText: string;
+    category: ts.DiagnosticCategory;
+    code: number;
+    callChain?: string[];
+    contextCallNode?: ts.CallExpression;
+    reason?: string;
+    reasonDetails?: string[];
+    relatedInfo?: Array<{
+        file: ts.SourceFile;
+        start: number;
+        length: number;
+        message: string;
+    }>;
+}
+export type CompileOptions = {
+    project?: string;
+    noEmit?: boolean;
+};
+/**
+ *  执行自定义检查
+ * @param program  ts.Program
+ * @param typeChecker  ts.TypeChecker
+ * @param customConfig  自定义配置
+ * @returns  CustomDiagnostic[] 自定义诊断列表
+ */
+export declare function performCustomChecks(pwd: string, program: ts.Program, typeChecker: ts.TypeChecker, customConfig: OakBuildChecksConfig): CustomDiagnostic[];
+export declare const build: (pwd: string, args: any[]) => void;
+export {};