aven 0.1.13

Local-first task manager CLI and sync server
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

import AvenLocalProofCore
import Foundation

@main
struct AvenLocalProofCommand {
    static func main() async throws {
        let arguments = Array(CommandLine.arguments.dropFirst())
        switch arguments.first {
        case "local" where arguments.count == 1:
            try await runLocalProof()
        case "sync" where arguments.count == 2:
            try await runSyncProof(binaryPath: arguments[1])
        default:
            throw ProofFailure.invariant(
                "usage: aven-local-proof local | sync <aven-binary>"
            )
        }
    }

    private static func runLocalProof() async throws {
        let directory = try temporaryDirectory(named: "aven-swift-local-proof")
        defer { try? FileManager.default.removeItem(at: directory) }

        let result = try await LocalProof().run(
            databasePath: directory.appendingPathComponent("local.sqlite").path
        )
        precondition(result.workspaceCount >= 1)
        precondition(result.taskCount == 1)
        precondition(result.statusName == "active")
        precondition(result.priorityName == "high")
        precondition(result.requestByteCount > 0)
        precondition(result.validationErrorMatched)
        precondition(result.notFoundErrorMatched)

        print("workspace_resolution=pass")
        print("create_fetch_list_update=pass")
        print("reopen_migrations=pass")
        print("typed_status_priority_dates=pass")
        print("typed_validation_not_found=pass")
        print("sync_byte_transfer=pass")
        print("worker_executor=pass")
    }

    private static func runSyncProof(binaryPath: String) async throws {
        let directory = try temporaryDirectory(named: "aven-swift-sync-proof")
        defer { try? FileManager.default.removeItem(at: directory) }
        let authToken = "swift-proof-private-authorization"
        let server = try ProofServer.start(
            binaryPath: binaryPath,
            directory: directory,
            authToken: authToken
        )
        defer { server.stop() }

        let result = try await SyncProof().run(
            directory: directory,
            server: server.url,
            authToken: authToken
        )
        precondition(result.malformedResponseAtomic)
        precondition(result.authorizationAccepted)
        precondition(result.conflictVariantsTyped)
        precondition(result.replicasConverged)
        precondition(result.unresolvedConflictCount == 0)

        print("urlsession_transport=pass")
        print("authorized_round_trip=pass")
        print("malformed_response_atomicity=pass")
        print("typed_conflict_variants=pass")
        print("conflict_resolution_convergence=pass")
        print("unresolved_conflicts=0")
        print("privacy_safe_output=pass")
    }

    private static func temporaryDirectory(named name: String) throws -> URL {
        let directory = FileManager.default.temporaryDirectory
            .appendingPathComponent("\(name)-\(UUID().uuidString)")
        try FileManager.default.createDirectory(
            at: directory,
            withIntermediateDirectories: true
        )
        return directory
    }
}