feat: add automatic mapping generation

Fixes #6

src/cli.ts

@@ -22,6 +22,7 @@ import {
   readFilePromisified,
   toArray,
 } from './common';
+import {generateTemplate} from './mapping';
 import {pack} from './pack';
 import {
   gatherRouteInformation,
@@ -77,6 +78,30 @@ commander
     Logger.ok(`Route documentation written to ${mdPath}.`);
   });
 
+commander
+  .command('mapping <srcPath> <destPath> [ignoredTags]')
+  .action(async (relativeSrcPath, relativeMappingPath, ignoredTags) => {
+    // get absolute paths
+    const srcPath = resolve(relativeSrcPath);
+    const mappingPath = resolve(relativeMappingPath);
+
+    let ignoredTagsList: string[] = [];
+    if (typeof ignoredTags === 'string') {
+      ignoredTagsList = ignoredTags.split(',');
+    }
+
+    // get project reflection
+    const projectReflection = getProjectReflection(srcPath);
+
+    const mapping = generateTemplate(projectReflection, ignoredTagsList);
+
+    // write documentation to file
+    // tslint:disable-next-line:no-magic-numbers
+    writeFileSync(mappingPath, JSON.stringify(mapping.template, null, 2));
+
+    Logger.ok(`Elasticsearch mapping written to ${mappingPath}.`);
+  });
+
 commander
   .command('schema <srcPath> <schemaPath>')
   .action(async (relativeSrcPath, relativeSchemaPath) => {

src/common.ts

@@ -142,6 +142,7 @@ export interface ExpectableValidationErrors {
  * Get a project reflection from a path
  *
  * @param srcPath Path to get reflection from
+ * @param excludeExternals Exclude external dependencies
  */
 export function getProjectReflection(srcPath: PathLike, excludeExternals = true): ProjectReflection {
   Logger.info(`Generating project reflection for ${srcPath.toString()}.`);
@@ -175,7 +176,7 @@ export function getProjectReflection(srcPath: PathLike, excludeExternals = true)
 }
 
 /**
- * Check if a schema has definitions
+ * Guard method for checking if a schema has definitions
  *
  * @param schema Schema to check
  */

src/mapping.ts

@@ -0,0 +1,480 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {Logger} from '@openstapps/logger';
+import * as deepmerge from 'deepmerge';
+import {stringify} from 'flatted';
+import {DeclarationReflection, ProjectReflection} from 'typedoc';
+import {
+  ArrayType,
+  CommentTag,
+  IntrinsicType,
+  ReferenceType, ReflectionType,
+  StringLiteralType,
+  Type, TypeParameterType,
+  UnionType,
+} from 'typedoc/dist/lib/models';
+import {fieldmap} from './mappings/definitions/fieldmap';
+import {premaps} from './mappings/definitions/premap';
+import {settings} from './mappings/definitions/settings';
+import {dynamicTypes, ElasticsearchDataType, typemap} from './mappings/definitions/typemap';
+import {
+  ElasticsearchDynamicTemplate,
+  ElasticsearchObject,
+  ElasticsearchTemplate,
+  ElasticsearchValue,
+  ReflectionGeneric,
+} from './mappings/mapping-definitions';
+
+const dynamicTemplates: ElasticsearchDynamicTemplate[] = [];
+let errors: string[] = [];
+let showErrors = true;
+
+const indexableTag = 'indexable';
+
+let ignoredTagsList = ['indexable', 'validatable'];
+
+/**
+ * Gets all interfaces that have an @indexable tag
+ *
+ * @param projectReflection the project reflection from which to extract the indexable interfaces
+ */
+export function getAllIndexableInterfaces(projectReflection: ProjectReflection): DeclarationReflection[] {
+
+  let indexableInterfaces: DeclarationReflection[] = [];
+
+  if (!Array.isArray(projectReflection.children) || projectReflection.children.length === 0) {
+    throw new Error('No DeclarationReflections found. Please check your input path');
+  }
+
+  // push all declaration reflections into one array
+  projectReflection.children.forEach((declarationReflection) => {
+    if (Array.isArray(declarationReflection.children)) {
+      indexableInterfaces = indexableInterfaces.concat(declarationReflection.children);
+    }
+  });
+
+  // filter all declaration reflections with an @indexable tag
+  indexableInterfaces = indexableInterfaces.filter((declarationReflection) => {
+    if (
+      typeof declarationReflection.comment === 'undefined' ||
+      typeof declarationReflection.comment.tags === 'undefined'
+    ) {
+      return false;
+    }
+
+    return typeof declarationReflection.comment.tags.find((commentTag) => {
+      return commentTag.tagName === indexableTag;
+    }) !== 'undefined';
+  });
+
+  return indexableInterfaces;
+}
+
+/**
+ * Composes error messages, that are readable and contain a certain minumum of information
+ *
+ * @param path the path where the error took place
+ * @param typeName the name of the object, with which something went wrong
+ * @param object the object or name
+ * @param message the error message
+ */
+function composeErrorMessage(path: string, typeName: string, object: string, message: string) {
+  const error = `At "${path.substr(0, path.length - 1)}" for ${typeName} "${object}": ${message}`;
+  errors.push(error);
+  if (showErrors) {
+    // tslint:disable-next-line:no-floating-promises
+    Logger.error(error);
+  }
+}
+
+/**
+ * Gets the Reflections and names for Generics in a ReferenceType of a DeclarationReflection
+ *
+ * Warning to future maintainers: The code for generics doesn't account for depth. when there is a new generic, it will
+ * override the previous one, if there isn't, it will just continue passing it down.
+ *
+ * @param type the ReferenceType of a DeclarationReflection
+ * @param out the previous reflection, it then overrides all parameters or keeps old ones
+ * @param path the current path to the object we are in
+ */
+function getReflectionGeneric(type: ReferenceType, out: ReflectionGeneric[], path: string): ReflectionGeneric[] {
+  if (typeof type.typeArguments !== 'undefined'
+    && type.reflection instanceof DeclarationReflection
+    && typeof type.reflection.typeParameters !== 'undefined'
+    && type.typeArguments.length === type.reflection.typeParameters.length) {
+    for (let i = 0; i < type.typeArguments.length; i++) {
+      let replaced = false;
+      for (const old of out) {
+        if (old.name === type.reflection.typeParameters[i].name) {
+          old.value = handleType(type.typeArguments[i], out, path);
+          replaced = true;
+        }
+      }
+      if (!replaced) {
+        out.push({
+          name: type.reflection.typeParameters[i].name,
+          value: handleType(type.typeArguments[i], out, path),
+        });
+      }
+    }
+  }
+
+  return out;
+}
+
+/**
+ * Handles a ReferenceType that has no value
+ *
+ * @param ref the ReferenceType
+ * @param generics the generics from levels above, so we can use them without having access to the parent
+ * @param path the current path to the object we are in
+ * @param tags any tags attached to the type
+ */
+function handleRefWithoutReflection(ref: ReferenceType, generics: ReflectionGeneric[],
+                                    path: string, tags?: CommentTag[]): ElasticsearchValue {
+  for (const premap in premaps) {
+    if (premap === ref.name) {
+      return readFieldTags(premaps[premap], path, tags);
+    }
+  }
+
+  if (ref.name === 'Array') { // basically an external type, but Array is quite common, especially with generics
+    if (typeof ref.typeArguments === 'undefined' || typeof ref.typeArguments[0] === 'undefined') {
+      composeErrorMessage(path, 'Array with generics', 'array', 'Failed to parse');
+
+      return {type: ElasticsearchDataType.parse_error};
+    }
+
+    return readFieldTags(handleType(ref.typeArguments[0], getReflectionGeneric(ref, generics, path), path),
+      path, tags);
+  }
+  if (ref.name === '__type') { // empty object
+    return {
+      dynamic: 'strict',
+      properties: {},
+    };
+  }
+
+  composeErrorMessage(path, 'external type', ref.name, 'Missing pre-map');
+
+  return readFieldTags({type: ElasticsearchDataType.missing_premap}, path, tags);
+}
+
+/**
+ * Handles an object
+ *
+ * @param decl the DeclarationReflection of the object
+ * @param generics the generics from levels above, so we can use them without having access to the parent
+ * @param path the current path to the object we are in
+ */
+function handleDeclarationReflection(decl: DeclarationReflection, generics: ReflectionGeneric[], path: string):
+  ElasticsearchValue {
+  // check if we have an object referencing a generic
+  for (const gRefl of generics) {
+    if (gRefl.name === decl.name) { // if the object name is the same as the generic name
+      return readFieldTags(gRefl.value, path, typeof decl.comment !== 'undefined' ? decl.comment.tags : undefined);
+      // use the value defined by the generic
+    }
+  }
+
+  // start the actual handling process
+  const out: ElasticsearchObject = {
+    dynamic: 'strict',
+    properties: {},
+  };
+
+  let empty = true;
+  // first check if there are any index signatures, so for example `[name: string]: Foo`
+  if (typeof decl.indexSignature !== 'undefined' && typeof decl.indexSignature.parameters !== 'undefined') {
+    for (const param of decl.indexSignature.parameters) {
+      empty = false;
+      const template: ElasticsearchDynamicTemplate = {};
+      template[decl.name] = {
+        mapping: handleDeclarationReflection(param as DeclarationReflection, generics, path),
+        match: '*',
+        match_mapping_type: '*',
+        path_match: `${path}*`,
+      };
+      dynamicTemplates.push(template);
+    }
+  }
+
+  // check all the children, so in this case we are dealing with an OBJECT
+  if (typeof decl.children !== 'undefined' && decl.children.length > 0) {
+    for (const child of decl.children) {
+      empty = false;
+      out.properties[child.name] = handleDeclarationReflection(child, generics, `${path}${child.name}.`);
+    }
+  } else if (decl.type instanceof Type) { // if the object is a type, so we are dealing with a PROPERTY
+    return handleType(decl.type, generics, path,
+      typeof decl.comment !== 'undefined' ? decl.comment.tags : undefined);
+  } else if (decl.kindString === 'Enumeration member') {
+    return readTypeTags(typeof decl.defaultValue, path,
+      typeof decl.comment !== 'undefined' ? decl.comment.tags : undefined);
+  }
+
+  if (empty) {
+    composeErrorMessage(path, 'object', decl.name, 'Empty object');
+  }
+
+  return readFieldTags(out, path, typeof decl.comment !== 'undefined' ? decl.comment.tags : undefined);
+}
+
+/**
+ * Handles UnionTypes
+ *
+ * Put into a separate function as it is a little bit more complex
+ * Works fairly reliable, although there are issues with primitive union types, which don't work at all (And never will)
+ *
+ * @param type the type object
+ * @param generics the generics from levels above, so we can use them without having access to the parent
+ * @param path the current path to the object we are in
+ */
+function handleUnionType(type: UnionType, generics: ReflectionGeneric[], path: string): ElasticsearchValue {
+  const list: ElasticsearchValue[] = [];
+
+  for (const subType of type.types) {
+    if (subType instanceof IntrinsicType && subType.name === 'undefined') {
+      continue;
+    }
+    list.push(handleType(subType, generics, path));
+  }
+
+  if (list.length > 0) {
+    let out = list[0];
+
+    for (const item of list) {
+      out = deepmerge(out, item);
+    }
+
+    return out;
+  }
+
+  composeErrorMessage(path, 'Union Type', stringify(list), 'Empty union type. This is likely not a user error.');
+
+  return {type: ElasticsearchDataType.parse_error};
+}
+
+/**
+ * Serves as a kind of distributor for the different types, should not contain any specific code
+ *
+ * @param type the type object
+ * @param generics the generics from levels above, so we can use them without having access to the parent
+ * @param path the current path to the object we are in
+ * @param tags any tags attached to the type
+ */
+function handleType(type: Type, generics: ReflectionGeneric[], path: string, tags?: CommentTag[]): ElasticsearchValue {
+  // logger.log((type as any).name);
+  if (type instanceof ArrayType) { // array is irrelevant in Elasticsearch, so just go with the element type
+    return handleType(type.elementType, generics, path, tags);
+  }
+  if (type.type === 'stringLiteral') { // a string literal, usually for type
+    return readTypeTags(type.type, path, tags);
+  }
+  if (type instanceof IntrinsicType) { // the absolute default type, like strings
+    return readTypeTags(type.name, path, tags);
+  }
+  if (type instanceof UnionType) { // the union type...
+    return handleUnionType(type, generics, path);
+  }
+  if (type instanceof ReferenceType) {
+    if (typeof type.reflection !== 'undefined') {
+      // there is really no way to make this typesafe, every element in DeclarationReflection is optional.
+      return handleDeclarationReflection(type.reflection as DeclarationReflection,
+        getReflectionGeneric(type, generics, path), path);
+    }
+
+    return handleRefWithoutReflection(type, generics, path, tags);
+  }
+  if (type instanceof TypeParameterType) {
+    // check if we have an object referencing a generic
+    for (const gRefl of generics) {
+      if (gRefl.name === type.name) { // if the object name is the same as the generic name
+        return gRefl.value; // use the value defined by the generic
+      }
+    }
+    composeErrorMessage(path, 'Generic', type.name, 'Missing reflection, please report!');
+
+    return {type: ElasticsearchDataType.parse_error};
+
+  }
+  if (type instanceof ReflectionType) {
+    return readFieldTags(handleDeclarationReflection(type.declaration, generics, path), path, tags);
+  }
+
+  composeErrorMessage(path, 'type', stringify(type), 'Not implemented type');
+
+  return {type: ElasticsearchDataType.parse_error};
+}
+
+/**
+ * Reads all tags related to Elasticsearch fields from the fieldMap
+ *
+ * @param prev the previous ElasticsearchValue, for example and object
+ * @param path the current path to the object we are in
+ * @param tags tags attached to the value
+ */
+function readFieldTags(prev: ElasticsearchValue, path: string, tags?: CommentTag[]): ElasticsearchValue {
+  if (typeof tags !== 'undefined') {
+    for (const tag of tags) {
+      if (!ignoredTagsList.includes(tag.tagName)) {
+        if (typeof fieldmap[tag.tagName] !== 'undefined') {
+          if (typeof prev.fields === 'undefined') {
+            prev.fields = {};
+          }
+          if (tag.text.trim() === '') {
+            // merge the fields
+            prev.fields = {...prev.fields, ...fieldmap[tag.tagName].default};
+          } else if (typeof fieldmap[tag.tagName][tag.text.trim()] !== 'undefined') {
+            // merge the fields
+            prev.fields = {...prev.fields, ...fieldmap[tag.tagName][tag.text.trim()]};
+          } else if (!fieldmap[tag.tagName].ignore.includes(tag.text.trim())) {
+            composeErrorMessage(path, 'tag', tag.tagName, `Not implemented tag param "${tag.text.trim()}"`);
+          }
+        } else {
+          composeErrorMessage(path, 'tag', tag.tagName, `Not implemented tag`);
+        }
+      }
+    }
+  }
+
+  return prev;
+}
+
+/**
+ * Reads all types related to Elasticsearch fields from the fieldMap
+ *
+ * @param type the type of the value
+ * @param path the current path to the object we are in
+ * @param tags tags attached to the value
+ */
+function readTypeTags(type: string, path: string, tags?: CommentTag[]): ElasticsearchValue {
+  let out: ElasticsearchValue = {type: ElasticsearchDataType.parse_error};
+
+  if (typeof typemap[type] !== 'undefined') { // first look if the value has a definition in the typemap
+    if (typeof tags !== 'undefined') { // look if there are any tags
+      for (let i = tags.length - 1; i >= 0; i--) {
+        if (!ignoredTagsList.includes(tags[i].tagName) && typeof typemap[type][tags[i].tagName] !== 'undefined') {
+          // if we have a tag that indicates a type
+          if (out.type !== ElasticsearchDataType.parse_error) {
+            composeErrorMessage(path, 'type', type, `Type conflict; "${typemap[type][tags[i].tagName]}" would` +
+              ` override "${out.type}"`);
+            out.type = ElasticsearchDataType.type_conflict;
+            continue;
+          }
+          out.type = typemap[type][tags[i].tagName];
+          tags.splice(i, 1); // we need this so readFieldTags can process correctly
+        }
+      }
+    }
+
+    if (out.type === ElasticsearchDataType.parse_error) {
+      out.type = typemap[type].default;
+    }
+
+    out = readFieldTags(out, path, tags);
+
+    return out;
+  }
+  if (dynamicTypes.includes(type)) { // Elasticsearch dynamic type
+    return {
+      dynamic: true,
+      properties: {},
+    };
+  }
+
+  composeErrorMessage(path, 'type', type, 'Not implemented type');
+
+  return out;
+}
+
+/**
+ * Takes a project reflection and generates an ElasticsearchTemplate from it
+ *
+ * Serves as the entry point for getting the mapping, so if you just want to get the mapping files for Elasticsearch,
+ * you can do so by calling this function, `RETURNED_VALUE.template` contains the mapping in a fashion that is directly
+ * readable by Elasticsearch.
+ *
+ * @param projectReflection a reflection of the project you want to get the ES Mappings from
+ * @param ignoredTags the tag names for which the error output should be suppressed
+ * @param showErrorOutput whether to print all errors in the command line or not
+ */
+export function generateTemplate(projectReflection: ProjectReflection, ignoredTags: string[], showErrorOutput = true):
+// tslint:disable-next-line:completed-docs
+  { errors: string[]; template: ElasticsearchTemplate; } {
+  errors = [];
+  showErrors = showErrorOutput;
+
+  ignoredTagsList = ['indexable', 'validatable'];
+  ignoredTagsList.push.apply(ignoredTagsList, ignoredTags);
+
+  const indexableInterfaces = getAllIndexableInterfaces(projectReflection);
+
+  const out: ElasticsearchTemplate = {
+    mappings: {
+      _default_: {
+        _source: {
+          excludes: [
+            'creation_date',
+          ],
+        },
+        date_detection: false,
+        dynamic_templates: [],
+        properties: {},
+      },
+    },
+    settings: settings,
+    template: 'stapps_*',
+  };
+
+  for (const _interface of indexableInterfaces) {
+    if (!Array.isArray(_interface.children) || _interface.children.length === 0) {
+      throw new Error('Interface needs at least some properties to be indexable');
+    }
+
+    const typeObject = _interface.children.find((declarationReflection) => {
+      return declarationReflection.name === 'type';
+    });
+
+    if (typeof typeObject === 'undefined' || typeof typeObject.type === 'undefined') {
+      throw new Error('Interface needs a type to be indexable');
+    }
+
+    let typeName = 'INVALID_TYPE';
+    if (typeObject.type instanceof ReferenceType) {
+      if (typeObject.type.reflection instanceof DeclarationReflection
+        && typeof typeObject.type.reflection.defaultValue === 'string') {
+        typeName = typeObject.type.reflection.defaultValue.replace('"', '')
+          .replace('"', '');
+      } else {
+        // tslint:disable-next-line:no-floating-promises
+        Logger.error('Your input files seem to be incorrect, or there is a major bug in the mapping generator.');
+      }
+    } else if (typeObject.type instanceof StringLiteralType) {
+      Logger.warn(`The interface ${_interface.name} uses a string literal as type, please use SCThingType.`);
+      typeName = typeObject.type.value;
+    } else {
+      // tslint:disable-next-line:no-floating-promises
+      Logger.error(`The interface ${_interface.name} is required to use an SCThingType as a type, please do so.`);
+    }
+
+    out.mappings._default_.properties[typeName] =
+      handleDeclarationReflection(_interface, [], '') as ElasticsearchObject;
+  }
+
+  out.mappings._default_.dynamic_templates = dynamicTemplates;
+
+  return {template: out, errors};
+}

src/mappings/definitions/fieldmap.ts

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {ElasticsearchFieldmap} from '../mapping-definitions';
+import {ElasticsearchDataType} from './typemap';
+
+export enum analyzers {
+  ducet_sort = 'ducet_sort',
+  search_german = 'search_german',
+}
+
+export const fieldmap: ElasticsearchFieldmap = {
+  aggregatable: {
+    default: {
+      raw: {
+        ignore_above: 10000,
+        type: ElasticsearchDataType.keyword,
+      },
+    },
+    ignore: [],
+  },
+  sortable: {
+    default: {
+      sort: {
+        analyzer: analyzers.ducet_sort,
+        fielddata: true,
+        type: ElasticsearchDataType.text,
+      },
+    },
+    ducet: {
+      sort: {
+        analyzer: analyzers.ducet_sort,
+        fielddata: true,
+        type: ElasticsearchDataType.text,
+      },
+    },
+    ignore: ['price'],
+  },
+};

src/mappings/definitions/premap.ts

@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {Logger} from '@openstapps/logger';
+import {ElasticsearchPremap, ElasticsearchValue} from '../mapping-definitions';
+import {ElasticsearchDataType} from './typemap';
+
+export const premaps: ElasticsearchPremap = {
+  CoordinateReferenceSystem: {
+    dynamic: 'strict',
+    properties: {
+      properties: {
+        dynamic: true,
+        properties: {},
+      },
+      type: {
+        type: ElasticsearchDataType.keyword,
+      },
+    },
+  },
+  LineString: {
+    dynamic: 'strict',
+    properties: {
+      coordinates: {
+        type: ElasticsearchDataType.float,
+      },
+      type: {
+        type: ElasticsearchDataType.keyword,
+      },
+    },
+  },
+  Point: {
+    dynamic: 'strict',
+    properties: {
+      bbox: {type: ElasticsearchDataType.float},
+      coordinates: {type: ElasticsearchDataType.geo_point}, // TODO: filterable
+      crs: {
+        dynamic: 'strict',
+        properties: {
+          properties: {
+            dynamic: true,
+            properties: {},
+          },
+          type: {type: ElasticsearchDataType.keyword},
+        },
+      },
+      type: {type: ElasticsearchDataType.keyword},
+    },
+  },
+  Polygon: { // a Polygon is mapped the same way as a Point is, you can just copy & paste
+    dynamic: 'strict',
+    properties: {
+      bbox: {type: ElasticsearchDataType.float},
+      coordinates: {type: ElasticsearchDataType.geo_point}, // TODO: filterable
+      crs: {
+        dynamic: 'strict',
+        properties: {
+          properties: {
+            dynamic: true,
+            properties: {},
+          },
+          type: {type: ElasticsearchDataType.keyword},
+        },
+      },
+      type: {type: ElasticsearchDataType.keyword},
+    },
+  },
+  'jsonpatch.OpPatch': {
+    dynamic: 'strict',
+    properties: {
+      from: {
+        type: ElasticsearchDataType.keyword,
+      },
+      op: {
+        type: ElasticsearchDataType.keyword,
+      },
+      path: {
+        type: ElasticsearchDataType.keyword,
+      },
+      value: {
+        dynamic: true,
+        properties: {},
+      },
+    },
+  },
+};
+
+/**
+ * Gets an ElasticsearchValue for a name
+ *
+ * @param name the name of the premap
+ */
+export function getPremap(name: string): ElasticsearchValue {
+  for (const premap in premaps) {
+    if (premap === name) {
+      return premaps[premap];
+    }
+  }
+
+  // tslint:disable-next-line:no-floating-promises
+  Logger.error(`Missing pre-map for external type ${name}`);
+
+  return {type: ElasticsearchDataType.missing_premap};
+}

src/mappings/definitions/settings.ts

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {ElasticsearchSettings} from '../mapping-definitions';
+
+export const settings: ElasticsearchSettings = {
+  analysis: {
+    analyzer: {
+      ducet_sort: {
+        filter: [
+          'german_phonebook',
+        ],
+        tokenizer: 'keyword',
+        type: 'custom',
+      },
+      search_german: {
+        filter: [
+          'lowercase',
+          'german_stop',
+          'german_stemmer',
+        ],
+        tokenizer: 'stapps_ngram',
+        type: 'custom',
+      },
+    },
+    filter: {
+      german_phonebook: {
+        country: 'DE',
+        language: 'de',
+        type: 'icu_collation',
+        variant: '@collation=phonebook',
+      },
+      german_stemmer: {
+        language: 'german',
+        type: 'stemmer',
+      },
+      german_stop: {
+        stopwords: '_german_',
+        type: 'stop',
+      },
+    },
+    tokenizer: {
+      stapps_ngram: {
+        max_gram: 7,
+        min_gram: 4,
+        type: 'ngram',
+      },
+    },
+  },
+  'mapping.total_fields.limit': 10000,
+  max_result_window: 30000,
+  number_of_replicas: 0,
+  number_of_shards: 1,
+};

src/mappings/definitions/typemap.ts

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {ElasticsearchTypemap} from '../mapping-definitions';
+
+export enum ElasticsearchDataType {
+  missing_premap = 'MISSING_PREMAP',
+  parse_error = 'PARSE_ERROR',
+  type_conflict = 'TYPE_CONFLICT',
+  text = 'text',
+  keyword = 'keyword',
+  date = 'date',
+  // long = 'long',
+  // double = 'double',
+  float = 'float',
+  boolean = 'boolean',
+  ip = 'ip',
+  integer = 'integer',
+  object = 'object',
+  nested = 'nested',
+  geo_point = 'geo_point',
+  geo_shape = 'geo_shape',
+  completion = 'completion',
+}
+
+export const typemap: ElasticsearchTypemap = {
+  boolean: {
+    default: ElasticsearchDataType.boolean,
+  },
+  false: {
+    default: ElasticsearchDataType.boolean,
+  },
+  number: {
+    default: ElasticsearchDataType.integer,
+    float: ElasticsearchDataType.float,
+    integer: ElasticsearchDataType.integer,
+  },
+  string: {
+    default: ElasticsearchDataType.text,
+    keyword: ElasticsearchDataType.keyword,
+    text: ElasticsearchDataType.text,
+  },
+  stringLiteral: {
+    default: ElasticsearchDataType.keyword,
+  },
+  true: {
+    default: ElasticsearchDataType.boolean,
+  },
+};
+
+export const dynamicTypes = ['any', 'unknown'];

src/mappings/mapping-definitions.ts

@@ -0,0 +1,313 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {ElasticsearchDataType} from './definitions/typemap';
+
+// tslint:disable:no-any
+
+/**
+ * ElasticsearchValue can be either a type or an object.
+ *
+ * Both are composed similarly, and can be the value of a propery
+ * of an Elasticsearch Object.
+ */
+export type ElasticsearchValue = ElasticsearchType | ElasticsearchObject;
+
+/**
+ * Used internally for saving a generic value contained in a reflection
+ */
+export interface ReflectionGeneric {
+  /**
+   * The name of the generic
+   *
+   * For example in `<number A>` the name would be 'A'
+   */
+  name: string;
+
+  /**
+   * The value of the generic
+   */
+  value: ElasticsearchValue;
+}
+
+/**
+ * The Typemap is used to get the corresponding ElasicsearchDataType for a name provided by the ProjectReflection
+ */
+export interface ElasticsearchTypemap {
+  /**
+   * The `stringLiteral` type must always be provided
+   */
+  stringLiteral: {
+    /**
+     * The default can be chosen freely, but must be provided
+     */
+    default: ElasticsearchDataType;
+  };
+
+  /**
+   * The name of the JS type, so for `number` it would be number
+   */
+  [name: string]: {
+    /**
+     * The default ElasticsearchDataType that should be used, if no tag or only not implemented tags are found
+     */
+    default: ElasticsearchDataType;
+
+    /**
+     * The name of the tag, so for `@integer` it would be `integer`
+     */
+    [name: string]: ElasticsearchDataType;
+  };
+}
+
+/**
+ * The representation of a `DynamicTemplate` in Elasticsearch
+ *
+ * https://www.elastic.co/guide/en/elasticsearch/reference/5.6/dynamic-templates.html
+ */
+export interface ElasticsearchDynamicTemplate {
+  /**
+   * The name of the dynamicTemplate
+   */
+  [name: string]: {
+    /**
+     * The mapping of the template
+     */
+    mapping: ElasticsearchValue;
+
+    /**
+     * With automatic mapping, we use `path_match` more or less out of convenience and because it is least error-prone
+     *
+     * This also means that match should match all ("*") interface names (because we provide the exact path of the
+     * interface)
+     */
+    match: '*';
+
+    /**
+     * With automatic mapping, we use `path_match` more or less out of convenience and because it is least error-prone
+     *
+     * This also means that match_mapping_type should match all ("*") names (because we provide the exact path of the
+     * interface)
+     */
+    match_mapping_type: '*';
+
+    /**
+     * With automatic mapping, we use `path_match` more or less out of convenience and because it is least error-prone
+     */
+    path_match: string;
+  };
+}
+
+/**
+ * The Fieldmap contains all tag names for fields and the corresponding fields
+ *
+ * The Fieldmap works in a similar fashion to the Typemap
+ */
+export interface ElasticsearchFieldmap {
+  /**
+   * The name of the tag, so for `@sortable` it would be `sortable`
+   */
+  [name: string]: {
+    /**
+     * The default value if no parameter is provided
+     */
+    default: {
+      /**
+       * To allow the usage of `prev.fields = {...prev.fields, ...fieldmap[tag.tagName].default}`
+       *
+       * We could also have used `default: any`, but this adds slightly more improved type-safety.
+       */
+      [name: string]: any;
+    };
+
+    /**
+     * The tag parameters that will be ignored
+     *
+     * Some tag parameters might not be important for your implementation, so you can add their names here to not get
+     * any errors. The `default` will be used in that case.
+     */
+    ignore: string[];
+
+    /**
+     * The parameters of the tag, so for `@sortable ducet` it would be `ducet`
+     */
+    [name: string]: {
+      /**
+       * To allow the usage of `prev.fields = {...prev.fields, ...fieldmap[tag.tagName][tag.text.trim()]}`
+       *
+       * We could also have used `default: any`, but this adds slightly more improved type-safety.
+       */
+      [name: string]: any;
+    };
+  };
+}
+
+/**
+ * A primitive data type
+ *
+ * https://www.elastic.co/guide/en/elasticsearch/reference/5.6/mapping-types.html
+ */
+export interface ElasticsearchType {
+  /**
+   * Fields for a type
+   *
+   * The fields are optional, they are used for things like sorting, which is not needed for every single type.
+   */
+  fields?: {
+    [name: string]: any;
+  };
+
+  /**
+   * The type as an ElasticsearchDataType
+   */
+  type: ElasticsearchDataType;
+}
+
+/**
+ * An object data type
+ *
+ * https://www.elastic.co/guide/en/elasticsearch/reference/5.6/object.html
+ */
+export interface ElasticsearchObject {
+  /**
+   * If the object is a dynamic
+   *
+   * https://www.elastic.co/guide/en/elasticsearch/reference/5.6/dynamic.html
+   * The default should be `'strict'`
+   */
+  dynamic: true | false | 'strict';
+
+  /**
+   * dynamic_templates for an object
+   *
+   * https://www.elastic.co/guide/en/elasticsearch/reference/5.6/dynamic-templates.html
+   * This is a more complex topic, before touching this you should really know what you are doing.
+   */
+  dynamic_templates?: ElasticsearchDynamicTemplate[];
+
+  /**
+   * Fields for a type
+   *
+   * The fields are optional, they are used for things like sorting, which is not needed for every single type.
+   */
+  fields?: {
+    [name: string]: any;
+  };
+
+  /**
+   * Any properties of the object
+   *
+   * https://www.elastic.co/guide/en/elasticsearch/reference/5.6/properties.html
+   */
+  properties: {
+    /**
+     * Each property can be any Elasticsearch value
+     *
+     * https://www.elastic.co/guide/en/elasticsearch/reference/5.6/mapping-types.html
+     */
+    [name: string]: ElasticsearchValue;
+  };
+}
+
+/**
+ * An Elasticsearch template
+ *
+ * https://www.elastic.co/guide/en/elasticsearch/reference/5.6/mapping.html
+ * This is what you pass to Elasticsearch
+ */
+export interface ElasticsearchTemplate {
+  /**
+   * This is a pre-defined structure you should use for your mapping
+   */
+  mappings: {
+    /**
+     * This mapping will be used by default for everything
+     */
+    _default_: {
+      /**
+       * Contains the original JSON document body
+       *
+       * https://www.elastic.co/guide/en/elasticsearch/reference/5.6/mapping-source-field.html
+       */
+      _source: {
+        /**
+         * Any fields that are excluded from the source
+         */
+        excludes: string[];
+      };
+
+      /**
+       * Whether Elasticsearch should automatically add date fields to objects
+       */
+      date_detection: false;
+
+      /**
+       * This is where all the dynamic templates should go
+       */
+      dynamic_templates: ElasticsearchDynamicTemplate[];
+
+      /**
+       * This is where all the mappings should go
+       */
+      properties: {
+        [name: string]: ElasticsearchObject;
+      };
+    };
+  };
+
+  /**
+   * The settings for Elasticsearch
+   */
+  settings: ElasticsearchSettings;
+
+  /**
+   * The name of the template, for referencing in Elasticsearch
+   */
+  template: string;
+}
+
+/**
+ * A representation of ElasticsearchSettings used in Mappings
+ */
+export interface ElasticsearchSettings {
+  /**
+   * The settings
+   */
+  [name: string]: any;
+
+  /**
+   * This is where any analyzers go
+   *
+   * https://www.elastic.co/guide/en/elasticsearch/reference/5.6/analysis-analyzers.html
+   */
+  analysis: {
+    [name: string]: any;
+  };
+}
+
+/**
+ * A premap for a specific value in a ProjectReflection
+ *
+ * This is meant to be used for external types. To aid performance, you usually should not include external libs in the
+ * ProjectReflection. This means that there is no way the generator can generate a mapping for it, so you can use the
+ * premaps to map out a type manually.
+ */
+export interface ElasticsearchPremap {
+  /**
+   * The name of the type with the corresponding map
+   *
+   * So for `const a: B` the name would be `B`
+   */
+  [name: string]: ElasticsearchValue;
+}