Czy uniemożliwić Sequelize wysyłanie kodu SQL do konsoli po wykonaniu zapytania?

Mam funkcję pobierania profilu użytkownika.

app.get('/api/user/profile', function (request, response)
{
  // Create the default error container
  var error = new Error();

  var User = db.User;
  User.find({
    where: { emailAddress: request.user.username}
  }).then(function(user)
  {
    if(!user)
    {
      error.status = 500; error.message = "ERROR_INVALID_USER"; error.code = 301;
      return next(error);
    }

    // Build the profile from the user object
    profile = {
      "firstName": user.firstName,
      "lastName": user.lastName,
      "emailAddress": user.emailAddress
    }
    response.status(200).send(profile);
  });
});

Po wywołaniu funkcji „znajdź” wyświetla ona instrukcję select na konsoli, na której serwer został uruchomiony.

Executing (default): SELECT `id`, `firstName`, `lastName`, `emailAddress`, `password`, `passwordRecoveryToken`, `passwordRecoveryTokenExpire`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`emailAddress` = 'johndoe@doe.com' LIMIT 1;

Czy istnieje sposób, aby nie wyświetlać tego? Jakieś flagi, które ustawiłem gdzieś w pliku konfiguracyjnym?

Podczas tworzenia obiektu Sequelize przejdź falsedo loggingparametru:

var sequelize = new Sequelize('database', 'username', 'password', {

  // disable logging; default: console.log
  logging: false

});

Aby uzyskać więcej opcji, sprawdź dokumenty .

Jeśli używany jest plik „config / config.json”, dodaj „logowanie”: false do pliku config.json w tym przypadku w sekcji konfiguracji programowania.

  // file config/config.json
  {
      {
      "development": {
        "username": "username",
        "password": "password",
        "database": "db_name",
        "host": "127.0.0.1",
        "dialect": "mysql",
        "logging": false
      },
      "test": {
    ...
   }

Podobnie jak w innych odpowiedziach, możesz po prostu ustawić logging:false, ale myślę, że lepiej niż całkowicie wyłączyć rejestrowanie, możesz po prostu uwzględnić poziomy dziennika w swojej aplikacji. Czasami możesz rzucić okiem na wykonane zapytania, więc lepiej jest skonfigurować Sequelize do logowania na poziomie szczegółowym lub debugowania. na przykład (używam tutaj Winstona jako frameworku rejestrowania, ale możesz użyć dowolnego innego frameworka):

var sequelize = new Sequelize('database', 'username', 'password', {
  logging: winston.debug
});

Spowoduje to wyświetlenie instrukcji SQL tylko wtedy, gdy dla poziomu dziennika winston ustawiono debugowanie lub niższe poziomy debugowania. Jeśli poziom dziennika jest ostrzeżony lub informacje, na przykład SQL nie zostanie zarejestrowany

Wszystkie te odpowiedzi są wyłączone podczas rejestrowania .

Ale co, jeśli musimy wyłączyć środowisko wykonawcze logowania ?

Przez środowisko uruchomieniowe mam na myśli po zainicjowaniu sequelizeobiektu za pomocą new Sequelize(..funkcji.

Zajrzałem do źródła github , znalazłem sposób na wyłączenie logowania w środowisku wykonawczym.

// Somewhere your code, turn off the logging
sequelize.options.logging = false

// Somewhere your code, turn on the logging
sequelize.options.logging = true 

Na podstawie tej dyskusji zbudowałem to, config.jsonco działa idealnie:

{
  "development": {
    "username": "root",
    "password": null,
    "logging" : false,
    "database": "posts_db_dev",
    "host": "127.0.0.1",
    "dialect": "mysql",
    "operatorsAliases": false 
  }
}

Oto moja odpowiedź:

Krótko : Używałemtypeorm jako biblioteki ORM. Aby ustawić poziom rejestrowania zapytania, użyłem następującej opcji zamiast bezpośredniego ustawienia opcji rejestrowania jako false.

Rozwiązanie: Nazwa pliku - ormconfig.ts

{
    'type': process.env.DB_DRIVER,
    'host': process.env.DB_HOST,
    'port': process.env.DB_PORT,
    'username': process.env.DB_USER,
    'password': process.env.DB_PASS,
    'database': process.env.DB_NAME,
    'migrations': [process.env.MIGRATIONS_ENTITIES],
    'synchronize': false,
    'logging': process.env.DB_QUERY_LEVEL,
    'entities': [
        process.env.ORM_ENTITIES
    ],
    'cli': {
        'migrationsDir': 'migrations'
     }
}

I w zmiennej środowiska ustaw DB_QUERY_LEVELjako [„zapytanie”, „błąd”].

Wynik: w rezultacie będzie się logować tylko wtedy, gdy zapytanie zawiera błąd, w przeciwnym razie nie będzie.

Odsyłacz referencyjny : typorm db zapytanie rejestrowanie doc

Mam nadzieję że to pomoże! Dzięki.

Używam Sequelize ORM 6.0.0 i używam „logowania”: false jako reszta, ale opublikowałem moją odpowiedź na najnowszą wersję ORM.

const sequelize = new Sequelize(
        process.env.databaseName,
        process.env.databaseUser,
        process.env.password,
        {
            host: process.env.databaseHost,
            dialect: process.env.dialect,
            "logging": false,
            define: {
                // Table names won't be pluralized.
                freezeTableName: true,
                // All tables won't have "createdAt" and "updatedAt" Auto fields.
                timestamps: false
            }
        }
    );

Uwaga: Moje sekrety przechowuję w pliku konfiguracyjnym, .envprzestrzegając metodologii 12-czynnikowej.

Rozwiązałem wiele problemów, używając następującego kodu. Problemy były:

1. Brak połączenia z bazą danych
2. Problemy z odrzuceniem połączenia z bazą danych
3. Pozbywanie się dzienników w konsoli (specyficzne dla tego).

const sequelize = new Sequelize("test", "root", "root", {
  host: "127.0.0.1",
  dialect: "mysql",
  port: "8889",
  connectionLimit: 10,
  socketPath: "/Applications/MAMP/tmp/mysql/mysql.sock",
  // It will disable logging
  logging: false
});