From 0f439c12113137eccfdb098721a8cd4c665e692a Mon Sep 17 00:00:00 2001 From: 1549469775 <1549469775@qq.com> Date: Mon, 28 Feb 2022 16:44:39 +0800 Subject: [PATCH] rrr --- docs/a.md | 1 + log/SQL.log | 41362 +++++++++++++++++++++ package.json | 2 +- packages/hapi-router/dist/hapi-router.cjs.js | 2 +- packages/hapi-router/dist/hapi-router.cjs.js.map | 2 +- packages/hapi-router/src/index.ts | 2 +- public/css/page/a.css | 3 + public/css/page/a.styl | 2 + public/css/page/css.css | 3 - route.txt | 19 + source/auth/index.ts | 2 + source/models/Constant.ts | 24 + source/route/api/user/index.ts | 1 - source/route/index/color.ts | 2 +- source/route/index/index.ts | 40 +- source/route/nav/index.ts | 9 + source/route/route.txt | 15 - source/run.ts | 2 +- template/views/index.pug | 2 +- 19 files changed, 41460 insertions(+), 35 deletions(-) create mode 100644 docs/a.md create mode 100644 public/css/page/a.css create mode 100644 public/css/page/a.styl create mode 100644 route.txt create mode 100644 source/models/Constant.ts create mode 100644 source/route/nav/index.ts delete mode 100644 source/route/route.txt diff --git a/docs/a.md b/docs/a.md new file mode 100644 index 0000000..38d86df --- /dev/null +++ b/docs/a.md @@ -0,0 +1 @@ +sdad \ No newline at end of file diff --git a/log/SQL.log b/log/SQL.log index 2b5aa14..10c8db2 100644 --- a/log/SQL.log +++ b/log/SQL.log @@ -17016,3 +17016,41365 @@ inMemory: 0, readWriteMode: 6 } +[2022-02-28T09:22:18.878] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:22:18.915] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:22:18.916] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:22:18.917] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:22:18.918] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:26:25.554] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:26:25.572] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:26:25.574] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:26:25.575] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:26:25.575] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:26:38.623] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:26:38.640] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:26:38.642] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:26:38.643] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:26:38.643] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:26:42.413] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:26:42.430] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:26:42.431] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:26:42.432] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:26:42.433] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:27:06.114] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:27:06.131] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:27:06.132] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:27:06.133] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:27:06.134] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:28:35.973] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:28:36.006] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:28:36.007] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:28:36.008] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:28:36.009] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:31:02.625] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:31:02.646] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:31:02.648] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:31:02.649] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:31:02.650] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:31:34.190] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:31:34.207] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:31:34.209] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:31:34.210] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:31:34.210] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:31:42.231] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:31:42.248] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:31:42.249] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:31:42.250] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:31:42.251] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:32:05.309] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:32:05.326] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:32:05.328] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:32:05.329] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:32:05.329] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:32:40.790] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:32:40.807] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:32:40.809] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:32:40.810] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:32:40.811] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:32:43.724] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:32:43.741] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:32:43.743] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:32:43.744] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:32:43.744] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:33:19.791] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:33:19.808] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:33:19.809] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:33:19.810] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:33:19.811] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:33:22.392] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:33:22.409] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:33:22.411] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:33:22.412] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:33:22.412] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:33:30.798] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:33:30.815] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:33:30.817] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:33:30.818] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:33:30.818] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:34:07.415] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:34:07.432] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:34:07.433] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:34:07.434] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:34:07.435] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:34:43.873] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:34:43.890] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:34:43.892] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:34:43.892] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:34:43.893] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:34:55.506] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:34:55.523] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:34:55.525] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:34:55.526] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:34:55.526] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:35:09.709] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:35:09.726] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:35:09.728] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:35:09.728] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:35:09.729] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:37:11.119] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:37:11.136] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:37:11.138] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:37:11.138] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:37:11.139] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:38:07.956] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:38:07.973] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:38:07.975] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:38:07.976] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:38:07.976] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:16.075] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:16.092] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:16.094] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:16.095] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:16.095] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:18.432] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:18.450] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:18.451] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:18.452] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:18.452] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:32.068] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:32.085] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:32.086] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:32.087] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:32.088] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:41.645] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:41.662] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:41.663] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:41.664] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:39:41.665] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:40:40.351] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:40:40.370] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:40:40.372] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:40:40.373] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:40:40.374] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:40:49.691] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:40:49.708] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:40:49.710] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:40:49.711] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:40:49.711] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:41:17.348] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:41:17.366] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:41:17.368] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:41:17.369] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:41:17.369] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:42:04.471] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:42:04.489] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:42:04.490] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:42:04.491] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:42:04.492] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:51:27.023] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:51:27.041] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:51:27.042] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:51:27.044] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:51:27.044] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:52:18.195] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:52:18.213] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:52:18.215] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:52:18.216] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:52:18.216] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:52:45.491] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:52:45.508] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:52:45.510] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:52:45.511] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:52:45.511] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:55:30.833] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:55:30.854] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:55:30.855] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:55:30.856] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:55:30.857] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:55:56.103] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`username` = 'xieyaxin' LIMIT 1; { + plain: true, + raw: false, + logging: [Function: bound ], + where: "`User`.`username` = 'xieyaxin'", + limit: 1, + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:55:56.191] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:55:58.244] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T09:56:09.107] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:03:18.850] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:03:18.867] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:03:18.869] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:03:18.870] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:03:18.871] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:03:26.978] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:03:26.995] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:03:26.996] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:03:26.997] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:03:26.998] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:03:29.531] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:03:29.549] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:03:29.550] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:03:29.551] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:03:29.551] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:03:34.451] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:04:47.156] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:04:47.173] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:04:47.175] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:04:47.176] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:04:47.176] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:05:15.456] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:05:15.473] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:05:15.475] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:05:15.476] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:05:15.476] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:05:19.783] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:05:19.807] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:05:19.808] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:05:19.811] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:05:19.812] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:06:04.305] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:06:04.322] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:06:04.324] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:06:04.325] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:06:04.325] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:08:16.457] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:08:16.474] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:08:16.476] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:08:16.477] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:08:16.478] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:09:28.686] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:09:28.703] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:09:28.704] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:09:28.705] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:09:28.706] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:09:38.681] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:09:38.699] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:09:38.700] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:09:38.701] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:09:38.702] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:09:51.666] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:09:51.683] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:09:51.685] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:09:51.686] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:09:51.687] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:09:52.546] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:10:01.297] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:10:01.314] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:10:01.316] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:10:01.317] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:10:01.317] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:10:08.202] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:10:16.601] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`username` = 'xieyaxin' LIMIT 1; { + plain: true, + raw: false, + logging: [Function: bound ], + where: "`User`.`username` = 'xieyaxin'", + limit: 1, + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:10:16.662] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:11:22.363] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:11:25.417] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:11:27.100] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:11:42.242] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`username` = 'xieyaxin' LIMIT 1; { + plain: true, + raw: false, + logging: [Function: bound ], + where: "`User`.`username` = 'xieyaxin'", + limit: 1, + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:11:52.100] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`username` = 'xieyaxin' LIMIT 1; { + plain: true, + raw: false, + logging: [Function: bound ], + where: "`User`.`username` = 'xieyaxin'", + limit: 1, + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:11:52.162] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:11:56.826] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:12:34.754] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:12:34.772] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:12:34.773] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:12:34.774] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:12:34.775] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:12:52.635] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`username` = 'xieyaxin' LIMIT 1; { + plain: true, + raw: false, + logging: [Function: bound ], + where: "`User`.`username` = 'xieyaxin'", + limit: 1, + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:12:52.698] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:12:53.915] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:13:16.772] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:13:16.789] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:13:16.791] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:13:16.791] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:13:16.792] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:13:38.148] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`username` = 'xieyaxin' LIMIT 1; { + plain: true, + raw: false, + logging: [Function: bound ], + where: "`User`.`username` = 'xieyaxin'", + limit: 1, + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:13:38.212] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:14:37.400] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:14:37.418] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:14:37.419] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:14:37.420] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:14:37.421] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:19:55.676] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:19:55.714] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:19:55.715] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:19:55.716] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:19:55.717] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:20:05.564] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`username` = 'xieyaxin' LIMIT 1; { + plain: true, + raw: false, + logging: [Function: bound ], + where: "`User`.`username` = 'xieyaxin'", + limit: 1, + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:20:05.630] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:20:35.913] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`username` = 'xieyaxin' LIMIT 1; { + plain: true, + raw: false, + logging: [Function: bound ], + where: "`User`.`username` = 'xieyaxin'", + limit: 1, + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:20:39.093] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:20:39.154] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:21:54.976] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:21:54.993] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:21:54.995] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:21:54.996] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:21:54.996] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:21:59.487] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:21:59.504] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:21:59.506] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:21:59.506] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:21:59.507] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:22:30.322] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:22:30.352] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:22:30.353] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:22:30.354] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:22:30.355] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:23:07.047] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:26:19.512] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:27:02.901] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:27:02.918] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:27:02.920] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:27:02.921] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:27:02.921] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:27:27.722] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:27:28.566] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:27:33.226] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:28:02.425] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:28:02.442] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:28:02.444] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:28:02.444] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T10:28:02.445] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:31:20.767] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:31:20.917] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:31:20.919] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:31:20.920] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:31:20.921] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:32:53.403] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:33:35.369] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:33:35.386] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:33:35.387] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:33:35.388] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:33:35.389] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:33:52.684] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:33:52.723] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:33:52.724] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:33:52.725] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:33:52.726] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:34:51.574] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:34:51.603] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:34:51.604] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:34:51.605] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:34:51.606] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:35:17.707] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:35:17.737] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:35:17.739] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:35:17.740] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:35:17.740] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:35:29.049] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`username` = 'xieyaxin' LIMIT 1; { + plain: true, + raw: false, + logging: [Function: bound ], + where: "`User`.`username` = 'xieyaxin'", + limit: 1, + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:35:29.114] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:35:33.933] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:35:37.489] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:35:38.879] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:35:40.817] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:36:54.276] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:36:54.293] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:36:54.295] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:36:54.296] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:36:54.296] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:36:56.756] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:37:28.265] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:37:28.282] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:37:28.284] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:37:28.285] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:37:28.285] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:37:30.453] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:37:40.412] [DEBUG] SQL - Executing (default): SELECT `id`, `username`, `password`, `email`, `createdAt`, `updatedAt` FROM `Users` AS `User` WHERE `User`.`id` = 4; { + plain: true, + raw: false, + logging: [Function: bound ], + where: '`User`.`id` = 4', + hooks: true, + rejectOnEmpty: false, + originalAttributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + attributes: [ 'id', 'username', 'password', 'email', 'createdAt', 'updatedAt' ], + tableNames: [ 'Users' ], + type: 'SELECT', + model: User, + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:37:54.880] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:37:54.897] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:37:54.899] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:37:54.900] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:37:54.901] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:41:44.523] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:41:44.540] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:41:44.541] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:41:44.542] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:41:44.543] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:45:26.660] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:45:26.677] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:45:26.678] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:45:26.679] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:45:26.680] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:58:11.128] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:58:11.158] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:58:11.159] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:58:11.160] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:58:11.161] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:34.712] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:34.788] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:34.790] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:34.791] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:34.792] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:36.627] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:36.645] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:36.647] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:36.648] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:36.649] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:37.854] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:37.871] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:37.872] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:37.873] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:37.874] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:39.022] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:39.039] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:39.041] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:39.042] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:39.043] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:40.257] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:40.275] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:40.276] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:40.277] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:40.278] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:41.449] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:41.466] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:41.468] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:41.469] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T14:59:41.469] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:11.435] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:11.464] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:11.466] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:11.467] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:11.467] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:12.798] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:12.815] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:12.817] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:12.818] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:12.818] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:14.036] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:14.054] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:14.056] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:14.057] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:14.057] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:15.300] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:15.317] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:15.319] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:15.320] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:00:15.320] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:01:02.332] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:01:02.358] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:01:02.360] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:01:02.361] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:01:02.361] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:01:03.680] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:01:03.697] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:01:03.698] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:01:03.699] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:01:03.700] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:01:04.881] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:01:04.899] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:01:04.900] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:01:04.901] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:01:04.901] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:02:55.164] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:02:55.192] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:02:55.194] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:02:55.195] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:02:55.195] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:03:20.363] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:03:20.380] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:03:20.382] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:03:20.383] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:03:20.383] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:03:37.920] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:03:37.937] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:03:37.938] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:03:37.939] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:03:37.940] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:03:53.823] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:03:53.841] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:03:53.842] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:03:53.843] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:03:53.844] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:04:20.948] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:04:20.965] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:04:20.967] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:04:20.968] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:04:20.968] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:04:23.947] [DEBUG] SQL - Executing (default): SELECT 1+1 AS result { + plain: true, + raw: true, + logging: [Function: bound ], + type: 'SELECT', + uuid: 'default', + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:04:23.966] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Colors` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `color` VARCHAR(255), `title` VARCHAR(255), `describe` VARCHAR(255)); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:04:23.967] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Colors`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: false, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Colors', singular: 'Color' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:04:23.968] [DEBUG] SQL - Executing (default): CREATE TABLE IF NOT EXISTS `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) NOT NULL, `password` VARCHAR(255) NOT NULL, `email` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL); { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + uniqueKeys: {}, + type: 'RAW', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} +[2022-02-28T15:04:23.969] [DEBUG] SQL - Executing (default): PRAGMA INDEX_LIST(`Users`) { + plain: false, + raw: true, + logging: [Function: bound ], + timestamps: true, + validate: {}, + freezeTableName: false, + underscored: false, + paranoid: false, + rejectOnEmpty: false, + whereCollection: null, + schema: null, + schemaDelimiter: '', + defaultScope: {}, + scopes: {}, + indexes: [], + name: { plural: 'Users', singular: 'User' }, + omitNull: false, + sequelize: Sequelize { + options: { + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + logging: [Function: bound ], + omitNull: false, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + hooks: {}, + retry: [Object], + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db' + }, + config: { + database: undefined, + username: undefined, + password: null, + host: 'localhost', + port: undefined, + pool: {}, + protocol: 'tcp', + native: false, + ssl: undefined, + replication: false, + dialectModule: null, + dialectModulePath: null, + keepDefaultTimezone: undefined, + dialectOptions: undefined + }, + dialect: SqliteDialect { + sequelize: [Circular *1], + connectionManager: [ConnectionManager], + queryGenerator: [SQLiteQueryGenerator], + queryInterface: [SQLiteQueryInterface] + }, + queryInterface: SQLiteQueryInterface { + sequelize: [Circular *1], + queryGenerator: [SQLiteQueryGenerator] + }, + models: { Color: Color, User: User }, + modelManager: ModelManager { models: [Array], sequelize: [Circular *1] }, + connectionManager: ConnectionManager { + sequelize: [Circular *1], + config: [Object], + dialect: [SqliteDialect], + versionPromise: null, + dialectName: 'sqlite', + pool: [Pool], + connections: [Object], + lib: [Object] + } + }, + hooks: true, + dialect: 'sqlite', + dialectModule: null, + dialectModulePath: null, + protocol: 'tcp', + define: {}, + query: {}, + sync: {}, + timezone: '+00:00', + clientMinMessages: 'warning', + standardConformingStrings: true, + native: false, + replication: false, + ssl: undefined, + pool: {}, + quoteIdentifiers: true, + retry: { max: 5, match: [ 'SQLITE_BUSY: database is locked' ] }, + transactionType: 'DEFERRED', + isolationLevel: null, + databaseVersion: 0, + typeValidation: false, + benchmark: false, + minifyAliases: false, + logQueryParameters: false, + storage: 'D:\\1XYX\\demo\\hapi-demo\\source\\db\\data.db', + force: false, + type: 'SHOWINDEXES', + uuid: 'default', + inMemory: 0, + readWriteMode: 6 +} diff --git a/package.json b/package.json index 3ba2e92..997f41c 100644 --- a/package.json +++ b/package.json @@ -6,7 +6,7 @@ "main": "index.js", "scripts": { "init": "ts-node --respawn --project ./tsconfig.json -r tsconfig-paths/register source/db/init.ts alter", - "start": "ts-node-dev --respawn --project ./tsconfig.json -r tsconfig-paths/register ./source/main.ts", + "start": "ts-node-dev --watch ./source/route --ignore-watch ./source/route/route.txt --respawn --project ./tsconfig.json -r tsconfig-paths/register ./source/main.ts", "dev": "npm start", "deva": "nodemon --exec 'ts-node --project ./tsconfig.json -r tsconfig-paths/register ./source/main.ts'" }, diff --git a/packages/hapi-router/dist/hapi-router.cjs.js b/packages/hapi-router/dist/hapi-router.cjs.js index f5f3074..6240662 100644 --- a/packages/hapi-router/dist/hapi-router.cjs.js +++ b/packages/hapi-router/dist/hapi-router.cjs.js @@ -302,7 +302,7 @@ var routePlugin = (function () { } } }); - fs.writeFileSync(path.resolve(sourceDir, "route.txt"), routes.join("\n"), { + fs.writeFileSync(path.resolve(process.cwd(), "route.txt"), routes.join("\n"), { encoding: "utf-8", }); }; diff --git a/packages/hapi-router/dist/hapi-router.cjs.js.map b/packages/hapi-router/dist/hapi-router.cjs.js.map index e8e94fe..dfcc619 100644 --- a/packages/hapi-router/dist/hapi-router.cjs.js.map +++ b/packages/hapi-router/dist/hapi-router.cjs.js.map @@ -1 +1 @@ -{"version":3,"file":"hapi-router.cjs.js","sources":["../src/util/index.ts","../src/util/decorators.ts","../src/index.ts"],"sourcesContent":["// @ts-nocheck\r\n\r\nconst path = require(\"path\")\r\nconst fs = require(\"fs\")\r\n\r\nexport function removeIndex(ss:any) {\r\n const remove = (str:any) => {\r\n if (str.endsWith(\"/index\")) {\r\n return str.slice(0, -6);\r\n }\r\n if (str.endsWith(\"index\")) {\r\n return str.slice(0, -5);\r\n }\r\n return str ? str : \"/\";\r\n };\r\n let r = true;\r\n let rr = ss;\r\n while (r) {\r\n if (rr.endsWith(\"/index\")) {\r\n rr = remove(rr);\r\n } else {\r\n r = false;\r\n }\r\n }\r\n return rr ? rr : \"/\";\r\n}\r\n\r\nexport function isIndexEnd(str:any) {\r\n return str.length == 1 && str.endsWith(\"/\");\r\n}\r\n\r\n\r\nexport function walkDir(\r\n filePath:any,\r\n exclude = [\"node_modules\", \"^_\", \".git\", \".idea\", \".gitignore\", \"client\",\"\\.txt$\"]\r\n) {\r\n let files:any[] = [];\r\n function Data(opts:any) {\r\n this.relativeDir = opts.relativeDir;\r\n this.relativeFile = opts.relativeFile;\r\n this.filename = opts.filename;\r\n this.file = opts.file;\r\n this.absoluteFile = opts.absoluteFile;\r\n this.relativeFileNoExt = opts.relativeFileNoExt;\r\n this.absoluteDir = opts.absoluteDir;\r\n }\r\n function readDir(filePath, dirname = \".\") {\r\n let res = fs.readdirSync(filePath);\r\n res.forEach((filename) => {\r\n const filepath = path.resolve(filePath, filename);\r\n const stat = fs.statSync(filepath);\r\n const name = filepath.split(path.sep).slice(-1)[0];\r\n if (typeof exclude === \"string\" && new RegExp(exclude).test(name)) {\r\n return;\r\n }\r\n if (Array.isArray(exclude)) {\r\n for (let i = 0; i < exclude.length; i++) {\r\n const excludeItem = exclude[i];\r\n if (new RegExp(excludeItem).test(name)) {\r\n return;\r\n }\r\n }\r\n }\r\n if (!stat.isFile()) {\r\n readDir(filepath, dirname + path.sep + name);\r\n } else {\r\n const data = new Data({\r\n relativeDir: dirname,\r\n relativeFile: dirname + path.sep + path.parse(filepath).base,\r\n relativeFileNoExt: dirname + path.sep + path.parse(filepath).name,\r\n file: path.parse(filepath).base,\r\n filename: path.parse(filepath).name,\r\n absoluteFile: filepath,\r\n absoluteDir: path.parse(filepath).dir,\r\n });\r\n files.push(data);\r\n }\r\n });\r\n }\r\n readDir(filePath);\r\n return files;\r\n}\r\n","// @ts-nocheck\r\n\r\nexport function method(opts?:string|Array) {\r\n return function (target, propertyKey: string, descriptor: PropertyDescriptor) {\r\n target[propertyKey].$method = opts\r\n }\r\n}\r\nexport function route(route?:string) {\r\n return function (target, propertyKey: string, descriptor: PropertyDescriptor) {\r\n target[propertyKey].$route = route\r\n }\r\n}\r\n\r\nexport function config(options:Object) {\r\n return function (target, propertyKey: string, descriptor: PropertyDescriptor) {\r\n target[propertyKey].$options = options\r\n }\r\n}\r\n\r\nexport function auth(isAuth:boolean = true) {\r\n return function (target, propertyKey: string, descriptor: PropertyDescriptor) {\r\n target[propertyKey].$auth = isAuth\r\n }\r\n}\r\n\r\nexport function validate(validate:Object) {\r\n return function (target, propertyKey: string, descriptor: PropertyDescriptor) {\r\n target[propertyKey].$validate = validate\r\n }\r\n}\r\n\r\nexport function swagger(desc,notes,tags) {\r\n return function (target, propertyKey: string, descriptor: PropertyDescriptor) {\r\n target[propertyKey].$swagger = [desc,notes,tags]\r\n }\r\n}\r\n","// @ts-nocheck\r\n\r\nimport { walkDir, removeIndex, isIndexEnd } from \"./util\";\r\nimport * as Joi from \"joi\";\r\nconst path = require(\"path\")\r\nconst fs = require(\"fs\")\r\n\r\nconst routes = [\"所有路由路径：\"];\r\n\r\nclass routePlugin {\r\n public name: string = \"routePlugin\";\r\n public version: string = \"0.0.1\";\r\n public register(server: any, options: any) {\r\n const sourceDir = options.sourceDir;\r\n const type = options.type || \"jwt\";\r\n\r\n const files = walkDir(sourceDir);\r\n files.forEach((file) => {\r\n let filename = file.relativeFileNoExt;\r\n let array = filename.split(path.sep).slice(1);\r\n let fileNoExt = removeIndex(\"/\" + array.join(\"/\"));\r\n const moduleName = path.resolve(sourceDir, filename);\r\n const obj = require(moduleName);\r\n if (obj.default) {\r\n const func = new (obj.default || obj)();\r\n const prototype = Object.getPrototypeOf(func);\r\n const keys = Reflect.ownKeys(prototype);\r\n for (const key of keys) {\r\n if (key !== \"constructor\") {\r\n let ff = func[key];\r\n // 默认方法\r\n const method = ff.$method || \"GET\";\r\n // 路由收集规则\r\n let route = \"\";\r\n if (ff.$route) {\r\n if (isIndexEnd(fileNoExt)) {\r\n route = ff.$route;\r\n } else {\r\n route = fileNoExt + ff.$route;\r\n }\r\n } else {\r\n if (isIndexEnd(fileNoExt)) {\r\n route = fileNoExt + key.toString();\r\n } else {\r\n route = fileNoExt + \"/\" + key.toString();\r\n }\r\n }\r\n route = removeIndex(route);\r\n // 配置规则\r\n const options = ff.$options ? ff.$options : {};\r\n if (!options.auth) {\r\n if (ff.$auth == undefined) {\r\n if (route.startsWith(\"/api\")) {\r\n options.auth = type;\r\n } else {\r\n options.auth = false;\r\n }\r\n } else if (ff.$auth) {\r\n options.auth = type;\r\n } else {\r\n options.auth = false;\r\n }\r\n }\r\n if (!options.validate) {\r\n let validateObj = ff.$validate || {};\r\n if(options.auth&&type === \"jwt\"){\r\n if (validateObj.headers) {\r\n validateObj.headers = validateObj.headers.keys({\r\n Authorization: Joi.string(),\r\n })\r\n }else{\r\n validateObj.headers = Joi.object({\r\n headers: Joi.object({\r\n Authorization: Joi.string(),\r\n }).unknown(), // 注意加上这个\r\n })\r\n }\r\n }\r\n if (validateObj) {\r\n options.validate = validateObj;\r\n }\r\n }\r\n // && route.startsWith(\"/api\")\r\n if (ff.$swagger) {\r\n options.description = ff.$swagger[0];\r\n options.notes = ff.$swagger[1];\r\n options.tags = ff.$swagger[2];\r\n }\r\n let str = route;\r\n if (options.auth) {\r\n str = \" 需要权限： \"+ \" \"+full(method)+\" \" + str;\r\n } else {\r\n str = \" 不需权限： \"+ \" \"+full(method)+\" \" + str;\r\n }\r\n routes.push(str);\r\n server.route({\r\n method: method,\r\n path: route,\r\n handler: ff,\r\n options: options,\r\n });\r\n }\r\n }\r\n }\r\n });\r\n fs.writeFileSync(path.resolve(sourceDir, \"route.txt\"), routes.join(\"\\n\"), {\r\n encoding: \"utf-8\",\r\n });\r\n }\r\n}\r\n\r\nfunction full(str: string, length=10) {\r\n let len = str.length;\r\n let need = length - len;\r\n if(need <= 0) return str \r\n return str+[...Array(need)].map((v,i)=>\" \").join(\"\")\r\n}\r\n\r\nconst plugin = new routePlugin();\r\n\r\nexport { plugin };\r\nexport * from \"./util/decorators\";\r\n"],"names":["path","fs","Joi"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAMA,MAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AAC5B,IAAMC,IAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;SAER,WAAW,CAAC,EAAM;IAChC,IAAM,MAAM,GAAG,UAAC,GAAO;QACrB,IAAI,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;YAC1B,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;SACzB;QACD,IAAI,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE;YACzB,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;SACzB;QACD,OAAO,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;KACxB,CAAC;IACF,IAAI,CAAC,GAAG,IAAI,CAAC;IACb,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,OAAO,CAAC,EAAE;QACR,IAAI,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;YACzB,EAAE,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;SACjB;aAAM;YACL,CAAC,GAAG,KAAK,CAAC;SACX;KACF;IACD,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,CAAC;AACvB,CAAC;SAEe,UAAU,CAAC,GAAO;IAChC,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;AAC9C,CAAC;SAGe,OAAO,CACrB,QAAY,EACZ,OAAkF;IAAlF,wBAAA,EAAA,WAAW,cAAc,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAC,QAAQ,CAAC;IAElF,IAAI,KAAK,GAAS,EAAE,CAAC;IACrB,SAAS,IAAI,CAAC,IAAQ;QACpB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QACpC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;QACtC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC9B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;QACtC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC;QAChD,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;KACrC;IACD,SAAS,OAAO,CAAC,QAAQ,EAAE,OAAa;QAAb,wBAAA,EAAA,aAAa;QACtC,IAAI,GAAG,GAAGA,IAAE,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QACnC,GAAG,CAAC,OAAO,CAAC,UAAC,QAAQ;YACnB,IAAM,QAAQ,GAAGD,MAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAClD,IAAM,IAAI,GAAGC,IAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;YACnC,IAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,CAACD,MAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACnD,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,IAAI,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;gBACjE,OAAO;aACR;YACD,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;gBAC1B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBACvC,IAAM,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;oBAC/B,IAAI,IAAI,MAAM,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;wBACtC,OAAO;qBACR;iBACF;aACF;YACD,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE;gBAClB,OAAO,CAAC,QAAQ,EAAE,OAAO,GAAGA,MAAI,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC;aAC9C;iBAAM;gBACL,IAAM,IAAI,GAAG,IAAI,IAAI,CAAC;oBACpB,WAAW,EAAE,OAAO;oBACpB,YAAY,EAAE,OAAO,GAAGA,MAAI,CAAC,GAAG,GAAGA,MAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,IAAI;oBAC5D,iBAAiB,EAAE,OAAO,GAAGA,MAAI,CAAC,GAAG,GAAGA,MAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,IAAI;oBACjE,IAAI,EAAEA,MAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,IAAI;oBAC/B,QAAQ,EAAEA,MAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,IAAI;oBACnC,YAAY,EAAE,QAAQ;oBACtB,WAAW,EAAEA,MAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,GAAG;iBACtC,CAAC,CAAC;gBACH,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aAClB;SACF,CAAC,CAAC;KACJ;IACD,OAAO,CAAC,QAAQ,CAAC,CAAC;IAClB,OAAO,KAAK,CAAC;AACf;;SC/EgB,MAAM,CAAC,IAA0B;IAC7C,OAAO,UAAU,MAAM,EAAE,WAAmB,EAAE,UAA8B;QACxE,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,GAAG,IAAI,CAAA;KACrC,CAAA;AACL,CAAC;SACe,KAAK,CAAC,KAAa;IAC/B,OAAO,UAAU,MAAM,EAAE,WAAmB,EAAE,UAA8B;QACxE,MAAM,CAAC,WAAW,CAAC,CAAC,MAAM,GAAG,KAAK,CAAA;KACrC,CAAA;AACL,CAAC;SAEe,MAAM,CAAC,OAAc;IACjC,OAAO,UAAU,MAAM,EAAE,WAAmB,EAAE,UAA8B;QACxE,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,GAAG,OAAO,CAAA;KACzC,CAAA;AACL,CAAC;SAEe,IAAI,CAAC,MAAqB;IAArB,uBAAA,EAAA,aAAqB;IACtC,OAAO,UAAU,MAAM,EAAE,WAAmB,EAAE,UAA8B;QACxE,MAAM,CAAC,WAAW,CAAC,CAAC,KAAK,GAAG,MAAM,CAAA;KACrC,CAAA;AACL,CAAC;SAEe,QAAQ,CAAC,QAAe;IACpC,OAAO,UAAU,MAAM,EAAE,WAAmB,EAAE,UAA8B;QACxE,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,GAAG,QAAQ,CAAA;KAC3C,CAAA;AACL,CAAC;SAEe,OAAO,CAAC,IAAI,EAAC,KAAK,EAAC,IAAI;IACnC,OAAO,UAAU,MAAM,EAAE,WAAmB,EAAE,UAA8B;QACxE,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,GAAG,CAAC,IAAI,EAAC,KAAK,EAAC,IAAI,CAAC,CAAA;KACnD,CAAA;AACL;;AC/BA,IAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AAC5B,IAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAExB,IAAM,MAAM,GAAG,CAAC,SAAS,CAAC,CAAC;AAE3B;IAAA;QACS,SAAI,GAAW,aAAa,CAAC;QAC7B,YAAO,GAAW,OAAO,CAAC;KAkGlC;IAjGQ,8BAAQ,GAAf,UAAgB,MAAW,EAAE,OAAY;QACvC,IAAM,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;QACpC,IAAM,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,KAAK,CAAC;QAEnC,IAAM,KAAK,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;QACjC,KAAK,CAAC,OAAO,CAAC,UAAC,IAAI;;YACjB,IAAI,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC;YACtC,IAAI,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAC9C,IAAI,SAAS,GAAG,WAAW,CAAC,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;YACnD,IAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;YACrD,IAAM,GAAG,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;YAChC,IAAI,GAAG,CAAC,OAAO,EAAE;gBACf,IAAM,IAAI,GAAG,KAAK,GAAG,CAAC,OAAO,IAAI,GAAG,GAAG,CAAC;gBACxC,IAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;gBAC9C,IAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;;oBACxC,KAAkB,IAAA,SAAA,SAAA,IAAI,CAAA,0BAAA,4CAAE;wBAAnB,IAAM,GAAG,iBAAA;wBACZ,IAAI,GAAG,KAAK,aAAa,EAAE;4BACzB,IAAI,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;4BAEnB,IAAM,MAAM,GAAG,EAAE,CAAC,OAAO,IAAI,KAAK,CAAC;4BAEnC,IAAI,KAAK,GAAG,EAAE,CAAC;4BACf,IAAI,EAAE,CAAC,MAAM,EAAE;gCACb,IAAI,UAAU,CAAC,SAAS,CAAC,EAAE;oCACzB,KAAK,GAAG,EAAE,CAAC,MAAM,CAAC;iCACnB;qCAAM;oCACL,KAAK,GAAG,SAAS,GAAG,EAAE,CAAC,MAAM,CAAC;iCAC/B;6BACF;iCAAM;gCACL,IAAI,UAAU,CAAC,SAAS,CAAC,EAAE;oCACzB,KAAK,GAAG,SAAS,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC;iCACpC;qCAAM;oCACL,KAAK,GAAG,SAAS,GAAG,GAAG,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC;iCAC1C;6BACF;4BACD,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;4BAE3B,IAAM,SAAO,GAAG,EAAE,CAAC,QAAQ,GAAG,EAAE,CAAC,QAAQ,GAAG,EAAE,CAAC;4BAC/C,IAAI,CAAC,SAAO,CAAC,IAAI,EAAE;gCACjB,IAAI,EAAE,CAAC,KAAK,IAAI,SAAS,EAAE;oCACzB,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;wCAC5B,SAAO,CAAC,IAAI,GAAG,IAAI,CAAC;qCACrB;yCAAM;wCACL,SAAO,CAAC,IAAI,GAAG,KAAK,CAAC;qCACtB;iCACF;qCAAM,IAAI,EAAE,CAAC,KAAK,EAAE;oCACnB,SAAO,CAAC,IAAI,GAAG,IAAI,CAAC;iCACrB;qCAAM;oCACL,SAAO,CAAC,IAAI,GAAG,KAAK,CAAC;iCACtB;6BACF;4BACD,IAAI,CAAC,SAAO,CAAC,QAAQ,EAAE;gCACrB,IAAI,WAAW,GAAG,EAAE,CAAC,SAAS,IAAI,EAAE,CAAC;gCACrC,IAAG,SAAO,CAAC,IAAI,IAAE,IAAI,KAAK,KAAK,EAAC;oCAC9B,IAAI,WAAW,CAAC,OAAO,EAAE;wCACvB,WAAW,CAAC,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC;4CAC7C,aAAa,EAAEE,cAAG,CAAC,MAAM,EAAE;yCAC5B,CAAC,CAAA;qCACH;yCAAI;wCACH,WAAW,CAAC,OAAO,GAAGA,cAAG,CAAC,MAAM,CAAC;4CAC/B,OAAO,EAAEA,cAAG,CAAC,MAAM,CAAC;gDAClB,aAAa,EAAEA,cAAG,CAAC,MAAM,EAAE;6CAC5B,CAAC,CAAC,OAAO,EAAE;yCACb,CAAC,CAAA;qCACH;iCACF;gCACD,IAAI,WAAW,EAAE;oCACf,SAAO,CAAC,QAAQ,GAAG,WAAW,CAAC;iCAChC;6BACF;4BAED,IAAI,EAAE,CAAC,QAAQ,EAAE;gCACf,SAAO,CAAC,WAAW,GAAG,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gCACrC,SAAO,CAAC,KAAK,GAAG,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gCAC/B,SAAO,CAAC,IAAI,GAAG,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;6BAC/B;4BACD,IAAI,GAAG,GAAG,KAAK,CAAC;4BAChB,IAAI,SAAO,CAAC,IAAI,EAAE;gCAChB,GAAG,GAAG,SAAS,GAAE,GAAG,GAAC,IAAI,CAAC,MAAM,CAAC,GAAC,GAAG,GAAG,GAAG,CAAC;6BAC7C;iCAAM;gCACL,GAAG,GAAG,SAAS,GAAE,GAAG,GAAC,IAAI,CAAC,MAAM,CAAC,GAAC,GAAG,GAAG,GAAG,CAAC;6BAC7C;4BACD,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;4BACjB,MAAM,CAAC,KAAK,CAAC;gCACX,MAAM,EAAE,MAAM;gCACd,IAAI,EAAE,KAAK;gCACX,OAAO,EAAE,EAAE;gCACX,OAAO,EAAE,SAAO;6BACjB,CAAC,CAAC;yBACJ;qBACF;;;;;;;;;aACF;SACF,CAAC,CAAC;QACH,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,WAAW,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;YACxE,QAAQ,EAAE,OAAO;SAClB,CAAC,CAAC;KACJ;IACH,kBAAC;AAAD,CAAC,IAAA;AAED,SAAS,IAAI,CAAC,GAAW,EAAE,MAAS;IAAT,uBAAA,EAAA,WAAS;IAChC,IAAI,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC;IACrB,IAAI,IAAI,GAAG,MAAM,GAAG,GAAG,CAAC;IACxB,IAAG,IAAI,IAAI,CAAC;QAAE,OAAO,GAAG,CAAA;IACxB,OAAO,GAAG,GAAC,SAAI,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,UAAC,CAAC,EAAC,CAAC,IAAG,OAAA,GAAG,GAAA,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;AACxD,CAAC;IAEK,MAAM,GAAG,IAAI,WAAW;;;;;;;;;;"} \ No newline at end of file +{"version":3,"file":"hapi-router.cjs.js","sources":["../src/util/index.ts","../src/util/decorators.ts","../src/index.ts"],"sourcesContent":["// @ts-nocheck\r\n\r\nconst path = require(\"path\")\r\nconst fs = require(\"fs\")\r\n\r\nexport function removeIndex(ss:any) {\r\n const remove = (str:any) => {\r\n if (str.endsWith(\"/index\")) {\r\n return str.slice(0, -6);\r\n }\r\n if (str.endsWith(\"index\")) {\r\n return str.slice(0, -5);\r\n }\r\n return str ? str : \"/\";\r\n };\r\n let r = true;\r\n let rr = ss;\r\n while (r) {\r\n if (rr.endsWith(\"/index\")) {\r\n rr = remove(rr);\r\n } else {\r\n r = false;\r\n }\r\n }\r\n return rr ? rr : \"/\";\r\n}\r\n\r\nexport function isIndexEnd(str:any) {\r\n return str.length == 1 && str.endsWith(\"/\");\r\n}\r\n\r\n\r\nexport function walkDir(\r\n filePath:any,\r\n exclude = [\"node_modules\", \"^_\", \".git\", \".idea\", \".gitignore\", \"client\",\"\\.txt$\"]\r\n) {\r\n let files:any[] = [];\r\n function Data(opts:any) {\r\n this.relativeDir = opts.relativeDir;\r\n this.relativeFile = opts.relativeFile;\r\n this.filename = opts.filename;\r\n this.file = opts.file;\r\n this.absoluteFile = opts.absoluteFile;\r\n this.relativeFileNoExt = opts.relativeFileNoExt;\r\n this.absoluteDir = opts.absoluteDir;\r\n }\r\n function readDir(filePath, dirname = \".\") {\r\n let res = fs.readdirSync(filePath);\r\n res.forEach((filename) => {\r\n const filepath = path.resolve(filePath, filename);\r\n const stat = fs.statSync(filepath);\r\n const name = filepath.split(path.sep).slice(-1)[0];\r\n if (typeof exclude === \"string\" && new RegExp(exclude).test(name)) {\r\n return;\r\n }\r\n if (Array.isArray(exclude)) {\r\n for (let i = 0; i < exclude.length; i++) {\r\n const excludeItem = exclude[i];\r\n if (new RegExp(excludeItem).test(name)) {\r\n return;\r\n }\r\n }\r\n }\r\n if (!stat.isFile()) {\r\n readDir(filepath, dirname + path.sep + name);\r\n } else {\r\n const data = new Data({\r\n relativeDir: dirname,\r\n relativeFile: dirname + path.sep + path.parse(filepath).base,\r\n relativeFileNoExt: dirname + path.sep + path.parse(filepath).name,\r\n file: path.parse(filepath).base,\r\n filename: path.parse(filepath).name,\r\n absoluteFile: filepath,\r\n absoluteDir: path.parse(filepath).dir,\r\n });\r\n files.push(data);\r\n }\r\n });\r\n }\r\n readDir(filePath);\r\n return files;\r\n}\r\n","// @ts-nocheck\r\n\r\nexport function method(opts?:string|Array) {\r\n return function (target, propertyKey: string, descriptor: PropertyDescriptor) {\r\n target[propertyKey].$method = opts\r\n }\r\n}\r\nexport function route(route?:string) {\r\n return function (target, propertyKey: string, descriptor: PropertyDescriptor) {\r\n target[propertyKey].$route = route\r\n }\r\n}\r\n\r\nexport function config(options:Object) {\r\n return function (target, propertyKey: string, descriptor: PropertyDescriptor) {\r\n target[propertyKey].$options = options\r\n }\r\n}\r\n\r\nexport function auth(isAuth:boolean = true) {\r\n return function (target, propertyKey: string, descriptor: PropertyDescriptor) {\r\n target[propertyKey].$auth = isAuth\r\n }\r\n}\r\n\r\nexport function validate(validate:Object) {\r\n return function (target, propertyKey: string, descriptor: PropertyDescriptor) {\r\n target[propertyKey].$validate = validate\r\n }\r\n}\r\n\r\nexport function swagger(desc,notes,tags) {\r\n return function (target, propertyKey: string, descriptor: PropertyDescriptor) {\r\n target[propertyKey].$swagger = [desc,notes,tags]\r\n }\r\n}\r\n","// @ts-nocheck\r\n\r\nimport { walkDir, removeIndex, isIndexEnd } from \"./util\";\r\nimport * as Joi from \"joi\";\r\nconst path = require(\"path\")\r\nconst fs = require(\"fs\")\r\n\r\nconst routes = [\"所有路由路径：\"];\r\n\r\nclass routePlugin {\r\n public name: string = \"routePlugin\";\r\n public version: string = \"0.0.1\";\r\n public register(server: any, options: any) {\r\n const sourceDir = options.sourceDir;\r\n const type = options.type || \"jwt\";\r\n\r\n const files = walkDir(sourceDir);\r\n files.forEach((file) => {\r\n let filename = file.relativeFileNoExt;\r\n let array = filename.split(path.sep).slice(1);\r\n let fileNoExt = removeIndex(\"/\" + array.join(\"/\"));\r\n const moduleName = path.resolve(sourceDir, filename);\r\n const obj = require(moduleName);\r\n if (obj.default) {\r\n const func = new (obj.default || obj)();\r\n const prototype = Object.getPrototypeOf(func);\r\n const keys = Reflect.ownKeys(prototype);\r\n for (const key of keys) {\r\n if (key !== \"constructor\") {\r\n let ff = func[key];\r\n // 默认方法\r\n const method = ff.$method || \"GET\";\r\n // 路由收集规则\r\n let route = \"\";\r\n if (ff.$route) {\r\n if (isIndexEnd(fileNoExt)) {\r\n route = ff.$route;\r\n } else {\r\n route = fileNoExt + ff.$route;\r\n }\r\n } else {\r\n if (isIndexEnd(fileNoExt)) {\r\n route = fileNoExt + key.toString();\r\n } else {\r\n route = fileNoExt + \"/\" + key.toString();\r\n }\r\n }\r\n route = removeIndex(route);\r\n // 配置规则\r\n const options = ff.$options ? ff.$options : {};\r\n if (!options.auth) {\r\n if (ff.$auth == undefined) {\r\n if (route.startsWith(\"/api\")) {\r\n options.auth = type;\r\n } else {\r\n options.auth = false;\r\n }\r\n } else if (ff.$auth) {\r\n options.auth = type;\r\n } else {\r\n options.auth = false;\r\n }\r\n }\r\n if (!options.validate) {\r\n let validateObj = ff.$validate || {};\r\n if(options.auth&&type === \"jwt\"){\r\n if (validateObj.headers) {\r\n validateObj.headers = validateObj.headers.keys({\r\n Authorization: Joi.string(),\r\n })\r\n }else{\r\n validateObj.headers = Joi.object({\r\n headers: Joi.object({\r\n Authorization: Joi.string(),\r\n }).unknown(), // 注意加上这个\r\n })\r\n }\r\n }\r\n if (validateObj) {\r\n options.validate = validateObj;\r\n }\r\n }\r\n // && route.startsWith(\"/api\")\r\n if (ff.$swagger) {\r\n options.description = ff.$swagger[0];\r\n options.notes = ff.$swagger[1];\r\n options.tags = ff.$swagger[2];\r\n }\r\n let str = route;\r\n if (options.auth) {\r\n str = \" 需要权限： \"+ \" \"+full(method)+\" \" + str;\r\n } else {\r\n str = \" 不需权限： \"+ \" \"+full(method)+\" \" + str;\r\n }\r\n routes.push(str);\r\n server.route({\r\n method: method,\r\n path: route,\r\n handler: ff,\r\n options: options,\r\n });\r\n }\r\n }\r\n }\r\n });\r\n fs.writeFileSync(path.resolve(process.cwd(), \"route.txt\"), routes.join(\"\\n\"), {\r\n encoding: \"utf-8\",\r\n });\r\n }\r\n}\r\n\r\nfunction full(str: string, length=10) {\r\n let len = str.length;\r\n let need = length - len;\r\n if(need <= 0) return str \r\n return str+[...Array(need)].map((v,i)=>\" \").join(\"\")\r\n}\r\n\r\nconst plugin = new routePlugin();\r\n\r\nexport { plugin };\r\nexport * from \"./util/decorators\";\r\n"],"names":["path","fs","Joi"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAMA,MAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AAC5B,IAAMC,IAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;SAER,WAAW,CAAC,EAAM;IAChC,IAAM,MAAM,GAAG,UAAC,GAAO;QACrB,IAAI,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;YAC1B,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;SACzB;QACD,IAAI,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE;YACzB,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;SACzB;QACD,OAAO,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;KACxB,CAAC;IACF,IAAI,CAAC,GAAG,IAAI,CAAC;IACb,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,OAAO,CAAC,EAAE;QACR,IAAI,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;YACzB,EAAE,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;SACjB;aAAM;YACL,CAAC,GAAG,KAAK,CAAC;SACX;KACF;IACD,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,CAAC;AACvB,CAAC;SAEe,UAAU,CAAC,GAAO;IAChC,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;AAC9C,CAAC;SAGe,OAAO,CACrB,QAAY,EACZ,OAAkF;IAAlF,wBAAA,EAAA,WAAW,cAAc,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAC,QAAQ,CAAC;IAElF,IAAI,KAAK,GAAS,EAAE,CAAC;IACrB,SAAS,IAAI,CAAC,IAAQ;QACpB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QACpC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;QACtC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC9B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;QACtC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC;QAChD,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;KACrC;IACD,SAAS,OAAO,CAAC,QAAQ,EAAE,OAAa;QAAb,wBAAA,EAAA,aAAa;QACtC,IAAI,GAAG,GAAGA,IAAE,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QACnC,GAAG,CAAC,OAAO,CAAC,UAAC,QAAQ;YACnB,IAAM,QAAQ,GAAGD,MAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAClD,IAAM,IAAI,GAAGC,IAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;YACnC,IAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,CAACD,MAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACnD,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,IAAI,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;gBACjE,OAAO;aACR;YACD,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;gBAC1B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBACvC,IAAM,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;oBAC/B,IAAI,IAAI,MAAM,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;wBACtC,OAAO;qBACR;iBACF;aACF;YACD,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE;gBAClB,OAAO,CAAC,QAAQ,EAAE,OAAO,GAAGA,MAAI,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC;aAC9C;iBAAM;gBACL,IAAM,IAAI,GAAG,IAAI,IAAI,CAAC;oBACpB,WAAW,EAAE,OAAO;oBACpB,YAAY,EAAE,OAAO,GAAGA,MAAI,CAAC,GAAG,GAAGA,MAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,IAAI;oBAC5D,iBAAiB,EAAE,OAAO,GAAGA,MAAI,CAAC,GAAG,GAAGA,MAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,IAAI;oBACjE,IAAI,EAAEA,MAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,IAAI;oBAC/B,QAAQ,EAAEA,MAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,IAAI;oBACnC,YAAY,EAAE,QAAQ;oBACtB,WAAW,EAAEA,MAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,GAAG;iBACtC,CAAC,CAAC;gBACH,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aAClB;SACF,CAAC,CAAC;KACJ;IACD,OAAO,CAAC,QAAQ,CAAC,CAAC;IAClB,OAAO,KAAK,CAAC;AACf;;SC/EgB,MAAM,CAAC,IAA0B;IAC7C,OAAO,UAAU,MAAM,EAAE,WAAmB,EAAE,UAA8B;QACxE,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,GAAG,IAAI,CAAA;KACrC,CAAA;AACL,CAAC;SACe,KAAK,CAAC,KAAa;IAC/B,OAAO,UAAU,MAAM,EAAE,WAAmB,EAAE,UAA8B;QACxE,MAAM,CAAC,WAAW,CAAC,CAAC,MAAM,GAAG,KAAK,CAAA;KACrC,CAAA;AACL,CAAC;SAEe,MAAM,CAAC,OAAc;IACjC,OAAO,UAAU,MAAM,EAAE,WAAmB,EAAE,UAA8B;QACxE,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,GAAG,OAAO,CAAA;KACzC,CAAA;AACL,CAAC;SAEe,IAAI,CAAC,MAAqB;IAArB,uBAAA,EAAA,aAAqB;IACtC,OAAO,UAAU,MAAM,EAAE,WAAmB,EAAE,UAA8B;QACxE,MAAM,CAAC,WAAW,CAAC,CAAC,KAAK,GAAG,MAAM,CAAA;KACrC,CAAA;AACL,CAAC;SAEe,QAAQ,CAAC,QAAe;IACpC,OAAO,UAAU,MAAM,EAAE,WAAmB,EAAE,UAA8B;QACxE,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,GAAG,QAAQ,CAAA;KAC3C,CAAA;AACL,CAAC;SAEe,OAAO,CAAC,IAAI,EAAC,KAAK,EAAC,IAAI;IACnC,OAAO,UAAU,MAAM,EAAE,WAAmB,EAAE,UAA8B;QACxE,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,GAAG,CAAC,IAAI,EAAC,KAAK,EAAC,IAAI,CAAC,CAAA;KACnD,CAAA;AACL;;AC/BA,IAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AAC5B,IAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAExB,IAAM,MAAM,GAAG,CAAC,SAAS,CAAC,CAAC;AAE3B;IAAA;QACS,SAAI,GAAW,aAAa,CAAC;QAC7B,YAAO,GAAW,OAAO,CAAC;KAkGlC;IAjGQ,8BAAQ,GAAf,UAAgB,MAAW,EAAE,OAAY;QACvC,IAAM,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;QACpC,IAAM,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,KAAK,CAAC;QAEnC,IAAM,KAAK,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;QACjC,KAAK,CAAC,OAAO,CAAC,UAAC,IAAI;;YACjB,IAAI,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC;YACtC,IAAI,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAC9C,IAAI,SAAS,GAAG,WAAW,CAAC,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;YACnD,IAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;YACrD,IAAM,GAAG,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;YAChC,IAAI,GAAG,CAAC,OAAO,EAAE;gBACf,IAAM,IAAI,GAAG,KAAK,GAAG,CAAC,OAAO,IAAI,GAAG,GAAG,CAAC;gBACxC,IAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;gBAC9C,IAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;;oBACxC,KAAkB,IAAA,SAAA,SAAA,IAAI,CAAA,0BAAA,4CAAE;wBAAnB,IAAM,GAAG,iBAAA;wBACZ,IAAI,GAAG,KAAK,aAAa,EAAE;4BACzB,IAAI,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;4BAEnB,IAAM,MAAM,GAAG,EAAE,CAAC,OAAO,IAAI,KAAK,CAAC;4BAEnC,IAAI,KAAK,GAAG,EAAE,CAAC;4BACf,IAAI,EAAE,CAAC,MAAM,EAAE;gCACb,IAAI,UAAU,CAAC,SAAS,CAAC,EAAE;oCACzB,KAAK,GAAG,EAAE,CAAC,MAAM,CAAC;iCACnB;qCAAM;oCACL,KAAK,GAAG,SAAS,GAAG,EAAE,CAAC,MAAM,CAAC;iCAC/B;6BACF;iCAAM;gCACL,IAAI,UAAU,CAAC,SAAS,CAAC,EAAE;oCACzB,KAAK,GAAG,SAAS,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC;iCACpC;qCAAM;oCACL,KAAK,GAAG,SAAS,GAAG,GAAG,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC;iCAC1C;6BACF;4BACD,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;4BAE3B,IAAM,SAAO,GAAG,EAAE,CAAC,QAAQ,GAAG,EAAE,CAAC,QAAQ,GAAG,EAAE,CAAC;4BAC/C,IAAI,CAAC,SAAO,CAAC,IAAI,EAAE;gCACjB,IAAI,EAAE,CAAC,KAAK,IAAI,SAAS,EAAE;oCACzB,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;wCAC5B,SAAO,CAAC,IAAI,GAAG,IAAI,CAAC;qCACrB;yCAAM;wCACL,SAAO,CAAC,IAAI,GAAG,KAAK,CAAC;qCACtB;iCACF;qCAAM,IAAI,EAAE,CAAC,KAAK,EAAE;oCACnB,SAAO,CAAC,IAAI,GAAG,IAAI,CAAC;iCACrB;qCAAM;oCACL,SAAO,CAAC,IAAI,GAAG,KAAK,CAAC;iCACtB;6BACF;4BACD,IAAI,CAAC,SAAO,CAAC,QAAQ,EAAE;gCACrB,IAAI,WAAW,GAAG,EAAE,CAAC,SAAS,IAAI,EAAE,CAAC;gCACrC,IAAG,SAAO,CAAC,IAAI,IAAE,IAAI,KAAK,KAAK,EAAC;oCAC9B,IAAI,WAAW,CAAC,OAAO,EAAE;wCACvB,WAAW,CAAC,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC;4CAC7C,aAAa,EAAEE,cAAG,CAAC,MAAM,EAAE;yCAC5B,CAAC,CAAA;qCACH;yCAAI;wCACH,WAAW,CAAC,OAAO,GAAGA,cAAG,CAAC,MAAM,CAAC;4CAC/B,OAAO,EAAEA,cAAG,CAAC,MAAM,CAAC;gDAClB,aAAa,EAAEA,cAAG,CAAC,MAAM,EAAE;6CAC5B,CAAC,CAAC,OAAO,EAAE;yCACb,CAAC,CAAA;qCACH;iCACF;gCACD,IAAI,WAAW,EAAE;oCACf,SAAO,CAAC,QAAQ,GAAG,WAAW,CAAC;iCAChC;6BACF;4BAED,IAAI,EAAE,CAAC,QAAQ,EAAE;gCACf,SAAO,CAAC,WAAW,GAAG,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gCACrC,SAAO,CAAC,KAAK,GAAG,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gCAC/B,SAAO,CAAC,IAAI,GAAG,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;6BAC/B;4BACD,IAAI,GAAG,GAAG,KAAK,CAAC;4BAChB,IAAI,SAAO,CAAC,IAAI,EAAE;gCAChB,GAAG,GAAG,SAAS,GAAE,GAAG,GAAC,IAAI,CAAC,MAAM,CAAC,GAAC,GAAG,GAAG,GAAG,CAAC;6BAC7C;iCAAM;gCACL,GAAG,GAAG,SAAS,GAAE,GAAG,GAAC,IAAI,CAAC,MAAM,CAAC,GAAC,GAAG,GAAG,GAAG,CAAC;6BAC7C;4BACD,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;4BACjB,MAAM,CAAC,KAAK,CAAC;gCACX,MAAM,EAAE,MAAM;gCACd,IAAI,EAAE,KAAK;gCACX,OAAO,EAAE,EAAE;gCACX,OAAO,EAAE,SAAO;6BACjB,CAAC,CAAC;yBACJ;qBACF;;;;;;;;;aACF;SACF,CAAC,CAAC;QACH,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,WAAW,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;YAC5E,QAAQ,EAAE,OAAO;SAClB,CAAC,CAAC;KACJ;IACH,kBAAC;AAAD,CAAC,IAAA;AAED,SAAS,IAAI,CAAC,GAAW,EAAE,MAAS;IAAT,uBAAA,EAAA,WAAS;IAChC,IAAI,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC;IACrB,IAAI,IAAI,GAAG,MAAM,GAAG,GAAG,CAAC;IACxB,IAAG,IAAI,IAAI,CAAC;QAAE,OAAO,GAAG,CAAA;IACxB,OAAO,GAAG,GAAC,SAAI,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,UAAC,CAAC,EAAC,CAAC,IAAG,OAAA,GAAG,GAAA,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;AACxD,CAAC;IAEK,MAAM,GAAG,IAAI,WAAW;;;;;;;;;;"} \ No newline at end of file diff --git a/packages/hapi-router/src/index.ts b/packages/hapi-router/src/index.ts index 125ad1d..34b074c 100755 --- a/packages/hapi-router/src/index.ts +++ b/packages/hapi-router/src/index.ts @@ -103,7 +103,7 @@ class routePlugin { } } }); - fs.writeFileSync(path.resolve(sourceDir, "route.txt"), routes.join("\n"), { + fs.writeFileSync(path.resolve(process.cwd(), "route.txt"), routes.join("\n"), { encoding: "utf-8", }); } diff --git a/public/css/page/a.css b/public/css/page/a.css new file mode 100644 index 0000000..e81d9a3 --- /dev/null +++ b/public/css/page/a.css @@ -0,0 +1,3 @@ +body { + color: #008000; +} diff --git a/public/css/page/a.styl b/public/css/page/a.styl new file mode 100644 index 0000000..7216b37 --- /dev/null +++ b/public/css/page/a.styl @@ -0,0 +1,2 @@ +body + color: green; \ No newline at end of file diff --git a/public/css/page/css.css b/public/css/page/css.css index 17db75a..6358389 100644 --- a/public/css/page/css.css +++ b/public/css/page/css.css @@ -16,9 +16,6 @@ html, body{ .title{ padding-left: 20px; - position: sticky; - top: 0; - background-color: white; z-index: 10; } diff --git a/route.txt b/route.txt new file mode 100644 index 0000000..3793d3a --- /dev/null +++ b/route.txt @@ -0,0 +1,19 @@ +所有路由路径： + 不需权限： GET /ad + 需要权限： GET /api/upload + 需要权限： POST /api/upload/upload + 不需权限： POST /api/user/register + 需要权限： POST /api/user/logout + 不需权限： POST /api/user/login + 需要权限： DELETE /api/user/del + 需要权限： GET /api/user/userinfo + 不需权限： GET /index/color + 不需权限： GET /404 + 不需权限： GET /css + 需要权限： GET / + 不需权限： GET /login + 不需权限： POST /login + 不需权限： GET /about + 需要权限： GET /docs/{path*} + 不需权限： GET /{path*} + 不需权限： GET /nav \ No newline at end of file diff --git a/source/auth/index.ts b/source/auth/index.ts index dea36af..f61f204 100644 --- a/source/auth/index.ts +++ b/source/auth/index.ts @@ -14,6 +14,8 @@ export async function validateJwt(decoded, request: Req, h) { } export async function validateSession(request: Req, session) { + console.log(request.path); + console.log(session); console.log(`session id: ${session.id}`); const User = request.getModel("User") if (session.id) { diff --git a/source/models/Constant.ts b/source/models/Constant.ts new file mode 100644 index 0000000..06c467c --- /dev/null +++ b/source/models/Constant.ts @@ -0,0 +1,24 @@ +module.exports = function (sequelize, DataTypes) { + const Constant = sequelize.define( + "Constant", + { + // 键 + key: { + type: DataTypes.STRING + }, + // 值 + value: { + type: DataTypes.STRING, + allowNull: true + }, + describe: { + type: DataTypes.STRING, + allowNull: true + }, + }, + { + timestamps: false, + } + ); + return Constant +}; \ No newline at end of file diff --git a/source/route/api/user/index.ts b/source/route/api/user/index.ts index a3318ee..a31de8f 100644 --- a/source/route/api/user/index.ts +++ b/source/route/api/user/index.ts @@ -97,7 +97,6 @@ export default class { }) @swagger("获取用户信息", "返回注册用户的信息", ["用户操作", "api"]) async userinfo(request: Req, h: Res): ReturnValue { - console.log(request); const { id } = request.auth.credentials; const User = request.getModel("User") let result = await User.findOne({ where: { id: id } }); diff --git a/source/route/index/color.ts b/source/route/index/color.ts index 0935ddd..137815e 100644 --- a/source/route/index/color.ts +++ b/source/route/index/color.ts @@ -2,6 +2,6 @@ export default class { index(req, h){ - + } } diff --git a/source/route/index/index.ts b/source/route/index/index.ts index 2adfec2..6e2fa13 100644 --- a/source/route/index/index.ts +++ b/source/route/index/index.ts @@ -9,12 +9,12 @@ import { import { Req, Res, ReturnValue } from "#/global"; import Joi from "joi"; import * as bcrypt from "bcrypt"; +import glob from "fast-glob"; +import path from "path"; export default class Index { - - async css(request: Req, h:Res): ReturnValue{ - - return h.view("views/css.pug") + async css(request: Req, h: Res): ReturnValue { + return h.view("views/css.pug"); } @auth() @@ -29,7 +29,7 @@ export default class Index { } else { // 未登录 } - return h.view("views/index.pug"); + return h.view("views/index.pug", { ss: request.auth.isAuthenticated }); } @method("GET") @route("/login") @@ -42,13 +42,12 @@ export default class Index { @route("/login") async login(request: Req, h: Res): ReturnValue { const { username, password } = request.payload as any; - const User = request.getModel("User") + const User = request.getModel("User"); const account = await User.findOne({ where: { username: username } }); if (!account || !(await bcrypt.compare(password, account.password))) { return h.redirect("/login"); } - request.cookieAuth.set({ id: account.id }); return h.redirect("/"); @@ -56,7 +55,7 @@ export default class Index { @route("/about") @auth(false) - async about(request, h) { + async about(request: Req, h) { console.log(request.auth); console.log(1); @@ -71,8 +70,31 @@ export default class Index { return h.view("views/about.ejs"); } + @auth() + @route("/docs/{path*}") + async docs(req: Req, h: Res): ReturnValue { + // const {id} = req.auth.credentials + // try { + // req.cookieAuth.ttl(720 * 24 * 60 * 60 * 1000) + // req.cookieAuth.set({ id: id }); + // } catch (error) { + // console.log(error); + + // } + if (req.path.endsWith(".md")) { + console.log(await glob(path.resolve(__dirname, "../../../docs/*.md"))); + // 解析文档 + return h.view("views/css.pug"); + } + // 404页面 + return h.redirect("/404"); + } @route("/{path*}") - async 404(req, h) { + async any(req: Req, h: Res): ReturnValue { + return h.view("404.pug"); + } + @route("/404") + async 404(req: Req, h: Res): ReturnValue { // 404页面 return h.view("404.pug"); } diff --git a/source/route/nav/index.ts b/source/route/nav/index.ts new file mode 100644 index 0000000..7c69e30 --- /dev/null +++ b/source/route/nav/index.ts @@ -0,0 +1,9 @@ +import { Req, Res, ReturnValue } from "#/global"; +import { gSuccess } from "@/util"; + +export default class Nav { + async index(req: Req, h: Res): ReturnValue{ + const Constant = req.getModel("Constant") + return gSuccess("31231") + } +} diff --git a/source/route/route.txt b/source/route/route.txt deleted file mode 100644 index ec92929..0000000 --- a/source/route/route.txt +++ /dev/null @@ -1,15 +0,0 @@ -所有路由路径： - 需要权限： GET /api/upload - 需要权限： POST /api/upload/upload - 不需权限： POST /api/user/register - 需要权限： POST /api/user/logout - 不需权限： POST /api/user/login - 需要权限： DELETE /api/user/del - 需要权限： GET /api/user/userinfo - 不需权限： GET /index/color - 不需权限： GET /{path*} - 不需权限： GET /css - 需要权限： GET / - 不需权限： GET /login - 不需权限： POST /login - 不需权限： GET /about \ No newline at end of file diff --git a/source/run.ts b/source/run.ts index 2488fc8..23802ae 100644 --- a/source/run.ts +++ b/source/run.ts @@ -11,7 +11,7 @@ import { Sequelize } from "sequelize"; const run = async (): Promise => { const server = Hapi.server({ - port: 3000, + port: 3388, host: "localhost", }); diff --git a/template/views/index.pug b/template/views/index.pug index c689f50..5dccdad 100644 --- a/template/views/index.pug +++ b/template/views/index.pug @@ -9,6 +9,6 @@ block head block content .container - h1.title 终是无缘一别两欢 + h1.title 终是无缘一别两欢#{ss} div.word 昨天看了我初中喜欢的人在空间发的一篇关于怀念初中的短篇小说吧，记录了他对一些记忆深刻的人的评价，而我也看到了我明明一直清楚，却不肯打心底接受的真相，他喜欢另外一个人，过往那么多的蛛丝马迹，那么多明明一件事就能看出他喜欢的人是她的真相，可我却是宁愿找借口自欺欺人，而今他给出坦白答案，他是放下了，才说出来，我是不是也该放下了，直到今日才明白我一个人自以为刻骨铭心的回忆，他也许早就忘怀，他的短篇小说故事中我没有丝言片语，也许若干年后他回想起来的只是我的名字，我只是个戏子，在他的故事中流着自己的泪，一个于他青春年华中不曾使他掀起过一丝波澜的模糊影子，而他不知道也永远不会知道，我的故事里他出现的很多，占了很多篇幅，我把他写进我的故事，因为他路过我心上，他踏着万千星河而来，又乘舟奔赴远方，我与春风皆过客，你携秋水揽星河。如今看来万般故事不过情伤，易水人去，明月如霜。 div.word(href="232") 他是无意穿堂风，却偏偏孤据引山洪。我是垂眉摆渡翁，却独独偏爱哝。 \ No newline at end of file