main entry added

Robin Buschmann · Robin Buschmann · commit 53a2826492be · 2016-09-30T15:27:31.000+02:00
diff --git a/dist/annotations/AutoIncrement.d.ts b/dist/annotations/AutoIncrement.d.ts
@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+/**
+ * Sets auto increment true for annotated field
+ */
+export declare function AutoIncrement(target: any, propertyName: string): void;
diff --git a/dist/annotations/BelongsTo.d.ts b/dist/annotations/BelongsTo.d.ts
@@ -0,0 +1,2 @@
+import { Model } from "../models/Model";
+export declare function BelongsTo(relatedClassGetter: () => typeof Model, foreignKey?: string): (target: any, propertyName: string) => void;
diff --git a/dist/annotations/BelongsToMany.d.ts b/dist/annotations/BelongsToMany.d.ts
@@ -0,0 +1,3 @@
+import { Model } from "../models/Model";
+export declare function BelongsToMany(relatedClassGetter: () => typeof Model, throughClass: () => typeof Model): any;
+export declare function BelongsToMany(relatedClassGetter: () => typeof Model, through: string, foreignKey?: string): any;
diff --git a/dist/annotations/Boolean.d.ts b/dist/annotations/Boolean.d.ts
@@ -0,0 +1,8 @@
+import 'reflect-metadata';
+/**
+ * Sets type option for annotated property to specified value.
+ * This annotation will not work together with Column(options) annotation,
+ * but has to be used with Column (Please notice the difference with and
+ * without options)
+ */
+export declare const Boolean: (target: any, propertyName: string) => void;
diff --git a/dist/annotations/Column.d.ts b/dist/annotations/Column.d.ts
@@ -0,0 +1,5 @@
+/// <reference types="sequelize" />
+import 'reflect-metadata';
+import { DefineAttributeColumnOptions } from "sequelize";
+export declare function Column(options: DefineAttributeColumnOptions): any;
+export declare function Column(target: any, propertyName: string): any;
diff --git a/dist/annotations/Default.d.ts b/dist/annotations/Default.d.ts
@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+/**
+ * Sets the specified default value for the annotated field
+ */
+export declare function Default(value: any): (target: any, propertyName: string) => void;
diff --git a/dist/annotations/DefaultScope.d.ts b/dist/annotations/DefaultScope.d.ts
@@ -0,0 +1,7 @@
+/// <reference types="sequelize" />
+import 'reflect-metadata';
+import { FindOptions } from "sequelize";
+/**
+ * Sets default scope for annotated class
+ */
+export declare function DefaultScope(scope: FindOptions | Function): (target: any) => void;
diff --git a/dist/annotations/ForeignKey.d.ts b/dist/annotations/ForeignKey.d.ts
@@ -0,0 +1,2 @@
+import { Model } from "../models/Model";
+export declare function ForeignKey(relatedClassGetter: () => typeof Model): (target: any, propertyName: string) => void;
diff --git a/dist/annotations/HasMany.d.ts b/dist/annotations/HasMany.d.ts
@@ -0,0 +1,2 @@
+import { Model } from "../models/Model";
+export declare function HasMany(relatedClassGetter: () => typeof Model, foreignKey?: string): (target: any, propertyName: string) => void;
diff --git a/dist/annotations/HasOne.d.ts b/dist/annotations/HasOne.d.ts
@@ -0,0 +1,2 @@
+import { Model } from "../models/Model";
+export declare function HasOne(relatedClassGetter: () => typeof Model, foreignKey?: string): (target: any, propertyName: string) => void;
diff --git a/dist/annotations/PrimaryKey.d.ts b/dist/annotations/PrimaryKey.d.ts
@@ -0,0 +1,8 @@
+import 'reflect-metadata';
+/**
+ * Sets primary key option true for annotated property.
+ * This annotation will not work together with Column(options) annotation,
+ * but has to be used with Column (Please notice the difference with and
+ * without options)
+ */
+export declare function PrimaryKey(target: any, propertyName: string): void;
diff --git a/dist/annotations/Scopes.d.ts b/dist/annotations/Scopes.d.ts
@@ -0,0 +1,7 @@
+/// <reference types="sequelize" />
+import 'reflect-metadata';
+import { DefineScopeOptions } from "sequelize";
+/**
+ * Sets scopes for annotated class
+ */
+export declare function Scopes(scopes: DefineScopeOptions): (target: any) => void;
diff --git a/dist/annotations/Table.d.ts b/dist/annotations/Table.d.ts
@@ -0,0 +1,5 @@
+/// <reference types="sequelize" />
+import 'reflect-metadata';
+import { DefineOptions } from "sequelize";
+export declare function Table(options: DefineOptions<any>): any;
+export declare function Table(target: any): any;
diff --git a/dist/annotations/Type.d.ts b/dist/annotations/Type.d.ts
@@ -0,0 +1,10 @@
+/// <reference types="sequelize" />
+import 'reflect-metadata';
+import { DataTypeAbstract } from "sequelize";
+/**
+ * Sets type option for annotated property to specified value.
+ * This annotation will not work together with Column(options) annotation,
+ * but has to be used with Column (Please notice the difference with and
+ * without options)
+ */
+export declare function Type(type: string | DataTypeAbstract): (target: any, propertyName: string) => void;
diff --git a/dist/interfaces/IFindOptions.d.ts b/dist/interfaces/IFindOptions.d.ts
@@ -0,0 +1,82 @@
+/// <reference types="sequelize" />
+import { Model } from "../models/Model";
+import { col } from "sequelize";
+import { and } from "sequelize";
+import { or } from "sequelize";
+import { WhereOptions } from "sequelize";
+import { FindOptionsAttriburesArray } from "sequelize";
+import { IIncludeOptions } from "./IIncludeOptions";
+import { literal } from "sequelize";
+import { SearchPathOptions } from "sequelize";
+import { LoggingOptions } from "sequelize";
+export interface IFindOptions extends LoggingOptions, SearchPathOptions {
+    /**
+     * A hash of attributes to describe your search. See above for examples.
+     */
+    where?: WhereOptions | Array<col | and | or | string>;
+    /**
+     * A list of the attributes that you want to select. To rename an attribute, you can pass an array, with
+     * two elements - the first is the name of the attribute in the DB (or some kind of expression such as
+     * `Sequelize.literal`, `Sequelize.fn` and so on), and the second is the name you want the attribute to
+     * have in the returned instance
+     */
+    attributes?: FindOptionsAttriburesArray | {
+        include?: FindOptionsAttriburesArray;
+        exclude?: Array<string>;
+    };
+    /**
+     * If true, only non-deleted records will be returned. If false, both deleted and non-deleted records will
+     * be returned. Only applies if `options.paranoid` is true for the model.
+     */
+    paranoid?: boolean;
+    /**
+     * A list of associations to eagerly load using a left join. Supported is either
+     * `{ include: [ Model1, Model2, ...]}` or `{ include: [{ model: Model1, as: 'Alias' }]}`.
+     * If your association are set up with an `as` (eg. `X.hasMany(Y, { as: 'Z }`, you need to specify Z in
+     * the as attribute when eager loading Y).
+     */
+    include?: Array<typeof Model | IIncludeOptions>;
+    /**
+     * Specifies an ordering. If a string is provided, it will be escaped. Using an array, you can provide
+     * several columns / functions to order by. Each element can be further wrapped in a two-element array. The
+     * first element is the column / function to order by, the second is the direction. For example:
+     * `order: [['name', 'DESC']]`. In this way the column will be escaped, but the direction will not.
+     */
+    order?: string | col | literal | Array<string | number | typeof Model | {
+        model: typeof Model;
+        as?: string;
+    }> | Array<string | col | literal | Array<string | number | typeof Model | {
+        model: typeof Model;
+        as?: string;
+    }>>;
+    /**
+     * Limit the results
+     */
+    limit?: number;
+    /**
+     * Skip the results;
+     */
+    offset?: number;
+    /**
+     * Lock the selected rows. Possible options are transaction.LOCK.UPDATE and transaction.LOCK.SHARE.
+     * Postgres also supports transaction.LOCK.KEY_SHARE, transaction.LOCK.NO_KEY_UPDATE and specific model
+     * locks with joins. See [transaction.LOCK for an example](transaction#lock)
+     */
+    lock?: string | {
+        level: string;
+        of: typeof Model;
+    };
+    /**
+     * Return raw result. See sequelize.query for more information.
+     */
+    raw?: boolean;
+    /**
+     * having ?!?
+     */
+    having?: WhereOptions;
+    /**
+     * Group by. It is not mentioned in sequelize's JSDoc, but mentioned in docs.
+     * https://github.com/sequelize/sequelize/blob/master/docs/docs/models-usage.md#user-content-manipulating-the-dataset-with-limit-offset-order-and-group
+     */
+    group?: string | string[] | Object;
+}
diff --git a/dist/interfaces/IIncludeOptions.d.ts b/dist/interfaces/IIncludeOptions.d.ts
@@ -0,0 +1,42 @@
+/// <reference types="sequelize" />
+import { Model } from "../models/Model";
+import { IncludeAssociation } from "sequelize";
+import { WhereOptions } from "sequelize";
+import { IncludeThroughOptions } from "sequelize";
+export interface IIncludeOptions {
+    /**
+     * The model you want to eagerly load
+     */
+    model?: typeof Model;
+    /**
+     * The alias of the relation, in case the model you want to eagerly load is aliassed. For `hasOne` /
+     * `belongsTo`, this should be the singular name, and for `hasMany`, it should be the plural
+     */
+    as?: string;
+    /**
+     * The association you want to eagerly load. (This can be used instead of providing a model/as pair)
+     */
+    association?: IncludeAssociation;
+    /**
+     * Where clauses to apply to the child models. Note that this converts the eager load to an inner join,
+     * unless you explicitly set `required: false`
+     */
+    where?: WhereOptions;
+    /**
+     * A list of attributes to select from the child model
+     */
+    attributes?: string[];
+    /**
+     * If true, converts to an inner join, which means that the parent model will only be loaded if it has any
+     * matching children. True if `include.where` is set, false otherwise.
+     */
+    required?: boolean;
+    /**
+     * Through Options
+     */
+    through?: IncludeThroughOptions;
+    /**
+     * Load further nested related models
+     */
+    include?: Array<typeof Model | IIncludeOptions>;
+}
diff --git a/dist/interfaces/ISequelizeAssociation.d.ts b/dist/interfaces/ISequelizeAssociation.d.ts
@@ -0,0 +1,9 @@
+import { Model } from "../models/Model";
+export interface ISequelizeAssociation {
+    relation: string;
+    relatedClassGetter: () => typeof Model;
+    through?: string;
+    throughClassGetter?: () => typeof Model;
+    foreignKey?: string;
+    as: string;
+}
diff --git a/dist/interfaces/ISequelizeConfig.d.ts b/dist/interfaces/ISequelizeConfig.d.ts
@@ -0,0 +1,7 @@
+export interface ISequelizeConfig {
+    name: string;
+    dialect: string;
+    host: string;
+    username: string;
+    password: string;
+}
diff --git a/dist/interfaces/ISequelizeForeignKeyConfig.d.ts b/dist/interfaces/ISequelizeForeignKeyConfig.d.ts
@@ -0,0 +1,5 @@
+import { Model } from "../models/Model";
+export interface ISequelizeForeignKeyConfig {
+    relatedClassGetter: () => typeof Model;
+    foreignKey: string;
+}
diff --git a/dist/main.d.ts b/dist/main.d.ts
@@ -0,0 +1,24 @@
+export { AutoIncrement } from "./annotations/AutoIncrement";
+export { BelongsTo } from "./annotations/BelongsTo";
+export { BelongsToMany } from "./annotations/BelongsToMany";
+export { Boolean } from "./annotations/Boolean";
+export { Column } from "./annotations/Column";
+export { Default } from "./annotations/Default";
+export { DefaultScope } from "./annotations/DefaultScope";
+export { ForeignKey } from "./annotations/ForeignKey";
+export { HasMany } from "./annotations/HasMany";
+export { HasOne } from "./annotations/HasOne";
+export { PrimaryKey } from "./annotations/PrimaryKey";
+export { Scopes } from "./annotations/Scopes";
+export { Table } from "./annotations/Table";
+export { Type } from "./annotations/Type";
+export { IFindOptions } from "./interfaces/IFindOptions";
+export { IIncludeOptions } from "./interfaces/IIncludeOptions";
+export { ISequelizeAssociation } from "./interfaces/ISequelizeAssociation";
+export { ISequelizeConfig } from "./interfaces/ISequelizeConfig";
+export { ISequelizeForeignKeyConfig } from "./interfaces/ISequelizeForeignKeyConfig";
+export { DataType } from "./models/DataType";
+export { Model } from "./models/Model";
+export { SequelizeService } from "./services/SequelizeService";
+export { SequelizeAssociationService } from "./services/SequelizeAssociationService";
+export { SequelizeModelService } from "./services/SequelizeModelService";
diff --git a/dist/main.js b/dist/main.js
diff --git a/dist/main.js.map b/dist/main.js.map
diff --git a/dist/models/DataType.d.ts b/dist/models/DataType.d.ts
@@ -0,0 +1,3 @@
+/// <reference types="sequelize" />
+import { DataTypes } from "sequelize";
+export declare const DataType: DataTypes;
diff --git a/dist/models/Model.d.ts b/dist/models/Model.d.ts
diff --git a/dist/services/SequelizeAssociationService.d.ts b/dist/services/SequelizeAssociationService.d.ts
diff --git a/dist/services/SequelizeModelService.d.ts b/dist/services/SequelizeModelService.d.ts
diff --git a/dist/services/SequelizeService.d.ts b/dist/services/SequelizeService.d.ts
diff --git a/package.json b/package.json
diff --git a/src/main.ts b/src/main.ts
diff --git a/tsconfig.json b/tsconfig.json

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+import { Model } from "../models/Model";`
	`2`	`+export declare function BelongsTo(relatedClassGetter: () => typeof Model, foreignKey?: string): (target: any, propertyName: string) => void;`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+import { Model } from "../models/Model";`
	`2`	`+export declare function BelongsToMany(relatedClassGetter: () => typeof Model, throughClass: () => typeof Model): any;`
	`3`	`+export declare function BelongsToMany(relatedClassGetter: () => typeof Model, through: string, foreignKey?: string): any;`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+import { Model } from "../models/Model";`
	`2`	`+export declare function ForeignKey(relatedClassGetter: () => typeof Model): (target: any, propertyName: string) => void;`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+import { Model } from "../models/Model";`
	`2`	`+export declare function HasMany(relatedClassGetter: () => typeof Model, foreignKey?: string): (target: any, propertyName: string) => void;`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+import { Model } from "../models/Model";`
	`2`	`+export declare function HasOne(relatedClassGetter: () => typeof Model, foreignKey?: string): (target: any, propertyName: string) => void;`