Unable to decode optional custom type

[pravdomil]

Build Information

    {
      "identity" : "sqlite.swift",
      "kind" : "remoteSourceControl",
      "location" : "https://github.com/stephencelis/SQLite.swift",
      "state" : {
        "revision" : "e78ae0220e17525a15ac68c697a155eb7a672a8e",
        "version" : "0.15.0"
      }
    }

How to Reproduce

package.swift

// swift-tools-version: 5.10
// The swift-tools-version declares the minimum version of Swift required to build this package.

import PackageDescription

let package = Package(
    name: "MyExecutable",
    dependencies: [
        .package(url: "https://github.com/stephencelis/SQLite.swift", .upToNextMajor(from: "0.15.0")),
        .package(url: "https://github.com/yaslab/ULID.swift", .upToNextMinor(from: "1.2.0")),
    ], targets: [
        .executableTarget(
            name: "MyExecutable", dependencies: [
                .product(name: "SQLite", package: "SQLite.swift"),
                .product(name: "ULID", package: "ULID.swift"),
            ]
        ),
    ]
)

main.swift

import Foundation
import SQLite
import ULID

struct User: Codable {
    let id: UUID
    let name: Name?
}

struct Name: Codable {
    let first: String
    let last: String
}

let users = Table("users")
let id = Expression<UUID>("id")
let name = Expression<String?>("name")

do {
    let db = try Connection("db.sqlite3")

    try db.run(users.create(ifNotExists: true) { t in
        t.column(id, primaryKey: true)
        t.column(name)
    })

    try print(db.run(users.insert(User(id: UUID(), name: nil))))
    try print(db.prepare(users).map { row in try row.decode() } as [User])

} catch {
    print(error)
}

gives

typeMismatch(MyExecutable.Name, Swift.DecodingError.Context(codingPath: [], debugDescription: "an unsupported type was found", underlyingError: nil))

[pravdomil]

SQLite.swift/Sources/SQLite/Typed/Coding.swift

Lines 498 to 517 in e78ae02

	func decodeIfPresent<T>(_ type: T.Type, forKey key: Key) throws -> T? where T: Swift.Decodable {
	switch type {
	case is Data.Type:
	return try? row.get(Expression<Data>(key.stringValue)) as? T
	case is Date.Type:
	return try? row.get(Expression<Date>(key.stringValue)) as? T
	case is UUID.Type:
	return try? row.get(Expression<UUID>(key.stringValue)) as? T
	default:
	guard let JSONString = try? row.get(Expression<String?>(key.stringValue)) else {
	throw DecodingError.typeMismatch(type, DecodingError.Context(codingPath: codingPath,
	debugDescription: "an unsupported type was found"))
	}
	guard let data = JSONString.data(using: .utf8) else {
	throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: codingPath,
	debugDescription: "invalid utf8 data found"))
	}
	return try JSONDecoder().decode(type, from: data)
	}
	}

[nathanfallet]

This is a duplicate of #1247 and was fixed in #1248 (released in 0.15.1)