Si encuentras alguna parte que no comprendes puedes comentarlo y trataremos de ayudarte rápidamente.
Solución:
El uso de decoradores es algo que debe evitar tanto como sea posible, no son estándar de ECMAScript. Incluso se consideran legados. Es por eso que les mostraré cómo usar la secuenciación con mecanografiado.
solo tenemos que seguir los documentos: https://sequelize.org/v5/manual/typescript.html pero como no está muy claro, o al menos para mí. Me tomó un tiempo entenderlo.
Allí dice que necesitas instalar este árbol.
* @types/node
* @types/validator // this one is not need it
* @types/bluebird
npm i -D @types/node @types/bluebird
entonces supongamos que su proyecto se ve así:
myProject
--src
----models
------index.ts
------user-model.ts
------other-model.ts
----controllers
----index.ts
--package.json
Primero creemos el modelo de usuario
`./src/models/user-model.ts`
import BuildOptions, DataTypes, Model, Sequelize from "sequelize";
export interface UserAttributes
id: number;
name: string;
email: string;
createdAt?: Date;
updatedAt?: Date;
export interface UserModel extends Model, UserAttributes
export class User extends Model
export type UserStatic = typeof Model &
new (values?: object, options?: BuildOptions): UserModel;
;
export function UserFactory (sequelize: Sequelize): UserStatic
return sequelize.define("users",
id:
type: DataTypes.INTEGER,
autoIncrement: true,
primaryKey: true,
,
email:
type: DataTypes.STRING,
allowNull: false,
unique: true,
,
name:
type: DataTypes.STRING,
allowNull: false,
,
createdAt:
type: DataTypes.DATE,
allowNull: false,
defaultValue: DataTypes.NOW,
,
updatedAt:
type: DataTypes.DATE,
allowNull: false,
defaultValue: DataTypes.NOW,
,
);
Ahora solo para jugar con la flecha, creemos otro modelo.ts
`./src/models/another-model.ts`
import BuildOptions, DataTypes, Model, Sequelize from "sequelize";
export interface SkillsAttributes
id: number;
skill: string;
createdAt?: Date;
updatedAt?: Date;
export interface SkillsModel extends Model, SkillsAttributes
export class Skills extends Model
export type SkillsStatic = typeof Model &
new (values?: object, options?: BuildOptions): SkillsModel;
;
export function SkillsFactory (sequelize: Sequelize): SkillsStatic
return sequelize.define("skills",
id:
type: DataTypes.INTEGER,
autoIncrement: true,
primaryKey: true,
,
skill:
type: DataTypes.STRING,
allowNull: false,
unique: true,
,
createdAt:
type: DataTypes.DATE,
allowNull: false,
defaultValue: DataTypes.NOW,
,
updatedAt:
type: DataTypes.DATE,
allowNull: false,
defaultValue: DataTypes.NOW,
,
);
Nuestras Entidades están hechas. ahora la conexión db.
abierto ./src/models/index.ts ahí es donde colocaremos la instancia de seqelize
`./src/models/index.ts`
import * as sequelize from "sequelize";
import userFactory from "./user-model";
import skillsFactory from "./other-model";
export const dbConfig = new sequelize.Sequelize(
(process.env.DB_NAME = "db-name"),
(process.env.DB_USER = "db-user"),
(process.env.DB_PASSWORD = "db-password"),
"localhost",
dialect: "postgres",
pool:
min: 0,
max: 5,
acquire: 30000,
idle: 10000,
,
);
// SOMETHING VERY IMPORTANT them Factory functions expect a
// sequelize instance as parameter give them `dbConfig`
export const User = userFactory(dbConfig);
export const Skills = skillsFactory(dbConfig);
// Users have skills then lets create that relationship
User.hasMay(Skills);
// or instead of that, maybe many users have many skills
Skills.belongsToMany(Users, through: "users_have_skills" );
// the skill is the limit!
en nuestro index.ts agregar, si solo desea abrir la conexión
db.sequelize
.authenticate()
.then(() => logger.info("connected to db"))
.catch(() =>
throw "error";
);
o si quieres crearles tablas
db.sequelize
.sync()
.then(() => logger.info("connected to db"))
.catch(() =>
throw "error";
);
algo como esto
import * as bodyParser from "body-parser";
import * as express from "express";
import dbConfig from "./models";
import routes from "./routes";
import logger from "./utils/logger";
import timeMiddleware from "./utils/middlewares";
export function expressApp ()
dbConfig
.authenticate()
.then(() => logger.info("connected to db"))
.catch(() =>
throw "error";
);
const app: Application = express();
if (process.env.NODE_ENV === "production")
app.use(require("helmet")());
app.use(require("compression")());
else
app.use(require("cors")());
app.use(bodyParser.json());
app.use(bodyParser.urlencoded( extended: true, limit: "5m" ));
app.use(timeMiddleware);
app.use("/", routes(db));
return app;
Una vez más el cielo es el límite. Si hace esto, tendrá todo el poder del autocompletado. aquí un ejemplo: https://github.com/EnetoJara/resume-app
Utilice sequelize-typecript. Convierta sus tablas y vistas en una clase que amplíe el objeto Modelo.
Use anotaciones en clases para definir su tabla.
import Table, Column, Model, HasMany from 'sequelize-typescript';
@Table
class Person extends Model
@Column
name: string;
@Column
birthday: Date;
@HasMany(() => Hobby)
hobbies: Hobby[];
Cree una conexión a DB creando el objeto:
const sequelize = new Sequelize(configuration...).
Luego registre sus tablas en este objeto.
sequelize.add([Person])
Para mayor referencia, consulte este módulo. Sequelize-Mecanografiado
Si para ti ha resultado de ayuda nuestro artículo, sería de mucha ayuda si lo compartieras con otros seniors de esta manera nos ayudas a extender este contenido.