Files
amis-fork/scripts/build-schemas.ts

549 lines
14 KiB
TypeScript

/**
* @file 用来生成 json-schemas
*/
import fs from 'fs';
import path from 'path';
import {
ObjectTypeFormatter,
LiteralUnionTypeFormatter,
IntersectionTypeFormatter,
IntersectionType,
SubTypeFormatter,
TypeFormatter,
UnionType,
derefType,
BaseType,
ObjectType,
Definition,
createFormatter,
SchemaGenerator,
createProgram,
createParser,
StringType,
LiteralType,
Context,
Schema,
uniqueArray,
ReferenceType,
ChainNodeParser,
IntersectionNodeParser
} from 'ts-json-schema-generator';
import ts from 'typescript';
import mkdirp from 'mkdirp';
import isPlainObject from 'lodash/isPlainObject';
/**
* 程序主入口
*/
async function main() {
const dir = path.join(__dirname, '../packages/amis/src');
const outDir = path.join(__dirname, '../packages/amis/');
const tsConfig = path.join(
__dirname,
'../packages/amis/tsconfig-for-declaration.json'
);
const config = {
path: path.join(dir, 'Schema.ts'),
tsconfig: tsConfig,
type: 'RootSchema',
skipTypeCheck: true,
jsDoc: 'extended' as 'extended',
additionalProperties: false
};
for (let {config: c, target, optimizeForMonaco} of [
{
config,
target: 'schema.json',
optimizeForMonaco: true
},
{
config: {
...config,
additionalProperties: true
},
target: 'schema-minimal.json'
}
]) {
// 创建 formatter 用于优化体积
const formatter = createFormatter(
c as any,
(fmt, circularReferenceTypeFormatter) => {
fmt.addTypeFormatter(
new MyNodeTypeFormatter(circularReferenceTypeFormatter)
);
fmt.addTypeFormatter(
new MyIntersectionTypeFormatter(circularReferenceTypeFormatter)
);
fmt.addTypeFormatter(new MyLiteralUnionTypeFormatter());
}
);
const program = createProgram(c as any);
const parser = createParser(program, c as any, prs => {
prs.addNodeParser(
new MyIntersectionNodeParser(
program.getTypeChecker(),
prs as ChainNodeParser
)
);
});
const generator = new SchemaGenerator(program, parser, formatter, c);
let schema = generator.createSchema(c.type);
if (optimizeForMonaco) {
convertAnyOfItemToConditionalItem(schema, [
'ActionSchema',
'CRUDSchema',
'CRUD2Schema',
'SchemaObject'
]);
schema = optimizeConditions(schema);
}
const outputFile = path.join(outDir, target);
mkdirp(path.dirname(outputFile));
fs.writeFileSync(outputFile, JSON.stringify(schema, null, 2));
}
}
class MyIntersectionNodeParser extends IntersectionNodeParser {
public createType(node: any, context: Context) {
const types = (node as ts.IntersectionType).types.map(subnode =>
this.childNodeParser.createType(subnode as any, context)
);
if (types.some(t => t.getName() === 'ActionSchema')) {
return new IntersectionType(types);
}
return super.createType(node, context);
}
}
class MyNodeTypeFormatter extends ObjectTypeFormatter {
getDefinition(type: ObjectType): Definition {
const types = type.getBaseTypes();
if (types.length === 0) {
return this.getObjectDefinition(type);
}
// 体积太大了,只能这样
const definition: Definition = {
allOf: [
this.getObjectDefinition(type),
...types.map((t: BaseType) => this.childTypeFormatter.getDefinition(t))
]
};
const firstType: Definition = definition.allOf![0] as any;
if (
firstType.type === 'object' &&
firstType.additionalProperties === false
) {
definition.allOf = definition.allOf?.map(item => {
if (typeof item === 'object' && item != null) {
if (item.$ref) {
item.additionalProperties = true;
} else {
delete item.additionalProperties;
}
}
return item;
});
definition.additionalProperties = false;
definition.properties = types.reduce((result, baseType) => {
const other = this.childTypeFormatter.getDefinition(
derefType(baseType)!
);
return {
...(other.properties
? this.getObjectBriefDefinition(other.properties)
: {}),
...result
};
}, this.getObjectBriefDefinition(firstType.properties));
if (firstType.required) {
definition.required = firstType.required;
}
if (
firstType.properties &&
definition.required &&
Object.keys(firstType.properties!).join(',') ===
definition.required.join(',')
) {
definition.allOf!.shift();
}
}
return definition;
}
getObjectBriefDefinition(properties: any): Record<string, any> {
return Object.keys(properties || {}).reduce((result, key) => {
const item = properties[key];
if (isIdentityField(item, key, properties)) {
result[key] = {
...item
};
delete result[key].description;
} else if (!result[key]) {
result[key] = true;
}
return result;
}, {} as Record<string, any>);
}
}
class MyLiteralUnionTypeFormatter extends LiteralUnionTypeFormatter {
getDefinition(type: UnionType): Definition {
const types = type.getTypes();
let definition = super.getDefinition(type);
// 表单项的 label 格式转换不对,针对这种场景修复
// label: string | false;
// 如以上定义会被处理成
// {type: "boolean", enum: [false]}
if (
!definition.anyOf &&
types.some(
item =>
item instanceof StringType && item.getPreserveLiterals() === false
) &&
types.some(item => item instanceof LiteralType && !item.isString())
) {
definition = {
anyOf: [{type: 'string'}, definition]
};
}
return definition;
}
}
class MyIntersectionTypeFormatter extends IntersectionTypeFormatter {
getDefinition(type: IntersectionType): Definition {
const types = type.getTypes();
if (
types.some(item =>
['SchemaObject', 'ActionSchema'].includes(item.getName())
)
) {
return {
allOf: types.map(item => {
const subType = this.childTypeFormatter.getDefinition(item);
return {
...subType,
additionalProperties: true
};
})
};
}
return super.getDefinition(type);
}
}
function isIdentityField(item: any, key: string, host: any) {
if (item?.const) {
return true;
} else if (item?.enum && /^(?:type|mode|actionType)$/i.test(key)) {
return !!(
key !== 'mode' ||
(host.type && ['crud', 'crud2'].includes(host.type.const))
);
}
return false;
}
function convertAnyOfItemToConditionalItem(schema: any, list: Array<string>) {
list.forEach(key => {
if (!Array.isArray(schema.definitions[key]?.anyOf)) {
return;
}
const list: Array<any> = schema.definitions[key].anyOf.concat();
const allOf: Array<any> = [];
while (list.length) {
const item: any = list.shift()!;
if (item.$ref) {
const src = schema.definitions[item.$ref.replace('#/definitions/', '')];
if (!src) {
console.log(`${item.$ref} not found`);
return;
}
if (Array.isArray(src.anyOf)) {
list.unshift.apply(list, src.anyOf);
continue;
}
const constProps = pickConstProperties(src);
Object.keys(constProps).length &&
allOf.push({
if: {
properties: constProps,
required: Object.keys(constProps)
},
then: item
});
} else {
const constProps = pickConstProperties(item);
Object.keys(constProps).length &&
allOf.push({
if: {
properties: constProps,
required: Object.keys(constProps)
},
then: item
});
}
}
schema.definitions[key] = {
allOf
};
});
}
function pickConstProperties(schema: any): any {
if (!schema.properties && schema.allOf?.[0]?.properties) {
return pickConstProperties(schema.allOf[0]);
}
const keys = Object.keys(schema.properties || {});
const filteredProperties: any = {};
keys.forEach((key: string) => {
if (isIdentityField(schema.properties[key], key, schema.properties)) {
filteredProperties[key] = {
...schema.properties[key]
};
delete filteredProperties[key].description;
}
});
return filteredProperties;
}
// 优化条件逻辑,主要处理 action 与 schemaObject 部分的 if
// 避免 monaco-editor 无法精确定位
function optimizeConditions(schema: any) {
const actionSchema = schema.definitions.ActionSchema;
const actionSchemaAllOf = actionSchema.allOf;
delete actionSchema.allOf;
actionSchema.if = {
required: ['actionType']
};
actionSchema.then = {
allOf: actionSchemaAllOf.map((item: any) => {
delete item.if.properties.type;
item.if.required = item.if.required.filter(
(item: string) => item !== 'type'
);
return item;
})
};
actionSchema.else = {
$ref: '#/definitions/VanillaAction'
};
const CRUDSchema = schema.definitions.CRUDSchema;
const CRUDSchemaAllOf = CRUDSchema.allOf;
delete CRUDSchema.allOf;
CRUDSchema.if = {
required: ['mode']
};
CRUDSchema.then = {
allOf: CRUDSchemaAllOf.map((item: any) => {
delete item.if.properties.type;
item.if.required = item.if.required.filter(
(item: string) => item !== 'type'
);
return item;
})
};
CRUDSchema.else = {
$ref: '#/definitions/CRUDTableSchema'
};
const schemaObjectSchema = schema.definitions.SchemaObject;
schemaObjectSchema.allOf = schemaObjectSchema.allOf
.filter(
(item: any) => !(item.if.properties.type && item.if.properties.actionType)
)
.map((item: any) => {
Object.keys(item.if.properties || {}).forEach(key => {
delete item.if.properties[key].description;
});
return item;
});
schemaObjectSchema.allOf.push({
if: {
properties: {
type: {enum: ['action', 'button', 'submit', 'reset']}
},
required: ['type']
},
then: {
$ref: '#/definitions/ActionSchema'
}
});
schemaObjectSchema.allOf.push({
if: {
properties: {
type: {const: 'crud'}
},
required: ['type']
},
then: {
$ref: '#/definitions/CRUDSchema'
}
});
schema.definitions.FormSchema.allOf = schema.definitions.BaseFormSchema.allOf;
schema.definitions.VanillaAction.allOf[1].additionalProperties = true;
// delete schema.definitions.FormSchemaBase.additionalProperties;
// delete schema.definitions.BaseSchemaWithoutType.additionalProperties;
// delete schema.definitions.FormSchema.additionalProperties;
// 替换 SchemaObject 与 ActionSchema 的定义
schema.definitions.SchemaObjectLoose = {
allOf: schema.definitions.SchemaObject.allOf.map((item: any) => {
return {
...item,
then: {
...item.then,
additionalProperties: true
}
};
})
};
schema.definitions.ActionSchemaLoose = {
if: schema.definitions.ActionSchema.if,
then: {
allOf: schema.definitions.ActionSchema.then.allOf.map((item: any) => {
return {
...item,
then: {
...item.then,
additionalProperties: true
}
};
})
},
else: schema.definitions.ActionSchema.else
};
schema = JSONValueMap(schema, item => {
if (
item?.$ref === '#/definitions/SchemaObject' &&
item.additionalProperties === true
) {
return {
$ref: '#/definitions/SchemaObjectLoose'
};
} else if (
item?.$ref === '#/definitions/ActionSchema' &&
item.additionalProperties === true
) {
return {
$ref: '#/definitions/ActionSchemaLoose'
};
}
return item;
});
return schema;
}
/**
* 每层都会执行,返回新的对象,新对象不会递归下去
* @param json
* @param mapper
* @returns
*/
export function JSONValueMap(
json: any,
mapper: (
value: any,
key: string | number,
host: Object,
stack: Array<Object>
) => any,
deepFirst: boolean = false,
stack: Array<Object> = []
) {
if (!isPlainObject(json) && !Array.isArray(json)) {
return json;
}
const iterator = (
origin: any,
key: number | string,
host: any,
stack: Array<any> = []
) => {
if (deepFirst) {
const value = JSONValueMap(origin, mapper, deepFirst, stack);
return mapper(value, key, host, stack) ?? value;
}
let mapped: any = mapper(origin, key, host, stack) ?? origin;
// 如果不是深度优先,上层的对象都修改了,就不继续递归进到新返回的对象了
if (mapped === origin) {
return JSONValueMap(origin, mapper, deepFirst, stack);
}
return mapped;
};
if (Array.isArray(json)) {
let modified = false;
let arr = json.map((value, index) => {
let newValue: any = iterator(value, index, json, [json].concat(stack));
modified = modified || newValue !== value;
return newValue;
});
return modified ? arr : json;
}
let modified = false;
const toUpdate: any = {};
Object.keys(json).forEach(key => {
const value: any = json[key];
let result: any = iterator(value, key, json, [json].concat(stack));
if (result !== value) {
modified = true;
toUpdate[key] = result;
}
});
return modified
? {
...json,
...toUpdate
}
: json;
}
main().catch(e => {
console.error(e);
});