mirror of
https://gitlab.com/openstapps/openstapps.git
synced 2026-01-20 00:23:03 +00:00
895 lines
29 KiB
TypeScript
895 lines
29 KiB
TypeScript
/*
|
|
* Copyright (C) 2019-2021 StApps
|
|
* This program is free software: you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the Free
|
|
* Software Foundation, version 3.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with
|
|
* this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
import {
|
|
MappingDynamicTemplate,
|
|
MappingObjectProperty,
|
|
MappingProperty,
|
|
} from '@elastic/elasticsearch/lib/api/types';
|
|
import merge from 'deepmerge';
|
|
import {stringify} from 'flatted';
|
|
import {DeclarationReflection, ProjectReflection, SignatureReflection} from 'typedoc';
|
|
import {
|
|
ArrayType,
|
|
Comment,
|
|
CommentTag,
|
|
IntrinsicType,
|
|
ReferenceType,
|
|
ReflectionType,
|
|
StringLiteralType,
|
|
Type,
|
|
TypeParameterType,
|
|
UnionType,
|
|
} from 'typedoc/dist/lib/models';
|
|
import {fieldmap, filterableMap, filterableTagName} from './config/fieldmap';
|
|
import {premaps} from './config/premap';
|
|
import {settings} from './config/settings';
|
|
import {dynamicTypes, isTagType, MISSING_PREMAP, PARSE_ERROR, TYPE_CONFLICT, typemap} from './config/typemap';
|
|
import type {AggregationSchema, ESNestedAggregation} from '../schema/aggregations';
|
|
import type {ElasticsearchTemplateCollection, MappingGenTemplate} from '../schema/mappings';
|
|
import * as console from 'console';
|
|
|
|
let dynamicTemplates: Record<string, MappingDynamicTemplate>[] = [];
|
|
let errors: string[] = [];
|
|
let showErrors = true;
|
|
|
|
let aggregations: AggregationSchema = {};
|
|
|
|
const indexableTag = 'indexable';
|
|
const aggregatableTag = 'aggregatable';
|
|
const aggregatableTagParameterGlobal = 'global';
|
|
const inheritTagsName = 'inherittags';
|
|
|
|
// clamp printed object to 1000 chars to keep error messages readable
|
|
const maxErrorObjectChars = 1000;
|
|
|
|
let ignoredTagsList = ['indexable', 'validatable', inheritTagsName];
|
|
let inheritTagsMap: {[path: string]: CommentTag[]} = {};
|
|
|
|
/**
|
|
* Gets all interfaces that have an @indexable tag
|
|
* @param projectReflection the project reflection from which to extract the indexable interfaces
|
|
*/
|
|
export function getAllIndexableInterfaces(projectReflection: ProjectReflection): DeclarationReflection[] {
|
|
let indexableInterfaces: DeclarationReflection[] = [];
|
|
|
|
if (!Array.isArray(projectReflection.children) || projectReflection.children.length === 0) {
|
|
throw new Error('No DeclarationReflections found. Please check your input path');
|
|
}
|
|
|
|
// push all declaration reflections into one array
|
|
for (const declarationReflection of projectReflection.children) {
|
|
if (Array.isArray(declarationReflection.children)) {
|
|
indexableInterfaces = [...indexableInterfaces, ...declarationReflection.children];
|
|
}
|
|
}
|
|
|
|
// filter all declaration reflections with an @indexable tag
|
|
indexableInterfaces = indexableInterfaces.filter(declarationReflection => {
|
|
if (declarationReflection.comment === undefined || declarationReflection.comment.tags === undefined) {
|
|
return false;
|
|
}
|
|
|
|
return declarationReflection.comment.tags.some(commentTag => {
|
|
return commentTag.tagName === indexableTag;
|
|
});
|
|
});
|
|
|
|
return indexableInterfaces;
|
|
}
|
|
|
|
/**
|
|
* Composes error messages, that are readable and contain a certain minimum of information
|
|
* @param path the path where the error took place
|
|
* @param topTypeName the name of the SCThingType
|
|
* @param typeName the name of the object, with which something went wrong
|
|
* @param object the object or name
|
|
* @param message the error message
|
|
*/
|
|
function composeErrorMessage(
|
|
path: string,
|
|
topTypeName: string,
|
|
typeName: string,
|
|
object: string,
|
|
message: string,
|
|
) {
|
|
const error = `At "${topTypeName}::${path.slice(
|
|
0,
|
|
Math.max(0, path.length - 1),
|
|
)}" for ${typeName} "${trimString(object, maxErrorObjectChars)}": ${message}`;
|
|
errors.push(error);
|
|
if (showErrors) {
|
|
// tslint:disable-next-line:no-floating-promises
|
|
void console.error(error);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Trims a string to a readable size and appends "..."
|
|
* @param value the string to trim
|
|
* @param maxLength the maximum allowed length before it is clamped
|
|
*/
|
|
function trimString(value: string, maxLength: number): string {
|
|
return value.length > maxLength ? `${value.slice(0, Math.max(0, maxLength))}...` : value;
|
|
}
|
|
|
|
/**
|
|
* Gets the Reflections and names for Generics in a ReferenceType of a DeclarationReflection
|
|
*
|
|
* Warning to future maintainers: The code for generics doesn't account for depth. when there is a new generic, it will
|
|
* override the previous one, if there isn't, it will just continue passing it down.
|
|
* @param type the ReferenceType of a DeclarationReflection
|
|
* @param out the previous reflection, it then overrides all parameters or keeps old ones
|
|
* @param topTypeName the name of the object, with which something went wrong
|
|
* @param path the current path to the object we are in
|
|
* @param tags any tags attached to the type
|
|
*/
|
|
function getReflectionGeneric(
|
|
type: ReferenceType,
|
|
out: Map<string, MappingProperty>,
|
|
topTypeName: string,
|
|
path: string,
|
|
tags: CommentTag[],
|
|
): Map<string, MappingProperty> {
|
|
if (
|
|
type.typeArguments !== undefined &&
|
|
type.reflection instanceof DeclarationReflection &&
|
|
type.reflection.typeParameters !== undefined
|
|
) {
|
|
for (let i = 0; i < type.reflection.typeParameters.length; i++) {
|
|
if (i < type.typeArguments.length) {
|
|
out.set(
|
|
type.reflection.typeParameters[i].name,
|
|
handleType(type.typeArguments[i], out, topTypeName, path, tags),
|
|
);
|
|
} else {
|
|
// this can happen due to a bug in TypeDoc https://github.com/TypeStrong/typedoc/issues/1061
|
|
// we have no way to know the type here, so we have to use this.
|
|
out.set(type.reflection.typeParameters[i].name, {
|
|
dynamic: true,
|
|
properties: {},
|
|
});
|
|
|
|
console.warn(
|
|
`Type "${type.name}": Defaults of generics (Foo<T = any>) currently don't work due to a bug` +
|
|
` in TypeDoc. It has been replaced by a dynamic type.`,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
/**
|
|
* Handles a ReferenceType that has no value
|
|
*
|
|
* Most of the times that is an external type.
|
|
* @param ref the ReferenceType
|
|
* @param generics the generics from levels above, so we can use them without having access to the parent
|
|
* @param path the current path to the object we are in
|
|
* @param topTypeName the name of the SCThingType
|
|
* @param tags any tags attached to the type
|
|
*/
|
|
function handleExternalType(
|
|
ref: ReferenceType,
|
|
generics: Map<string, MappingProperty>,
|
|
path: string,
|
|
topTypeName: string,
|
|
tags: CommentTag[],
|
|
): MappingProperty {
|
|
for (const premap of Object.keys(premaps)) {
|
|
if (premap === ref.name) {
|
|
return readFieldTags(premaps[premap], path, topTypeName, tags);
|
|
}
|
|
}
|
|
|
|
if (ref.name === 'Array') {
|
|
// basically an external type, but Array is quite common, especially with generics
|
|
if (ref.typeArguments === undefined || ref.typeArguments[0] === undefined) {
|
|
composeErrorMessage(path, topTypeName, 'Array with generics', 'array', 'Failed to parse');
|
|
|
|
return {type: PARSE_ERROR};
|
|
}
|
|
|
|
return readFieldTags(
|
|
handleType(
|
|
ref.typeArguments[0],
|
|
getReflectionGeneric(ref, new Map(generics), path, topTypeName, tags),
|
|
path,
|
|
topTypeName,
|
|
tags,
|
|
),
|
|
path,
|
|
topTypeName,
|
|
tags,
|
|
);
|
|
}
|
|
if (ref.name === '__type') {
|
|
// empty object
|
|
return {
|
|
dynamic: 'strict',
|
|
properties: {},
|
|
};
|
|
}
|
|
|
|
composeErrorMessage(path, topTypeName, 'external type', ref.name, 'Missing pre-map');
|
|
|
|
return readFieldTags({type: MISSING_PREMAP}, path, topTypeName, tags);
|
|
}
|
|
|
|
/**
|
|
* Handles an object
|
|
* @param decl the DeclarationReflection of the object
|
|
* @param generics the generics from levels above, so we can use them without having access to the parent
|
|
* @param path the current path to the object we are in
|
|
* @param topTypeName the name of the SCThingType
|
|
* @param inheritedTags the inherited tags
|
|
*/
|
|
function handleDeclarationReflection(
|
|
decl: DeclarationReflection,
|
|
generics: Map<string, MappingProperty>,
|
|
path: string,
|
|
topTypeName: string,
|
|
inheritedTags?: CommentTag[],
|
|
): MappingProperty {
|
|
// check if we have an object referencing a generic
|
|
if (generics.has(decl.name)) {
|
|
// if the object name is the same as the generic name
|
|
return readFieldTags(generics.get(decl.name)!, path, topTypeName, decl.comment?.tags ?? []);
|
|
// use the value defined by the generic
|
|
}
|
|
|
|
// start the actual handling process
|
|
const out: MappingProperty = {
|
|
dynamic: 'strict',
|
|
properties: {},
|
|
};
|
|
|
|
let empty = true;
|
|
// first check if there are any index signatures, so for example `[name: string]: Foo`
|
|
if (decl.indexSignature !== undefined) {
|
|
out.dynamic = true;
|
|
|
|
if (decl.indexSignature.type !== undefined) {
|
|
empty = false;
|
|
const template: Record<string, MappingDynamicTemplate> = {};
|
|
template[decl.name] = {
|
|
mapping: handleType(
|
|
decl.indexSignature.type,
|
|
new Map(generics),
|
|
path,
|
|
topTypeName,
|
|
getCommentTags(decl.indexSignature, path, topTypeName),
|
|
),
|
|
match: '*',
|
|
match_mapping_type: '*',
|
|
path_match: `${path}*`,
|
|
};
|
|
dynamicTemplates.push(template);
|
|
}
|
|
}
|
|
|
|
if (decl.kindString === 'Enumeration') {
|
|
return readTypeTags('string', path, topTypeName, getCommentTags(decl, path, topTypeName, inheritedTags));
|
|
}
|
|
|
|
// check all the children, so in this case we are dealing with an OBJECT
|
|
if (decl.children !== undefined && decl.children.length > 0) {
|
|
for (const child of decl.children) {
|
|
empty = false;
|
|
out.properties![child.name] = handleDeclarationReflection(
|
|
child,
|
|
new Map(generics),
|
|
`${path}${child.name}.`,
|
|
topTypeName,
|
|
);
|
|
}
|
|
} else if (decl.type instanceof Type) {
|
|
// if the object is a type, so we are dealing with a PROPERTY
|
|
// get inherited tags
|
|
const tags =
|
|
(inheritedTags ?? []).length > 0
|
|
? inheritedTags!.some(it => isTagType(it.tagName))
|
|
? inheritedTags!
|
|
: [...(inheritedTags ?? []), ...getCommentTags(decl, path, topTypeName)]
|
|
: getCommentTags(decl, path, topTypeName);
|
|
|
|
return handleType(decl.type, new Map(generics), path, topTypeName, tags);
|
|
} else if (decl.kindString === 'Enumeration member') {
|
|
return readTypeTags(
|
|
typeof decl.defaultValue,
|
|
path,
|
|
topTypeName,
|
|
getCommentTags(decl, path, topTypeName, inheritedTags),
|
|
);
|
|
}
|
|
|
|
if (empty) {
|
|
composeErrorMessage(path, topTypeName, 'object', decl.name, 'Empty object');
|
|
}
|
|
|
|
return readFieldTags(out, path, topTypeName, getCommentTags(decl, path, topTypeName));
|
|
}
|
|
|
|
/**
|
|
* Reads all comment tags, including inherited ones
|
|
* @param decl the DeclarationReflection to read the tags from
|
|
* @param path the path on which the comments lie
|
|
* @param topTypeName the name of the SCThingType
|
|
* @param inheritedTags any tags that might have been inherited by a parent
|
|
* @param breakId the id of the previous reflection to prevent infinite recursion in some cases
|
|
*/
|
|
function getCommentTags(
|
|
decl: DeclarationReflection | SignatureReflection,
|
|
path: string,
|
|
topTypeName: string,
|
|
inheritedTags: CommentTag[] = [],
|
|
// tslint:disable-next-line:no-unnecessary-initializer
|
|
breakId: number | undefined = undefined,
|
|
): CommentTag[] {
|
|
if (decl.id === breakId) {
|
|
return [];
|
|
}
|
|
|
|
let out: CommentTag[] =
|
|
decl.comment instanceof Comment
|
|
? decl.comment.tags !== undefined
|
|
? decl.comment.tags
|
|
: inheritedTags
|
|
: inheritedTags;
|
|
if (
|
|
decl.overwrites instanceof ReferenceType &&
|
|
decl.overwrites.reflection instanceof DeclarationReflection
|
|
) {
|
|
out = arrayPriorityJoin(
|
|
getCommentTags(decl.overwrites.reflection, path, topTypeName, inheritedTags, decl.id),
|
|
out,
|
|
);
|
|
}
|
|
if (
|
|
decl.inheritedFrom instanceof ReferenceType &&
|
|
decl.inheritedFrom.reflection instanceof DeclarationReflection
|
|
) {
|
|
out = arrayPriorityJoin(
|
|
getCommentTags(decl.inheritedFrom.reflection, path, topTypeName, inheritedTags, decl.id),
|
|
out,
|
|
);
|
|
}
|
|
|
|
saveCommentTags(out, path, topTypeName);
|
|
const inheritTag = out.find(value => value.tagName === inheritTagsName);
|
|
if (inheritTag !== undefined) {
|
|
out = arrayPriorityJoin(out, retrieveCommentTags(inheritTag.text.trim(), path, topTypeName));
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
/**
|
|
* Saves all comment tags to the map
|
|
* @param tags all tags to be saved (@see and @[inheritTags] will be stripped)
|
|
* @param path the path of field
|
|
* @param topTypeName the name of the SCThingType
|
|
*/
|
|
function saveCommentTags(tags: CommentTag[], path: string, topTypeName: string) {
|
|
inheritTagsMap[`${topTypeName}::${path.slice(0, Math.max(0, path.length - 1))}`] = tags.filter(
|
|
value => value.tagName !== 'see' && value.tagName !== inheritTagsName,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Retrieves any saved tags
|
|
* @param path the path to the original field
|
|
* @param currentPath the current path to the object we are in
|
|
* @param topTypeName the name of the SCThingType
|
|
*/
|
|
function retrieveCommentTags(path: string, currentPath: string, topTypeName: string): CommentTag[] {
|
|
if (!(path in inheritTagsMap)) {
|
|
composeErrorMessage(currentPath, topTypeName, path, 'Comment', 'Referenced path to tags does not exist!');
|
|
|
|
return [];
|
|
}
|
|
|
|
return inheritTagsMap[path];
|
|
}
|
|
|
|
/**
|
|
* Joins two arrays of CommentTags, but overrides all original CommentTags with the same tagName
|
|
* @param originals the original array
|
|
* @param overrider the array that should be appended and provide the override values
|
|
*/
|
|
function arrayPriorityJoin(originals: CommentTag[], overrider: CommentTag[]): CommentTag[] {
|
|
const out: CommentTag[] = overrider;
|
|
|
|
for (const original of originals) {
|
|
const result = overrider.find(element => original.tagName === element.tagName);
|
|
|
|
// no support for multiple tags with the same name
|
|
if (!(result instanceof CommentTag)) {
|
|
out.push(original);
|
|
}
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
/**
|
|
* Handles UnionTypes
|
|
*
|
|
* Put into a separate function as it is a little bit more complex
|
|
* Works fairly reliable, although there are issues with primitive union types, which don't work at all (And never will)
|
|
* @param type the type object
|
|
* @param generics the generics from levels above, so we can use them without having access to the parent
|
|
* @param path the current path to the object we are in
|
|
* @param topTypeName the name of the SCThingType
|
|
* @param tags any tags attached to the type
|
|
*/
|
|
function handleUnionType(
|
|
type: UnionType,
|
|
generics: Map<string, MappingProperty>,
|
|
path: string,
|
|
topTypeName: string,
|
|
tags: CommentTag[],
|
|
): MappingProperty {
|
|
const list: MappingProperty[] = [];
|
|
|
|
for (const subType of type.types) {
|
|
if (subType instanceof IntrinsicType && subType.name === 'undefined') {
|
|
continue;
|
|
}
|
|
list.push(handleType(subType, new Map(generics), path, topTypeName, tags));
|
|
}
|
|
|
|
if (list.length > 0) {
|
|
let out = list[0];
|
|
|
|
for (const item of list) {
|
|
out = merge<MappingProperty>(out, item);
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
composeErrorMessage(
|
|
path,
|
|
topTypeName,
|
|
'Union Type',
|
|
stringify(list),
|
|
'Empty union type. This is likely not a user error.',
|
|
);
|
|
|
|
return {type: PARSE_ERROR};
|
|
}
|
|
|
|
/**
|
|
* Serves as a kind of distributor for the different types, should not contain any specific code
|
|
* @param type the type object
|
|
* @param generics the generics from levels above, so we can use them without having access to the parent
|
|
* @param path the current path to the object we are in
|
|
* @param topTypeName the name of the SCThingType
|
|
* @param tags any tags attached to the type
|
|
*/
|
|
function handleType(
|
|
type: Type,
|
|
generics: Map<string, MappingProperty>,
|
|
path: string,
|
|
topTypeName: string,
|
|
tags: CommentTag[],
|
|
): MappingProperty {
|
|
// logger.log((type as any).name);
|
|
if (type instanceof ArrayType) {
|
|
// array is irrelevant in Elasticsearch, so just go with the element type
|
|
const esType = handleType(type.elementType, new Map(generics), path, topTypeName, tags);
|
|
// also merge tags of the array to the element type
|
|
// filter out the type tags lazily, this can lead to double messages for "Not implemented tag"
|
|
let newTags = tags;
|
|
if ('type' in esType) {
|
|
newTags = tags.filter(tag => {
|
|
return !(tag.tagName === esType.type);
|
|
});
|
|
}
|
|
|
|
return readFieldTags(esType, path, topTypeName, newTags);
|
|
}
|
|
if (type.type === 'stringLiteral') {
|
|
// a string literal, usually for type
|
|
return readTypeTags(type.type, path, topTypeName, tags);
|
|
}
|
|
if (type instanceof IntrinsicType) {
|
|
// the absolute default type, like strings
|
|
return readTypeTags(type.name, path, topTypeName, tags);
|
|
}
|
|
if (type instanceof UnionType) {
|
|
// the union type...
|
|
return handleUnionType(type, new Map(generics), path, topTypeName, tags);
|
|
}
|
|
if (type instanceof ReferenceType) {
|
|
if (premaps[type.name] === undefined && type.reflection !== undefined) {
|
|
// there is really no way to make this typesafe, every element in DeclarationReflection is optional.
|
|
return handleDeclarationReflection(
|
|
type.reflection as DeclarationReflection,
|
|
getReflectionGeneric(type, new Map(generics), path, topTypeName, tags),
|
|
path,
|
|
topTypeName,
|
|
tags,
|
|
);
|
|
}
|
|
|
|
return handleExternalType(type, new Map(generics), path, topTypeName, tags);
|
|
}
|
|
if (type instanceof TypeParameterType) {
|
|
// check if we have an object referencing a generic
|
|
if (generics.has(type.name)) {
|
|
return generics.get(type.name)!;
|
|
}
|
|
composeErrorMessage(path, topTypeName, 'Generic', type.name, 'Missing reflection, please report!');
|
|
|
|
return {type: PARSE_ERROR};
|
|
}
|
|
if (type instanceof ReflectionType) {
|
|
return readFieldTags(
|
|
handleDeclarationReflection(type.declaration, new Map(generics), path, topTypeName),
|
|
path,
|
|
topTypeName,
|
|
tags,
|
|
);
|
|
}
|
|
|
|
composeErrorMessage(path, topTypeName, 'type', stringify(type), 'Not implemented type');
|
|
|
|
return {type: PARSE_ERROR};
|
|
}
|
|
|
|
/**
|
|
* Adds an aggregatable to the aggregations list
|
|
* @param path the current path
|
|
* @param topTypeName the name of the top type
|
|
* @param global whether the topTypeName will be used
|
|
*/
|
|
function addAggregatable(path: string, topTypeName: string, global: boolean) {
|
|
// push type.path and remove the '.' at the end of the path
|
|
|
|
if (global) {
|
|
const property_ = path.slice(0, -1).split('.').pop() as string; // cannot be undefined
|
|
|
|
return ((aggregations['@all'] as ESNestedAggregation).aggs[property_.split('.').pop() as string] = {
|
|
terms: {
|
|
field: `${property_}.raw`,
|
|
size: 1000,
|
|
},
|
|
});
|
|
}
|
|
|
|
const property = path.slice(0, -1);
|
|
|
|
return ((aggregations[topTypeName] as ESNestedAggregation).aggs[property] = {
|
|
terms: {
|
|
field: `${property}.raw`,
|
|
size: 1000,
|
|
},
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Reads all tags related to Elasticsearch fields from the fieldMap
|
|
* @param previous the previous ElasticsearchValue, for example and object
|
|
* @param path the current path to the object we are in
|
|
* @param topTypeName the name of the SCThingType
|
|
* @param tags tags attached to the value
|
|
* @param dataType the ElasticsearchDataType, for checking if a tag is a type tag
|
|
*/
|
|
function readFieldTags(
|
|
previous: MappingProperty,
|
|
path: string,
|
|
topTypeName: string,
|
|
tags: CommentTag[],
|
|
dataType?: string,
|
|
): MappingProperty {
|
|
for (const tag of tags) {
|
|
if (tag.tagName === aggregatableTag) {
|
|
addAggregatable(path, topTypeName, tag.text.trim() === aggregatableTagParameterGlobal);
|
|
}
|
|
|
|
if (!ignoredTagsList.includes(tag.tagName)) {
|
|
if (fieldmap[tag.tagName] !== undefined) {
|
|
if (previous.fields === undefined) {
|
|
// create in case it doesn't exist
|
|
previous.fields = {};
|
|
}
|
|
if (tag.text.trim() === '') {
|
|
// merge fields
|
|
previous.fields = {...previous.fields, ...fieldmap[tag.tagName].default};
|
|
} else if (fieldmap[tag.tagName][tag.text.trim()] !== undefined) {
|
|
// merge fields
|
|
previous.fields = {...previous.fields, ...fieldmap[tag.tagName][tag.text.trim()]};
|
|
} else if (!fieldmap[tag.tagName].ignore.includes(tag.text.trim())) {
|
|
// when there is an unidentified tag
|
|
composeErrorMessage(
|
|
path,
|
|
topTypeName,
|
|
'tag',
|
|
tag.tagName,
|
|
`Not implemented tag param "${tag.text.trim()}"`,
|
|
);
|
|
}
|
|
} else if (tag.tagName === filterableTagName) {
|
|
if (previous.fields === undefined) {
|
|
previous.fields = {};
|
|
}
|
|
if ('type' in previous) {
|
|
const type = filterableMap[previous.type!];
|
|
if (type !== undefined) {
|
|
// merge fields
|
|
previous.fields = {...previous.fields, raw: {type: type}};
|
|
} else {
|
|
composeErrorMessage(
|
|
path,
|
|
topTypeName,
|
|
'tag',
|
|
tag.tagName,
|
|
`Not implemented for ${previous.type}`,
|
|
);
|
|
}
|
|
} else {
|
|
composeErrorMessage(path, topTypeName, 'tag', tag.tagName, 'Not applicable for object types');
|
|
}
|
|
} else if (dataType === undefined || typemap[dataType][tag.tagName] === undefined) {
|
|
composeErrorMessage(path, topTypeName, 'tag', tag.tagName, `Not implemented tag`);
|
|
}
|
|
}
|
|
}
|
|
|
|
return previous;
|
|
}
|
|
|
|
/**
|
|
* Reads all types related to Elasticsearch fields from the fieldMap
|
|
* @param type the type of the value
|
|
* @param path the current path to the object we are in
|
|
* @param topTypeName the name of the SCThingType
|
|
* @param tags tags attached to the value
|
|
*/
|
|
function readTypeTags(type: string, path: string, topTypeName: string, tags: CommentTag[]): MappingProperty {
|
|
let out: MappingProperty = {type: PARSE_ERROR};
|
|
|
|
if (typemap[type] !== undefined) {
|
|
// first look if the value has a definition in the typemap
|
|
for (let i = tags.length - 1; i >= 0; i--) {
|
|
if (!ignoredTagsList.includes(tags[i].tagName) && typemap[type][tags[i].tagName] !== undefined) {
|
|
// if we have a tag that indicates a type
|
|
if (out.type !== PARSE_ERROR) {
|
|
composeErrorMessage(
|
|
path,
|
|
topTypeName,
|
|
'type',
|
|
type,
|
|
`Type conflict; "${typemap[type][tags[i].tagName]}" would override "${
|
|
(out as MappingProperty).type
|
|
}"`,
|
|
);
|
|
(out as MappingProperty).type = TYPE_CONFLICT;
|
|
continue;
|
|
}
|
|
(out as MappingProperty).type = typemap[type][tags[i].tagName];
|
|
}
|
|
}
|
|
|
|
if (out.type === PARSE_ERROR) {
|
|
(out as MappingProperty).type = typemap[type].default;
|
|
}
|
|
|
|
out = readFieldTags(out, path, topTypeName, tags, type);
|
|
|
|
return out;
|
|
}
|
|
if (dynamicTypes.includes(type)) {
|
|
// Elasticsearch dynamic type TODO: doesn't work for direct types
|
|
return {
|
|
dynamic: true,
|
|
properties: {},
|
|
};
|
|
}
|
|
|
|
composeErrorMessage(path, topTypeName, 'type', type, 'Not implemented type');
|
|
|
|
return out;
|
|
}
|
|
|
|
/**
|
|
* Reset the state
|
|
*
|
|
* This is kind of a suboptimal solution and should be changed in the future.
|
|
* https://gitlab.com/openstapps/core-tools/-/issues/49
|
|
* @param resetInheritTags whether inherited tags should be reset as well
|
|
*/
|
|
function reset(resetInheritTags = true) {
|
|
errors = [];
|
|
dynamicTemplates = [];
|
|
aggregations = {
|
|
'@all': {
|
|
aggs: {},
|
|
filter: {
|
|
match_all: {},
|
|
},
|
|
},
|
|
};
|
|
|
|
if (resetInheritTags) {
|
|
inheritTagsMap = {};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Takes a project reflection and generates an ElasticsearchTemplate from it
|
|
*
|
|
* Serves as the entry point for getting the mapping, so if you just want to get the mapping files for Elasticsearch,
|
|
* you can do so by calling this function, `RETURNED_VALUE.template` contains the mapping in a fashion that is directly
|
|
* readable by Elasticsearch.
|
|
* @param projectReflection a reflection of the project you want to get the ES Mappings from
|
|
* @param ignoredTags the tag names for which the error output should be suppressed
|
|
* @param showErrorOutput whether to print all errors in the command line or not
|
|
* @param interfaceFilter only parse specific interfaces, this is for testing purposes
|
|
*/
|
|
export function generateTemplate(
|
|
projectReflection: ProjectReflection,
|
|
ignoredTags: string[],
|
|
showErrorOutput = true,
|
|
interfaceFilter: string[] = [],
|
|
): MappingGenTemplate {
|
|
reset();
|
|
|
|
showErrors = showErrorOutput;
|
|
|
|
ignoredTagsList = ['indexable', 'validatable', inheritTagsName];
|
|
// eslint-disable-next-line prefer-spread
|
|
ignoredTagsList.push.apply(ignoredTagsList, ignoredTags);
|
|
|
|
const indexableInterfaces = getAllIndexableInterfaces(projectReflection);
|
|
|
|
const out: ElasticsearchTemplateCollection = {};
|
|
|
|
for (const _interface of indexableInterfaces) {
|
|
// TODO: lots of duplicate code, this all needs to be changed https://gitlab.com/openstapps/core-tools/-/issues/49
|
|
if (!Array.isArray(_interface.children) || _interface.children.length === 0) {
|
|
throw new Error('Interface needs at least some properties to be indexable');
|
|
}
|
|
|
|
const typeObject = _interface.children.find(declarationReflection => {
|
|
return declarationReflection.name === 'type';
|
|
});
|
|
|
|
if (typeObject === undefined || typeObject.type === undefined) {
|
|
throw new TypeError('Interface needs a type to be indexable');
|
|
}
|
|
|
|
let typeName = 'INVALID_TYPE';
|
|
if (typeObject.type instanceof ReferenceType) {
|
|
if (
|
|
typeObject.type.reflection instanceof DeclarationReflection &&
|
|
typeof typeObject.type.reflection.defaultValue === 'string'
|
|
) {
|
|
typeName = typeObject.type.reflection.defaultValue.replace('"', '').replace('"', '');
|
|
} else {
|
|
// tslint:disable-next-line:no-floating-promises
|
|
void console.error(
|
|
'Your input files seem to be incorrect, or there is a major bug in the mapping generator.',
|
|
);
|
|
}
|
|
} else if (typeObject.type instanceof StringLiteralType) {
|
|
console.warn(`The interface ${_interface.name} uses a string literal as type, please use SCThingType.`);
|
|
typeName = typeObject.type.value;
|
|
} else {
|
|
// tslint:disable-next-line:no-floating-promises
|
|
void console.error(
|
|
`The interface ${_interface.name} is required to use an SCThingType as a type, please do so.`,
|
|
);
|
|
}
|
|
// init aggregation schema for type
|
|
aggregations[typeName] = {
|
|
aggs: {},
|
|
filter: {
|
|
term: {
|
|
type: typeName,
|
|
},
|
|
},
|
|
};
|
|
handleDeclarationReflection(_interface, new Map(), '', typeName);
|
|
}
|
|
|
|
// second traversal
|
|
reset(false);
|
|
|
|
for (const _interface of indexableInterfaces) {
|
|
if (!Array.isArray(_interface.children) || _interface.children.length === 0) {
|
|
throw new Error('Interface needs at least some properties to be indexable');
|
|
}
|
|
|
|
const typeObject = _interface.children.find(declarationReflection => {
|
|
return declarationReflection.name === 'type';
|
|
});
|
|
|
|
if (typeObject === undefined || typeObject.type === undefined) {
|
|
throw new TypeError('Interface needs a type to be indexable');
|
|
}
|
|
|
|
let typeName = 'INVALID_TYPE';
|
|
if (typeObject.type instanceof ReferenceType) {
|
|
if (
|
|
typeObject.type.reflection instanceof DeclarationReflection &&
|
|
typeof typeObject.type.reflection.defaultValue === 'string'
|
|
) {
|
|
typeName = typeObject.type.reflection.defaultValue.replace('"', '').replace('"', '');
|
|
} else {
|
|
// tslint:disable-next-line:no-floating-promises
|
|
void console.error(
|
|
'Your input files seem to be incorrect, or there is a major bug in the mapping generator.',
|
|
);
|
|
}
|
|
} else if (typeObject.type instanceof StringLiteralType) {
|
|
console.warn(`The interface ${_interface.name} uses a string literal as type, please use SCThingType.`);
|
|
typeName = typeObject.type.value;
|
|
} else {
|
|
// tslint:disable-next-line:no-floating-promises
|
|
void console.error(
|
|
`The interface ${_interface.name} is required to use an SCThingType as a type, please do so.`,
|
|
);
|
|
}
|
|
|
|
// filter out
|
|
if (interfaceFilter.length > 0 && !interfaceFilter.includes(typeName)) {
|
|
continue;
|
|
}
|
|
|
|
// init aggregation schema for type
|
|
aggregations[typeName] = {
|
|
aggs: {},
|
|
filter: {
|
|
term: {
|
|
type: typeName,
|
|
},
|
|
},
|
|
};
|
|
|
|
// eslint-disable-next-line unicorn/prefer-string-replace-all
|
|
const typeNameWithoutSpaces = typeName.toLowerCase().replace(/\s/g, '_');
|
|
const templateName = `template_${typeNameWithoutSpaces}`;
|
|
|
|
out[templateName] = {
|
|
mappings: handleDeclarationReflection(_interface, new Map(), '', typeName) as MappingObjectProperty,
|
|
settings: settings,
|
|
index_patterns: [`stapps_${typeNameWithoutSpaces}*`],
|
|
};
|
|
out[templateName].mappings!.properties!.creation_date = {
|
|
type: 'date',
|
|
};
|
|
|
|
out[templateName].mappings!.dynamic_templates = dynamicTemplates;
|
|
|
|
// Set some properties
|
|
out[templateName].mappings!._source = {
|
|
excludes: ['creation_date'],
|
|
};
|
|
out[templateName].mappings!.date_detection = false;
|
|
|
|
dynamicTemplates = [];
|
|
|
|
if (Object.keys((aggregations[typeName] as ESNestedAggregation).aggs).length === 0) {
|
|
delete aggregations[typeName];
|
|
}
|
|
}
|
|
|
|
return {aggregations, mappings: out, errors};
|
|
}
|