Theaninova/openstapps
1
0
Fork 0
mirror of https://gitlab.com/openstapps/openstapps.git synced 2026-01-09 19:22:51 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

refactor: mapping generation for `Elasticsearch 8.4

Browse Source
This commit is contained in:
Thea Schöbl
2023-04-27 09:33:09 +00:00
committed by Rainer Killinger
parent 08ec4e4381
commit 61fee2bbf3
52 changed files with 1859 additions and 972 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
.eslintignore Normal file
View File

3
.eslintrc Normal file
View File

@@ -0,0 +1,3 @@
{
"extends": "@openstapps"
}

3
.gitignore vendored
View File

@@ -96,3 +96,6 @@ docs/
# ignore openapi resources
openapi/
# generated mappings
/mappings

1389
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

18
package.json
View File

@@ -8,9 +8,9 @@
"bin": {
"openstapps-es-mapping-generator": "./lib/cli.js"
},
"author": "Wieland Schöbl <wulkanat@gmail.com>",
"author": "Thea Schöbl <dev@theaninova.de>",
"scripts": {
"build": "npm run tslint && npm run compile",
"build": "npm run lint && npm run compile",
"changelog": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0 && git add CHANGELOG.md && git commit -m 'docs: update changelog'",
"check-configuration": "openstapps-configuration",
"compile": "rimraf lib && tsc && prepend lib/cli.js '#!/usr/bin/env node\n'",
@@ -20,7 +20,8 @@
"preversion": "npm run prepublishOnly",
"push": "git push && git push origin \"v$npm_package_version\"",
"test": "mocha --require ts-node/register test/*.spec.ts",
"tslint": "tslint -p tsconfig.json -c tslint.json 'src/**/*.ts'"
"lint": "eslint -c .eslintrc --ignore-path .eslintignore --ext .ts src/ test/",
"lint:fix": "eslint --fix -c .eslintrc --ignore-path .eslintignore --ext .ts src/ test/"
},
"dependencies": {
"@openstapps/logger": "1.1.1",
@@ -33,6 +34,7 @@
},
"devDependencies": {
"@testdeck/mocha": "0.3.3",
"@openstapps/eslint-config": "1.1.0",
"@types/chai": "4.3.4",
"@types/mocha": "9.1.1",
"@types/node": "14.18.36",
@@ -44,7 +46,13 @@
"prepend-file-cli": "1.0.6",
"rimraf": "3.0.2",
"ts-node": "10.9.1",
"tslint": "6.1.3",
"tslint-eslint-rules": "5.4.0"
"@typescript-eslint/eslint-plugin": "5.40.0",
"@typescript-eslint/parser": "5.40.0",
"eslint": "8.25.0",
"eslint-config-prettier": "8.5.0",
"eslint-plugin-jsdoc": "39.3.6",
"eslint-plugin-prettier": "4.2.1",
"eslint-plugin-unicorn": "44.0.2",
"prettier": "2.7.1"
}
}

39
src/cli.ts
View File

@@ -1,3 +1,4 @@
/* eslint-disable unicorn/no-null */
/*
* Copyright (C) 2018-2021 StApps
* This program is free software: you can redistribute it and/or modify it
@@ -16,7 +17,7 @@ import {Logger} from '@openstapps/logger';
import {Command} from 'commander';
import {readFileSync, writeFileSync} from 'fs';
import got from 'got';
import {resolve} from 'path';
import path from 'path';
import {exit} from 'process';
import {generateTemplate} from './mapping';
import {getProjectReflection} from './project-reflection';
@@ -33,11 +34,8 @@ process.on('unhandledRejection', async (reason: unknown) => {
const commander = new Command('openstapps-core-tools');
commander
.version(JSON.parse(
readFileSync(resolve(__dirname, '..', 'package.json'))
.toString(),
).version);
// eslint-disable-next-line unicorn/prefer-module
commander.version(JSON.parse(readFileSync(path.resolve(__dirname, '..', 'package.json')).toString()).version);
commander
.command('mapping <relativeSrcPath>')
@@ -45,9 +43,9 @@ commander
.option('-i, --ignoredTags <ignoredTags>', 'Ignored Tags (comma-separated)')
.option('-a, --aggPath <relativeAggregationPath>', 'Aggregations Path')
.option('-e, --errorPath <relativeErrorPath>', 'Error Path')
.action(async (relativeSrcPath, options) => {
.action(async (relativeSourcePath, options) => {
// get absolute paths
const srcPath = resolve(relativeSrcPath);
const sourcePath = path.resolve(relativeSourcePath);
let ignoredTagsList: string[] = [];
if (typeof options.ignoredTags === 'string') {
@@ -55,10 +53,10 @@ commander
}
// get project reflection
const projectReflection = getProjectReflection(srcPath);
const projectReflection = getProjectReflection(sourcePath);
const result = generateTemplate(projectReflection, ignoredTagsList, true);
if (result.errors.length !== 0) {
if (result.errors.length > 0) {
await Logger.error('Mapping generated with errors!');
} else {
Logger.ok('Mapping generated without errors!');
@@ -66,22 +64,22 @@ commander
// write documentation to file
if (typeof options.aggPath !== 'undefined') {
const aggPath = resolve(options.aggPath);
const aggPath = path.resolve(options.aggPath);
// tslint:disable-next-line:no-magic-numbers
writeFileSync(aggPath, JSON.stringify(result.aggregations, null, 2));
Logger.ok(`Elasticsearch aggregations written to ${aggPath}.`);
}
if (typeof options.mappingPath !== 'undefined') {
const mappingPath = resolve(options.mappingPath);
const mappingPath = path.resolve(options.mappingPath);
// tslint:disable-next-line:no-magic-numbers
writeFileSync(mappingPath, JSON.stringify(result.mappings, null, 2));
Logger.ok(`Elasticsearch mappings written to ${mappingPath}.`);
}
if (typeof options.errorPath !== 'undefined') {
const errPath = resolve(options.errorPath);
const errorPath = path.resolve(options.errorPath);
// tslint:disable-next-line:no-magic-numbers
writeFileSync(errPath, JSON.stringify(result.errors, null, 2));
Logger.ok(`Mapping errors written to ${errPath}.`);
writeFileSync(errorPath, JSON.stringify(result.errors, null, 2));
Logger.ok(`Mapping errors written to ${errorPath}.`);
} else if (result.errors.length > 0) {
for (const error of result.errors) {
await Logger.error(error);
@@ -93,12 +91,13 @@ commander
commander
.command('put-es-templates <srcPath> <esAddress> [ignoredTags]')
.action(async (relativeSrcPath, esAddress) => {
.action(async (relativeSourcePath, esAddress) => {
// get absolute paths
const srcPath = resolve(relativeSrcPath);
const sourcePath = path.resolve(relativeSourcePath);
// get project reflection
const templates = require(srcPath) as ElasticsearchTemplateCollection;
// eslint-disable-next-line @typescript-eslint/no-var-requires,unicorn/prefer-module
const templates = require(sourcePath) as ElasticsearchTemplateCollection;
for (const template in templates) {
if (!templates.hasOwnProperty(template)) {
@@ -111,7 +110,9 @@ commander
const HTTP_STATUS_OK = 200;
if (response.statusCode !== HTTP_STATUS_OK) {
await Logger.error(`Template for "${template}" failed in Elasticsearch:\n${JSON.stringify(response.body)}`);
await Logger.error(
`Template for "${template}" failed in Elasticsearch:\n${JSON.stringify(response.body)}`,
);
exit(-1);
}
}

24
src/config/fieldmap.ts
View File

@@ -15,16 +15,18 @@
import {ElasticsearchFieldmap, ElasticsearchFilterableMap} from '../types/mapping';
import {ElasticsearchDataType} from './typemap';
export enum analyzers {
ducet_sort = 'ducet_sort',
search_german = 'search_german',
}
const ducetSort = {
type: 'icu_collation_keyword',
language: 'de',
country: 'DE',
variant: '@collation=phonebook',
};
export const fieldmap: ElasticsearchFieldmap = {
aggregatable: {
default: {
raw: {
ignore_above: 10000,
ignore_above: 10_000,
type: ElasticsearchDataType.keyword,
},
},
@@ -32,18 +34,10 @@ export const fieldmap: ElasticsearchFieldmap = {
},
sortable: {
default: {
sort: {
analyzer: analyzers.ducet_sort,
fielddata: true,
type: ElasticsearchDataType.text,
},
sort: ducetSort,
},
ducet: {
sort: {
analyzer: analyzers.ducet_sort,
fielddata: true,
type: ElasticsearchDataType.text,
},
sort: ducetSort,
},
ignore: ['price'],
},

14
src/config/premap.ts
View File

@@ -16,7 +16,7 @@ import {ElasticsearchPremap} from '../types/mapping';
import {ElasticsearchDataType} from './typemap';
export const premaps: ElasticsearchPremap = {
CoordinateReferenceSystem: {
'CoordinateReferenceSystem': {
dynamic: true,
properties: {
type: {
@@ -24,12 +24,10 @@ export const premaps: ElasticsearchPremap = {
},
},
},
LineString: {
precision: '1m',
tree: 'quadtree',
'LineString': {
type: ElasticsearchDataType.geo_shape,
},
Point: {
'Point': {
properties: {
type: {
type: ElasticsearchDataType.keyword,
@@ -40,12 +38,10 @@ export const premaps: ElasticsearchPremap = {
},
dynamic: 'strict',
},
Polygon: {
precision: '1m',
tree: 'quadtree',
'Polygon': {
type: ElasticsearchDataType.geo_shape,
},
SCISO8601DateRange: {
'SCISO8601DateRange': {
type: ElasticsearchDataType.date_range,
},
'jsonpatch.OpPatch': {

51
src/config/settings.ts
View File

@@ -15,51 +15,8 @@
import {ElasticsearchSettings} from '../types/mapping';
export const settings: ElasticsearchSettings = {
analysis: {
analyzer: {
ducet_sort: {
filter: [
'german_phonebook',
],
tokenizer: 'keyword',
type: 'custom',
},
search_german: {
filter: [
'lowercase',
'german_stop',
'german_stemmer',
],
tokenizer: 'stapps_ngram',
type: 'custom',
},
},
filter: {
german_phonebook: {
country: 'DE',
language: 'de',
type: 'icu_collation',
variant: '@collation=phonebook',
},
german_stemmer: {
language: 'german',
type: 'stemmer',
},
german_stop: {
stopwords: '_german_',
type: 'stop',
},
},
tokenizer: {
stapps_ngram: {
max_gram: 7,
min_gram: 4,
type: 'ngram',
},
},
},
'mapping.total_fields.limit': 10000,
max_result_window: 30000,
number_of_replicas: 0,
number_of_shards: 1,
'mapping.total_fields.limit': 10_000,
'max_result_window': 30_000,
'number_of_replicas': 0,
'number_of_shards': 1,
};

4
src/config/typemap.ts
View File

@@ -70,9 +70,9 @@ export const typemap: ElasticsearchTypemap = {
/**
* If the string is a tag type
*/
export function isTagType(str: string): boolean {
export function isTagType(string_: string): boolean {
for (const key in typemap) {
if (typemap.hasOwnProperty(key) && typeof typemap[key][str] !== 'undefined') {
if (typemap.hasOwnProperty(key) && typeof typemap[key][string_] !== 'undefined') {
return true;
}
}

441
src/mapping.ts
View File

@@ -38,7 +38,8 @@ import {
ElasticsearchObject,
ElasticsearchTemplateCollection,
ElasticsearchType,
ElasticsearchValue, MappingGenTemplate,
ElasticsearchValue,
MappingGenTemplate,
} from './types/mapping';
let dynamicTemplates: ElasticsearchDynamicTemplate[] = [];
@@ -56,7 +57,7 @@ const inheritTagsName = 'inherittags';
const maxErrorObjectChars = 1000;
let ignoredTagsList = ['indexable', 'validatable', inheritTagsName];
let inheritTagsMap: { [path: string]: CommentTag[]; } = {};
let inheritTagsMap: {[path: string]: CommentTag[]} = {};
/**
* Gets all interfaces that have an @indexable tag
@@ -64,7 +65,6 @@ let inheritTagsMap: { [path: string]: CommentTag[]; } = {};
* @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) {
@@ -72,14 +72,14 @@ export function getAllIndexableInterfaces(projectReflection: ProjectReflection):
}
// push all declaration reflections into one array
projectReflection.children.forEach((declarationReflection) => {
for (const declarationReflection of projectReflection.children) {
if (Array.isArray(declarationReflection.children)) {
indexableInterfaces = indexableInterfaces.concat(declarationReflection.children);
indexableInterfaces = [...indexableInterfaces, ...declarationReflection.children];
}
});
}
// filter all declaration reflections with an @indexable tag
indexableInterfaces = indexableInterfaces.filter((declarationReflection) => {
indexableInterfaces = indexableInterfaces.filter(declarationReflection => {
if (
typeof declarationReflection.comment === 'undefined' ||
typeof declarationReflection.comment.tags === 'undefined'
@@ -87,9 +87,11 @@ export function getAllIndexableInterfaces(projectReflection: ProjectReflection):
return false;
}
return typeof declarationReflection.comment.tags.find((commentTag) => {
return commentTag.tagName === indexableTag;
}) !== 'undefined';
return (
typeof declarationReflection.comment.tags.find(commentTag => {
return commentTag.tagName === indexableTag;
}) !== 'undefined'
);
});
return indexableInterfaces;
@@ -104,8 +106,17 @@ export function getAllIndexableInterfaces(projectReflection: ProjectReflection):
* @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.substr(0, path.length - 1)}" for ${typeName} "${trimString(object, maxErrorObjectChars)}": ${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
@@ -120,9 +131,7 @@ function composeErrorMessage(path: string, topTypeName: string, typeName: string
* @param maxLength the maximum allowed length before it is clamped
*/
function trimString(value: string, maxLength: number): string {
return value.length > maxLength ?
`${value.substring(0, maxLength)}...` :
value;
return value.length > maxLength ? `${value.slice(0, Math.max(0, maxLength))}...` : value;
}
/**
@@ -137,18 +146,24 @@ function trimString(value: string, maxLength: number): string {
* @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, ElasticsearchValue>,
topTypeName: string,
path: string,
tags: CommentTag[]): Map<string, ElasticsearchValue> {
if (typeof type.typeArguments !== 'undefined'
&& type.reflection instanceof DeclarationReflection
&& typeof type.reflection.typeParameters !== 'undefined') {
function getReflectionGeneric(
type: ReferenceType,
out: Map<string, ElasticsearchValue>,
topTypeName: string,
path: string,
tags: CommentTag[],
): Map<string, ElasticsearchValue> {
if (
typeof type.typeArguments !== 'undefined' &&
type.reflection instanceof DeclarationReflection &&
typeof 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));
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.
@@ -157,8 +172,10 @@ function getReflectionGeneric(type: ReferenceType,
properties: {},
});
Logger.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.`);
Logger.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.`,
);
}
}
}
@@ -177,15 +194,21 @@ function getReflectionGeneric(type: ReferenceType,
* @param topTypeName the name of the SCThingType
* @param tags any tags attached to the type
*/
function handleExternalType(ref: ReferenceType, generics: Map<string, ElasticsearchValue>,
path: string, topTypeName: string, tags: CommentTag[]): ElasticsearchValue {
function handleExternalType(
ref: ReferenceType,
generics: Map<string, ElasticsearchValue>,
path: string,
topTypeName: string,
tags: CommentTag[],
): ElasticsearchValue {
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.name === 'Array') {
// basically an external type, but Array is quite common, especially with generics
if (typeof ref.typeArguments === 'undefined' || typeof ref.typeArguments[0] === 'undefined') {
composeErrorMessage(path, topTypeName, 'Array with generics', 'array', 'Failed to parse');
@@ -194,12 +217,19 @@ function handleExternalType(ref: ReferenceType, generics: Map<string, Elasticsea
return readFieldTags(
handleType(
ref.typeArguments[0], getReflectionGeneric(
ref, new Map(generics), path, topTypeName, tags),
path, topTypeName, tags),
path, topTypeName, tags);
ref.typeArguments[0],
getReflectionGeneric(ref, new Map(generics), path, topTypeName, tags),
path,
topTypeName,
tags,
),
path,
topTypeName,
tags,
);
}
if (ref.name === '__type') { // empty object
if (ref.name === '__type') {
// empty object
return {
dynamic: 'strict',
properties: {},
@@ -220,18 +250,23 @@ function handleExternalType(ref: ReferenceType, generics: Map<string, Elasticsea
* @param topTypeName the name of the SCThingType
* @param inheritedTags the inherited tags
*/
function handleDeclarationReflection(decl: DeclarationReflection,
generics: Map<string, ElasticsearchValue>,
path: string,
topTypeName: string,
inheritedTags?: CommentTag[]):
ElasticsearchValue {
function handleDeclarationReflection(
decl: DeclarationReflection,
generics: Map<string, ElasticsearchValue>,
path: string,
topTypeName: string,
inheritedTags?: CommentTag[],
): ElasticsearchValue {
// 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) as ElasticsearchObject | ElasticsearchType, path, topTypeName,
decl.comment?.tags ?? []);
if (generics.has(decl.name)) {
// if the object name is the same as the generic name
return readFieldTags(
generics.get(decl.name) as ElasticsearchObject | ElasticsearchType,
path,
topTypeName,
decl.comment?.tags ?? [],
);
// use the value defined by the generic
}
// start the actual handling process
@@ -251,7 +286,9 @@ function handleDeclarationReflection(decl: DeclarationReflection,
template[decl.name] = {
mapping: handleType(
decl.indexSignature.type,
new Map(generics), path, topTypeName,
new Map(generics),
path,
topTypeName,
getCommentTags(decl.indexSignature, path, topTypeName),
),
match: '*',
@@ -270,21 +307,31 @@ function handleDeclarationReflection(decl: DeclarationReflection,
if (typeof 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);
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
} 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
? (typeof inheritedTags!.find(it => isTagType(it.tagName)) !== 'undefined'
? inheritedTags!
: [...inheritedTags ?? [], ...getCommentTags(decl, path, topTypeName)])
: getCommentTags(decl, path, topTypeName);
const tags =
(inheritedTags ?? []).length > 0
? typeof inheritedTags!.find(it => isTagType(it.tagName)) !== 'undefined'
? 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));
return readTypeTags(
typeof decl.defaultValue,
path,
topTypeName,
getCommentTags(decl, path, topTypeName, inheritedTags),
);
}
if (empty) {
@@ -315,19 +362,33 @@ function getCommentTags(
return [];
}
let out: CommentTag[] = decl.comment instanceof Comment ?
typeof decl.comment.tags !== 'undefined' ? decl.comment.tags : inheritedTags : inheritedTags;
if (decl.overwrites instanceof ReferenceType && decl.overwrites.reflection instanceof DeclarationReflection) {
let out: CommentTag[] =
decl.comment instanceof Comment
? typeof 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);
getCommentTags(decl.overwrites.reflection, path, topTypeName, inheritedTags, decl.id),
out,
);
}
if (decl.inheritedFrom instanceof ReferenceType && decl.inheritedFrom.reflection instanceof DeclarationReflection) {
if (
decl.inheritedFrom instanceof ReferenceType &&
decl.inheritedFrom.reflection instanceof DeclarationReflection
) {
out = arrayPriorityJoin(
getCommentTags(decl.inheritedFrom.reflection, path, topTypeName, inheritedTags, decl.id), out);
getCommentTags(decl.inheritedFrom.reflection, path, topTypeName, inheritedTags, decl.id),
out,
);
}
saveCommentTags(out, path, topTypeName);
const inheritTag = out.find(((value) => value.tagName === inheritTagsName));
const inheritTag = out.find(value => value.tagName === inheritTagsName);
if (typeof inheritTag !== 'undefined') {
out = arrayPriorityJoin(out, retrieveCommentTags(inheritTag.text.trim(), path, topTypeName));
}
@@ -343,8 +404,9 @@ function getCommentTags(
* @param topTypeName the name of the SCThingType
*/
function saveCommentTags(tags: CommentTag[], path: string, topTypeName: string) {
inheritTagsMap[`${topTypeName}::${path.substr(0, path.length - 1)}`] =
tags.filter(((value) => value.tagName !== 'see' && value.tagName !== inheritTagsName));
inheritTagsMap[`${topTypeName}::${path.slice(0, Math.max(0, path.length - 1))}`] = tags.filter(
value => value.tagName !== 'see' && value.tagName !== inheritTagsName,
);
}
/**
@@ -373,14 +435,14 @@ function retrieveCommentTags(path: string, currentPath: string, topTypeName: str
function arrayPriorityJoin(originals: CommentTag[], overrider: CommentTag[]): CommentTag[] {
const out: CommentTag[] = overrider;
originals.forEach((original) => {
const result = overrider.find((element) => original.tagName === element.tagName);
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;
}
@@ -397,11 +459,13 @@ function arrayPriorityJoin(originals: CommentTag[], overrider: CommentTag[]): Co
* @param topTypeName the name of the SCThingType
* @param tags any tags attached to the type
*/
function handleUnionType(type: UnionType,
generics: Map<string, ElasticsearchValue>,
path: string,
topTypeName: string,
tags: CommentTag[]): ElasticsearchValue {
function handleUnionType(
type: UnionType,
generics: Map<string, ElasticsearchValue>,
path: string,
topTypeName: string,
tags: CommentTag[],
): ElasticsearchValue {
const list: ElasticsearchValue[] = [];
for (const subType of type.types) {
@@ -421,8 +485,13 @@ function handleUnionType(type: UnionType,
return out;
}
composeErrorMessage(path, topTypeName, 'Union Type', stringify(list),
'Empty union type. This is likely not a user error.');
composeErrorMessage(
path,
topTypeName,
'Union Type',
stringify(list),
'Empty union type. This is likely not a user error.',
);
return {type: ElasticsearchDataType.parse_error};
}
@@ -436,37 +505,50 @@ function handleUnionType(type: UnionType,
* @param topTypeName the name of the SCThingType
* @param tags any tags attached to the type
*/
function handleType(type: Type, generics: Map<string, ElasticsearchValue>, path: string, topTypeName: string,
tags: CommentTag[]):
ElasticsearchValue {
function handleType(
type: Type,
generics: Map<string, ElasticsearchValue>,
path: string,
topTypeName: string,
tags: CommentTag[],
): ElasticsearchValue {
// logger.log((type as any).name);
if (type instanceof ArrayType) { // array is irrelevant in Elasticsearch, so just go with the element type
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) => {
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
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
if (type instanceof IntrinsicType) {
// the absolute default type, like strings
return readTypeTags(type.name, path, topTypeName, tags);
}
if (type instanceof UnionType) { // the union type...
if (type instanceof UnionType) {
// the union type...
return handleUnionType(type, new Map(generics), path, topTypeName, tags);
}
if (type instanceof ReferenceType) {
if (typeof premaps[type.name] === 'undefined' && typeof 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 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);
@@ -479,11 +561,14 @@ function handleType(type: Type, generics: Map<string, ElasticsearchValue>, path:
composeErrorMessage(path, topTypeName, 'Generic', type.name, 'Missing reflection, please report!');
return {type: ElasticsearchDataType.parse_error};
}
if (type instanceof ReflectionType) {
return readFieldTags(handleDeclarationReflection(type.declaration, new Map(generics), path, topTypeName),
path, topTypeName, tags);
return readFieldTags(
handleDeclarationReflection(type.declaration, new Map(generics), path, topTypeName),
path,
topTypeName,
tags,
);
}
composeErrorMessage(path, topTypeName, 'type', stringify(type), 'Not implemented type');
@@ -502,43 +587,42 @@ function addAggregatable(path: string, topTypeName: string, global: boolean) {
// push type.path and remove the '.' at the end of the path
if (global) {
const prop = path.slice(0, -1)
.split('.')
.pop() as string; // cannot be undefined
const property_ = path.slice(0, -1).split('.').pop() as string; // cannot be undefined
return (aggregations['@all'] as ESNestedAggregation).aggs[prop.split('.')
.pop() as string] = {
return ((aggregations['@all'] as ESNestedAggregation).aggs[property_.split('.').pop() as string] = {
terms: {
field: `${prop}.raw`,
field: `${property_}.raw`,
size: 1000,
},
};
});
}
const property = path.slice(0, -1);
return (aggregations[topTypeName] as ESNestedAggregation).aggs[property] = {
return ((aggregations[topTypeName] as ESNestedAggregation).aggs[property] = {
terms: {
field: `${property}.raw`,
size: 1000,
},
};
});
}
/**
* Reads all tags related to Elasticsearch fields from the fieldMap
*
* @param prev the previous ElasticsearchValue, for example and object
* @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(prev: ElasticsearchValue,
path: string,
topTypeName: string,
tags: CommentTag[],
dataType?: string): ElasticsearchValue {
function readFieldTags(
previous: ElasticsearchValue,
path: string,
topTypeName: string,
tags: CommentTag[],
dataType?: string,
): ElasticsearchValue {
for (const tag of tags) {
if (tag.tagName === aggregatableTag) {
addAggregatable(path, topTypeName, tag.text.trim() === aggregatableTagParameterGlobal);
@@ -546,31 +630,43 @@ function readFieldTags(prev: ElasticsearchValue,
if (!ignoredTagsList.includes(tag.tagName)) {
if (typeof fieldmap[tag.tagName] !== 'undefined') {
if (typeof prev.fields === 'undefined') {
if (typeof previous.fields === 'undefined') {
// create in case it doesn't exist
prev.fields = {};
previous.fields = {};
}
if (tag.text.trim() === '') {
// merge fields
prev.fields = {...prev.fields, ...fieldmap[tag.tagName].default};
previous.fields = {...previous.fields, ...fieldmap[tag.tagName].default};
} else if (typeof fieldmap[tag.tagName][tag.text.trim()] !== 'undefined') {
// merge fields
prev.fields = {...prev.fields, ...fieldmap[tag.tagName][tag.text.trim()]};
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()}"`);
composeErrorMessage(
path,
topTypeName,
'tag',
tag.tagName,
`Not implemented tag param "${tag.text.trim()}"`,
);
}
} else if (tag.tagName === filterableTagName) {
if (typeof prev.fields === 'undefined') {
prev.fields = {};
if (typeof previous.fields === 'undefined') {
previous.fields = {};
}
if ('type' in prev) {
const type = filterableMap[prev.type];
if ('type' in previous) {
const type = filterableMap[previous.type];
if (typeof type !== 'undefined') {
// merge fields
prev.fields = {...prev.fields, ...{raw: {type: type}}};
previous.fields = {...previous.fields, raw: {type: type}};
} else {
composeErrorMessage(path, topTypeName, 'tag', tag.tagName, `Not implemented for ${prev.type}`);
composeErrorMessage(
path,
topTypeName,
'tag',
tag.tagName,
`Not implemented for ${previous.type}`,
);
}
} else {
composeErrorMessage(path, topTypeName, 'tag', tag.tagName, 'Not applicable for object types');
@@ -581,7 +677,7 @@ function readFieldTags(prev: ElasticsearchValue,
}
}
return prev;
return previous;
}
/**
@@ -592,16 +688,30 @@ function readFieldTags(prev: ElasticsearchValue,
* @param topTypeName the name of the SCThingType
* @param tags tags attached to the value
*/
function readTypeTags(type: string, path: string, topTypeName: string, tags: CommentTag[]): ElasticsearchValue {
function readTypeTags(
type: string,
path: string,
topTypeName: string,
tags: CommentTag[],
): ElasticsearchValue {
let out: ElasticsearchValue = {type: ElasticsearchDataType.parse_error};
if (typeof typemap[type] !== 'undefined') { // first look if the value has a definition in the typemap
if (typeof 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) && typeof typemap[type][tags[i].tagName] !== 'undefined') {
if (
!ignoredTagsList.includes(tags[i].tagName) &&
typeof typemap[type][tags[i].tagName] !== 'undefined'
) {
// if we have a tag that indicates a type
if (out.type !== ElasticsearchDataType.parse_error) {
composeErrorMessage(path, topTypeName, 'type', type,
`Type conflict; "${typemap[type][tags[i].tagName]}" would override "${out.type}"`);
composeErrorMessage(
path,
topTypeName,
'type',
type,
`Type conflict; "${typemap[type][tags[i].tagName]}" would override "${out.type}"`,
);
out.type = ElasticsearchDataType.type_conflict;
continue;
}
@@ -617,7 +727,8 @@ function readTypeTags(type: string, path: string, topTypeName: string, tags: Com
return out;
}
if (dynamicTypes.includes(type)) { // Elasticsearch dynamic type TODO: doesn't work for direct types
if (dynamicTypes.includes(type)) {
// Elasticsearch dynamic type TODO: doesn't work for direct types
return {
dynamic: true,
properties: {},
@@ -666,15 +777,18 @@ function reset(resetInheritTags = true) {
* @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 {
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);
@@ -687,37 +801,42 @@ export function generateTemplate(projectReflection: ProjectReflection,
throw new Error('Interface needs at least some properties to be indexable');
}
const typeObject = _interface.children.find((declarationReflection) => {
const typeObject = _interface.children.find(declarationReflection => {
return declarationReflection.name === 'type';
});
if (typeof typeObject === 'undefined' || typeof typeObject.type === 'undefined') {
throw new Error('Interface needs a type to be indexable');
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('"', '');
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 Logger.error('Your input files seem to be incorrect, or there is a major bug in the mapping generator.');
void Logger.error(
'Your input files seem to be incorrect, or there is a major bug in the mapping generator.',
);
}
} else if (typeObject.type instanceof StringLiteralType) {
Logger.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 Logger.error(`The interface ${_interface.name} is required to use an SCThingType as a type, please do so.`);
void Logger.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: {
type: {
value: typeName,
term: {
type: typeName,
},
},
};
@@ -732,45 +851,48 @@ export function generateTemplate(projectReflection: ProjectReflection,
throw new Error('Interface needs at least some properties to be indexable');
}
const typeObject = _interface.children.find((declarationReflection) => {
const typeObject = _interface.children.find(declarationReflection => {
return declarationReflection.name === 'type';
});
if (typeof typeObject === 'undefined' || typeof typeObject.type === 'undefined') {
throw new Error('Interface needs a type to be indexable');
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('"', '');
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 Logger.error('Your input files seem to be incorrect, or there is a major bug in the mapping generator.');
void Logger.error(
'Your input files seem to be incorrect, or there is a major bug in the mapping generator.',
);
}
} else if (typeObject.type instanceof StringLiteralType) {
Logger.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 Logger.error(`The interface ${_interface.name} is required to use an SCThingType as a type, please do so.`);
void Logger.error(
`The interface ${_interface.name} is required to use an SCThingType as a type, please do so.`,
);
}
// filter out
if (interfaceFilter.length !== 0) {
if (typeof interfaceFilter.find((it) => it === typeName) === 'undefined') {
continue;
}
if (interfaceFilter.length > 0 && typeof interfaceFilter.find(it => it === typeName) === 'undefined') {
continue;
}
// init aggregation schema for type
aggregations[typeName] = {
aggs: {},
filter: {
type: {
value: typeName,
term: {
type: typeName,
},
},
};
@@ -782,26 +904,21 @@ export function generateTemplate(projectReflection: ProjectReflection,
const templateName = `template_${typeNameWithoutSpaces}`;
out[templateName] = {
mappings: {
[typeName]: handleDeclarationReflection(_interface, new Map(), '', typeName) as ElasticsearchObject,
},
mappings: handleDeclarationReflection(_interface, new Map(), '', typeName) as ElasticsearchObject,
settings: settings,
template: `stapps_${typeNameWithoutSpaces}*`,
}
;
out[templateName].mappings[typeName].properties.creation_date = {
index_patterns: [`stapps_${typeNameWithoutSpaces}*`],
};
out[templateName].mappings.properties.creation_date = {
type: ElasticsearchDataType.date,
};
out[templateName].mappings[typeName].dynamic_templates = dynamicTemplates;
out[templateName].mappings.dynamic_templates = dynamicTemplates;
// Set some properties
out[templateName].mappings[typeName]._source = {
excludes: [
'creation_date',
],
out[templateName].mappings._source = {
excludes: ['creation_date'],
};
out[templateName].mappings[typeName].date_detection = false;
out[templateName].mappings.date_detection = false;
dynamicTemplates = [];

28
src/project-reflection.ts
View File

@@ -15,20 +15,20 @@
import {Logger} from '@openstapps/logger';
import {existsSync, PathLike} from 'fs';
import {platform} from 'os';
import {join, sep} from 'path';
import path from 'path';
import {Application, ProjectReflection} from 'typedoc';
import {ModuleKind, ScriptTarget} from 'typescript';
/**
* Get a project reflection from a path
*
* @param srcPath Path to get reflection from
* @param sourcePath Path to get reflection from
* @param excludeExternals Exclude external dependencies
*/
export function getProjectReflection(srcPath: PathLike, excludeExternals = true): ProjectReflection {
Logger.info(`Generating project reflection for ${srcPath.toString()}.`);
export function getProjectReflection(sourcePath: PathLike, excludeExternals = true): ProjectReflection {
Logger.info(`Generating project reflection for ${sourcePath.toString()}.`);
const tsconfigPath = getTsconfigPath(srcPath.toString());
const tsconfigPath = getTsconfigPath(sourcePath.toString());
// initialize new Typedoc application
const app = new Application();
@@ -39,12 +39,12 @@ export function getProjectReflection(srcPath: PathLike, excludeExternals = true)
includeDeclarations: true,
module: ModuleKind.CommonJS,
target: ScriptTarget.Latest,
tsconfig: join(tsconfigPath, 'tsconfig.json'),
tsconfig: path.join(tsconfigPath, 'tsconfig.json'),
});
let inputFilePath = srcPath;
let inputFilePath = sourcePath;
if (inputFilePath === tsconfigPath) {
inputFilePath = join(tsconfigPath, 'src');
inputFilePath = path.join(tsconfigPath, 'src');
}
// get input files
@@ -54,7 +54,7 @@ export function getProjectReflection(srcPath: PathLike, excludeExternals = true)
const result = app.convert(inputFiles);
if (typeof result === 'undefined') {
throw new Error('Project reflection could not be generated.');
throw new TypeError('Project reflection could not be generated.');
}
return result;
@@ -69,12 +69,10 @@ export function getTsconfigPath(startPath: string): string {
let tsconfigPath = startPath;
// see https://stackoverflow.com/questions/9652043/identifying-the-file-system-root-with-node-js
const root = (platform() === 'win32') ? process
.cwd()
.split(sep)[0] : '/';
const root = platform() === 'win32' ? process.cwd().split(path.sep)[0] : '/';
// repeat until a tsconfig.json is found
while (!existsSync(join(tsconfigPath, 'tsconfig.json'))) {
while (!existsSync(path.join(tsconfigPath, 'tsconfig.json'))) {
if (tsconfigPath === root) {
throw new Error(
`Reached file system root ${root} while searching for 'tsconfig.json' in ${startPath}!`,
@@ -82,9 +80,9 @@ export function getTsconfigPath(startPath: string): string {
}
// pop last directory
const tsconfigPathParts = tsconfigPath.split(sep);
const tsconfigPathParts = tsconfigPath.split(path.sep);
tsconfigPathParts.pop();
tsconfigPath = tsconfigPathParts.join(sep);
tsconfigPath = tsconfigPathParts.join(path.sep);
}
Logger.info(`Using 'tsconfig.json' from ${tsconfigPath}.`);

7
src/types/aggregation.d.ts vendored
View File

@@ -15,6 +15,7 @@
/**
* An elasticsearch bucket aggregation
*
* @see https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-aggregations-bucket.html
*/
export interface AggregationSchema {
@@ -48,11 +49,11 @@ export interface ESAggTypeFilter {
/**
* The type of the object to find
*/
type: {
term: {
/**
* The name of the type
*/
value: string;
type: string;
};
}
@@ -63,7 +64,7 @@ export interface ESAggMatchAllFilter {
/**
* Filter that matches everything
*/
match_all: {};
match_all: object;
}
/**

22
src/types/mapping.d.ts vendored
View File

@@ -1,3 +1,4 @@
/* eslint-disable @typescript-eslint/no-explicit-any */
/*
* Copyright (C) 2019-2021 StApps
* This program is free software: you can redistribute it and/or modify it
@@ -219,7 +220,6 @@ export interface ElasticsearchGeoShape {
* https://www.elastic.co/guide/en/elasticsearch/reference/5.6/object.html
*/
export interface ElasticsearchObject {
/**
* Only for the top type
*/
@@ -227,9 +227,7 @@ export interface ElasticsearchObject {
/**
* Fields that should be excluded in the _source field
*/
excludes: [
'creation_date'
];
excludes: ['creation_date'];
};
/**
@@ -291,22 +289,20 @@ export interface ElasticsearchTemplateCollection {
* This is what you pass to Elasticsearch
*/
export interface ElasticsearchTemplate {
/**
* The name of the template, for referencing in Elasticsearch
*/
index_patterns: [string];
/**
* This is a pre-defined structure you should use for your mapping
*/
mappings: {
[typeName: string]: ElasticsearchObject;
};
mappings: ElasticsearchObject;
/**
* The settings for Elasticsearch
*/
settings: ElasticsearchSettings;
/**
* The name of the template, for referencing in Elasticsearch
*/
template: string;
}
/**
@@ -323,7 +319,7 @@ export interface ElasticsearchSettings {
*
* https://www.elastic.co/guide/en/elasticsearch/reference/5.6/analysis-analyzers.html
*/
analysis: {
analysis?: {
[name: string]: any;
};
}

23
test/aggregations.spec.ts
View File

@@ -1,3 +1,4 @@
/* eslint-disable unicorn/consistent-function-scoping */
/*
* Copyright (C) 2020 StApps
* This program is free software: you can redistribute it and/or modify it
@@ -15,8 +16,8 @@
import {Logger} from '@openstapps/logger';
import {readdirSync, statSync} from 'fs';
import path from 'path';
import {MapAggTest} from './mapping-model/MapAggTest';
import {MapAggTestOptions} from './mapping-model/MapAggTestOptions';
import {MapAggTest} from './mapping-model/map-agg-test';
import {MapAggTestOptions} from './mapping-model/map-agg-test-options';
describe('ES Aggregation Gen', async () => {
const magAppInstance = new MapAggTest('aggregations');
@@ -29,14 +30,20 @@ describe('ES Aggregation Gen', async () => {
const directory = statSync(fullPath);
return directory.isDirectory()
? ([] as string[]).concat(...readdirSync(fullPath).map(fragment =>
expandPathToFilesSync(path.resolve(sourcePath, fragment), accept),
))
? // eslint-disable-next-line unicorn/prefer-spread
([] as string[]).concat(
...readdirSync(fullPath).map(fragment =>
expandPathToFilesSync(path.resolve(sourcePath, fragment), accept),
),
)
: [fullPath].filter(accept);
}
for (const file of expandPathToFilesSync('./test/mapping-model/aggregations/', file => file.endsWith('agg-test.ts'))) {
for (const file of expandPathToFilesSync('./test/mapping-model/aggregations/', file =>
file.endsWith('agg-test.ts'),
)) {
try {
// eslint-disable-next-line unicorn/no-await-expression-member
const test = (await import(file))['testConfig'] as MapAggTestOptions;
it(test.testName, function () {
@@ -47,4 +54,6 @@ describe('ES Aggregation Gen', async () => {
process.exit(1);
}
}
}).timeout(20_000).slow(10_000);
})
.timeout(20_000)
.slow(10_000);

2
test/mapping-model/aggregations/src/agg-array.agg-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
/**
* @indexable

2
test/mapping-model/aggregations/src/agg-global-nested.agg-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
/**
* @indexable

2
test/mapping-model/aggregations/src/agg-global.agg-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
/**
* @indexable

3
test/mapping-model/aggregations/src/agg-inherited-global.agg-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
/**
* @indexable
@@ -23,7 +23,6 @@ export interface AggInheritedGlobal extends Foo {
type: ThingType.AggInheritedGlobal;
}
interface Foo {
/**
* @aggregatable global

3
test/mapping-model/aggregations/src/agg-inherited-overwritten.agg-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
/**
* @indexable
@@ -28,7 +28,6 @@ export interface AggInherited extends Foo {
type: ThingType.AggInheritedOverwritten;
}
interface Foo {
/**
* @aggregatable

3
test/mapping-model/aggregations/src/agg-inherited.agg-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
/**
* @indexable
@@ -23,7 +23,6 @@ export interface AggInherited extends Foo {
type: ThingType.AggInherited;
}
interface Foo {
/**
* @aggregatable

2
test/mapping-model/aggregations/src/agg-nested.agg-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
/**
* @indexable

2
test/mapping-model/MapAggTestOptions.ts → test/mapping-model/map-agg-test-options.ts
View File

@@ -21,7 +21,7 @@ export interface MapAggTestOptions {
agg?: {
fields?: string[];
globals?: string[];
}
};
map?: MinimalMappingDescription;
err?: string[];
ignoredTags?: string[];

66
test/mapping-model/MapAggTest.ts → test/mapping-model/map-agg-test.ts
View File

@@ -14,21 +14,23 @@
*/
import {ElasticsearchDataType} from '../../src/config/typemap';
import {generateTemplate} from '../../src/mapping';
import {resolve} from "path";
import {expect} from "chai";
import path from 'path';
import {expect} from 'chai';
import {ProjectReflection} from 'typedoc';
import {getProjectReflection} from '../../src/project-reflection';
import {AggregationSchema, ESNestedAggregation} from '../../src/types/aggregation';
import {ElasticsearchTemplateCollection} from '../../src/types/mapping';
import {MapAggTestOptions, MinimalMappingDescription} from './MapAggTestOptions';
import {MapAggTestOptions, MinimalMappingDescription} from './map-agg-test-options';
import {settings} from '../../src/config/settings';
export class MapAggTest {
mapping_model_path!: string;
reflection!: ProjectReflection;
constructor(dir: string) {
this.mapping_model_path = resolve(__dirname, dir);
constructor(directory: string) {
// eslint-disable-next-line unicorn/prefer-module
this.mapping_model_path = path.resolve(__dirname, directory);
this.reflection = getProjectReflection(this.mapping_model_path);
}
@@ -37,14 +39,18 @@ export class MapAggTest {
if (typeof options.err !== 'undefined') {
for (const error of template.errors) {
expect(options.err).to.include(error, "Unexpected Error!")
expect(options.err).to.include(error, 'Unexpected Error!');
}
} else {
expect(template.errors).to.be.deep.equal([], 'Unexpected Error!');
}
if (typeof options.agg !== 'undefined') {
const expectedAggSchema = MapAggTest.buildAggregation(options.name, options.agg.fields, options.agg.globals)
const expectedAggSchema = MapAggTest.buildAggregation(
options.name,
options.agg.fields,
options.agg.globals,
);
expect(template.aggregations).to.be.deep.equal(expectedAggSchema, 'Aggregation schema not equal!');
}
@@ -59,8 +65,8 @@ export class MapAggTest {
'@all': {
aggs: {},
filter: {
match_all: {}
}
match_all: {},
},
},
};
@@ -69,8 +75,8 @@ export class MapAggTest {
terms: {
field: `${global}.raw`,
size: 1000,
}
}
},
};
}
if (typeof fields === 'undefined' || fields.length === 0) {
@@ -80,19 +86,19 @@ export class MapAggTest {
out[name] = {
aggs: {},
filter: {
type: {
value: name,
}
}
}
term: {
type: name,
},
},
};
for (const field of fields) {
(out[name]! as ESNestedAggregation).aggs[field] = {
terms: {
field: `${field}.raw`,
size: 1000,
}
}
},
};
}
return out;
@@ -107,28 +113,30 @@ export class MapAggTest {
const out: ElasticsearchTemplateCollection = {};
const templateName = `template_${typeNameWithoutSpaces}`;
out[templateName] = {
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore empty object
mappings: {},
settings: settings,
template: `stapps_${typeNameWithoutSpaces}*`,
}
index_patterns: [`stapps_${typeNameWithoutSpaces}*`],
};
const maps = map.maps ?? {};
maps.type = {
type: ElasticsearchDataType.text
}
type: ElasticsearchDataType.text,
};
maps.creation_date = {
type: ElasticsearchDataType.date
}
out[templateName].mappings[name] = {
type: ElasticsearchDataType.date,
};
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore can be used to index
out[templateName].mappings = {
_source: {
excludes: [
'creation_date'
]
excludes: ['creation_date'],
},
date_detection: false,
dynamic: 'strict',
properties: maps,
dynamic_templates: map.dynamicTemplates ?? [],
}
};
return out;
}

15
test/mapping-model/mappings/src/any-unknown.mapping-test.ts
View File

@@ -14,17 +14,18 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
/**
* @indexable
*/
export interface AnyUnknown {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
foo: any;
bar: unknown;
type: ThingType.AnyUnknown
type: ThingType.AnyUnknown;
}
export const testConfig: MapAggTestOptions = {
@@ -34,12 +35,12 @@ export const testConfig: MapAggTestOptions = {
maps: {
foo: {
dynamic: true,
properties: {}
properties: {},
},
bar: {
dynamic: true,
properties: {}
}
}
}
properties: {},
},
},
},
};

10
test/mapping-model/mappings/src/date.mapping-test.ts
View File

@@ -14,13 +14,13 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
* @date
*/
export type SCISO8601Date = string
export type SCISO8601Date = string;
/**
* @indexable
@@ -33,7 +33,7 @@ export interface DateAndRange {
dateAlias: SCISO8601Date;
type: ThingType.Date
type: ThingType.Date;
}
export const testConfig: MapAggTestOptions = {
@@ -47,6 +47,6 @@ export const testConfig: MapAggTestOptions = {
dateAlias: {
type: ElasticsearchDataType.date,
},
}
}
},
},
};

16
test/mapping-model/mappings/src/default-generics.mapping-test.ts
View File

@@ -15,7 +15,7 @@
import {ElasticsearchDataType} from '../../../../src/config/typemap';
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
/**
* @indexable
@@ -39,13 +39,11 @@ export const testConfig: MapAggTestOptions = {
dynamic: 'strict',
properties: {
bar: {
type: ElasticsearchDataType.parse_error
}
}
}
}
type: ElasticsearchDataType.parse_error,
},
},
},
},
},
err: [
`At "${ThingType.DefaultGeneric}::foo.bar" for Generic "T": Missing reflection, please report!`
]
err: [`At "${ThingType.DefaultGeneric}::foo.bar" for Generic "T": Missing reflection, please report!`],
};

14
test/mapping-model/mappings/src/double-type-conflict.mapping-test.ts
View File

@@ -15,7 +15,7 @@
import {ElasticsearchDataType} from '../../../../src/config/typemap';
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
/**
* @indexable
@@ -42,15 +42,15 @@ export const testConfig: MapAggTestOptions = {
map: {
maps: {
stringDoubleTypeConflict: {
type: ElasticsearchDataType.type_conflict
type: ElasticsearchDataType.type_conflict,
},
numberDoubleTypeConflict: {
type: ElasticsearchDataType.type_conflict
}
}
type: ElasticsearchDataType.type_conflict,
},
},
},
err: [
`At "${ThingType.DoubleTypeConflict}::stringDoubleTypeConflict" for type "string": Type conflict; "keyword" would override "text"`,
`At "${ThingType.DoubleTypeConflict}::numberDoubleTypeConflict" for type "number": Type conflict; "integer" would override "float"`
]
`At "${ThingType.DoubleTypeConflict}::numberDoubleTypeConflict" for type "number": Type conflict; "integer" would override "float"`,
],
};

17
test/mapping-model/mappings/src/enum.mapping-test.ts
View File

@@ -14,16 +14,16 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
* @indexable
*/
export interface Enum {
foo: Bar,
foo: Bar;
bar: Baz,
bar: Baz;
type: ThingType.Enum;
}
@@ -36,6 +36,7 @@ enum Bar {
enum Baz {
d = 'd',
// eslint-disable-next-line unicorn/prevent-abbreviations
e = 'e',
f = 'f',
}
@@ -48,11 +49,11 @@ export const testConfig: MapAggTestOptions = {
map: {
maps: {
foo: {
type: ElasticsearchDataType.text
type: ElasticsearchDataType.text,
},
bar: {
type: ElasticsearchDataType.text
}
}
}
type: ElasticsearchDataType.text,
},
},
},
};

38
test/mapping-model/mappings/src/filterable-tag.mapping-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
export type FilterableEnumType = 'a' | 'b' | 'c';
@@ -38,14 +38,14 @@ export interface FilterableTag {
/**
* @filterable
*/
baz: 'some literal'
baz: 'some literal';
/**
* @filterable
*/
buz: FilterableEnumType
buz: FilterableEnumType;
type: ThingType.FilterableTag
type: ThingType.FilterableTag;
}
export const testConfig: MapAggTestOptions = {
@@ -57,34 +57,34 @@ export const testConfig: MapAggTestOptions = {
type: ElasticsearchDataType.text,
fields: {
raw: {
type: ElasticsearchDataType.keyword
}
}
type: ElasticsearchDataType.keyword,
},
},
},
bar: {
type: ElasticsearchDataType.keyword,
fields: {
raw: {
type: ElasticsearchDataType.keyword
}
}
type: ElasticsearchDataType.keyword,
},
},
},
baz: {
type: ElasticsearchDataType.keyword,
fields: {
raw: {
type: ElasticsearchDataType.keyword
}
}
type: ElasticsearchDataType.keyword,
},
},
},
buz: {
type: ElasticsearchDataType.keyword,
fields: {
raw: {
type: ElasticsearchDataType.keyword
}
}
}
}
}
type: ElasticsearchDataType.keyword,
},
},
},
},
},
};

22
test/mapping-model/mappings/src/generics.mapping-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
@@ -22,7 +22,7 @@ import {ElasticsearchDataType} from '../../../../src/config/typemap';
*/
export interface Generics {
foo: InterfaceWithDefaultGeneric<number>;
baz: InterfaceWithStringGeneric<string>
baz: InterfaceWithStringGeneric<string>;
type: ThingType.Generics;
}
@@ -44,18 +44,18 @@ export const testConfig: MapAggTestOptions = {
dynamic: 'strict',
properties: {
bar: {
type: ElasticsearchDataType.integer
}
}
type: ElasticsearchDataType.integer,
},
},
},
baz: {
dynamic: 'strict',
properties: {
bar: {
type: ElasticsearchDataType.text
}
}
}
}
}
type: ElasticsearchDataType.text,
},
},
},
},
},
};

14
test/mapping-model/mappings/src/impossible-union.mapping-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
@@ -23,7 +23,7 @@ import {ElasticsearchDataType} from '../../../../src/config/typemap';
export interface ImpossibleUnion {
foo: 'a' | 1 | boolean;
type: ThingType.ImpossibleUnion
type: ThingType.ImpossibleUnion;
}
export const testConfig: MapAggTestOptions = {
@@ -32,11 +32,11 @@ export const testConfig: MapAggTestOptions = {
map: {
maps: {
foo: {
type: ElasticsearchDataType.boolean
}
}
type: ElasticsearchDataType.boolean,
},
},
},
err: [
`At "${ThingType.ImpossibleUnion}::foo" for type "[{"type":"1","name":"2"},"unknown","1"]": Not implemented type`
]
`At "${ThingType.ImpossibleUnion}::foo" for type "[{"type":"1","name":"2"},"unknown","1"]": Not implemented type`,
],
};

17
test/mapping-model/mappings/src/incompatible-type.mapping-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
@@ -41,7 +41,6 @@ export interface DoubleTypeConflict {
*/
floatString: string;
type: ThingType.IncompatibleType;
}
@@ -51,23 +50,23 @@ export const testConfig: MapAggTestOptions = {
map: {
maps: {
keywordNumber: {
type: ElasticsearchDataType.integer
type: ElasticsearchDataType.integer,
},
textNumber: {
type: ElasticsearchDataType.integer
type: ElasticsearchDataType.integer,
},
integerString: {
type: ElasticsearchDataType.text
type: ElasticsearchDataType.text,
},
floatString: {
type: ElasticsearchDataType.text
}
}
type: ElasticsearchDataType.text,
},
},
},
err: [
`At "${ThingType.IncompatibleType}::keywordNumber" for tag "keyword": Not implemented tag`,
`At "${ThingType.IncompatibleType}::textNumber" for tag "text": Not implemented tag`,
`At "${ThingType.IncompatibleType}::floatString" for tag "float": Not implemented tag`,
`At "${ThingType.IncompatibleType}::integerString" for tag "integer": Not implemented tag`,
]
],
};

28
test/mapping-model/mappings/src/index-signature.mapping-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
@@ -25,8 +25,8 @@ export interface IndexSignature {
[key: string]: {
bar: number;
baz: string;
}
}
};
};
type: ThingType.IndexSignature;
}
@@ -38,8 +38,8 @@ export const testConfig: MapAggTestOptions = {
maps: {
foo: {
dynamic: true,
properties: {}
}
properties: {},
},
},
dynamicTemplates: [
{
@@ -48,18 +48,18 @@ export const testConfig: MapAggTestOptions = {
dynamic: 'strict',
properties: {
bar: {
type: ElasticsearchDataType.integer
type: ElasticsearchDataType.integer,
},
baz: {
type: ElasticsearchDataType.text
}
}
type: ElasticsearchDataType.text,
},
},
},
match: '*',
match_mapping_type: '*',
path_match: 'foo.*'
}
}
]
}
path_match: 'foo.*',
},
},
],
},
};

14
test/mapping-model/mappings/src/inferred-type-filterable.mapping-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ElasticsearchDataType} from '../../../../src/config/typemap';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ThingType} from './types';
/**
@@ -36,7 +36,7 @@ export interface InferredTypeFilterable {
*/
bar: SCISO8601Date;
type: ThingType.InferredTypeFilterable
type: ThingType.InferredTypeFilterable;
}
export const testConfig: MapAggTestOptions = {
@@ -49,12 +49,12 @@ export const testConfig: MapAggTestOptions = {
fields: {
raw: {
type: ElasticsearchDataType.keyword,
}
}
},
},
},
bar: {
type: ElasticsearchDataType.date,
}
}
}
},
},
},
};

20
test/mapping-model/mappings/src/inherit-tags.mapping-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ElasticsearchDataType} from '../../../../src/config/typemap';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ThingType} from './types';
/**
@@ -24,14 +24,14 @@ export interface InheritTags {
/**
* @inheritTags inherit tags::bar.baz
*/
foo: number,
foo: number;
bar: {
/**
* @float
*/
baz: number
}
baz: number;
};
type: ThingType.InheritTags;
}
@@ -42,16 +42,16 @@ export const testConfig: MapAggTestOptions = {
map: {
maps: {
foo: {
type: ElasticsearchDataType.float
type: ElasticsearchDataType.float,
},
bar: {
dynamic: 'strict',
properties: {
baz: {
type: ElasticsearchDataType.float
}
}
type: ElasticsearchDataType.float,
},
},
},
}
}
},
},
};

18
test/mapping-model/mappings/src/inherited-property.mapping-test.ts
View File

@@ -14,14 +14,14 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
* @indexable
*/
export interface InheritedProperty extends Bar{
foo: number,
export interface InheritedProperty extends Bar {
foo: number;
type: ThingType.InheritedProperty;
}
@@ -44,14 +44,14 @@ export const testConfig: MapAggTestOptions = {
map: {
maps: {
foo: {
type: ElasticsearchDataType.integer
type: ElasticsearchDataType.integer,
},
bar: {
type: ElasticsearchDataType.keyword
type: ElasticsearchDataType.keyword,
},
baz: {
type: ElasticsearchDataType.float
}
}
}
type: ElasticsearchDataType.float,
},
},
},
};

13
test/mapping-model/mappings/src/invalid-tag.mapping-test.ts
View File

@@ -1,3 +1,4 @@
/* eslint-disable jsdoc/check-tag-names */
/*
* Copyright (C) 2020 StApps
* This program is free software: you can redistribute it and/or modify it
@@ -14,7 +15,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
@@ -35,11 +36,9 @@ export const testConfig: MapAggTestOptions = {
map: {
maps: {
foo: {
type: ElasticsearchDataType.text
}
}
type: ElasticsearchDataType.text,
},
},
},
err: [
`At "${ThingType.InvalidTag}::foo" for tag "aninvalidtag": Not implemented tag`
]
err: [`At "${ThingType.InvalidTag}::foo" for tag "aninvalidtag": Not implemented tag`],
};

22
test/mapping-model/mappings/src/map-explicit-types.mapping-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
@@ -44,12 +44,12 @@ export interface MapExplicitTypes {
/**
* @date
*/
esEpochMsDate: number
esEpochMsDate: number;
/**
* @date
*/
esStringDate: string
esStringDate: string;
type: ThingType.MapExplicitTypes;
}
@@ -60,23 +60,23 @@ export const testConfig: MapAggTestOptions = {
map: {
maps: {
esInteger: {
type: ElasticsearchDataType.integer
type: ElasticsearchDataType.integer,
},
esFloat: {
type: ElasticsearchDataType.float
type: ElasticsearchDataType.float,
},
esKeyword: {
type: ElasticsearchDataType.keyword
type: ElasticsearchDataType.keyword,
},
esText: {
type: ElasticsearchDataType.text
type: ElasticsearchDataType.text,
},
esEpochMsDate: {
type: ElasticsearchDataType.date
type: ElasticsearchDataType.date,
},
esStringDate: {
type: ElasticsearchDataType.date
type: ElasticsearchDataType.date,
},
}
}
},
},
};

12
test/mapping-model/mappings/src/missing-premap.mapping-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
@@ -35,11 +35,9 @@ export const testConfig: MapAggTestOptions = {
map: {
maps: {
foo: {
type: ElasticsearchDataType.missing_premap
}
}
type: ElasticsearchDataType.missing_premap,
},
},
},
err: [
`At "${ThingType.MissingPremap}::foo" for external type "HTMLAllCollection": Missing pre-map`
]
err: [`At "${ThingType.MissingPremap}::foo" for external type "HTMLAllCollection": Missing pre-map`],
};

32
test/mapping-model/mappings/src/nested.mapping-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
@@ -29,10 +29,10 @@ export interface Nested {
* @keyword
*/
depth3_2: string;
}
};
depth2_2: boolean;
}
}
};
};
type: ThingType.Nested;
}
@@ -52,20 +52,20 @@ export const testConfig: MapAggTestOptions = {
dynamic: 'strict',
properties: {
depth3_1: {
type: ElasticsearchDataType.integer
type: ElasticsearchDataType.integer,
},
depth3_2: {
type: ElasticsearchDataType.keyword
}
}
type: ElasticsearchDataType.keyword,
},
},
},
depth2_2: {
type: ElasticsearchDataType.boolean
}
}
}
}
}
}
}
type: ElasticsearchDataType.boolean,
},
},
},
},
},
},
},
};

20
test/mapping-model/mappings/src/object-union.mapping-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
@@ -23,7 +23,7 @@ import {ElasticsearchDataType} from '../../../../src/config/typemap';
export interface ObjectUnion {
foo: Boo | Buu;
type: ThingType.ObjectUnion
type: ThingType.ObjectUnion;
}
// we can't name them Bar or Baz, look here for more info:
@@ -49,16 +49,16 @@ export const testConfig: MapAggTestOptions = {
dynamic: 'strict',
properties: {
a: {
type: ElasticsearchDataType.boolean
type: ElasticsearchDataType.boolean,
},
b: {
type: ElasticsearchDataType.integer
type: ElasticsearchDataType.integer,
},
intersection: {
type: ElasticsearchDataType.text
}
}
}
}
}
type: ElasticsearchDataType.text,
},
},
},
},
},
};

27
test/mapping-model/mappings/src/paired-tags.mapping-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
@@ -46,23 +46,24 @@ export const testConfig: MapAggTestOptions = {
type: ElasticsearchDataType.keyword,
fields: {
raw: {
type: ElasticsearchDataType.keyword
}
}
type: ElasticsearchDataType.keyword,
},
},
},
bar: {
type: ElasticsearchDataType.text,
fields: {
raw: {
type: ElasticsearchDataType.keyword
type: ElasticsearchDataType.keyword,
},
sort: {
analyzer: 'ducet_sort',
fielddata: true,
type: ElasticsearchDataType.text
}
}
}
}
}
country: 'DE',
language: 'de',
type: 'icu_collation_keyword',
variant: '@collation=phonebook',
},
},
},
},
},
};

20
test/mapping-model/mappings/src/sensible-defaults.mapping-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
@@ -37,23 +37,23 @@ export const testConfig: MapAggTestOptions = {
map: {
maps: {
numberDefault: {
type: ElasticsearchDataType.integer
type: ElasticsearchDataType.integer,
},
stringDefault: {
type: ElasticsearchDataType.text
type: ElasticsearchDataType.text,
},
booleanDefault: {
type: ElasticsearchDataType.boolean
type: ElasticsearchDataType.boolean,
},
stringLiteralDefault: {
type: ElasticsearchDataType.keyword
type: ElasticsearchDataType.keyword,
},
booleanTrueLiteralDefault: {
type: ElasticsearchDataType.boolean
type: ElasticsearchDataType.boolean,
},
booleanFalseLiteralDefault: {
type: ElasticsearchDataType.boolean
}
}
}
type: ElasticsearchDataType.boolean,
},
},
},
};

43
test/mapping-model/mappings/src/sortable-tag.mapping-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
@@ -36,7 +36,7 @@ export interface SortableTag {
*/
baz: number;
type: ThingType.SortableTag
type: ThingType.SortableTag;
}
export const testConfig: MapAggTestOptions = {
@@ -48,32 +48,35 @@ export const testConfig: MapAggTestOptions = {
type: ElasticsearchDataType.text,
fields: {
sort: {
analyzer: 'ducet_sort',
fielddata: true,
type: 'text'
}
}
country: 'DE',
language: 'de',
type: 'icu_collation_keyword',
variant: '@collation=phonebook',
},
},
},
bar: {
type: ElasticsearchDataType.text,
fields: {
sort: {
analyzer: 'ducet_sort',
fielddata: true,
type: 'text'
}
}
country: 'DE',
language: 'de',
type: 'icu_collation_keyword',
variant: '@collation=phonebook',
},
},
},
baz: {
type: ElasticsearchDataType.integer,
fields: {
sort: {
analyzer: 'ducet_sort',
fielddata: true,
type: 'text'
}
}
}
}
}
country: 'DE',
language: 'de',
type: 'icu_collation_keyword',
variant: '@collation=phonebook',
},
},
},
},
},
};

26
test/mapping-model/mappings/src/tags-ignore-case.mapping-test.ts
View File

@@ -13,7 +13,7 @@
* this program. If not, see <https://www.gnu.org/licenses/>.
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
@@ -23,19 +23,19 @@ export interface TagsIgnoreCase {
/**
* @inheritTags inherit tags::bar.baz
*/
camelCase: number,
camelCase: number;
/**
* @inherittags inherit tags::bar.baz
* @inheritTags inherit tags::bar.baz
*/
lowerCase: number,
lowerCase: number;
bar: {
/**
* @float
*/
baz: number
}
baz: number;
};
type: ThingType.TagsIgnoreCase;
}
@@ -46,19 +46,19 @@ export const testConfig: MapAggTestOptions = {
map: {
maps: {
camelCase: {
type: ElasticsearchDataType.float
type: ElasticsearchDataType.float,
},
lowerCase: {
type: ElasticsearchDataType.float
type: ElasticsearchDataType.float,
},
bar: {
dynamic: 'strict',
properties: {
baz: {
type: ElasticsearchDataType.float
}
}
type: ElasticsearchDataType.float,
},
},
},
}
}
},
},
};

12
test/mapping-model/mappings/src/type-alias.mapping-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
@@ -24,17 +24,17 @@ export interface TypeAlias {
/**
*
*/
textProperty: ATextAlias,
textProperty: ATextAlias;
/**
*
*/
keywordProperty: AKeywordAlias,
keywordProperty: AKeywordAlias;
/**
* @keyword
*/
overriddenTextAsKeyword: ATextAlias
overriddenTextAsKeyword: ATextAlias;
type: ThingType.TypeAlias;
}
@@ -63,6 +63,6 @@ export const testConfig: MapAggTestOptions = {
overriddenTextAsKeyword: {
type: ElasticsearchDataType.keyword,
},
}
}
},
},
};

8
test/mapping-model/mappings/src/type-overrides.mapping-test.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
export interface SCISO8601DateRange {
@@ -27,7 +27,7 @@ export interface SCISO8601DateRange {
export interface TypeOverrides {
foo: SCISO8601DateRange;
type: ThingType.TypeOverrides
type: ThingType.TypeOverrides;
}
export const testConfig: MapAggTestOptions = {
@@ -38,6 +38,6 @@ export const testConfig: MapAggTestOptions = {
foo: {
type: ElasticsearchDataType.date_range,
},
}
}
},
},
};

12
test/mapping-model/mappings/src/type-query.mapping-test.disabled.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
@@ -29,7 +29,7 @@ export interface TypeQuery {
enum Bar {
'a',
'b',
'c'
'c',
}
// https://gitlab.com/openstapps/core-tools/-/issues/47
@@ -39,8 +39,8 @@ export const testConfig: MapAggTestOptions = {
map: {
maps: {
foo: {
type: ElasticsearchDataType.text
}
}
}
type: ElasticsearchDataType.text,
},
},
},
};

20
test/mapping-model/mappings/src/type-wrapper-inheritance.mapping-test.disabled.ts
View File

@@ -14,7 +14,7 @@
*/
import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions';
import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap';
/**
@@ -36,7 +36,7 @@ export interface TypeWrapperInheritance {
*/
stringLiteralWrapper: StringLiteralWrapper;
type: ThingType.TypeWrapperInheritance
type: ThingType.TypeWrapperInheritance;
}
type NumberWrapper = number;
@@ -53,16 +53,16 @@ export const testConfig: MapAggTestOptions = {
dynamic: 'strict',
properties: {
numberWrapper: {
type: ElasticsearchDataType.float
type: ElasticsearchDataType.float,
},
stringWrapper: {
type: ElasticsearchDataType.keyword
type: ElasticsearchDataType.keyword,
},
stringLiteralWrapper: {
type: ElasticsearchDataType.text
}
}
}
}
}
type: ElasticsearchDataType.text,
},
},
},
},
},
};

27
test/mapping.spec.ts
View File

@@ -15,8 +15,8 @@
import {Logger} from '@openstapps/logger';
import {readdirSync, statSync} from 'fs';
import path from 'path';
import {MapAggTest} from './mapping-model/MapAggTest';
import {MapAggTestOptions} from './mapping-model/MapAggTestOptions';
import {MapAggTest} from './mapping-model/map-agg-test';
import {MapAggTestOptions} from './mapping-model/map-agg-test-options';
describe('ES Mapping Gen', async () => {
const magAppInstance = new MapAggTest('mappings');
@@ -24,27 +24,36 @@ describe('ES Mapping Gen', async () => {
/**
* Expand a path to a list of all files deeply contained in it
*/
// eslint-disable-next-line unicorn/consistent-function-scoping
function expandPathToFilesSync(sourcePath: string, accept: (fileName: string) => boolean): string[] {
const fullPath = path.resolve(sourcePath);
const directory = statSync(fullPath);
return directory.isDirectory()
? ([] as string[]).concat(...readdirSync(fullPath).map(fragment =>
expandPathToFilesSync(path.resolve(sourcePath, fragment), accept),
))
? // eslint-disable-next-line unicorn/prefer-spread
([] as string[]).concat(
...readdirSync(fullPath).map(fragment =>
expandPathToFilesSync(path.resolve(sourcePath, fragment), accept),
),
)
: [fullPath].filter(accept);
}
for (const file of expandPathToFilesSync('./test/mapping-model/mappings/', file => file.endsWith('mapping-test.ts'))) {
for (const file of expandPathToFilesSync('./test/mapping-model/mappings/', file =>
file.endsWith('mapping-test.ts'),
)) {
try {
// eslint-disable-next-line unicorn/no-await-expression-member
const test = (await import(file))['testConfig'] as MapAggTestOptions;
it(test.testName, function () {
magAppInstance.testInterfaceAgainstPath(test)
})
magAppInstance.testInterfaceAgainstPath(test);
});
} catch (error) {
await Logger.error('UNHANDLED REJECTION', error.stack);
process.exit(1);
}
}
}).timeout(20_000).slow(10_000);
})
.timeout(20_000)
.slow(10_000);

143
tslint.json
View File

@@ -1,143 +0,0 @@
{
"defaultSeverity": "error",
"extends": [
"tslint:recommended",
"tslint-eslint-rules"
],
"rules": {
"array-type": [
true,
"array-simple"
],
"arrow-return-shorthand": true,
"await-promise": true,
"ban-comma-operator": true,
"ban-ts-ignore": true,
"completed-docs": true,
"curly": true,
"encoding": true,
"file-header": true,
"file-name-casing": [
true,
"kebab-case"
],
"forin": true,
"indent": [
true,
"spaces",
2
],
"interface-name": [
true,
"never-prefix"
],
"linebreak-style": [
true,
"LF"
],
"max-classes-per-file": false,
"member-access": false,
"member-ordering": [
true,
{
"alphabetize": true,
"order": [
"private-static-field",
"protected-static-field",
"public-static-field",
"private-instance-field",
"protected-instance-field",
"public-instance-field",
"private-static-method",
"protected-static-method",
"public-static-method",
"constructor",
"private-instance-method",
"protected-instance-method",
"public-instance-method"
]
}
],
"newline-before-return": true,
"newline-per-chained-call": true,
"no-angle-bracket-type-assertion": true,
"no-any": true,
"no-boolean-literal-compare": true,
"no-conditional-assignment": true,
"no-construct": true,
"no-default-export": true,
"no-default-import": true,
"no-duplicate-super": true,
"no-floating-promises": true,
"no-implicit-dependencies": true,
"no-inferrable-types": true,
"no-magic-numbers": true,
"no-parameter-reassignment": true,
"no-redundant-jsdoc": true,
"no-reference": true,
"no-return-await": true,
"no-shadowed-variable": true,
"no-sparse-arrays": true,
"no-string-throw": true,
"no-trailing-whitespace": [
true,
"ignore-comments",
"ignore-jsdoc"
],
"object-curly-spacing": [
true,
"never"
],
"object-literal-key-quotes": false,
"object-literal-shorthand": false,
"one-variable-per-declaration": true,
"ordered-imports": [
true,
{
"import-sources-order": "case-insensitive",
"named-imports-order": "case-insensitive"
}
],
"prefer-const": true,
"prefer-for-of": true,
"prefer-function-over-method": true,
"prefer-object-spread": true,
"prefer-readonly": true,
"prefer-template": true,
"promise-function-async": true,
"quotemark": [
true,
"single",
"avoid-escape"
],
"semicolon": true,
"static-this": true,
"strict-boolean-expressions": true,
"trailing-comma": [
true,
{
"multiline": "always",
"singleline": "never"
}
],
"type-literal-delimiter": [
true,
{
"singleLine": "always"
}
],
"unnecessary-bind": true,
"unnecessary-else": true,
"variable-name": [
true,
"ban-keywords",
"check-format",
"allow-leading-underscore"
]
},
"linterOptions": {
"exclude": [
"../../../test/**"
]
}
}