How to use sequelize-typescript - 10 common examples

export const createContainer = (): Container => {
  const container = new Container();
  // Generics
  container.bind(Symbols.generic.appConfig)
    .toConstantValue(JSON.parse(JSON.stringify(require(`${__dirname}/../integration/config.json`))));
  container.bind(Symbols.generic.genesisBlock)
    .toConstantValue(JSON.parse(JSON.stringify(require(`${__dirname}/../integration/genesisBlock.json`))));
  const genesis              = container.get(Symbols.generic.genesisBlock)
  genesis.generatorPublicKey = Buffer.from(genesis.generatorPublicKey, 'hex');
  genesis.blockSignature     = Buffer.from(genesis.blockSignature, 'hex');

  container.bind(Symbols.generic.socketIO).to(SocketIOStub).inSingletonScope();
  container.bind(Symbols.generic.zschema).to(ZSchemaStub).inSingletonScope();
  container.bind(Symbols.generic.sequelize).toConstantValue(new Sequelize({
    database: 'test',
    //dialect: 'sqlite',
    dialect : 'postgres',
    username: 'root',
    password: 'test',
    //storage: ':memory',
    logging : !('SEQ_SILENT' in process.env),
  }));

  container.bind(Symbols.helpers.constants).toConstantValue({ ...{}, ...constants });
  container.bind(Symbols.helpers.bus).to(BusStub).inSingletonScope();
  container.bind(Symbols.helpers.crypto).to(CryptoStub).inSingletonScope();
  container.bind(Symbols.helpers.db).to(DbStub).inSingletonScope();
  container.bind(Symbols.helpers.migrator).to(MigratorStub).inSingletonScope();
  container.bind(Symbols.helpers.exceptionsManager).to(ExceptionsManagerStub).inSingletonScope();
  container.bind(Symbols.helpers.jobsQueue).to(JobsQueueStub).inSingletonScope();

{
    id: 'PostModel',
    provider: factory,
  },
]);
// you need to export the type of Model class to ensure
// type-safety outside
export type IPostModel = typeof PostModel;

@Scopes({
  // a self-defined scope means "non-soft-deleted rows"
  avaliable: {
    where: {status: 1},
  },
})
@Table({
  // you can claim your tableName explicitly
  freezeTableName: true,
  tableName: 'my_posts_table',
})
export class PostModel extends Model {

  @Column({
    type: BIGINT(20),
    primaryKey: true,
    autoIncrement: true,
    comment: 'post id',
  })
  id: number;

  @Column({
    type: STRING(1024),

// tslint:disable
import { Column, DataType, ForeignKey, Model, PrimaryKey, Table } from 'sequelize-typescript';
import 'reflect-metadata';
import { publicKey } from '../types/sanityTypes';
import { BlocksModel } from './BlocksModel';
import { AccountsModel } from './AccountsModel';


@Table({ tableName: 'mem_rounds' })
export class MemRoundsModel extends Model {
  @PrimaryKey
  @ForeignKey(() => AccountsModel)
  @Column
  public address: string;

  @PrimaryKey
  @Column
  public amount: number;

  @PrimaryKey
  @Column(DataType.TEXT)
  public delegate: publicKey;

  @PrimaryKey
  @ForeignKey(() => BlocksModel)

import {Sequelize} from 'sequelize-typescript';
import * as config from '../config/config.json';

// dynamic configuration depending on env
const env = process.env.NODE_ENV || 'development';
const sequelize = new Sequelize(config[env]);
sequelize.addModels([`${__dirname}/../models`]);

// Convert decimals from String to Number right away - mainly for PSS in number instead of string
Sequelize.postgres.DECIMAL.parse = value => parseFloat(value);

export default sequelize;

let config;
switch (process.env.NODE_ENV) {
    case 'prod':
    case 'production':
        config = databaseConfig.production;
    case 'dev':
    case 'development':
        config = databaseConfig.development;
    case 'test':
        config = databaseConfig.test;
    default:
        config = databaseConfig.development;
}

const sequelize = new Sequelize(config);

const umzug = new Umzug({
    storage: 'sequelize',
    storageOptions: { sequelize },

    // see: https://github.com/sequelize/umzug/issues/17
    migrations: {
        params: [
            sequelize,
            sequelize.constructor, // DataTypes
            function() {
                throw new Error(
                    'Migration tried to use old style "done" callback. Please upgrade to "umzug" and return a promise instead.'
                );
            }
        ],

AllowNull,
  BelongsTo,
  Column,
  DataType,
  ForeignKey,
  Model,
  Table,
} from "sequelize-typescript";
import Experiment from "./experiment";
import User from "./user";
import getScheduler from "../scheduler";

@Table
export default class NotificationRequest extends Model {
  @ForeignKey(() => Experiment)
  @AllowNull(false)
  @Column(DataType.UUID)
  public experimentId: string;

  @BelongsTo(() => Experiment)
  public experiment: Experiment;

  @ForeignKey(() => User)
  @AllowNull(false)
  @Column(DataType.STRING)
  public userId: string;

  @BelongsTo(() => User)
  public user: User;

  public static async findAllWithWorkAvailable() {
    // Notification system disabled

*/
    @Column({
        type: DataType.CHAR(63),
        allowNull: false,
        defaultValue: () => nanoid(),
        unique: 'unique_slug',
        // unique: 'unique_slug_version',
    })
    slug: string;

    /**
     * The user-defined name of the playground.
     *
     */
    @Column({
        type: DataType.STRING(1023),
    })
    name: string;

    /**
     * The user-defined description of the playground.
     *
     */
    @Column({
        type: DataType.STRING(4095),
    })
    description: string;

    /**
     * The playground contents.
     *
     */

@BelongsTo(() => Employee)
    employee: Employee;

    // Role
    @ForeignKey(() => Role)
    @Column
    roleId: number;

    @BelongsTo(() => Role)
    role: Role;

    @CreatedAt
    @Column({
        type: DataType.DATE,
        defaultValue: DataType.NOW
    })
    createdAt: Date;

    @UpdatedAt
    @Column({
        type: DataType.DATE,
        defaultValue: DataType.NOW
    })
    updatedAt: Date;
}

import {
  FilteredModelAttributes,
  IAccountsModel,
} from '@risevision/core-types';
import 'reflect-metadata';
import { BuildOptions } from 'sequelize';
import { Column, DataType, DefaultScope } from 'sequelize-typescript';

@DefaultScope(() => ({
  attributes: ['secondSignature', 'secondPublicKey', 'u_secondSignature'],
}))
export class AccountsModelWith2ndSign extends IAccountsModel {
  @Column
  public secondSignature: 0 | 1;
  @Column(DataType.BLOB)
  public secondPublicKey: Buffer;
  @Column
  // tslint:disable-next-line variable-name
  public u_secondSignature: 0 | 1;

  constructor(
    values?: FilteredModelAttributes,
    options?: BuildOptions
  ) {
    super(values, options);
  }
}

@Column
  public numberOfTransactions: number;

  @Column(DataType.BIGINT)
  public totalAmount: bigint;

  @Column(DataType.BIGINT)
  public totalFee: bigint;

  @Column(DataType.BIGINT)
  public reward: bigint;

  @Column
  public payloadLength: number;

  @Column(DataType.BLOB)
  public payloadHash: Buffer;

  @Column(DataType.BLOB)
  public generatorPublicKey: Buffer;

  @Column(DataType.BLOB)
  public blockSignature: Buffer;

  public transactions: ITransactionsModel[];

  // tslint:disable-next-line
  @HasMany(
    () =>
      this.BlocksModel.container.getNamed(
        ModelSymbols.model,
        Symbols.models.transactions