TypeScript Sequelize.addModels方法代碼示例

async function initDatabaseModels (silent: boolean) {
  sequelizeTypescript.addModels([
    ApplicationModel,
    ActorModel,
    ActorFollowModel,
    AvatarModel,
    AccountModel,
    OAuthClientModel,
    OAuthTokenModel,
    ServerModel,
    TagModel,
    AccountVideoRateModel,
    UserModel,
    VideoAbuseModel,
    VideoChannelModel,
    VideoShareModel,
    VideoFileModel,
    VideoBlacklistModel,
    VideoTagModel,
    VideoModel,
    VideoCommentModel,
    ScheduleVideoUpdateModel
  ])

  if (!silent) logger.info('Database %s is ready.', dbname)

  return
}

 useFactory: async () => {
     const sequelize = new Sequelize({
         dialect: 'mssql',
         host: 'localhost',
         port: 1433,
         username: 'sa',
         password: 'Aa123456',
         database: 'IronManNest'
     });
     sequelize.addModels([Users]);
     await sequelize.sync();
     return sequelize;
 }

 useFactory: async () => {
   const sequelize = new Sequelize({
     operatorsAliases: false,
     dialect: 'mysql',
     host: 'localhost',
     port: 3306,
     username: 'root',
     password: 'root',
     database: 'test',
   });
   sequelize.addModels([Cat]);
   await sequelize.sync();
   return sequelize;
 },

    constructor() {
        let dbConfig = config.databaseConfig;

        if (config.isTest === true) {
            this._sequelize = new SequelizeMock('', '', '', {
                autoQueryFallback: false,
            });
        } else {
            this._sequelize = new Sequelize({
                database: dbConfig.database,
                dialect: 'sqlite',
                username: dbConfig.username,
                password: dbConfig.password,
                storage: dbConfig.outputPath,
                logging: false,
            });
            this._sequelize.addModels([AppSetting, Settings, TrackItem]);
            console.info(`Models path ${__dirname + '/models'}`);
        }
    }

/* eslint-disable import/no-extraneous-dependencies,no-new */

import path from 'path'
import { Sequelize } from 'sequelize-typescript'
import Animal from './models/animal'
import Dog from './models/dog'
import Bird from './models/bird'
// , Dog, Bird

const sequelize = new Sequelize('mysql://root:jarvis@127.0.0.1:3306/ts_test')
//                             dialect://username:password@host:port/db_name

sequelize.addModels([path.resolve(__dirname, `./models/`)]);
(async () => {
  try {
    const animalList = await Animal.getList()
    const dogList = await Dog.getList<Dog>()

    console.log(animalList)
    console.log(dogList)

    // console.log(dogList[0].leg)

    // Animal.create<Animal>({
    //   name: 'Niko',
    //   weight: 19,
    // })

    process.exit(0)
  } catch (e) {
    console.error(e)

    console.log(`${chalk.bold('SQL')} ${now()} ${chalk.gray(sql)}`)
  }
  : console.log

const sequelize = new Sequelize({
  database: config.db.database,
  dialect: config.db.dialect,
  username: config.db.username,
  password: config.db.password,
  host: config.db.host,
  port: config.db.port,
  pool: config.db.pool,
  logging: config.db.logging ? logging : false,
})

sequelize.addModels([__dirname + '/bo'])
sequelize.authenticate()
  .then((/* err */) => {
    console.log('----------------------------------------')
    console.log('DATABASE √')
    console.log('    HOST     %s', config.db.host)
    console.log('    PORT     %s', config.db.port)
    console.log('    DATABASE %s', config.db.database)
    console.log('----------------------------------------')
    MigrateService.checkAndFix()
  })
  .catch(err => {
    console.log('Unable to connect to the database:', err)
  })

  export default sequelize

"use strict";

import { Sequelize } from "sequelize-typescript";

import { Account } from "./Account";
import { Provider } from "./Provider";

import { Database } from "../config/-index";

const env = process.env.NODE_ENV || "development";
const db  = Database[env];

const sequelize = new Sequelize({
  host      : db.host,
  database  : db.database,
  dialect   : db.dialect,
  username  : db.username,
  password  : db.password,
  operatorsAliases: false
});


sequelize.addModels([ Account, Provider ]);

export { sequelize, Sequelize };

import {Sequelize} from 'sequelize-typescript';
import { Stem, Track } from './models';

const env = process.env.NODE_ENV || "development";
const dbProdName = "implib.prod.sqlite";
const dbConfig = require(`${__dirname}/config/dbConfig.json`)[env];
const appConfig = require(`${__dirname}/../config/appConfig.json`)[env];

// TODO: Get these paths configured and available in a global settings file
//If in production, make sure to setup the DB in the user's app data folder
if(env === "production") {
  dbConfig.storage = path.join(
    require("electron").remote.app.getPath("appData"),
    appConfig.appName,
    dbProdName);
}
console.log("SQLite DB instantiated at [" + dbConfig.storage + "]");

const sequelize = new Sequelize(dbConfig);
sequelize.addModels([ Stem, Track]);
sequelize.sync({force: true});

const db = {
  sequelize,
  Sequelize,
  Stem: Stem,
  Track: Track
}

export default db;