Theaninova/openstapps
1
0
Fork 0
mirror of https://gitlab.com/openstapps/openstapps.git synced 2026-03-15 19:22:27 +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 # ignore openapi resources
openapi/ 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": { "bin": {
"openstapps-es-mapping-generator": "./lib/cli.js" "openstapps-es-mapping-generator": "./lib/cli.js"
}, },
"author": "Wieland Schöbl <wulkanat@gmail.com>", "author": "Thea Schöbl <dev@theaninova.de>",
"scripts": { "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'", "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", "check-configuration": "openstapps-configuration",
"compile": "rimraf lib && tsc && prepend lib/cli.js '#!/usr/bin/env node\n'", "compile": "rimraf lib && tsc && prepend lib/cli.js '#!/usr/bin/env node\n'",
@@ -20,7 +20,8 @@
"preversion": "npm run prepublishOnly", "preversion": "npm run prepublishOnly",
"push": "git push && git push origin \"v$npm_package_version\"", "push": "git push && git push origin \"v$npm_package_version\"",
"test": "mocha --require ts-node/register test/*.spec.ts", "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": { "dependencies": {
"@openstapps/logger": "1.1.1", "@openstapps/logger": "1.1.1",
@@ -33,6 +34,7 @@
}, },
"devDependencies": { "devDependencies": {
"@testdeck/mocha": "0.3.3", "@testdeck/mocha": "0.3.3",
"@openstapps/eslint-config": "1.1.0",
"@types/chai": "4.3.4", "@types/chai": "4.3.4",
"@types/mocha": "9.1.1", "@types/mocha": "9.1.1",
"@types/node": "14.18.36", "@types/node": "14.18.36",
@@ -44,7 +46,13 @@
"prepend-file-cli": "1.0.6", "prepend-file-cli": "1.0.6",
"rimraf": "3.0.2", "rimraf": "3.0.2",
"ts-node": "10.9.1", "ts-node": "10.9.1",
"tslint": "6.1.3", "@typescript-eslint/eslint-plugin": "5.40.0",
"tslint-eslint-rules": "5.4.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 * Copyright (C) 2018-2021 StApps
* This program is free software: you can redistribute it and/or modify it * 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 {Command} from 'commander';
import {readFileSync, writeFileSync} from 'fs'; import {readFileSync, writeFileSync} from 'fs';
import got from 'got'; import got from 'got';
import {resolve} from 'path'; import path from 'path';
import {exit} from 'process'; import {exit} from 'process';
import {generateTemplate} from './mapping'; import {generateTemplate} from './mapping';
import {getProjectReflection} from './project-reflection'; import {getProjectReflection} from './project-reflection';
@@ -33,11 +34,8 @@ process.on('unhandledRejection', async (reason: unknown) => {
const commander = new Command('openstapps-core-tools'); const commander = new Command('openstapps-core-tools');
commander // eslint-disable-next-line unicorn/prefer-module
.version(JSON.parse( commander.version(JSON.parse(readFileSync(path.resolve(__dirname, '..', 'package.json')).toString()).version);
readFileSync(resolve(__dirname, '..', 'package.json'))
.toString(),
).version);
commander commander
.command('mapping <relativeSrcPath>') .command('mapping <relativeSrcPath>')
@@ -45,9 +43,9 @@ commander
.option('-i, --ignoredTags <ignoredTags>', 'Ignored Tags (comma-separated)') .option('-i, --ignoredTags <ignoredTags>', 'Ignored Tags (comma-separated)')
.option('-a, --aggPath <relativeAggregationPath>', 'Aggregations Path') .option('-a, --aggPath <relativeAggregationPath>', 'Aggregations Path')
.option('-e, --errorPath <relativeErrorPath>', 'Error Path') .option('-e, --errorPath <relativeErrorPath>', 'Error Path')
.action(async (relativeSrcPath, options) => { .action(async (relativeSourcePath, options) => {
// get absolute paths // get absolute paths
const srcPath = resolve(relativeSrcPath); const sourcePath = path.resolve(relativeSourcePath);
let ignoredTagsList: string[] = []; let ignoredTagsList: string[] = [];
if (typeof options.ignoredTags === 'string') { if (typeof options.ignoredTags === 'string') {
@@ -55,10 +53,10 @@ commander
} }
// get project reflection // get project reflection
const projectReflection = getProjectReflection(srcPath); const projectReflection = getProjectReflection(sourcePath);
const result = generateTemplate(projectReflection, ignoredTagsList, true); const result = generateTemplate(projectReflection, ignoredTagsList, true);
if (result.errors.length !== 0) { if (result.errors.length > 0) {
await Logger.error('Mapping generated with errors!'); await Logger.error('Mapping generated with errors!');
} else { } else {
Logger.ok('Mapping generated without errors!'); Logger.ok('Mapping generated without errors!');
@@ -66,22 +64,22 @@ commander
// write documentation to file // write documentation to file
if (typeof options.aggPath !== 'undefined') { if (typeof options.aggPath !== 'undefined') {
const aggPath = resolve(options.aggPath); const aggPath = path.resolve(options.aggPath);
// tslint:disable-next-line:no-magic-numbers // tslint:disable-next-line:no-magic-numbers
writeFileSync(aggPath, JSON.stringify(result.aggregations, null, 2)); writeFileSync(aggPath, JSON.stringify(result.aggregations, null, 2));
Logger.ok(`Elasticsearch aggregations written to ${aggPath}.`); Logger.ok(`Elasticsearch aggregations written to ${aggPath}.`);
} }
if (typeof options.mappingPath !== 'undefined') { if (typeof options.mappingPath !== 'undefined') {
const mappingPath = resolve(options.mappingPath); const mappingPath = path.resolve(options.mappingPath);
// tslint:disable-next-line:no-magic-numbers // tslint:disable-next-line:no-magic-numbers
writeFileSync(mappingPath, JSON.stringify(result.mappings, null, 2)); writeFileSync(mappingPath, JSON.stringify(result.mappings, null, 2));
Logger.ok(`Elasticsearch mappings written to ${mappingPath}.`); Logger.ok(`Elasticsearch mappings written to ${mappingPath}.`);
} }
if (typeof options.errorPath !== 'undefined') { if (typeof options.errorPath !== 'undefined') {
const errPath = resolve(options.errorPath); const errorPath = path.resolve(options.errorPath);
// tslint:disable-next-line:no-magic-numbers // tslint:disable-next-line:no-magic-numbers
writeFileSync(errPath, JSON.stringify(result.errors, null, 2)); writeFileSync(errorPath, JSON.stringify(result.errors, null, 2));
Logger.ok(`Mapping errors written to ${errPath}.`); Logger.ok(`Mapping errors written to ${errorPath}.`);
} else if (result.errors.length > 0) { } else if (result.errors.length > 0) {
for (const error of result.errors) { for (const error of result.errors) {
await Logger.error(error); await Logger.error(error);
@@ -93,12 +91,13 @@ commander
commander commander
.command('put-es-templates <srcPath> <esAddress> [ignoredTags]') .command('put-es-templates <srcPath> <esAddress> [ignoredTags]')
.action(async (relativeSrcPath, esAddress) => { .action(async (relativeSourcePath, esAddress) => {
// get absolute paths // get absolute paths
const srcPath = resolve(relativeSrcPath); const sourcePath = path.resolve(relativeSourcePath);
// get project reflection // 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) { for (const template in templates) {
if (!templates.hasOwnProperty(template)) { if (!templates.hasOwnProperty(template)) {
@@ -111,7 +110,9 @@ commander
const HTTP_STATUS_OK = 200; const HTTP_STATUS_OK = 200;
if (response.statusCode !== HTTP_STATUS_OK) { 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); exit(-1);
} }
} }

24
src/config/fieldmap.ts
View File

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

14
src/config/premap.ts
View File

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

51
src/config/settings.ts
View File

@@ -15,51 +15,8 @@
import {ElasticsearchSettings} from '../types/mapping'; import {ElasticsearchSettings} from '../types/mapping';
export const settings: ElasticsearchSettings = { export const settings: ElasticsearchSettings = {
analysis: { 'mapping.total_fields.limit': 10_000,
analyzer: { 'max_result_window': 30_000,
ducet_sort: { 'number_of_replicas': 0,
filter: [ 'number_of_shards': 1,
'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,
}; };

4
src/config/typemap.ts
View File

@@ -70,9 +70,9 @@ export const typemap: ElasticsearchTypemap = {
/** /**
* If the string is a tag type * If the string is a tag type
*/ */
export function isTagType(str: string): boolean { export function isTagType(string_: string): boolean {
for (const key in typemap) { 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; return true;
} }
} }

441
src/mapping.ts
View File

@@ -38,7 +38,8 @@ import {
ElasticsearchObject, ElasticsearchObject,
ElasticsearchTemplateCollection, ElasticsearchTemplateCollection,
ElasticsearchType, ElasticsearchType,
ElasticsearchValue, MappingGenTemplate, ElasticsearchValue,
MappingGenTemplate,
} from './types/mapping'; } from './types/mapping';
let dynamicTemplates: ElasticsearchDynamicTemplate[] = []; let dynamicTemplates: ElasticsearchDynamicTemplate[] = [];
@@ -56,7 +57,7 @@ const inheritTagsName = 'inherittags';
const maxErrorObjectChars = 1000; const maxErrorObjectChars = 1000;
let ignoredTagsList = ['indexable', 'validatable', inheritTagsName]; let ignoredTagsList = ['indexable', 'validatable', inheritTagsName];
let inheritTagsMap: { [path: string]: CommentTag[]; } = {}; let inheritTagsMap: {[path: string]: CommentTag[]} = {};
/** /**
* Gets all interfaces that have an @indexable tag * 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 * @param projectReflection the project reflection from which to extract the indexable interfaces
*/ */
export function getAllIndexableInterfaces(projectReflection: ProjectReflection): DeclarationReflection[] { export function getAllIndexableInterfaces(projectReflection: ProjectReflection): DeclarationReflection[] {
let indexableInterfaces: DeclarationReflection[] = []; let indexableInterfaces: DeclarationReflection[] = [];
if (!Array.isArray(projectReflection.children) || projectReflection.children.length === 0) { 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 // push all declaration reflections into one array
projectReflection.children.forEach((declarationReflection) => { for (const declarationReflection of projectReflection.children) {
if (Array.isArray(declarationReflection.children)) { if (Array.isArray(declarationReflection.children)) {
indexableInterfaces = indexableInterfaces.concat(declarationReflection.children); indexableInterfaces = [...indexableInterfaces, ...declarationReflection.children];
} }
}); }
// filter all declaration reflections with an @indexable tag // filter all declaration reflections with an @indexable tag
indexableInterfaces = indexableInterfaces.filter((declarationReflection) => { indexableInterfaces = indexableInterfaces.filter(declarationReflection => {
if ( if (
typeof declarationReflection.comment === 'undefined' || typeof declarationReflection.comment === 'undefined' ||
typeof declarationReflection.comment.tags === 'undefined' typeof declarationReflection.comment.tags === 'undefined'
@@ -87,9 +87,11 @@ export function getAllIndexableInterfaces(projectReflection: ProjectReflection):
return false; return false;
} }
return typeof declarationReflection.comment.tags.find((commentTag) => { return (
return commentTag.tagName === indexableTag; typeof declarationReflection.comment.tags.find(commentTag => {
}) !== 'undefined'; return commentTag.tagName === indexableTag;
}) !== 'undefined'
);
}); });
return indexableInterfaces; return indexableInterfaces;
@@ -104,8 +106,17 @@ export function getAllIndexableInterfaces(projectReflection: ProjectReflection):
* @param object the object or name * @param object the object or name
* @param message the error message * @param message the error message
*/ */
function composeErrorMessage(path: string, topTypeName: string, typeName: string, object: string, message: string) { function composeErrorMessage(
const error = `At "${topTypeName}::${path.substr(0, path.length - 1)}" for ${typeName} "${trimString(object, maxErrorObjectChars)}": ${message}`; 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); errors.push(error);
if (showErrors) { if (showErrors) {
// tslint:disable-next-line:no-floating-promises // 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 * @param maxLength the maximum allowed length before it is clamped
*/ */
function trimString(value: string, maxLength: number): string { function trimString(value: string, maxLength: number): string {
return value.length > maxLength ? return value.length > maxLength ? `${value.slice(0, Math.max(0, maxLength))}...` : value;
`${value.substring(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 path the current path to the object we are in
* @param tags any tags attached to the type * @param tags any tags attached to the type
*/ */
function getReflectionGeneric(type: ReferenceType, function getReflectionGeneric(
out: Map<string, ElasticsearchValue>, type: ReferenceType,
topTypeName: string, out: Map<string, ElasticsearchValue>,
path: string, topTypeName: string,
tags: CommentTag[]): Map<string, ElasticsearchValue> { path: string,
if (typeof type.typeArguments !== 'undefined' tags: CommentTag[],
&& type.reflection instanceof DeclarationReflection ): Map<string, ElasticsearchValue> {
&& typeof type.reflection.typeParameters !== 'undefined') { if (
typeof type.typeArguments !== 'undefined' &&
type.reflection instanceof DeclarationReflection &&
typeof type.reflection.typeParameters !== 'undefined'
) {
for (let i = 0; i < type.reflection.typeParameters.length; i++) { for (let i = 0; i < type.reflection.typeParameters.length; i++) {
if (i < type.typeArguments.length) { if (i < type.typeArguments.length) {
out out.set(
.set(type.reflection.typeParameters[i].name, handleType(type.typeArguments[i], out, topTypeName, path, tags)); type.reflection.typeParameters[i].name,
handleType(type.typeArguments[i], out, topTypeName, path, tags),
);
} else { } else {
// this can happen due to a bug in TypeDoc https://github.com/TypeStrong/typedoc/issues/1061 // 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. // we have no way to know the type here, so we have to use this.
@@ -157,8 +172,10 @@ function getReflectionGeneric(type: ReferenceType,
properties: {}, properties: {},
}); });
Logger.warn(`Type "${type.name}": Defaults of generics (Foo<T = any>) currently don't work due to a bug` + Logger.warn(
` in TypeDoc. It has been replaced by a dynamic type.`); `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 topTypeName the name of the SCThingType
* @param tags any tags attached to the type * @param tags any tags attached to the type
*/ */
function handleExternalType(ref: ReferenceType, generics: Map<string, ElasticsearchValue>, function handleExternalType(
path: string, topTypeName: string, tags: CommentTag[]): ElasticsearchValue { ref: ReferenceType,
generics: Map<string, ElasticsearchValue>,
path: string,
topTypeName: string,
tags: CommentTag[],
): ElasticsearchValue {
for (const premap of Object.keys(premaps)) { for (const premap of Object.keys(premaps)) {
if (premap === ref.name) { if (premap === ref.name) {
return readFieldTags(premaps[premap], path, topTypeName, tags); 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') { if (typeof ref.typeArguments === 'undefined' || typeof ref.typeArguments[0] === 'undefined') {
composeErrorMessage(path, topTypeName, 'Array with generics', 'array', 'Failed to parse'); composeErrorMessage(path, topTypeName, 'Array with generics', 'array', 'Failed to parse');
@@ -194,12 +217,19 @@ function handleExternalType(ref: ReferenceType, generics: Map<string, Elasticsea
return readFieldTags( return readFieldTags(
handleType( handleType(
ref.typeArguments[0], getReflectionGeneric( ref.typeArguments[0],
ref, new Map(generics), path, topTypeName, tags), getReflectionGeneric(ref, new Map(generics), path, topTypeName, tags),
path, topTypeName, tags), path,
path, topTypeName, tags); topTypeName,
tags,
),
path,
topTypeName,
tags,
);
} }
if (ref.name === '__type') { // empty object if (ref.name === '__type') {
// empty object
return { return {
dynamic: 'strict', dynamic: 'strict',
properties: {}, properties: {},
@@ -220,18 +250,23 @@ function handleExternalType(ref: ReferenceType, generics: Map<string, Elasticsea
* @param topTypeName the name of the SCThingType * @param topTypeName the name of the SCThingType
* @param inheritedTags the inherited tags * @param inheritedTags the inherited tags
*/ */
function handleDeclarationReflection(decl: DeclarationReflection, function handleDeclarationReflection(
generics: Map<string, ElasticsearchValue>, decl: DeclarationReflection,
path: string, generics: Map<string, ElasticsearchValue>,
topTypeName: string, path: string,
inheritedTags?: CommentTag[]): topTypeName: string,
ElasticsearchValue { inheritedTags?: CommentTag[],
): ElasticsearchValue {
// check if we have an object referencing a generic // 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 if (generics.has(decl.name)) {
return readFieldTags(generics.get(decl.name) as ElasticsearchObject | ElasticsearchType, path, topTypeName, // if the object name is the same as the generic name
decl.comment?.tags ?? []); return readFieldTags(
generics.get(decl.name) as ElasticsearchObject | ElasticsearchType,
path,
topTypeName,
decl.comment?.tags ?? [],
);
// use the value defined by the generic // use the value defined by the generic
} }
// start the actual handling process // start the actual handling process
@@ -251,7 +286,9 @@ function handleDeclarationReflection(decl: DeclarationReflection,
template[decl.name] = { template[decl.name] = {
mapping: handleType( mapping: handleType(
decl.indexSignature.type, decl.indexSignature.type,
new Map(generics), path, topTypeName, new Map(generics),
path,
topTypeName,
getCommentTags(decl.indexSignature, path, topTypeName), getCommentTags(decl.indexSignature, path, topTypeName),
), ),
match: '*', match: '*',
@@ -270,21 +307,31 @@ function handleDeclarationReflection(decl: DeclarationReflection,
if (typeof decl.children !== 'undefined' && decl.children.length > 0) { if (typeof decl.children !== 'undefined' && decl.children.length > 0) {
for (const child of decl.children) { for (const child of decl.children) {
empty = false; empty = false;
out.properties[child.name] = out.properties[child.name] = handleDeclarationReflection(
handleDeclarationReflection(child, new Map(generics), `${path}${child.name}.`, topTypeName); 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 // get inherited tags
const tags = (inheritedTags ?? []).length > 0 const tags =
? (typeof inheritedTags!.find(it => isTagType(it.tagName)) !== 'undefined' (inheritedTags ?? []).length > 0
? inheritedTags! ? typeof inheritedTags!.find(it => isTagType(it.tagName)) !== 'undefined'
: [...inheritedTags ?? [], ...getCommentTags(decl, path, topTypeName)]) ? inheritedTags!
: getCommentTags(decl, path, topTypeName); : [...(inheritedTags ?? []), ...getCommentTags(decl, path, topTypeName)]
: getCommentTags(decl, path, topTypeName);
return handleType(decl.type, new Map(generics), path, topTypeName, tags); return handleType(decl.type, new Map(generics), path, topTypeName, tags);
} else if (decl.kindString === 'Enumeration member') { } else if (decl.kindString === 'Enumeration member') {
return readTypeTags(typeof decl.defaultValue, path, topTypeName, return readTypeTags(
getCommentTags(decl, path, topTypeName, inheritedTags)); typeof decl.defaultValue,
path,
topTypeName,
getCommentTags(decl, path, topTypeName, inheritedTags),
);
} }
if (empty) { if (empty) {
@@ -315,19 +362,33 @@ function getCommentTags(
return []; return [];
} }
let out: CommentTag[] = decl.comment instanceof Comment ? let out: CommentTag[] =
typeof decl.comment.tags !== 'undefined' ? decl.comment.tags : inheritedTags : inheritedTags; decl.comment instanceof Comment
if (decl.overwrites instanceof ReferenceType && decl.overwrites.reflection instanceof DeclarationReflection) { ? typeof decl.comment.tags !== 'undefined'
? decl.comment.tags
: inheritedTags
: inheritedTags;
if (
decl.overwrites instanceof ReferenceType &&
decl.overwrites.reflection instanceof DeclarationReflection
) {
out = arrayPriorityJoin( 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( 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); saveCommentTags(out, path, topTypeName);
const inheritTag = out.find(((value) => value.tagName === inheritTagsName)); const inheritTag = out.find(value => value.tagName === inheritTagsName);
if (typeof inheritTag !== 'undefined') { if (typeof inheritTag !== 'undefined') {
out = arrayPriorityJoin(out, retrieveCommentTags(inheritTag.text.trim(), path, topTypeName)); out = arrayPriorityJoin(out, retrieveCommentTags(inheritTag.text.trim(), path, topTypeName));
} }
@@ -343,8 +404,9 @@ function getCommentTags(
* @param topTypeName the name of the SCThingType * @param topTypeName the name of the SCThingType
*/ */
function saveCommentTags(tags: CommentTag[], path: string, topTypeName: string) { function saveCommentTags(tags: CommentTag[], path: string, topTypeName: string) {
inheritTagsMap[`${topTypeName}::${path.substr(0, path.length - 1)}`] = inheritTagsMap[`${topTypeName}::${path.slice(0, Math.max(0, path.length - 1))}`] = tags.filter(
tags.filter(((value) => value.tagName !== 'see' && value.tagName !== inheritTagsName)); 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[] { function arrayPriorityJoin(originals: CommentTag[], overrider: CommentTag[]): CommentTag[] {
const out: CommentTag[] = overrider; const out: CommentTag[] = overrider;
originals.forEach((original) => { for (const original of originals) {
const result = overrider.find((element) => original.tagName === element.tagName); const result = overrider.find(element => original.tagName === element.tagName);
// no support for multiple tags with the same name // no support for multiple tags with the same name
if (!(result instanceof CommentTag)) { if (!(result instanceof CommentTag)) {
out.push(original); out.push(original);
} }
}); }
return out; return out;
} }
@@ -397,11 +459,13 @@ function arrayPriorityJoin(originals: CommentTag[], overrider: CommentTag[]): Co
* @param topTypeName the name of the SCThingType * @param topTypeName the name of the SCThingType
* @param tags any tags attached to the type * @param tags any tags attached to the type
*/ */
function handleUnionType(type: UnionType, function handleUnionType(
generics: Map<string, ElasticsearchValue>, type: UnionType,
path: string, generics: Map<string, ElasticsearchValue>,
topTypeName: string, path: string,
tags: CommentTag[]): ElasticsearchValue { topTypeName: string,
tags: CommentTag[],
): ElasticsearchValue {
const list: ElasticsearchValue[] = []; const list: ElasticsearchValue[] = [];
for (const subType of type.types) { for (const subType of type.types) {
@@ -421,8 +485,13 @@ function handleUnionType(type: UnionType,
return out; return out;
} }
composeErrorMessage(path, topTypeName, 'Union Type', stringify(list), composeErrorMessage(
'Empty union type. This is likely not a user error.'); path,
topTypeName,
'Union Type',
stringify(list),
'Empty union type. This is likely not a user error.',
);
return {type: ElasticsearchDataType.parse_error}; return {type: ElasticsearchDataType.parse_error};
} }
@@ -436,37 +505,50 @@ function handleUnionType(type: UnionType,
* @param topTypeName the name of the SCThingType * @param topTypeName the name of the SCThingType
* @param tags any tags attached to the type * @param tags any tags attached to the type
*/ */
function handleType(type: Type, generics: Map<string, ElasticsearchValue>, path: string, topTypeName: string, function handleType(
tags: CommentTag[]): type: Type,
ElasticsearchValue { generics: Map<string, ElasticsearchValue>,
path: string,
topTypeName: string,
tags: CommentTag[],
): ElasticsearchValue {
// logger.log((type as any).name); // 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); const esType = handleType(type.elementType, new Map(generics), path, topTypeName, tags);
// also merge tags of the array to the element type // 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" // filter out the type tags lazily, this can lead to double messages for "Not implemented tag"
let newTags = tags; let newTags = tags;
if ('type' in esType) { if ('type' in esType) {
newTags = tags.filter((tag) => { newTags = tags.filter(tag => {
return !(tag.tagName === esType.type); return !(tag.tagName === esType.type);
}); });
} }
return readFieldTags(esType, path, topTypeName, newTags); 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); 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); 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); return handleUnionType(type, new Map(generics), path, topTypeName, tags);
} }
if (type instanceof ReferenceType) { if (type instanceof ReferenceType) {
if (typeof premaps[type.name] === 'undefined' && typeof type.reflection !== 'undefined') { 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. // there is really no way to make this typesafe, every element in DeclarationReflection is optional.
return handleDeclarationReflection(type.reflection as DeclarationReflection, return handleDeclarationReflection(
getReflectionGeneric(type, new Map(generics), path, topTypeName, tags), path, topTypeName, tags); type.reflection as DeclarationReflection,
getReflectionGeneric(type, new Map(generics), path, topTypeName, tags),
path,
topTypeName,
tags,
);
} }
return handleExternalType(type, new Map(generics), 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!'); composeErrorMessage(path, topTypeName, 'Generic', type.name, 'Missing reflection, please report!');
return {type: ElasticsearchDataType.parse_error}; return {type: ElasticsearchDataType.parse_error};
} }
if (type instanceof ReflectionType) { if (type instanceof ReflectionType) {
return readFieldTags(handleDeclarationReflection(type.declaration, new Map(generics), path, topTypeName), return readFieldTags(
path, topTypeName, tags); handleDeclarationReflection(type.declaration, new Map(generics), path, topTypeName),
path,
topTypeName,
tags,
);
} }
composeErrorMessage(path, topTypeName, 'type', stringify(type), 'Not implemented type'); 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 // push type.path and remove the '.' at the end of the path
if (global) { if (global) {
const prop = path.slice(0, -1) const property_ = path.slice(0, -1).split('.').pop() as string; // cannot be undefined
.split('.')
.pop() as string; // cannot be undefined
return (aggregations['@all'] as ESNestedAggregation).aggs[prop.split('.') return ((aggregations['@all'] as ESNestedAggregation).aggs[property_.split('.').pop() as string] = {
.pop() as string] = {
terms: { terms: {
field: `${prop}.raw`, field: `${property_}.raw`,
size: 1000, size: 1000,
}, },
}; });
} }
const property = path.slice(0, -1); const property = path.slice(0, -1);
return (aggregations[topTypeName] as ESNestedAggregation).aggs[property] = { return ((aggregations[topTypeName] as ESNestedAggregation).aggs[property] = {
terms: { terms: {
field: `${property}.raw`, field: `${property}.raw`,
size: 1000, size: 1000,
}, },
}; });
} }
/** /**
* Reads all tags related to Elasticsearch fields from the fieldMap * 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 path the current path to the object we are in
* @param topTypeName the name of the SCThingType * @param topTypeName the name of the SCThingType
* @param tags tags attached to the value * @param tags tags attached to the value
* @param dataType the ElasticsearchDataType, for checking if a tag is a type tag * @param dataType the ElasticsearchDataType, for checking if a tag is a type tag
*/ */
function readFieldTags(prev: ElasticsearchValue, function readFieldTags(
path: string, previous: ElasticsearchValue,
topTypeName: string, path: string,
tags: CommentTag[], topTypeName: string,
dataType?: string): ElasticsearchValue { tags: CommentTag[],
dataType?: string,
): ElasticsearchValue {
for (const tag of tags) { for (const tag of tags) {
if (tag.tagName === aggregatableTag) { if (tag.tagName === aggregatableTag) {
addAggregatable(path, topTypeName, tag.text.trim() === aggregatableTagParameterGlobal); addAggregatable(path, topTypeName, tag.text.trim() === aggregatableTagParameterGlobal);
@@ -546,31 +630,43 @@ function readFieldTags(prev: ElasticsearchValue,
if (!ignoredTagsList.includes(tag.tagName)) { if (!ignoredTagsList.includes(tag.tagName)) {
if (typeof fieldmap[tag.tagName] !== 'undefined') { if (typeof fieldmap[tag.tagName] !== 'undefined') {
if (typeof prev.fields === 'undefined') { if (typeof previous.fields === 'undefined') {
// create in case it doesn't exist // create in case it doesn't exist
prev.fields = {}; previous.fields = {};
} }
if (tag.text.trim() === '') { if (tag.text.trim() === '') {
// merge fields // 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') { } else if (typeof fieldmap[tag.tagName][tag.text.trim()] !== 'undefined') {
// merge fields // 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())) { } else if (!fieldmap[tag.tagName].ignore.includes(tag.text.trim())) {
// when there is an unidentified tag // 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) { } else if (tag.tagName === filterableTagName) {
if (typeof prev.fields === 'undefined') { if (typeof previous.fields === 'undefined') {
prev.fields = {}; previous.fields = {};
} }
if ('type' in prev) { if ('type' in previous) {
const type = filterableMap[prev.type]; const type = filterableMap[previous.type];
if (typeof type !== 'undefined') { if (typeof type !== 'undefined') {
// merge fields // merge fields
prev.fields = {...prev.fields, ...{raw: {type: type}}}; previous.fields = {...previous.fields, raw: {type: type}};
} else { } else {
composeErrorMessage(path, topTypeName, 'tag', tag.tagName, `Not implemented for ${prev.type}`); composeErrorMessage(
path,
topTypeName,
'tag',
tag.tagName,
`Not implemented for ${previous.type}`,
);
} }
} else { } else {
composeErrorMessage(path, topTypeName, 'tag', tag.tagName, 'Not applicable for object types'); 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 topTypeName the name of the SCThingType
* @param tags tags attached to the value * @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}; 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--) { 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 we have a tag that indicates a type
if (out.type !== ElasticsearchDataType.parse_error) { if (out.type !== ElasticsearchDataType.parse_error) {
composeErrorMessage(path, topTypeName, 'type', type, composeErrorMessage(
`Type conflict; "${typemap[type][tags[i].tagName]}" would override "${out.type}"`); path,
topTypeName,
'type',
type,
`Type conflict; "${typemap[type][tags[i].tagName]}" would override "${out.type}"`,
);
out.type = ElasticsearchDataType.type_conflict; out.type = ElasticsearchDataType.type_conflict;
continue; continue;
} }
@@ -617,7 +727,8 @@ function readTypeTags(type: string, path: string, topTypeName: string, tags: Com
return out; 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 { return {
dynamic: true, dynamic: true,
properties: {}, properties: {},
@@ -666,15 +777,18 @@ function reset(resetInheritTags = true) {
* @param showErrorOutput whether to print all errors in the command line or not * @param showErrorOutput whether to print all errors in the command line or not
* @param interfaceFilter only parse specific interfaces, this is for testing purposes * @param interfaceFilter only parse specific interfaces, this is for testing purposes
*/ */
export function generateTemplate(projectReflection: ProjectReflection, export function generateTemplate(
ignoredTags: string[], projectReflection: ProjectReflection,
showErrorOutput = true, ignoredTags: string[],
interfaceFilter: string[] = []): MappingGenTemplate { showErrorOutput = true,
interfaceFilter: string[] = [],
): MappingGenTemplate {
reset(); reset();
showErrors = showErrorOutput; showErrors = showErrorOutput;
ignoredTagsList = ['indexable', 'validatable', inheritTagsName]; ignoredTagsList = ['indexable', 'validatable', inheritTagsName];
// eslint-disable-next-line prefer-spread
ignoredTagsList.push.apply(ignoredTagsList, ignoredTags); ignoredTagsList.push.apply(ignoredTagsList, ignoredTags);
const indexableInterfaces = getAllIndexableInterfaces(projectReflection); 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'); 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'; return declarationReflection.name === 'type';
}); });
if (typeof typeObject === 'undefined' || typeof typeObject.type === 'undefined') { 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'; let typeName = 'INVALID_TYPE';
if (typeObject.type instanceof ReferenceType) { if (typeObject.type instanceof ReferenceType) {
if (typeObject.type.reflection instanceof DeclarationReflection if (
&& typeof typeObject.type.reflection.defaultValue === 'string') { typeObject.type.reflection instanceof DeclarationReflection &&
typeName = typeObject.type.reflection.defaultValue.replace('"', '') typeof typeObject.type.reflection.defaultValue === 'string'
.replace('"', ''); ) {
typeName = typeObject.type.reflection.defaultValue.replace('"', '').replace('"', '');
} else { } else {
// tslint:disable-next-line:no-floating-promises // 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) { } else if (typeObject.type instanceof StringLiteralType) {
Logger.warn(`The interface ${_interface.name} uses a string literal as type, please use SCThingType.`); Logger.warn(`The interface ${_interface.name} uses a string literal as type, please use SCThingType.`);
typeName = typeObject.type.value; typeName = typeObject.type.value;
} else { } else {
// tslint:disable-next-line:no-floating-promises // 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 // init aggregation schema for type
aggregations[typeName] = { aggregations[typeName] = {
aggs: {}, aggs: {},
filter: { filter: {
type: { term: {
value: typeName, type: typeName,
}, },
}, },
}; };
@@ -732,45 +851,48 @@ export function generateTemplate(projectReflection: ProjectReflection,
throw new Error('Interface needs at least some properties to be indexable'); 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'; return declarationReflection.name === 'type';
}); });
if (typeof typeObject === 'undefined' || typeof typeObject.type === 'undefined') { 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'; let typeName = 'INVALID_TYPE';
if (typeObject.type instanceof ReferenceType) { if (typeObject.type instanceof ReferenceType) {
if (typeObject.type.reflection instanceof DeclarationReflection if (
&& typeof typeObject.type.reflection.defaultValue === 'string') { typeObject.type.reflection instanceof DeclarationReflection &&
typeName = typeObject.type.reflection.defaultValue.replace('"', '') typeof typeObject.type.reflection.defaultValue === 'string'
.replace('"', ''); ) {
typeName = typeObject.type.reflection.defaultValue.replace('"', '').replace('"', '');
} else { } else {
// tslint:disable-next-line:no-floating-promises // 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) { } else if (typeObject.type instanceof StringLiteralType) {
Logger.warn(`The interface ${_interface.name} uses a string literal as type, please use SCThingType.`); Logger.warn(`The interface ${_interface.name} uses a string literal as type, please use SCThingType.`);
typeName = typeObject.type.value; typeName = typeObject.type.value;
} else { } else {
// tslint:disable-next-line:no-floating-promises // 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 // filter out
if (interfaceFilter.length !== 0) { if (interfaceFilter.length > 0 && typeof interfaceFilter.find(it => it === typeName) === 'undefined') {
if (typeof interfaceFilter.find((it) => it === typeName) === 'undefined') { continue;
continue;
}
} }
// init aggregation schema for type // init aggregation schema for type
aggregations[typeName] = { aggregations[typeName] = {
aggs: {}, aggs: {},
filter: { filter: {
type: { term: {
value: typeName, type: typeName,
}, },
}, },
}; };
@@ -782,26 +904,21 @@ export function generateTemplate(projectReflection: ProjectReflection,
const templateName = `template_${typeNameWithoutSpaces}`; const templateName = `template_${typeNameWithoutSpaces}`;
out[templateName] = { out[templateName] = {
mappings: { mappings: handleDeclarationReflection(_interface, new Map(), '', typeName) as ElasticsearchObject,
[typeName]: handleDeclarationReflection(_interface, new Map(), '', typeName) as ElasticsearchObject,
},
settings: settings, settings: settings,
template: `stapps_${typeNameWithoutSpaces}*`, index_patterns: [`stapps_${typeNameWithoutSpaces}*`],
} };
; out[templateName].mappings.properties.creation_date = {
out[templateName].mappings[typeName].properties.creation_date = {
type: ElasticsearchDataType.date, type: ElasticsearchDataType.date,
}; };
out[templateName].mappings[typeName].dynamic_templates = dynamicTemplates; out[templateName].mappings.dynamic_templates = dynamicTemplates;
// Set some properties // Set some properties
out[templateName].mappings[typeName]._source = { out[templateName].mappings._source = {
excludes: [ excludes: ['creation_date'],
'creation_date',
],
}; };
out[templateName].mappings[typeName].date_detection = false; out[templateName].mappings.date_detection = false;
dynamicTemplates = []; dynamicTemplates = [];

28
src/project-reflection.ts
View File

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

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

@@ -15,6 +15,7 @@
/** /**
* An elasticsearch bucket aggregation * An elasticsearch bucket aggregation
*
* @see https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-aggregations-bucket.html * @see https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-aggregations-bucket.html
*/ */
export interface AggregationSchema { export interface AggregationSchema {
@@ -48,11 +49,11 @@ export interface ESAggTypeFilter {
/** /**
* The type of the object to find * The type of the object to find
*/ */
type: { term: {
/** /**
* The name of the type * The name of the type
*/ */
value: string; type: string;
}; };
} }
@@ -63,7 +64,7 @@ export interface ESAggMatchAllFilter {
/** /**
* Filter that matches everything * 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 * Copyright (C) 2019-2021 StApps
* This program is free software: you can redistribute it and/or modify it * 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 * https://www.elastic.co/guide/en/elasticsearch/reference/5.6/object.html
*/ */
export interface ElasticsearchObject { export interface ElasticsearchObject {
/** /**
* Only for the top type * Only for the top type
*/ */
@@ -227,9 +227,7 @@ export interface ElasticsearchObject {
/** /**
* Fields that should be excluded in the _source field * Fields that should be excluded in the _source field
*/ */
excludes: [ excludes: ['creation_date'];
'creation_date'
];
}; };
/** /**
@@ -291,22 +289,20 @@ export interface ElasticsearchTemplateCollection {
* This is what you pass to Elasticsearch * This is what you pass to Elasticsearch
*/ */
export interface ElasticsearchTemplate { 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 * This is a pre-defined structure you should use for your mapping
*/ */
mappings: { mappings: ElasticsearchObject;
[typeName: string]: ElasticsearchObject;
};
/** /**
* The settings for Elasticsearch * The settings for Elasticsearch
*/ */
settings: ElasticsearchSettings; 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 * https://www.elastic.co/guide/en/elasticsearch/reference/5.6/analysis-analyzers.html
*/ */
analysis: { analysis?: {
[name: string]: any; [name: string]: any;
}; };
} }

23
test/aggregations.spec.ts
View File

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

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

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

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

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

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

@@ -14,7 +14,7 @@
*/ */
import {ThingType} from './types'; import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
/** /**
* @indexable * @indexable
@@ -23,7 +23,6 @@ export interface AggInheritedGlobal extends Foo {
type: ThingType.AggInheritedGlobal; type: ThingType.AggInheritedGlobal;
} }
interface Foo { interface Foo {
/** /**
* @aggregatable global * @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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
/** /**
* @indexable * @indexable
@@ -28,7 +28,6 @@ export interface AggInherited extends Foo {
type: ThingType.AggInheritedOverwritten; type: ThingType.AggInheritedOverwritten;
} }
interface Foo { interface Foo {
/** /**
* @aggregatable * @aggregatable

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

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

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

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

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

@@ -14,17 +14,18 @@
*/ */
import {ThingType} from './types'; import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
/** /**
* @indexable * @indexable
*/ */
export interface AnyUnknown { export interface AnyUnknown {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
foo: any; foo: any;
bar: unknown; bar: unknown;
type: ThingType.AnyUnknown type: ThingType.AnyUnknown;
} }
export const testConfig: MapAggTestOptions = { export const testConfig: MapAggTestOptions = {
@@ -34,12 +35,12 @@ export const testConfig: MapAggTestOptions = {
maps: { maps: {
foo: { foo: {
dynamic: true, dynamic: true,
properties: {} properties: {},
}, },
bar: { bar: {
dynamic: true, 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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
* @date * @date
*/ */
export type SCISO8601Date = string export type SCISO8601Date = string;
/** /**
* @indexable * @indexable
@@ -33,7 +33,7 @@ export interface DateAndRange {
dateAlias: SCISO8601Date; dateAlias: SCISO8601Date;
type: ThingType.Date type: ThingType.Date;
} }
export const testConfig: MapAggTestOptions = { export const testConfig: MapAggTestOptions = {
@@ -47,6 +47,6 @@ export const testConfig: MapAggTestOptions = {
dateAlias: { dateAlias: {
type: ElasticsearchDataType.date, 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 {ElasticsearchDataType} from '../../../../src/config/typemap';
import {ThingType} from './types'; import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
/** /**
* @indexable * @indexable
@@ -39,13 +39,11 @@ export const testConfig: MapAggTestOptions = {
dynamic: 'strict', dynamic: 'strict',
properties: { properties: {
bar: { bar: {
type: ElasticsearchDataType.parse_error type: ElasticsearchDataType.parse_error,
} },
} },
} },
} },
}, },
err: [ err: [`At "${ThingType.DefaultGeneric}::foo.bar" for Generic "T": Missing reflection, please report!`],
`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 {ElasticsearchDataType} from '../../../../src/config/typemap';
import {ThingType} from './types'; import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
/** /**
* @indexable * @indexable
@@ -42,15 +42,15 @@ export const testConfig: MapAggTestOptions = {
map: { map: {
maps: { maps: {
stringDoubleTypeConflict: { stringDoubleTypeConflict: {
type: ElasticsearchDataType.type_conflict type: ElasticsearchDataType.type_conflict,
}, },
numberDoubleTypeConflict: { numberDoubleTypeConflict: {
type: ElasticsearchDataType.type_conflict type: ElasticsearchDataType.type_conflict,
} },
} },
}, },
err: [ err: [
`At "${ThingType.DoubleTypeConflict}::stringDoubleTypeConflict" for type "string": Type conflict; "keyword" would override "text"`, `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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
* @indexable * @indexable
*/ */
export interface Enum { export interface Enum {
foo: Bar, foo: Bar;
bar: Baz, bar: Baz;
type: ThingType.Enum; type: ThingType.Enum;
} }
@@ -36,6 +36,7 @@ enum Bar {
enum Baz { enum Baz {
d = 'd', d = 'd',
// eslint-disable-next-line unicorn/prevent-abbreviations
e = 'e', e = 'e',
f = 'f', f = 'f',
} }
@@ -48,11 +49,11 @@ export const testConfig: MapAggTestOptions = {
map: { map: {
maps: { maps: {
foo: { foo: {
type: ElasticsearchDataType.text type: ElasticsearchDataType.text,
}, },
bar: { 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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
export type FilterableEnumType = 'a' | 'b' | 'c'; export type FilterableEnumType = 'a' | 'b' | 'c';
@@ -38,14 +38,14 @@ export interface FilterableTag {
/** /**
* @filterable * @filterable
*/ */
baz: 'some literal' baz: 'some literal';
/** /**
* @filterable * @filterable
*/ */
buz: FilterableEnumType buz: FilterableEnumType;
type: ThingType.FilterableTag type: ThingType.FilterableTag;
} }
export const testConfig: MapAggTestOptions = { export const testConfig: MapAggTestOptions = {
@@ -57,34 +57,34 @@ export const testConfig: MapAggTestOptions = {
type: ElasticsearchDataType.text, type: ElasticsearchDataType.text,
fields: { fields: {
raw: { raw: {
type: ElasticsearchDataType.keyword type: ElasticsearchDataType.keyword,
} },
} },
}, },
bar: { bar: {
type: ElasticsearchDataType.keyword, type: ElasticsearchDataType.keyword,
fields: { fields: {
raw: { raw: {
type: ElasticsearchDataType.keyword type: ElasticsearchDataType.keyword,
} },
} },
}, },
baz: { baz: {
type: ElasticsearchDataType.keyword, type: ElasticsearchDataType.keyword,
fields: { fields: {
raw: { raw: {
type: ElasticsearchDataType.keyword type: ElasticsearchDataType.keyword,
} },
} },
}, },
buz: { buz: {
type: ElasticsearchDataType.keyword, type: ElasticsearchDataType.keyword,
fields: { fields: {
raw: { 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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
@@ -22,7 +22,7 @@ import {ElasticsearchDataType} from '../../../../src/config/typemap';
*/ */
export interface Generics { export interface Generics {
foo: InterfaceWithDefaultGeneric<number>; foo: InterfaceWithDefaultGeneric<number>;
baz: InterfaceWithStringGeneric<string> baz: InterfaceWithStringGeneric<string>;
type: ThingType.Generics; type: ThingType.Generics;
} }
@@ -44,18 +44,18 @@ export const testConfig: MapAggTestOptions = {
dynamic: 'strict', dynamic: 'strict',
properties: { properties: {
bar: { bar: {
type: ElasticsearchDataType.integer type: ElasticsearchDataType.integer,
} },
} },
}, },
baz: { baz: {
dynamic: 'strict', dynamic: 'strict',
properties: { properties: {
bar: { 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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
@@ -23,7 +23,7 @@ import {ElasticsearchDataType} from '../../../../src/config/typemap';
export interface ImpossibleUnion { export interface ImpossibleUnion {
foo: 'a' | 1 | boolean; foo: 'a' | 1 | boolean;
type: ThingType.ImpossibleUnion type: ThingType.ImpossibleUnion;
} }
export const testConfig: MapAggTestOptions = { export const testConfig: MapAggTestOptions = {
@@ -32,11 +32,11 @@ export const testConfig: MapAggTestOptions = {
map: { map: {
maps: { maps: {
foo: { foo: {
type: ElasticsearchDataType.boolean type: ElasticsearchDataType.boolean,
} },
} },
}, },
err: [ 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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
@@ -41,7 +41,6 @@ export interface DoubleTypeConflict {
*/ */
floatString: string; floatString: string;
type: ThingType.IncompatibleType; type: ThingType.IncompatibleType;
} }
@@ -51,23 +50,23 @@ export const testConfig: MapAggTestOptions = {
map: { map: {
maps: { maps: {
keywordNumber: { keywordNumber: {
type: ElasticsearchDataType.integer type: ElasticsearchDataType.integer,
}, },
textNumber: { textNumber: {
type: ElasticsearchDataType.integer type: ElasticsearchDataType.integer,
}, },
integerString: { integerString: {
type: ElasticsearchDataType.text type: ElasticsearchDataType.text,
}, },
floatString: { floatString: {
type: ElasticsearchDataType.text type: ElasticsearchDataType.text,
} },
} },
}, },
err: [ err: [
`At "${ThingType.IncompatibleType}::keywordNumber" for tag "keyword": Not implemented tag`, `At "${ThingType.IncompatibleType}::keywordNumber" for tag "keyword": Not implemented tag`,
`At "${ThingType.IncompatibleType}::textNumber" for tag "text": 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}::floatString" for tag "float": Not implemented tag`,
`At "${ThingType.IncompatibleType}::integerString" for tag "integer": 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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
@@ -25,8 +25,8 @@ export interface IndexSignature {
[key: string]: { [key: string]: {
bar: number; bar: number;
baz: string; baz: string;
} };
} };
type: ThingType.IndexSignature; type: ThingType.IndexSignature;
} }
@@ -38,8 +38,8 @@ export const testConfig: MapAggTestOptions = {
maps: { maps: {
foo: { foo: {
dynamic: true, dynamic: true,
properties: {} properties: {},
} },
}, },
dynamicTemplates: [ dynamicTemplates: [
{ {
@@ -48,18 +48,18 @@ export const testConfig: MapAggTestOptions = {
dynamic: 'strict', dynamic: 'strict',
properties: { properties: {
bar: { bar: {
type: ElasticsearchDataType.integer type: ElasticsearchDataType.integer,
}, },
baz: { baz: {
type: ElasticsearchDataType.text type: ElasticsearchDataType.text,
} },
} },
}, },
match: '*', match: '*',
match_mapping_type: '*', 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 {ElasticsearchDataType} from '../../../../src/config/typemap';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ThingType} from './types'; import {ThingType} from './types';
/** /**
@@ -36,7 +36,7 @@ export interface InferredTypeFilterable {
*/ */
bar: SCISO8601Date; bar: SCISO8601Date;
type: ThingType.InferredTypeFilterable type: ThingType.InferredTypeFilterable;
} }
export const testConfig: MapAggTestOptions = { export const testConfig: MapAggTestOptions = {
@@ -49,12 +49,12 @@ export const testConfig: MapAggTestOptions = {
fields: { fields: {
raw: { raw: {
type: ElasticsearchDataType.keyword, type: ElasticsearchDataType.keyword,
} },
} },
}, },
bar: { bar: {
type: ElasticsearchDataType.date, 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 {ElasticsearchDataType} from '../../../../src/config/typemap';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ThingType} from './types'; import {ThingType} from './types';
/** /**
@@ -24,14 +24,14 @@ export interface InheritTags {
/** /**
* @inheritTags inherit tags::bar.baz * @inheritTags inherit tags::bar.baz
*/ */
foo: number, foo: number;
bar: { bar: {
/** /**
* @float * @float
*/ */
baz: number baz: number;
} };
type: ThingType.InheritTags; type: ThingType.InheritTags;
} }
@@ -42,16 +42,16 @@ export const testConfig: MapAggTestOptions = {
map: { map: {
maps: { maps: {
foo: { foo: {
type: ElasticsearchDataType.float type: ElasticsearchDataType.float,
}, },
bar: { bar: {
dynamic: 'strict', dynamic: 'strict',
properties: { properties: {
baz: { 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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
* @indexable * @indexable
*/ */
export interface InheritedProperty extends Bar{ export interface InheritedProperty extends Bar {
foo: number, foo: number;
type: ThingType.InheritedProperty; type: ThingType.InheritedProperty;
} }
@@ -44,14 +44,14 @@ export const testConfig: MapAggTestOptions = {
map: { map: {
maps: { maps: {
foo: { foo: {
type: ElasticsearchDataType.integer type: ElasticsearchDataType.integer,
}, },
bar: { bar: {
type: ElasticsearchDataType.keyword type: ElasticsearchDataType.keyword,
}, },
baz: { 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 * Copyright (C) 2020 StApps
* This program is free software: you can redistribute it and/or modify it * This program is free software: you can redistribute it and/or modify it
@@ -14,7 +15,7 @@
*/ */
import {ThingType} from './types'; import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
@@ -35,11 +36,9 @@ export const testConfig: MapAggTestOptions = {
map: { map: {
maps: { maps: {
foo: { foo: {
type: ElasticsearchDataType.text type: ElasticsearchDataType.text,
} },
} },
}, },
err: [ err: [`At "${ThingType.InvalidTag}::foo" for tag "aninvalidtag": Not implemented tag`],
`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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
@@ -44,12 +44,12 @@ export interface MapExplicitTypes {
/** /**
* @date * @date
*/ */
esEpochMsDate: number esEpochMsDate: number;
/** /**
* @date * @date
*/ */
esStringDate: string esStringDate: string;
type: ThingType.MapExplicitTypes; type: ThingType.MapExplicitTypes;
} }
@@ -60,23 +60,23 @@ export const testConfig: MapAggTestOptions = {
map: { map: {
maps: { maps: {
esInteger: { esInteger: {
type: ElasticsearchDataType.integer type: ElasticsearchDataType.integer,
}, },
esFloat: { esFloat: {
type: ElasticsearchDataType.float type: ElasticsearchDataType.float,
}, },
esKeyword: { esKeyword: {
type: ElasticsearchDataType.keyword type: ElasticsearchDataType.keyword,
}, },
esText: { esText: {
type: ElasticsearchDataType.text type: ElasticsearchDataType.text,
}, },
esEpochMsDate: { esEpochMsDate: {
type: ElasticsearchDataType.date type: ElasticsearchDataType.date,
}, },
esStringDate: { 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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
@@ -35,11 +35,9 @@ export const testConfig: MapAggTestOptions = {
map: { map: {
maps: { maps: {
foo: { foo: {
type: ElasticsearchDataType.missing_premap type: ElasticsearchDataType.missing_premap,
} },
} },
}, },
err: [ err: [`At "${ThingType.MissingPremap}::foo" for external type "HTMLAllCollection": Missing pre-map`],
`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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
@@ -29,10 +29,10 @@ export interface Nested {
* @keyword * @keyword
*/ */
depth3_2: string; depth3_2: string;
} };
depth2_2: boolean; depth2_2: boolean;
} };
} };
type: ThingType.Nested; type: ThingType.Nested;
} }
@@ -52,20 +52,20 @@ export const testConfig: MapAggTestOptions = {
dynamic: 'strict', dynamic: 'strict',
properties: { properties: {
depth3_1: { depth3_1: {
type: ElasticsearchDataType.integer type: ElasticsearchDataType.integer,
}, },
depth3_2: { depth3_2: {
type: ElasticsearchDataType.keyword type: ElasticsearchDataType.keyword,
} },
} },
}, },
depth2_2: { 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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
@@ -23,7 +23,7 @@ import {ElasticsearchDataType} from '../../../../src/config/typemap';
export interface ObjectUnion { export interface ObjectUnion {
foo: Boo | Buu; foo: Boo | Buu;
type: ThingType.ObjectUnion type: ThingType.ObjectUnion;
} }
// we can't name them Bar or Baz, look here for more info: // we can't name them Bar or Baz, look here for more info:
@@ -49,16 +49,16 @@ export const testConfig: MapAggTestOptions = {
dynamic: 'strict', dynamic: 'strict',
properties: { properties: {
a: { a: {
type: ElasticsearchDataType.boolean type: ElasticsearchDataType.boolean,
}, },
b: { b: {
type: ElasticsearchDataType.integer type: ElasticsearchDataType.integer,
}, },
intersection: { 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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
@@ -46,23 +46,24 @@ export const testConfig: MapAggTestOptions = {
type: ElasticsearchDataType.keyword, type: ElasticsearchDataType.keyword,
fields: { fields: {
raw: { raw: {
type: ElasticsearchDataType.keyword type: ElasticsearchDataType.keyword,
} },
} },
}, },
bar: { bar: {
type: ElasticsearchDataType.text, type: ElasticsearchDataType.text,
fields: { fields: {
raw: { raw: {
type: ElasticsearchDataType.keyword type: ElasticsearchDataType.keyword,
}, },
sort: { sort: {
analyzer: 'ducet_sort', country: 'DE',
fielddata: true, language: 'de',
type: ElasticsearchDataType.text 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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
@@ -37,23 +37,23 @@ export const testConfig: MapAggTestOptions = {
map: { map: {
maps: { maps: {
numberDefault: { numberDefault: {
type: ElasticsearchDataType.integer type: ElasticsearchDataType.integer,
}, },
stringDefault: { stringDefault: {
type: ElasticsearchDataType.text type: ElasticsearchDataType.text,
}, },
booleanDefault: { booleanDefault: {
type: ElasticsearchDataType.boolean type: ElasticsearchDataType.boolean,
}, },
stringLiteralDefault: { stringLiteralDefault: {
type: ElasticsearchDataType.keyword type: ElasticsearchDataType.keyword,
}, },
booleanTrueLiteralDefault: { booleanTrueLiteralDefault: {
type: ElasticsearchDataType.boolean type: ElasticsearchDataType.boolean,
}, },
booleanFalseLiteralDefault: { 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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
@@ -36,7 +36,7 @@ export interface SortableTag {
*/ */
baz: number; baz: number;
type: ThingType.SortableTag type: ThingType.SortableTag;
} }
export const testConfig: MapAggTestOptions = { export const testConfig: MapAggTestOptions = {
@@ -48,32 +48,35 @@ export const testConfig: MapAggTestOptions = {
type: ElasticsearchDataType.text, type: ElasticsearchDataType.text,
fields: { fields: {
sort: { sort: {
analyzer: 'ducet_sort', country: 'DE',
fielddata: true, language: 'de',
type: 'text' type: 'icu_collation_keyword',
} variant: '@collation=phonebook',
} },
},
}, },
bar: { bar: {
type: ElasticsearchDataType.text, type: ElasticsearchDataType.text,
fields: { fields: {
sort: { sort: {
analyzer: 'ducet_sort', country: 'DE',
fielddata: true, language: 'de',
type: 'text' type: 'icu_collation_keyword',
} variant: '@collation=phonebook',
} },
},
}, },
baz: { baz: {
type: ElasticsearchDataType.integer, type: ElasticsearchDataType.integer,
fields: { fields: {
sort: { sort: {
analyzer: 'ducet_sort', country: 'DE',
fielddata: true, language: 'de',
type: 'text' 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/>. * this program. If not, see <https://www.gnu.org/licenses/>.
*/ */
import {ThingType} from './types'; import {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
@@ -23,19 +23,19 @@ export interface TagsIgnoreCase {
/** /**
* @inheritTags inherit tags::bar.baz * @inheritTags inherit tags::bar.baz
*/ */
camelCase: number, camelCase: number;
/** /**
* @inherittags inherit tags::bar.baz * @inheritTags inherit tags::bar.baz
*/ */
lowerCase: number, lowerCase: number;
bar: { bar: {
/** /**
* @float * @float
*/ */
baz: number baz: number;
} };
type: ThingType.TagsIgnoreCase; type: ThingType.TagsIgnoreCase;
} }
@@ -46,19 +46,19 @@ export const testConfig: MapAggTestOptions = {
map: { map: {
maps: { maps: {
camelCase: { camelCase: {
type: ElasticsearchDataType.float type: ElasticsearchDataType.float,
}, },
lowerCase: { lowerCase: {
type: ElasticsearchDataType.float type: ElasticsearchDataType.float,
}, },
bar: { bar: {
dynamic: 'strict', dynamic: 'strict',
properties: { properties: {
baz: { 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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
@@ -24,17 +24,17 @@ export interface TypeAlias {
/** /**
* *
*/ */
textProperty: ATextAlias, textProperty: ATextAlias;
/** /**
* *
*/ */
keywordProperty: AKeywordAlias, keywordProperty: AKeywordAlias;
/** /**
* @keyword * @keyword
*/ */
overriddenTextAsKeyword: ATextAlias overriddenTextAsKeyword: ATextAlias;
type: ThingType.TypeAlias; type: ThingType.TypeAlias;
} }
@@ -63,6 +63,6 @@ export const testConfig: MapAggTestOptions = {
overriddenTextAsKeyword: { overriddenTextAsKeyword: {
type: ElasticsearchDataType.keyword, 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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
export interface SCISO8601DateRange { export interface SCISO8601DateRange {
@@ -27,7 +27,7 @@ export interface SCISO8601DateRange {
export interface TypeOverrides { export interface TypeOverrides {
foo: SCISO8601DateRange; foo: SCISO8601DateRange;
type: ThingType.TypeOverrides type: ThingType.TypeOverrides;
} }
export const testConfig: MapAggTestOptions = { export const testConfig: MapAggTestOptions = {
@@ -38,6 +38,6 @@ export const testConfig: MapAggTestOptions = {
foo: { foo: {
type: ElasticsearchDataType.date_range, 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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
@@ -29,7 +29,7 @@ export interface TypeQuery {
enum Bar { enum Bar {
'a', 'a',
'b', 'b',
'c' 'c',
} }
// https://gitlab.com/openstapps/core-tools/-/issues/47 // https://gitlab.com/openstapps/core-tools/-/issues/47
@@ -39,8 +39,8 @@ export const testConfig: MapAggTestOptions = {
map: { map: {
maps: { maps: {
foo: { 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 {ThingType} from './types';
import {MapAggTestOptions} from '../../MapAggTestOptions'; import {MapAggTestOptions} from '../../map-agg-test-options';
import {ElasticsearchDataType} from '../../../../src/config/typemap'; import {ElasticsearchDataType} from '../../../../src/config/typemap';
/** /**
@@ -36,7 +36,7 @@ export interface TypeWrapperInheritance {
*/ */
stringLiteralWrapper: StringLiteralWrapper; stringLiteralWrapper: StringLiteralWrapper;
type: ThingType.TypeWrapperInheritance type: ThingType.TypeWrapperInheritance;
} }
type NumberWrapper = number; type NumberWrapper = number;
@@ -53,16 +53,16 @@ export const testConfig: MapAggTestOptions = {
dynamic: 'strict', dynamic: 'strict',
properties: { properties: {
numberWrapper: { numberWrapper: {
type: ElasticsearchDataType.float type: ElasticsearchDataType.float,
}, },
stringWrapper: { stringWrapper: {
type: ElasticsearchDataType.keyword type: ElasticsearchDataType.keyword,
}, },
stringLiteralWrapper: { stringLiteralWrapper: {
type: ElasticsearchDataType.text type: ElasticsearchDataType.text,
} },
} },
} },
} },
} },
}; };

27
test/mapping.spec.ts
View File

@@ -15,8 +15,8 @@
import {Logger} from '@openstapps/logger'; import {Logger} from '@openstapps/logger';
import {readdirSync, statSync} from 'fs'; import {readdirSync, statSync} from 'fs';
import path from 'path'; import path from 'path';
import {MapAggTest} from './mapping-model/MapAggTest'; import {MapAggTest} from './mapping-model/map-agg-test';
import {MapAggTestOptions} from './mapping-model/MapAggTestOptions'; import {MapAggTestOptions} from './mapping-model/map-agg-test-options';
describe('ES Mapping Gen', async () => { describe('ES Mapping Gen', async () => {
const magAppInstance = new MapAggTest('mappings'); 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 * 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[] { function expandPathToFilesSync(sourcePath: string, accept: (fileName: string) => boolean): string[] {
const fullPath = path.resolve(sourcePath); const fullPath = path.resolve(sourcePath);
const directory = statSync(fullPath); const directory = statSync(fullPath);
return directory.isDirectory() return directory.isDirectory()
? ([] as string[]).concat(...readdirSync(fullPath).map(fragment => ? // eslint-disable-next-line unicorn/prefer-spread
expandPathToFilesSync(path.resolve(sourcePath, fragment), accept), ([] as string[]).concat(
)) ...readdirSync(fullPath).map(fragment =>
expandPathToFilesSync(path.resolve(sourcePath, fragment), accept),
),
)
: [fullPath].filter(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 { try {
// eslint-disable-next-line unicorn/no-await-expression-member
const test = (await import(file))['testConfig'] as MapAggTestOptions; const test = (await import(file))['testConfig'] as MapAggTestOptions;
it(test.testName, function () { it(test.testName, function () {
magAppInstance.testInterfaceAgainstPath(test) magAppInstance.testInterfaceAgainstPath(test);
}) });
} catch (error) { } catch (error) {
await Logger.error('UNHANDLED REJECTION', error.stack); await Logger.error('UNHANDLED REJECTION', error.stack);
process.exit(1); 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/**"
]
}
}