feat: add automatic mapping generation

Fixes #6

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;
+}