@capacitor-community/sqlite 3.3.1 → 3.3.3-3

package/ios/Plugin/Database.swift

@@ -33,27 +33,38 @@ class Database {
     var encrypted: Bool
     var mode: String
     var vUpgDict: [Int: [String: Any]]
+    var databaseLocation: String
     var path: String = ""
     var mDb: OpaquePointer?
     let globalData: GlobalSQLite = GlobalSQLite()
     let uUpg: UtilsUpgrade = UtilsUpgrade()
+    var readOnly: Bool = false
+    var ncDB: Bool = false
 
     // MARK: - Init
-    init(databaseName: String, encrypted: Bool,
+    init(databaseLocation: String, databaseName: String, encrypted: Bool,
          mode: String, version: Int,
          vUpgDict: [Int: [String: Any]] = [:]) throws {
-        print("databaseName: \(databaseName) ")
         self.dbVersion = version
         self.encrypted = encrypted
         self.dbName = databaseName
         self.mode = mode
         self.vUpgDict = vUpgDict
-        do {
-            self.path = try UtilsFile.getFilePath(
-                fileName: databaseName)
-        } catch UtilsFileError.getFilePathFailed {
-            throw DatabaseError.filePath(
-                message: "Could not generate the file path")
+        self.databaseLocation = databaseLocation
+        if databaseName.contains("/")  &&
+            databaseName.suffix(9) != "SQLite.db" {
+            self.readOnly = true
+            self.path = databaseName
+            self.ncDB = true
+        } else {
+            do {
+                self.path = try UtilsFile.getFilePath(
+                    databaseLocation: databaseLocation,
+                    fileName: databaseName)
+            } catch UtilsFileError.getFilePathFailed {
+                throw DatabaseError.filePath(
+                    message: "Could not generate the file path")
+            }
         }
         print("database path \(self.path)")
     }
@@ -64,6 +75,12 @@ class Database {
         return isOpen
     }
 
+    // MARK: - isNCDB
+
+    func isNCDB () -> Bool {
+        return ncDB
+    }
+
     // MARK: - Open
 
     // swiftlint:disable cyclomatic_complexity
@@ -76,7 +93,8 @@ class Database {
         if mode == "encryption" {
             do {
                 let ret: Bool = try UtilsEncryption
-                    .encryptDatabase(filePath: path, password: password)
+                    .encryptDatabase(databaseLocation: databaseLocation,
+                                     filePath: path, password: password)
                 if !ret {
                     let msg: String = "Failed in encryption"
                     throw DatabaseError.open(message: msg)
@@ -92,27 +110,33 @@ class Database {
             mDb = try UtilsSQLCipher
                 .openOrCreateDatabase(filename: path,
                                       password: password,
-                                      readonly: false)
+                                      readonly: self.readOnly)
             isOpen = true
             // PRAGMA foreign_keys = ON;
             try UtilsSQLCipher
                 .setForeignKeyConstraintsEnabled(mDB: self,
                                                  toggle: true)
-            var curVersion: Int = try UtilsSQLCipher
-                .getVersion(mDB: self)
-            if curVersion == 0 {
-                try UtilsSQLCipher.setVersion(mDB: self, version: 1)
-                curVersion = try UtilsSQLCipher.getVersion(mDB: self)
-            }
-            if dbVersion > curVersion {
-                if vUpgDict.count > 0 {
-                    _ = try uUpg.onUpgrade(mDB: self, upgDict: vUpgDict,
-                                           dbName: dbName,
-                                           currentVersion: curVersion,
-                                           targetVersion: dbVersion)
-                    try UtilsSQLCipher.deleteBackupDB(databaseName: dbName)
-                } else {
-                    try UtilsSQLCipher.setVersion(mDB: self, version: dbVersion)
+            if !ncDB {
+                var curVersion: Int = try UtilsSQLCipher
+                    .getVersion(mDB: self)
+                if curVersion == 0 {
+                    try UtilsSQLCipher.setVersion(mDB: self, version: 1)
+                    curVersion = try UtilsSQLCipher.getVersion(mDB: self)
+                }
+                if dbVersion > curVersion {
+                    if vUpgDict.count > 0 {
+                        _ = try uUpg
+                            .onUpgrade(mDB: self, upgDict: vUpgDict,
+                                       dbName: dbName,
+                                       currentVersion: curVersion,
+                                       targetVersion: dbVersion,
+                                       databaseLocation: databaseLocation)
+                        try UtilsSQLCipher
+                            .deleteBackupDB(databaseLocation: databaseLocation,
+                                            databaseName: dbName)
+                    } else {
+                        try UtilsSQLCipher.setVersion(mDB: self, version: dbVersion)
+                    }
                 }
             }
         } catch UtilsSQLCipherError.openOrCreateDatabase(let message) {
@@ -140,7 +164,9 @@ class Database {
         } catch UtilsUpgradeError.onUpgradeFailed(let message) {
             //restore the database
             do {
-                try UtilsSQLCipher.restoreDB(databaseName: dbName)
+                try UtilsSQLCipher
+                    .restoreDB(databaseLocation: databaseLocation,
+                               databaseName: dbName)
                 let msg: String = "Failed OnUpgrade \(message)"
                 try close()
                 throw DatabaseError.open(message: msg)
@@ -210,6 +236,7 @@ class Database {
         do {
             try UtilsSQLCipher.execute(mDB: self, sql: sql)
             changes = UtilsSQLCipher.dbChanges(mDB: mDb) - initChanges
+
         } catch UtilsSQLCipherError.execute(let message) {
             if transaction {
                 do {
@@ -361,7 +388,8 @@ class Database {
 
     func deleteDB(databaseName: String) throws -> Bool {
         let isFileExists: Bool = UtilsFile
-            .isFileExist(fileName: databaseName)
+            .isFileExist(databaseLocation: databaseLocation,
+                         fileName: databaseName)
         if isFileExists && !isOpen {
             // open the database
             do {
@@ -379,7 +407,8 @@ class Database {
         // delete the database
         if isFileExists {
             do {
-                try UtilsSQLCipher.deleteDB(databaseName: databaseName)
+                try UtilsSQLCipher.deleteDB(databaseLocation: databaseLocation,
+                                            databaseName: databaseName)
             } catch UtilsSQLCipherError.deleteDB(let message ) {
                 throw DatabaseError.deleteDB(message: message)
             }

package/ios/Plugin/ImportExportJson/ImportFromJson.swift

@@ -245,7 +245,8 @@ class ImportFromJson {
         var statements: [String] = []
         for jpos in 0..<mIndexes.count {
             var mUnique: String = ""
-            if let mMode = mIndexes[jpos].mode {
+            if var mMode = mIndexes[jpos].mode {
+                mMode = mMode.uppercased()
                 if mMode == "UNIQUE" {
                     mUnique = mMode + " "
                 }

package/ios/Plugin/ImportExportJson/JsonSQLite.swift

@@ -108,7 +108,7 @@ public struct JsonIndex: Codable {
         print("value: \(value) ")
         if let mMode = mode {
             if mMode.count > 0 {
-                print("mode: \(mMode) ")
+                print("mode: \(mMode.uppercased()) ")
             }
         }
     }

package/ios/Plugin/ReturnHandler.swift

@@ -93,4 +93,17 @@ class ReturnHandler {
             return
         }
     }
+
+    // MARK: - rPath
+
+    func rPath(call: CAPPluginCall, ret: String,
+               message: String? = nil) {
+        if let intMessage = message {
+            call.reject(intMessage)
+            return
+        } else {
+            call.resolve(["path": ret])
+            return
+        }
+    }
 }

package/ios/Plugin/SqliteConfig.swift

@@ -0,0 +1,10 @@
+//
+//  config.swift
+//  CapacitorCommunitySqlite
+//
+//  Created by  Quéau Jean Pierre on 01/01/2022.
+//
+
+public struct SqliteConfig {
+    var iosDatabaseLocation: String?
+}

package/ios/Plugin/Utils/UtilsEncryption.swift

@@ -17,17 +17,19 @@ class UtilsEncryption {
     // MARK: - EncryptDatabase
 
     // swiftlint:disable function_body_length
-    class func encryptDatabase(filePath: String, password: String)
-    throws -> Bool {
+    class func encryptDatabase(databaseLocation: String, filePath: String,
+                               password: String) throws -> Bool {
         var ret: Bool = false
         var oDB: OpaquePointer?
         do {
             if UtilsFile.isFileExist(filePath: filePath) {
                 do {
-                    let tempPath: String = try UtilsFile.getFilePath(
-                        fileName: "temp.db")
+                    let tempPath: String = try UtilsFile
+                        .getFilePath(databaseLocation: databaseLocation,
+                                     fileName: "temp.db")
                     try UtilsFile.renameFile(filePath: filePath,
-                                             toFilePath: tempPath)
+                                             toFilePath: tempPath,
+                                             databaseLocation: databaseLocation)
                     oDB = try UtilsSQLCipher
                         .openOrCreateDatabase(filename: tempPath,
                                               password: "",
@@ -43,8 +45,9 @@ class UtilsEncryption {
                     stmt.append("DETACH DATABASE encrypted;")
                     if sqlite3_exec(oDB, stmt, nil, nil, nil) ==
                         SQLITE_OK {
-                        try _ = UtilsFile.deleteFile(
-                            fileName: "temp.db")
+                        try _ = UtilsFile
+                            .deleteFile(fileName: "temp.db",
+                                        databaseLocation: databaseLocation)
                         ret = true
                     }
                     // close the db

package/ios/Plugin/Utils/UtilsFile.swift

@@ -12,6 +12,7 @@ import ZIPFoundation
 enum UtilsFileError: Error {
     case getFilePathFailed
     case copyFileFailed
+    case moveFileFailed
     case renameFileFailed
     case deleteFileFailed
     case getAssetsDatabasesPathFailed
@@ -25,6 +26,9 @@ enum UtilsFileError: Error {
     case copyFromAssetToDatabaseFailed(message: String)
     case unzipFromAssetToDatabaseFailed(message: String)
     case copyFromNamesFailed
+    case getFolderURLFailed(message: String)
+    case createDirFailed(message: String)
+    case moveAllDBSQLiteFailed(message: String)
 }
 // swiftlint:disable file_length
 // swiftlint:disable type_body_length
@@ -39,6 +43,70 @@ class UtilsFile {
         return exists && isDir.boolValue
     }
 
+    class func createDirCopyDB(url: URL) throws {
+        do {
+            var dirUrl = url
+            let dirPath: String = url.path
+            if !UtilsFile.isDirExist(dirPath: dirPath) {
+                // create the directory
+                try FileManager.default
+                    .createDirectory(at: dirUrl, withIntermediateDirectories: true)
+                // exclude the directory from iCloud Backup
+                try UtilsFile.setExcludeFromiCloudBackup(&dirUrl,
+                                                         isExcluded: true)
+                // move all SQLite database from Documents folder
+                // to this new directory
+                try UtilsFile.moveAllDBSQLite(dirUrl: dirUrl)
+            }
+        } catch UtilsFileError.getFolderURLFailed(let message) {
+            throw UtilsFileError.createDirFailed(message: message)
+        } catch UtilsFileError.moveAllDBSQLiteFailed(let message) {
+            throw UtilsFileError.createDirFailed(message: message)
+        } catch let error {
+            var msg: String = "createDir command failed :"
+            msg.append(" \(error.localizedDescription)")
+            throw UtilsFileError.createDirFailed(message: msg)
+        }
+
+    }
+
+    // MARK: - moveAllDBSQLite
+
+    class func moveAllDBSQLite(dirUrl: URL) throws {
+        // get the db list from Documents folder
+        do {
+            let databaseURL: URL = try UtilsFile
+                .getDatabasesUrl().absoluteURL
+            let fileList: [String] = try UtilsFile
+                .getFileList(path: databaseURL.path,
+                             ext: "SQLite.db")
+            for file in fileList {
+                let fromFileURL: URL = databaseURL
+                    .appendingPathComponent(file).absoluteURL
+                let toFileURL = dirUrl
+                    .appendingPathComponent(file).absoluteURL
+                let retB: Bool = try UtilsFile
+                    .moveFile(pathName: fromFileURL.path,
+                              toPathName: toFileURL.path, overwrite: true)
+                if !retB {
+                    let msg: String = "moveFile command failed :"
+                    throw UtilsFileError.moveAllDBSQLiteFailed(message: msg)
+                }
+            }
+
+        } catch UtilsFileError.getFileListFailed {
+            let msg: String = "getFileList command failed :"
+            throw UtilsFileError.moveAllDBSQLiteFailed(message: msg)
+        } catch UtilsFileError.moveFileFailed {
+            let msg: String = "moveFile command failed :"
+            throw UtilsFileError.moveAllDBSQLiteFailed(message: msg)
+        } catch let error {
+            var msg: String = "moveAllDBSQLite command failed :"
+            msg.append(" \(error.localizedDescription)")
+            throw UtilsFileError.moveAllDBSQLiteFailed(message: msg)
+        }
+
+    }
     // MARK: - IsFileExist
 
     class func isFileExist(filePath: String) -> Bool {
@@ -49,11 +117,12 @@ class UtilsFile {
         }
         return ret
     }
-    class func isFileExist(fileName: String) -> Bool {
+    class func isFileExist(databaseLocation: String, fileName: String) -> Bool {
         var ret: Bool = false
         do {
             let filePath: String =
                 try UtilsFile.getFilePath(
+                    databaseLocation: databaseLocation,
                     fileName: fileName)
             ret = UtilsFile.isFileExist(filePath: filePath)
             return ret
@@ -64,14 +133,58 @@ class UtilsFile {
         }
     }
 
-    // MARK: - GetFilePath
+    // MARK: - getFolderURL
 
-    class func getFilePath(fileName: String) throws -> String {
+    class func getFolderURL(folderPath: String) throws -> URL {
         do {
-            let url = try getDatabasesUrl()
-            return url.appendingPathComponent("\(fileName)").path
+            let databaseURL = try UtilsFile.getDatabasesUrl().absoluteURL
+            var dbPathURL: URL
+            let first = folderPath.split(separator: "/", maxSplits: 1)
+            if first[0] == "Applications" {
+                dbPathURL = try UtilsFile.getApplicationURL().absoluteURL
+            } else if first[0] == "Library" {
+                dbPathURL = try UtilsFile.getLibraryURL().absoluteURL
+            } else if first[0] == "Documents" || first[0] == "default" {
+                dbPathURL = databaseURL
+            } else {
+                var msg: String = "getFolderURL command failed :"
+                msg.append(" Folder '\(first[0])' not allowed")
+                throw UtilsFileError.getFolderURLFailed(message: msg)
+            }
+            if first.count > 1 {
+                dbPathURL = dbPathURL
+                    .appendingPathComponent(String(first[1])).absoluteURL
+            }
+            return dbPathURL
         } catch UtilsFileError.getDatabasesURLFailed {
-            print("Error: getDatabasesUrl Failed")
+            throw UtilsFileError.getFolderURLFailed(message: "getDatabasesURLFailed")
+        } catch UtilsFileError.getApplicationURLFailed {
+            throw UtilsFileError
+            .getFolderURLFailed(message: "getApplicationURLFailed")
+        } catch let error {
+            var msg: String = "getFolderURL command failed :"
+            msg.append(" \(error.localizedDescription)")
+            throw UtilsFileError.getFolderURLFailed(message: msg)
+        }
+    }
+
+    // MARK: - GetFilePath
+
+    class func getFilePath(databaseLocation: String,
+                           fileName: String) throws -> String {
+        do {
+            let url: URL = try UtilsFile
+                .getFolderURL(folderPath: databaseLocation)
+            if databaseLocation.prefix(9) != "Documents" &&
+                databaseLocation.prefix(7) != "default" {
+                // create the directories if they do not exists
+                try UtilsFile.createDirCopyDB(url: url)
+            }
+            let dbPath: String = url
+                .appendingPathComponent("\(fileName)").path
+            return dbPath
+        } catch UtilsFileError.getFolderURLFailed(let message) {
+            print("Error: getFilePath Failed \(message)")
             throw UtilsFileError.getFilePathFailed
         }
     }
@@ -157,7 +270,6 @@ class UtilsFile {
 
     class func getAssetsDatabasesPath() throws -> URL {
         if let appFolder = Bundle.main.resourceURL {
-            print("getAssetsDatabasesPath appFolder \(appFolder)")
             return appFolder.appendingPathComponent("public/assets/databases")
         } else {
             print("Error: getAssetsDatabasePath did not find app folder")
@@ -180,17 +292,24 @@ class UtilsFile {
 
     // MARK: - GetFileList
 
-    class func getFileList(path: String, ext: String) throws -> [String] {
+    class func getFileList(path: String, ext: String? = nil) throws -> [String] {
+
         do {
-            var dbs: [String] = []
+            var files: [String] = []
             let filenames = try FileManager.default
                 .contentsOfDirectory(atPath: path)
             for file in filenames {
-                if file.hasSuffix(ext) {
-                    dbs.append(file)
+                if let mExtension = ext {
+                    if file.hasSuffix(mExtension) {
+                        files.append(file)
+                    }
+                } else {
+                    if file.prefix(1) != "." {
+                        files.append(file)
+                    }
                 }
             }
-            return dbs
+            return files
         } catch let error {
             print("Error: \(error)")
             throw UtilsFileError.getFileListFailed
@@ -223,16 +342,16 @@ class UtilsFile {
 
     // MARK: - CopyFromAssetToDatabase
 
-    class func copyFromAssetToDatabase(fromDb: String, toDb: String,
-                                       overwrite: Bool) throws {
+    class func copyFromAssetToDatabase(databaseLocation: String, fromDb: String,
+                                       toDb: String, overwrite: Bool) throws {
         do {
             let uAsset: URL = try getAssetsDatabasesPath()
                 .appendingPathComponent(fromDb)
-            let pAsset: String = uAsset.path
-            let uDb: URL = try getDatabasesUrl()
+
+            let uDb: URL = try getFolderURL(folderPath: databaseLocation)
                 .appendingPathComponent(toDb)
-            let pDb: String = uDb.path
-            let bRet: Bool = try copyFile(pathName: pAsset, toPathName: pDb,
+            let bRet: Bool = try copyFile(pathName: uAsset.path,
+                                          toPathName: uDb.path,
                                           overwrite: overwrite)
             if bRet {
                 return
@@ -245,11 +364,9 @@ class UtilsFile {
             let msg = "Error: getAssetsDatabasesPath Failed"
             print("\(msg)")
             throw UtilsFileError.copyFromAssetToDatabaseFailed(message: msg)
-        } catch UtilsFileError.getDatabasesURLFailed {
-            let msg = "Error: getDatabasesUrl Failed"
-            print("\(msg)")
-
-            throw UtilsFileError.copyFromAssetToDatabaseFailed(message: msg)
+        } catch UtilsFileError.getFolderURLFailed(let message) {
+            print("Error: getFolderUrl Failed \(message)")
+            throw UtilsFileError.copyFromAssetToDatabaseFailed(message: message)
         } catch UtilsFileError.copyFileFailed {
             let msg = "Error: copyFile Failed"
             print("\(msg)")
@@ -263,7 +380,8 @@ class UtilsFile {
 
     }
 
-    class func unzipFromAssetToDatabase(zip: String, overwrite: Bool) throws {
+    class func unzipFromAssetToDatabase(databaseLocation: String, zip: String,
+                                        overwrite: Bool) throws {
         do {
             let zipAsset: URL = try getAssetsDatabasesPath()
                 .appendingPathComponent(zip)
@@ -272,10 +390,10 @@ class UtilsFile {
                 print("\(msg)")
                 throw UtilsFileError.unzipFromAssetToDatabaseFailed(message: msg)
             }
+            let uDb: URL = try getFolderURL(folderPath: databaseLocation)
             for entry in archive {
                 let dbEntry = setPathSuffix(sDb: entry.path)
-                let zipCopy: URL = try getDatabasesUrl()
-                    .appendingPathComponent(dbEntry)
+                let zipCopy: URL = uDb.appendingPathComponent(dbEntry)
                 do {
                     let isExist: Bool = isFileExist(filePath: zipCopy.path)
                     if !isExist || overwrite {
@@ -295,10 +413,9 @@ class UtilsFile {
             let msg = "Error: getAssetsDatabasesPath Failed"
             print("\(msg)")
             throw UtilsFileError.unzipFromAssetToDatabaseFailed(message: msg)
-        } catch UtilsFileError.getDatabasesURLFailed {
-            let msg = "Error: getDatabasesUrl Failed"
-            print("\(msg)")
-            throw UtilsFileError.unzipFromAssetToDatabaseFailed(message: msg)
+        } catch UtilsFileError.getFolderURLFailed(let message) {
+            print("Error: getFolderUrl Failed \(message)")
+            throw UtilsFileError.unzipFromAssetToDatabaseFailed(message: message)
         } catch let error {
             let msg = "Error: \(error)"
             print("\(msg)")
@@ -306,6 +423,36 @@ class UtilsFile {
         }
     }
 
+    // MARK: - MoveFile
+
+    class func moveFile(pathName: String, toPathName: String, overwrite: Bool) throws -> Bool {
+        if pathName.count > 0 && toPathName.count > 0 {
+            let isPath = isFileExist(filePath: pathName)
+            if isPath {
+                do {
+                    let isExist: Bool = isFileExist(filePath: toPathName)
+                    if !isExist || overwrite {
+                        if overwrite && isExist {
+                            _ = try deleteFile(filePath: toPathName)
+                        }
+                        let fileManager = FileManager.default
+                        try fileManager.moveItem(atPath: pathName,
+                                                 toPath: toPathName)
+                    }
+                    return true
+                } catch let error {
+                    print("Error: \(error)")
+                    throw UtilsFileError.moveFileFailed
+                }
+            } else {
+                print("Error: MoveFile Failed pathName does not exist")
+                throw UtilsFileError.moveFileFailed
+            }
+        } else {
+            print("Error: MoveFile Failed paths count = 0")
+            throw UtilsFileError.moveFileFailed
+        }
+    }
     // MARK: - CopyFile
 
     class func copyFile(pathName: String, toPathName: String, overwrite: Bool) throws -> Bool {
@@ -339,12 +486,17 @@ class UtilsFile {
 
     // MARK: - CopyFile
 
-    class func copyFile(fileName: String, toFileName: String)
+    class func copyFile(fileName: String, toFileName: String,
+                        databaseLocation: String)
     throws -> Bool {
         var ret: Bool = false
         do {
-            let fromPath: String = try getFilePath(fileName: fileName)
-            let toPath: String = try getFilePath(fileName: toFileName)
+            let fromPath: String = try
+                getFilePath(databaseLocation: databaseLocation,
+                            fileName: fileName)
+            let toPath: String = try
+                getFilePath(databaseLocation: databaseLocation,
+                            fileName: toFileName)
             ret = try copyFile(pathName: fromPath, toPathName: toPath, overwrite: true)
             return ret
         } catch UtilsFileError.getFilePathFailed {
@@ -380,10 +532,13 @@ class UtilsFile {
 
     // MARK: - DeleteFile
 
-    class func deleteFile(fileName: String) throws -> Bool {
+    class func deleteFile(fileName: String,
+                          databaseLocation: String) throws -> Bool {
         var ret: Bool = false
         do {
-            let filePath: String = try getFilePath(fileName: fileName)
+            let filePath: String = try
+                getFilePath(databaseLocation: databaseLocation,
+                            fileName: fileName)
             ret = try deleteFile(filePath: filePath)
         } catch let error {
             print("Error: \(error)")
@@ -411,14 +566,15 @@ class UtilsFile {
 
     // MARK: - RenameFile
 
-    class func renameFile (filePath: String, toFilePath: String)
-    throws {
+    class func renameFile (filePath: String, toFilePath: String,
+                           databaseLocation: String) throws {
         let fileManager = FileManager.default
         do {
             if isFileExist(filePath: toFilePath) {
                 let fileName = URL(
                     fileURLWithPath: toFilePath).lastPathComponent
-                try  _ = deleteFile(fileName: fileName)
+                try  _ = deleteFile(fileName: fileName,
+                                    databaseLocation: databaseLocation)
             }
             try fileManager.moveItem(atPath: filePath,
                                      toPath: toFilePath)
@@ -427,6 +583,19 @@ class UtilsFile {
             throw UtilsFileError.renameFileFailed
         }
     }
+
+    class func setExcludeFromiCloudBackup(_ fileOrDirectoryURL: inout URL, isExcluded: Bool) throws {
+        var values = URLResourceValues()
+        values.isExcludedFromBackup = isExcluded
+        try fileOrDirectoryURL.setResourceValues(values)
+    }
+
+    class func getExcludeFromiCloudBackup(_ fileOrDirectoryURL: URL) throws -> Bool {
+        let keySet: Set<URLResourceKey> = [.isExcludedFromBackupKey]
+
+        return try
+            fileOrDirectoryURL.resourceValues(forKeys: keySet).isExcludedFromBackup ?? false
+    }
 }
 // swiftlint:enable type_body_length
 // swiftlint:enable file_length