hunk.code_window: * changed the way how entity schemas are created (now more type-safe), now interface EntitySchema is a class
   * added `@Unique` decorator. Accepts custom unique constraint name and columns to be unique. Used only on as 
   composite unique constraint, on table level. E.g. `@Unique("uq_id_name", ["id", "name"])`
   * fixed `Oracle` issues, now it will be maintained as other drivers 
   * implemented migrations functionality in all drivers
   ## 0.1.13
  
hunk.labels: keep keep keep keep add keep keep keep
hunk.after_edit: * CLI commands changed from `migrations:create`, `migrations:generate` and `migrations:revert` to `migration:create`, `migration:generate` and `migration:revert`
  
hunk.file_path: CHANGELOG.md
hunk.type: add
file: import {ColumnOptions, getMetadataArgsStorage} from "../../";
  import {
      ColumnType, SimpleColumnType, WithLengthColumnType,
      WithPrecisionColumnType
  } from "../../driver/types/ColumnTypes";
  import {ColumnMetadataArgs} from "../../metadata-args/ColumnMetadataArgs";
  import {ColumnCommonOptions} from "../options/ColumnCommonOptions";
  import {ColumnWithLengthOptions} from "../options/ColumnWithLengthOptions";
  import {ColumnNumericOptions} from "../options/ColumnNumericOptions";
  import {ColumnEnumOptions} from "../options/ColumnEnumOptions";
  import {ColumnEmbeddedOptions} from "../options/ColumnEmbeddedOptions";
  import {EmbeddedMetadataArgs} from "../../metadata-args/EmbeddedMetadataArgs";
  import {ColumnTypeUndefinedError} from "../../error/ColumnTypeUndefinedError";
  import {ColumnHstoreOptions} from "../options/ColumnHstoreOptions";
  
  /**
   * Column decorator is used to mark a specific class property as a table column. Only properties decorated with this
   * decorator will be persisted to the database when entity be saved.
   */
  export function Column(): Function;
  
  /**
   * Column decorator is used to mark a specific class property as a table column.
   * Only properties decorated with this decorator will be persisted to the database when entity be saved.
   */
  export function Column(options: ColumnOptions): Function;
  
  /**
   * Column decorator is used to mark a specific class property as a table column.
   * Only properties decorated with this decorator will be persisted to the database when entity be saved.
   */
  export function Column(type: SimpleColumnType, options?: ColumnCommonOptions): Function;
  
  /**
   * Column decorator is used to mark a specific class property as a table column.
   * Only properties decorated with this decorator will be persisted to the database when entity be saved.
   */
  export function Column(type: WithLengthColumnType, options?: ColumnCommonOptions & ColumnWithLengthOptions): Function;
  
  /**
   * Column decorator is used to mark a specific class property as a table column.
   * Only properties decorated with this decorator will be persisted to the database when entity be saved.
   */
  export function Column(type: WithPrecisionColumnType, options?: ColumnCommonOptions & ColumnNumericOptions): Function;
  
  /**
   * Column decorator is used to mark a specific class property as a table column.
   * Only properties decorated with this decorator will be persisted to the database when entity be saved.
   */
  export function Column(type: "enum", options?: ColumnCommonOptions & ColumnEnumOptions): Function;
  
  /**
   * Column decorator is used to mark a specific class property as a table column.
   * Only properties decorated with this decorator will be persisted to the database when entity be saved.
   */
  export function Column(type: "hstore", options?: ColumnCommonOptions & ColumnHstoreOptions): Function;
  
  /**
   * Column decorator is used to mark a specific class property as a table column.
   * Only properties decorated with this decorator will be persisted to the database when entity be saved.
   *
   * Property in entity can be marked as Embedded, and on persist all columns from the embedded are mapped to the
   * single table of the entity where Embedded is used. And on hydration all columns which supposed to be in the
   * embedded will be mapped to it from the single table.
   */
  export function Column(type: (type?: any) => Function, options?: ColumnEmbeddedOptions): Function;
  
  /**
   * Column decorator is used to mark a specific class property as a table column.
   * Only properties decorated with this decorator will be persisted to the database when entity be saved.
   */
  export function Column(typeOrOptions?: ((type?: any) => Function)|ColumnType|(ColumnOptions&ColumnEmbeddedOptions), options?: (ColumnOptions&ColumnEmbeddedOptions)): Function {
      return function (object: Object, propertyName: string) {
  
          // normalize parameters
          let type: ColumnType|undefined;
          if (typeof typeOrOptions === "string" || typeOrOptions instanceof Function) {
              type = <ColumnType> typeOrOptions;
  
          } else if (typeOrOptions) {
              options = <ColumnOptions> typeOrOptions;
              type = typeOrOptions.type;
          }
          if (!options) options = {} as ColumnOptions;
  
          // if type is not given explicitly then try to guess it
          const reflectMetadataType = Reflect && (Reflect as any).getMetadata ? (Reflect as any).getMetadata("design:type", object, propertyName) : undefined;
          if (!type && reflectMetadataType) // if type is not given explicitly then try to guess it
              type = reflectMetadataType;
  
          // check if there is no type in column options then set type from first function argument, or guessed one
          if (!options.type && type)
              options.type = type;
  
          // specify HSTORE type if column is HSTORE
          if (options.type === "hstore" && !options.hstoreType)
              options.hstoreType = reflectMetadataType === Object ? "object" : "string";
  
          if (typeOrOptions instanceof Function) { // register an embedded
              getMetadataArgsStorage().embeddeds.push({
                  target: object.constructor,
                  propertyName: propertyName,
                  isArray: reflectMetadataType === Array || options.array === true,
                  prefix: options.prefix !== undefined ? options.prefix : undefined,
                  type: typeOrOptions as (type?: any) => Function
              } as EmbeddedMetadataArgs);
  
          } else { // register a regular column
  
              // if we still don't have a type then we need to give error to user that type is required
              if (!options.type)
                  throw new ColumnTypeUndefinedError(object, propertyName);
  
              getMetadataArgsStorage().columns.push({
                  target: object.constructor,
                  propertyName: propertyName,
                  mode: "regular",
                  options: options
              } as ColumnMetadataArgs);
          }
      };
  }
  