vapor / fluent-sqlite-driver Goto Github PK

// Shared models package, imported by both client and server
class User: Codable {
  let id: Int?
  let name: String
  let age: Int
}

// Client
extension User: SQLiteModel, Migration {}

// Server
extension User: PostgresModel, Migration {}

struct UserMigration_v1_0_0: Migration {
	func prepare(on database: Database) -> EventLoopFuture<Void> {
		database.eventLoop.flatten([
			database.schema(UserModel.schema)
				.id()
				.field(UserModel.FieldKeys.email, .string, .required)
				.field(UserModel.FieldKeys.password, .string, .required)
				.unique(on: UserModel.FieldKeys.email)
				.create(),
		])
	}

	func revert(on database: Database) -> EventLoopFuture<Void> {
		database.eventLoop.flatten([
			database.schema(UserModel.schema).delete()
		])
	}
}

struct UserMigration_v1_2_0: Migration {
	func prepare(on database: Database) -> EventLoopFuture<Void> {
		database.schema(UserModel.schema)
			.field(UserModel.FieldKeys.appleId, .string)
			.unique(on: UserModel.FieldKeys.appleId)
			.update()
	}

	func revert(on database: Database) -> EventLoopFuture<Void> {
		database.schema(UserModel.schema)
			.deleteField(UserModel.FieldKeys.appleId)
			.update()
	}
}

struct UserMigration_v1_2_0: Migration {
	func prepare(on database: Database) -> EventLoopFuture<Void> {
		database.eventLoop.flatten([
			database.schema(UserModel.schema)
				.field(UserModel.FieldKeys.appleId, .string)
				.update(),
			database.schema(UserModel.schema)
				.unique(on: UserModel.FieldKeys.appleId)
				.update(),
		])
	}

	func revert(on database: Database) -> EventLoopFuture<Void> {
		database.schema(UserModel.schema)
			.deleteField(UserModel.FieldKeys.appleId)
			.update()
	}
}

// GET http://localhost:8080/api/zession/crud-class-id-given-create
zessionRoutes.get("crud-class-id-given-create") { 
    (request: Request) -> Future<ZessionClass> in
    
    // Instantiate Class
    let zessionClass = ZessionClass(integer: 11, string: "crud-class-id-given-create")
    let uuid11 = UUID.init(uuidString: "dcc7d98d-92f4-46c5-b866-79e67f9c24fe")!
    zessionClass.id = uuid11
    print("\n@11a uuid11 = \(uuid11.uuidString)")
    print("@11b zessionClass = \(zessionClass.description())")
    
    // Create: existing, non-stored, uuid value will be changed.
    let didCreate11: EventLoopFuture<ZessionClass> = zessionClass.create(on: request)
    
    print("@11c zessionClass = \(zessionClass.description())")
    
    return didCreate11.map({ 
        (zessionClass: ZessionClass) -> ZessionClass in
        print("@11d \(zessionClass.description())")
        return zessionClass
    })
}

// GET http://localhost:8080/api/zession/crud-class-id-given-save
zessionRoutes.get("crud-class-id-given-save") { 
    (request: Request) -> Future<ZessionClass> in
    
    // Instantiate Class
    let zessionClass = ZessionClass(integer: 51, string: "crud-class-id-given-save")
    let uuid51 = UUID.init(uuidString: "7e0569f4-fafe-40a9-9d8f-e7d4c0e0a273")!
    zessionClass.id = uuid51
    print("\n@51a uuid51 = \(uuid51.uuidString)")
    print("@51b zessionClass = \(zessionClass.description())")
    
    // Create: existing, non-stored, uuid value will be changed.
    let didCreate51: EventLoopFuture<ZessionClass> = zessionClass.save(on: request)
    
    print("@51c zessionClass = \(zessionClass.description())")
    
    return didCreate51.map({ 
        (zessionClass: ZessionClass) -> ZessionClass in
        print("@51d \(zessionClass.description())")
        return zessionClass
    })
}

final class SampleProduct: SQLiteModel {
    
    static var entity: String = "products"
    
    var id: Int?
    var title: String
    var price: Int
    var brandId: Int
    var brandName: String
    
    init(id: Int? = nil, title: String, price: Int, brandId: Int, brandName: String) {
        self.id = id
        self.title = title
        self.price = price
        self.brandId = brandId
        self.brandName = brandName
    }
}

SampleProduct.query(on: conn).groupBy(\.brandId).all()

final class City: Content {
    var id: Int?
    let regionId: Region.ID
    let name: String

extension City: Migration {
    static func prepare(on connection: SQLiteConnection) -> Future<Void> {
        return Database.create(self, on: connection) { builder in
            try addProperties(to: builder)
            try builder.addReference(from: \.regionId, to: \Region.id)
        }
    }
}

	func test(_ req: Request) throws -> Future<[Todo]> {
		var todos = [Future<Todo>]()
		for i in 1...5 {
			let todo = Todo(title: "item \(i)")
			todos.append(todo.save(on: req).map {
				print("todo: \($0.id!), title: \($0.title)")
				return $0
			})
		}
		return todos.flatten(on: req)
	}

import FluentSQLite
import Vapor

struct MakeCategoriesUnique: Migration {
    typealias Database = SQLiteDatabase
    static func prepare(on connection: SQLiteConnection) -> Future<Void> {
        return Database.update(Category.self, on: connection) { builder in
            builder.unique(on: \.name)
        }
    }
    static func revert(on connection: SQLiteConnection) -> Future<Void> {
        return Database.update(Category.self, on: connection) { builder in
            builder.deleteUnique(from: \.name)
        }
    }
}

    /// See `SchemaSupporting`.
    public static func schemaExecute(_ fluent: Schema, on conn: SQLiteConnection) -> Future<Void> {
        let query: SQLiteQuery
        switch fluent.statement {
        case ._createTable:
            var createTable: SQLiteCreateTable = .createTable(fluent.table)
            createTable.columns = fluent.columns
            createTable.tableConstraints = fluent.constraints
            query = ._createTable(createTable)
        case ._alterTable:
            guard fluent.columns.count == 1 && fluent.constraints.count == 0 else {
                jjprint(fluent.columns.count) // 0 columns
                jjprint(fluent.constraints.count) // 1 constraint
                /// See https://www.sqlite.org/lang_altertable.html
/*>>>>>>>>>*/   fatalError("SQLite only supports adding one (1) column in an ALTER query.")
            }
            query = .alterTable(.init(
                table: fluent.table,
                value: .addColumn(fluent.columns[0])
            ))
        case ._dropTable:
            let dropTable: SQLiteDropTable = .dropTable(fluent.table)
            query = ._dropTable(dropTable)
        }
        return conn.query(query).transform(to: ())
    }

struct Migration1: Migration { 
    func prepare(on database: Database) -> EventLoopFuture<Void> {
        database.schema("my_table")
            .field("field", .double, .required)
            .field("other_field", .double)
            .create()
    }
    func revert(on database: Database) -> EventLoopFuture<Void> {
        database.schema("my_table").delete()
    }
}

struct Migration2: Migration {
    func prepare(on database: Database) -> EventLoopFuture<Void> {
        database.schema("my_table")
            .deleteField("field")
            .update()
    }
    func revert(on database: Database) -> EventLoopFuture<Void> {
        database.schema("my_table")
            .field("field", .double, .required)
            .update()
    }
}

final class Branch: Model, Content {
    static let schema = "t_branch"

    @ID(key: .id)
    var id: UUID?

    @Field(key: "name")
    var name: String

    @Siblings(through: BranchPerson.self, from: \.$branch, to: \.$person)
    var persons: [Person]

    init() { }

    init(id: UUID? = nil, name: String) {
        self.id = id
        self.name = name
    }
}

final class Person: Model, Content {
    static let schema = "t_person"

    @ID(key: .id)
    var id: UUID?

    @Field(key: "name")
    var name: String

    @Siblings(through: BranchPerson.self, from: \.$person, to: \.$branch)
    var branches: [Branch]

    init() { }

    init(id: UUID? = nil, name: String) {
        self.id = id
        self.name = name
    }
}

final class BranchPerson: Model, Content {
    static let schema = "t_branch_person"

    @ID(key: .id)
    var id: UUID?

    @Parent(key: "branchId")
    var branch: Branch

    @Parent(key: "personId")
    var person: Person

    init() { }

    init(id: UUID? = nil, branch: Branch, person: Person) throws {
        self.id = id
        self.$branch.id = try branch.requireID()
        self.$person.id = try person.requireID()
    }
}

struct CreateBranchPerson: AsyncMigration {
    func prepare(on database: Database) async throws {
        try await database.schema("t_branch_person")
            .id()
            .field("branchId", .uuid, .required, .references("branch", "id", onDelete: .cascade))
            .field("personId", .uuid, .required, .references("person", "id", onDelete: .cascade))
            .unique(on: "branchId", "personId") // 不允许重复的关系
            .create()
    }

    func revert(on database: Database) async throws {
        try await database.schema("t_branch_person").delete()
    }
}

public func configure(_ app: Application) throws {
    app.middleware.use(FileMiddleware(publicDirectory: app.directory.publicDirectory))
    app.views.use(.leaf)

    app.databases.use(.sqlite(.file("db.sqlite")), as: .sqlite)
    app.migrations.add(CreateBranch())
    app.migrations.add(CreatePerson())
    app.migrations.add(CreateBranchPerson())

    try routes(app)
}

struct PersonWatchOnBranchController: RouteCollection {
    func boot(routes: RoutesBuilder) throws {
        routes.post("person", ":personId", "watchOn", ":branchId",  use: createPersonWatchOnBranchHandler)
    }

    func createPersonWatchOnBranchHandler(req: Request) async throws -> HTTPStatus {
        guard let person = try await Person.find(req.parameters.get("personId"), on: req.db),
              let branch = try await Branch.find(req.parameters.get("branchId"), on: req.db)
        else {
            throw Abort(.notFound)
        }

        // 只有当关系不存在时才附加
        try await person.$branches.attach(branch, method: .ifNotExists, on: req.db)
        //try await branch.$persons.attach(person, method: .ifNotExists, on: req.db)

        return .ok
    }
}

let package = Package(
    name: "ipas",
    platforms: [
       .macOS(.v12)
    ],
    dependencies: [
        // 💧 A server-side Swift web framework.
        .package(url: "https://github.com/vapor/vapor.git", from: "4.67.1"),
        .package(url: "https://github.com/vapor/fluent.git", from: "4.5.0"),
        .package(url: "https://github.com/vapor/fluent-sqlite-driver.git", from: "4.2.0"),
        .package(url: "https://github.com/m-barthelemy/vapor-queues-fluent-driver.git", from: "3.0.0-beta1"),
        .package(url: "https://github.com/vapor/leaf.git", from: "4.2.2"),
    ],
    targets: [
        .target(
            name: "App",
            dependencies: [
                .product(name: "Fluent", package: "fluent"),
                .product(name: "FluentSQLiteDriver", package: "fluent-sqlite-driver"),
                .product(name: "QueuesFluentDriver", package: "vapor-queues-fluent-driver"),
                .product(name: "Leaf", package: "leaf"),
                .product(name: "Vapor", package: "vapor")
            ],
            swiftSettings: [
                // Enable better optimizations when building in Release configuration. Despite the use of
                // the `.unsafeFlags` construct required by SwiftPM, this flag is recommended for Release
                // builds. See <https://github.com/swift-server/guides/blob/main/docs/building.md#building-for-production> for details.
                .unsafeFlags(["-cross-module-optimization"], .when(configuration: .release))
            ]
        ),
        .executableTarget(name: "Run", dependencies: [.target(name: "App")]),
        .testTarget(name: "AppTests", dependencies: [
            .target(name: "App"),
            .product(name: "XCTVapor", package: "vapor"),
        ])
    ]
)

[ INFO ] POST /person/D9B06675-532F-45A8-BD93-CA10241DDA7B/watchOn/8F25A197-1BC8-4679-BC28-E4AC3F1CDAF7 [request-id: EF168AC8-6511-4E7B-9F59-11C40A1176DA] (Vapor/RouteLoggingMiddleware.swift:13)
[ DEBUG ] query read t_person filters=[t_person[id] = D9B06675-532F-45A8-BD93-CA10241DDA7B] limits=[count(1)] [database-id: sqlite, request-id: EF168AC8-6511-4E7B-9F59-11C40A1176DA] (FluentKit/QueryBuilder.swift:293)
[ DEBUG ] No available connections on this event loop, creating a new one (AsyncKit/EventLoopConnectionPool.swift:202)
[ DEBUG ] Connected to sqlite db: db.sqlite (SQLiteNIO/SQLiteConnection.swift:112)
[ DEBUG ] PRAGMA foreign_keys = ON [] (SQLiteNIO/SQLiteConnection.swift:161)
[ DEBUG ] SELECT "t_person"."id" AS "t_person_id", "t_person"."name" AS "t_person_name", "t_person"."email" AS "t_person_email", "t_person"."telephone" AS "t_person_telephone", "t_person"."dingTalkId" AS "t_person_dingTalkId" FROM "t_person" WHERE "t_person"."id" = ? LIMIT 1 ["D9B06675-532F-45A8-BD93-CA10241DDA7B"] [database-id: sqlite, request-id: EF168AC8-6511-4E7B-9F59-11C40A1176DA] (SQLiteNIO/SQLiteConnection.swift:161)
[ DEBUG ] query read t_branch filters=[t_branch[id] = 8F25A197-1BC8-4679-BC28-E4AC3F1CDAF7] limits=[count(1)] [database-id: sqlite, request-id: EF168AC8-6511-4E7B-9F59-11C40A1176DA] (FluentKit/QueryBuilder.swift:293)
[ DEBUG ] SELECT "t_branch"."id" AS "t_branch_id", "t_branch"."name" AS "t_branch_name" FROM "t_branch" WHERE "t_branch"."id" = ? LIMIT 1 ["8F25A197-1BC8-4679-BC28-E4AC3F1CDAF7"] [database-id: sqlite, request-id: EF168AC8-6511-4E7B-9F59-11C40A1176DA] (SQLiteNIO/SQLiteConnection.swift:161)
[ DEBUG ] query read t_branch_person filters=[t_branch_person[personId] = D9B06675-532F-45A8-BD93-CA10241DDA7B, t_branch_person[branchId] = 8F25A197-1BC8-4679-BC28-E4AC3F1CDAF7] limits=[count(1)] [database-id: sqlite, request-id: EF168AC8-6511-4E7B-9F59-11C40A1176DA] (FluentKit/QueryBuilder.swift:293)
[ DEBUG ] SELECT "t_branch_person"."id" AS "t_branch_person_id", "t_branch_person"."branchId" AS "t_branch_person_branchId", "t_branch_person"."personId" AS "t_branch_person_personId" FROM "t_branch_person" WHERE "t_branch_person"."personId" = ? AND "t_branch_person"."branchId" = ? LIMIT 1 ["D9B06675-532F-45A8-BD93-CA10241DDA7B", "8F25A197-1BC8-4679-BC28-E4AC3F1CDAF7"] [database-id: sqlite, request-id: EF168AC8-6511-4E7B-9F59-11C40A1176DA] (SQLiteNIO/SQLiteConnection.swift:161)
[ DEBUG ] query create t_branch_person input=[[branchId: 8F25A197-1BC8-4679-BC28-E4AC3F1CDAF7, personId: D9B06675-532F-45A8-BD93-CA10241DDA7B, id: 265A29D6-8205-48B1-B225-E838BCDA3E63]] [database-id: sqlite, request-id: EF168AC8-6511-4E7B-9F59-11C40A1176DA] (FluentKit/QueryBuilder.swift:293)
[ DEBUG ] INSERT INTO "t_branch_person" ("branchId", "personId", "id") VALUES (?, ?, ?) ["8F25A197-1BC8-4679-BC28-E4AC3F1CDAF7", "D9B06675-532F-45A8-BD93-CA10241DDA7B", "265A29D6-8205-48B1-B225-E838BCDA3E63"] [database-id: sqlite, request-id: EF168AC8-6511-4E7B-9F59-11C40A1176DA] (SQLiteNIO/SQLiteConnection.swift:161)
[ WARNING ] error: no such table: main.person [request-id: EF168AC8-6511-4E7B-9F59-11C40A1176DA] (Vapor/Middleware/ErrorMiddleware.swift:42)

{
      "identity" : "vapor",
      "kind" : "remoteSourceControl",
      "location" : "https://github.com/vapor/vapor.git",
      "state" : {
        "revision" : "0eacdf3c7eab6df493ce328f2e97c2873b3e1c1e",
        "version" : "4.67.1"
      }
    }

final class Device: Model, Content {
    
    typealias IDValue = String
    
    // Name of the table or collection.
    static let schema = "devices"
    
    // Unique identifier for this Device.
    @ID(custom: "id")
    var id: String?
    
    // The device's name.
    @Field(key: "name")
    var name: String?
    
    // Creates a new, empty Device.
    init() { }
    
    // Creates a new Device with all properties set.
    init(id: String, name: String) {
        self.id = id
        self.name = name
    }
} 

let newDevice = Device(id: "12345", name: "myDevice")
newDevice.create(on: req.db).whenSuccess({})

let deviceOnDB: EventLoopFuture<Device?> = Device.find("12345", on: req.db)
deviceOnDB.whenComplete { (result) in
    switch result {
    case .success(let device):
        if let device = device {
            req.logger.info("Success")
        }
    case .failure(let error):
            req.logger.error("Failure")
    }
}

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        
        let semaphore = DispatchSemaphore(value: 0)
        var values = [Todo]()
        
        try? FLite.prepare(migration: Todo.self).wait()
        
        try! FLite.add(model: Todo(title: "Hello World", strings: ["hello", "world"])).wait()
        
        FLite.fetch(model: Todo.self)
            .whenSuccess { (todos) in
                values = todos
                semaphore.signal()
        }
        
        semaphore.wait()
        
        print("Values: \(values)")
    }
}