Add ReaderAPI and AccountError packages.

SyncClients/ReaderAPI/Sources/ReaderAPI/ReaderAPI.swift

@@ -0,0 +1,6 @@
+public struct ReaderAPI {
+    public private(set) var text = "Hello, World!"
+
+    public init() {
+    }
+}

SyncClients/ReaderAPI/Sources/ReaderAPI/ReaderAPICaller.swift

@@ -0,0 +1,823 @@
+//
+//  ReaderAPICaller.swift
+//  Account
+//
+//  Created by Jeremy Beker on 5/28/19.
+//  Copyright © 2019 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+import AccountError
+import RSWeb
+import Secrets
+
+public enum CreateReaderAPISubscriptionResult {
+	case created(ReaderAPISubscription)
+	case notFound
+}
+
+public protocol ReaderAPICallerDelegate: AnyObject {
+
+	var apiBaseURL: URL? { get }
+	var lastArticleFetchStartTime: Date? { get set }
+	var lastArticleFetchEndTime: Date? { get set }
+
+	func createURLRequest(url: URL, credentials: Credentials?) -> URLRequest
+}
+
+struct MissingDelegateError: Error {}
+
+public final class ReaderAPICaller {
+	
+	public enum ItemIDType {
+		case unread
+		case starred
+		case allForAccount
+		case allForFeed
+	}
+	
+	private enum ReaderState: String {
+		case read = "user/-/state/com.google/read"
+		case starred = "user/-/state/com.google/starred"
+	}
+	
+	private enum ReaderStreams: String {
+		case readingList = "user/-/state/com.google/reading-list"
+	}
+	
+	private enum ReaderAPIEndpoints: String {
+		case login = "/accounts/ClientLogin"
+		case token = "/reader/api/0/token"
+		case disableTag = "/reader/api/0/disable-tag"
+		case renameTag = "/reader/api/0/rename-tag"
+		case tagList = "/reader/api/0/tag/list"
+		case subscriptionList = "/reader/api/0/subscription/list"
+		case subscriptionEdit = "/reader/api/0/subscription/edit"
+		case subscriptionAdd = "/reader/api/0/subscription/quickadd"
+		case contents = "/reader/api/0/stream/items/contents"
+		case itemIds = "/reader/api/0/stream/items/ids"
+		case editTag = "/reader/api/0/edit-tag"
+	}
+	
+	public weak var delegate: ReaderAPICallerDelegate?
+
+	private var transport: Transport!
+	private let missingDelegateError = MissingDelegateError()
+	private let uriComponentAllowed: CharacterSet
+
+	private var accessToken: String?
+	
+	public var variant: ReaderAPIVariant = .generic
+	public var credentials: Credentials?
+
+	public var server: String? {
+		get {
+			return apiBaseURL?.host
+		}
+	}
+	
+	private var apiBaseURL: URL? {
+		get {
+			delegate!.apiBaseURL
+		}
+	}
+	
+	public init(transport: Transport) {
+		self.transport = transport
+
+		var urlHostAllowed = CharacterSet.urlHostAllowed
+		urlHostAllowed.remove("+")
+		urlHostAllowed.remove("&")
+		uriComponentAllowed = urlHostAllowed
+	}
+	
+	public func cancelAll() {
+		transport.cancelAll()
+	}
+
+	public static func validateCredentials(credentials: Credentials, transport: Transport, endpoint: URL, variant: ReaderAPIVariant, createURLRequest: (URL, Credentials?) -> URLRequest, completion: @escaping (Result<Credentials?, Error>) -> Void) {
+
+		var request = createURLRequest(endpoint.appendingPathComponent(ReaderAPIEndpoints.login.rawValue), credentials)
+		addVariantHeaders(&request, variant)
+
+		transport.send(request: request) { result in
+			switch result {
+			case .success(let (_, data)):
+				guard let resultData = data else {
+					completion(.failure(TransportError.noData))
+					break
+				}
+
+				// Convert the return data to UTF8 and then parse out the Auth token
+				guard let rawData = String(data: resultData, encoding: .utf8) else {
+					completion(.failure(TransportError.noData))
+					break
+				}
+
+				var authData: [String: String] = [:]
+				rawData.split(separator: "\n").forEach({ (line: Substring) in
+					let items = line.split(separator: "=").map{String($0)}
+					if items.count == 2 {
+						authData[items[0]] = items[1]
+					}
+				})
+
+				guard let authString = authData["Auth"] else {
+					completion(.failure(CredentialsError.incompleteCredentials))
+					break
+				}
+
+				let validatedCredentials = Credentials(type: .readerAPIKey, username: credentials.username, secret: authString)
+				completion(.success(validatedCredentials))
+			case .failure(let error):
+				if let transportError = error as? TransportError, case .httpError(let code) = transportError, code == 404 {
+					completion(.failure(ReaderAPIError.urlNotFound))
+				} else {
+					completion(.failure(error))
+				}
+			}
+		}
+	}
+	
+	public func validateCredentials(endpoint: URL, completion: @escaping (Result<Credentials?, Error>) -> Void) {
+		guard let delegate else {
+			completion(.failure(missingDelegateError))
+			return
+		}
+		guard let credentials else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+
+		Self.validateCredentials(credentials: credentials, transport: transport, endpoint: endpoint, variant: variant, createURLRequest: delegate.createURLRequest) { result in
+
+			switch result {
+
+			case .success(let validatedCredentials):
+				// Save Auth Token for later use
+				if let validatedCredentials {
+					self.credentials = validatedCredentials
+				}
+				completion(.success(validatedCredentials))
+
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+	}
+	
+	func requestAuthorizationToken(endpoint: URL, completion: @escaping (Result<String, Error>) -> Void) {
+		guard let delegate else {
+			completion(.failure(missingDelegateError))
+			return
+		}
+		// If we have a token already, use it
+		if let accessToken = accessToken {
+			completion(.success(accessToken))
+			return
+		}
+		
+		// Otherwise request one.
+		guard let credentials = credentials else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		var request = delegate.createURLRequest(url: endpoint.appendingPathComponent(ReaderAPIEndpoints.token.rawValue), credentials: credentials)
+		addVariantHeaders(&request)
+		
+		transport.send(request: request) { result in
+			switch result {
+			case .success(let (_, data)):
+				guard let resultData = data else {
+					completion(.failure(TransportError.noData))
+					break
+				}
+				
+				// Convert the return data to UTF8 and then parse out the Auth token
+				guard let accessToken = String(data: resultData, encoding: .utf8) else {
+					completion(.failure(TransportError.noData))
+					break
+				}
+				
+				self.accessToken = accessToken
+				completion(.success(accessToken))
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+	}
+	
+	
+	public func retrieveTags(completion: @escaping (Result<[ReaderAPITag]?, Error>) -> Void) {
+		guard let delegate else {
+			completion(.failure(missingDelegateError))
+			return
+		}
+		guard let baseURL = apiBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		var url = baseURL
+			.appendingPathComponent(ReaderAPIEndpoints.tagList.rawValue)
+			.appendingQueryItem(URLQueryItem(name: "output", value: "json"))
+		
+		if variant == .inoreader {
+			url = url?.appendingQueryItem(URLQueryItem(name: "types", value: "1"))
+		}
+		
+		guard let callURL = url else {
+			completion(.failure(TransportError.noURL))
+			return
+		}
+
+		var request = delegate.createURLRequest(url: callURL, credentials: credentials)
+		addVariantHeaders(&request)
+
+		transport.send(request: request, resultType: ReaderAPITagContainer.self) { result in
+			switch result {
+			case .success(let (_, wrapper)):
+				completion(.success(wrapper?.tags))
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+		
+	}
+
+	public func renameTag(oldName: String, newName: String, completion: @escaping (Result<Void, Error>) -> Void) {
+		guard let baseURL = apiBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		self.requestAuthorizationToken(endpoint: baseURL) { (result) in
+			switch result {
+			case .success(let token):
+				guard let delegate = self.delegate else {
+					completion(.failure(self.missingDelegateError))
+					return
+				}
+				var request = delegate.createURLRequest(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.renameTag.rawValue), credentials: self.credentials)
+				self.addVariantHeaders(&request)
+				request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+				request.httpMethod = "POST"
+				
+				guard let encodedOldName = self.encodeForURLPath(oldName), let encodedNewName = self.encodeForURLPath(newName) else {
+					completion(.failure(ReaderAPIError.invalidParameter))
+					return
+				}
+				
+				let oldTagName = "user/-/label/\(encodedOldName)"
+				let newTagName = "user/-/label/\(encodedNewName)"
+				let postData = "T=\(token)&s=\(oldTagName)&dest=\(newTagName)".data(using: String.Encoding.utf8)
+				
+				self.transport.send(request: request, method: HTTPMethod.post, payload: postData!, completion: { (result) in
+					switch result {
+					case .success:
+						completion(.success(()))
+						break
+					case .failure(let error):
+						completion(.failure(error))
+						break
+					}
+				})
+				
+				
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+	}
+	
+    @MainActor public func deleteTag(folderExternalID: String?, completion: @escaping (Result<Void, Error>) -> Void) {
+		guard let baseURL = apiBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		guard let folderExternalID else {
+			completion(.failure(ReaderAPIError.invalidParameter))
+			return
+		}
+		
+		self.requestAuthorizationToken(endpoint: baseURL) { (result) in
+			switch result {
+			case .success(let token):
+				guard let delegate = self.delegate else {
+					completion(.failure(self.missingDelegateError))
+					return
+				}
+				var request = delegate.createURLRequest(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.disableTag.rawValue), credentials: self.credentials)
+				self.addVariantHeaders(&request)
+				request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+				request.httpMethod = "POST"
+				
+				let postData = "T=\(token)&s=\(folderExternalID)".data(using: String.Encoding.utf8)
+				
+				self.transport.send(request: request, method: HTTPMethod.post, payload: postData!, completion: { (result) in
+					switch result {
+					case .success:
+						completion(.success(()))
+						break
+					case .failure(let error):
+						completion(.failure(error))
+						break
+					}
+				})
+				
+				
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+	}
+	
+	public func retrieveSubscriptions(completion: @escaping (Result<[ReaderAPISubscription]?, Error>) -> Void) {
+		guard let delegate else {
+			completion(.failure(missingDelegateError))
+			return
+		}
+		guard let baseURL = apiBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		let url = baseURL
+			.appendingPathComponent(ReaderAPIEndpoints.subscriptionList.rawValue)
+			.appendingQueryItem(URLQueryItem(name: "output", value: "json"))
+		
+		guard let callURL = url else {
+			completion(.failure(TransportError.noURL))
+			return
+		}
+		
+		var request = delegate.createURLRequest(url: callURL, credentials: credentials)
+		addVariantHeaders(&request)
+
+		transport.send(request: request, resultType: ReaderAPISubscriptionContainer.self) { result in
+			switch result {
+			case .success(let (_, container)):
+				completion(.success(container?.subscriptions))
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+	}
+	
+	public func createSubscription(url: String, name: String?, completion: @escaping (Result<CreateReaderAPISubscriptionResult, Error>) -> Void) {
+		guard let baseURL = apiBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		func findSubscription(streamID: String, completion: @escaping (Result<CreateReaderAPISubscriptionResult, Error>) -> Void) {
+			// There is no call to get a single subscription entry, so we get them all,
+			// look up the one we just subscribed to and return that
+			self.retrieveSubscriptions(completion: { (result) in
+				switch result {
+				case .success(let subscriptions):
+					guard let subscriptions = subscriptions else {
+						completion(.failure(AccountError.createErrorNotFound))
+						return
+					}
+
+					guard let subscription = subscriptions.first(where: { (sub) -> Bool in
+						sub.feedID == streamID
+					}) else {
+						completion(.failure(AccountError.createErrorNotFound))
+						return
+					}
+
+					completion(.success(.created(subscription)))
+
+				case .failure(let error):
+					completion(.failure(error))
+				}
+			})
+		}
+		
+
+		self.requestAuthorizationToken(endpoint: baseURL) { (result) in
+			switch result {
+			case .success(let token):
+				guard let delegate = self.delegate else {
+					completion(.failure(self.missingDelegateError))
+					return
+				}
+				let callURL = baseURL
+					.appendingPathComponent(ReaderAPIEndpoints.subscriptionAdd.rawValue)
+				
+				var request = delegate.createURLRequest(url: callURL, credentials: self.credentials)
+				self.addVariantHeaders(&request)
+				request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+				request.httpMethod = "POST"
+				
+				guard let encodedFeedURL = self.encodeForURLPath(url) else {
+					completion(.failure(ReaderAPIError.invalidParameter))
+					return
+				}
+				let postData = "T=\(token)&quickadd=\(encodedFeedURL)".data(using: String.Encoding.utf8)
+
+				self.transport.send(request: request, method: HTTPMethod.post, data: postData!, resultType: ReaderAPIQuickAddResult.self, completion: { (result) in
+					switch result {
+					case .success(let (_, subResult)):
+
+						switch subResult?.numResults {
+						case 0:
+							completion(.success(.notFound))
+						default:
+							guard let streamId = subResult?.streamId else {
+								completion(.failure(AccountError.createErrorNotFound))
+								return
+							}
+
+							findSubscription(streamID: streamId, completion: completion)
+						}
+						
+					case .failure(let error):
+						completion(.failure(error))
+					}
+
+				})
+
+			case .failure(let error):
+				completion(.failure(error))
+			}
+				
+		}
+
+	}
+	
+	public func renameSubscription(subscriptionID: String, newName: String, completion: @escaping (Result<Void, Error>) -> Void) {
+		changeSubscription(subscriptionID: subscriptionID, title: newName, completion: completion)
+	}
+	
+	public func deleteSubscription(subscriptionID: String, completion: @escaping (Result<Void, Error>) -> Void) {
+		guard let baseURL = apiBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		self.requestAuthorizationToken(endpoint: baseURL) { (result) in
+			switch result {
+			case .success(let token):
+				guard let delegate = self.delegate else {
+					completion(.failure(self.missingDelegateError))
+					return
+				}
+				var request = delegate.createURLRequest(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.subscriptionEdit.rawValue), credentials: self.credentials)
+				self.addVariantHeaders(&request)
+				request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+				request.httpMethod = "POST"
+				
+				let postData = "T=\(token)&s=\(subscriptionID)&ac=unsubscribe".data(using: String.Encoding.utf8)
+				
+				self.transport.send(request: request, method: HTTPMethod.post, payload: postData!, completion: { (result) in
+					switch result {
+					case .success:
+						completion(.success(()))
+						break
+					case .failure(let error):
+						completion(.failure(error))
+						break
+					}
+				})
+				
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+	}
+	
+	public func createTagging(subscriptionID: String, tagName: String, completion: @escaping (Result<Void, Error>) -> Void) {
+		changeSubscription(subscriptionID: subscriptionID, addTagName: tagName, completion: completion)
+	}
+	
+	public func deleteTagging(subscriptionID: String, tagName: String, completion: @escaping (Result<Void, Error>) -> Void) {
+		changeSubscription(subscriptionID: subscriptionID, removeTagName: tagName, completion: completion)
+	}
+	
+	public func moveSubscription(subscriptionID: String, fromTag: String, toTag: String, completion: @escaping (Result<Void, Error>) -> Void) {
+		changeSubscription(subscriptionID: subscriptionID, removeTagName: fromTag, addTagName: toTag, completion: completion)
+	}
+	
+	private func changeSubscription(subscriptionID: String, removeTagName: String? = nil, addTagName: String? = nil, title: String? = nil, completion: @escaping (Result<Void, Error>) -> Void) {
+		guard removeTagName != nil || addTagName != nil || title != nil else {
+			completion(.failure(ReaderAPIError.invalidParameter))
+			return
+		}
+		
+		guard let baseURL = apiBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		self.requestAuthorizationToken(endpoint: baseURL) { (result) in
+			switch result {
+			case .success(let token):
+				guard let delegate = self.delegate else {
+					completion(.failure(self.missingDelegateError))
+					return
+				}
+				var request = delegate.createURLRequest(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.subscriptionEdit.rawValue), credentials: self.credentials)
+				self.addVariantHeaders(&request)
+				request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+				request.httpMethod = "POST"
+				
+				var postString = "T=\(token)&s=\(subscriptionID)&ac=edit"
+				if let fromLabel = self.encodeForURLPath(removeTagName) {
+					postString += "&r=user/-/label/\(fromLabel)"
+				}
+				if let toLabel = self.encodeForURLPath(addTagName) {
+					postString += "&a=user/-/label/\(toLabel)"
+				}
+				if let encodedTitle = self.encodeForURLPath(title) {
+					postString += "&t=\(encodedTitle)"
+				}
+				let postData = postString.data(using: String.Encoding.utf8)
+				
+				self.transport.send(request: request, method: HTTPMethod.post, payload: postData!, completion: { (result) in
+					switch result {
+					case .success:
+						completion(.success(()))
+						break
+					case .failure(let error):
+						completion(.failure(error))
+						break
+					}
+				})
+				
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+	}
+	
+	public func retrieveEntries(articleIDs: [String], completion: @escaping (Result<([ReaderAPIEntry]?), Error>) -> Void) {
+		
+		guard !articleIDs.isEmpty else {
+			completion(.success(([ReaderAPIEntry]())))
+			return
+		}
+		
+		guard let baseURL = apiBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		self.requestAuthorizationToken(endpoint: baseURL) { (result) in
+			switch result {
+			case .success(let token):
+				guard let delegate = self.delegate else {
+					completion(.failure(self.missingDelegateError))
+					return
+				}
+				var request = delegate.createURLRequest(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.contents.rawValue), credentials: self.credentials)
+				self.addVariantHeaders(&request)
+				request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+				request.httpMethod = "POST"
+				
+				// Get ids from above into hex representation of value
+				let idsToFetch = articleIDs.map({ articleID -> String in
+					if self.variant == .theOldReader {
+						return "i=tag:google.com,2005:reader/item/\(articleID)"
+					} else {
+						let idValue = Int(articleID)!
+						let idHexString = String(idValue, radix: 16, uppercase: false)
+						return "i=tag:google.com,2005:reader/item/\(idHexString)"
+					}
+				}).joined(separator:"&")
+				
+				let postData = "T=\(token)&output=json&\(idsToFetch)".data(using: String.Encoding.utf8)
+				
+				self.transport.send(request: request, method: HTTPMethod.post, data: postData!, resultType: ReaderAPIEntryWrapper.self, completion: { (result) in
+					switch result {
+					case .success(let (_, entryWrapper)):
+						guard let entryWrapper = entryWrapper else {
+							completion(.failure(ReaderAPIError.invalidResponse))
+							return
+						}
+						
+						completion(.success((entryWrapper.entries)))
+					case .failure(let error):
+						completion(.failure(error))
+					}
+				})
+				
+				
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+
+	}
+	
+	public func retrieveItemIDs(type: ItemIDType, feedID: String? = nil, completion: @escaping ((Result<[String], Error>) -> Void)) {
+		guard let delegate else {
+			completion(.failure(missingDelegateError))
+			return
+		}
+		guard let baseURL = apiBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		var queryItems = [
+			URLQueryItem(name: "n", value: "1000"),
+			URLQueryItem(name: "output", value: "json")
+		]
+		
+		switch type {
+		case .allForAccount:
+			let since: Date = {
+				if let lastArticleFetch = delegate.lastArticleFetchStartTime {
+					return lastArticleFetch
+				} else {
+					return Calendar.current.date(byAdding: .month, value: -3, to: Date()) ?? Date()
+				}
+			}()
+			
+			let sinceTimeInterval = since.timeIntervalSince1970
+			queryItems.append(URLQueryItem(name: "ot", value: String(Int(sinceTimeInterval))))
+			queryItems.append(URLQueryItem(name: "s", value: ReaderStreams.readingList.rawValue))
+		case .allForFeed:
+			guard let feedID = feedID else {
+				completion(.failure(ReaderAPIError.invalidParameter))
+				return
+			}
+			let sinceTimeInterval = (Calendar.current.date(byAdding: .month, value: -3, to: Date()) ?? Date()).timeIntervalSince1970
+			queryItems.append(URLQueryItem(name: "ot", value: String(Int(sinceTimeInterval))))
+			queryItems.append(URLQueryItem(name: "s", value: feedID))
+		case .unread:
+			queryItems.append(URLQueryItem(name: "s", value: ReaderStreams.readingList.rawValue))
+			queryItems.append(URLQueryItem(name: "xt", value: ReaderState.read.rawValue))
+		case .starred:
+			queryItems.append(URLQueryItem(name: "s", value: ReaderState.starred.rawValue))
+		}
+		
+		let url = baseURL
+			.appendingPathComponent(ReaderAPIEndpoints.itemIds.rawValue)
+			.appendingQueryItems(queryItems)
+		
+		guard let callURL = url else {
+			completion(.failure(TransportError.noURL))
+			return
+		}
+		
+		var request = delegate.createURLRequest(url: callURL, credentials: credentials)
+		addVariantHeaders(&request)
+
+		self.transport.send(request: request, resultType: ReaderAPIReferenceWrapper.self) { result in
+			switch result {
+			case .success(let (response, entries)):
+				guard let entriesItemRefs = entries?.itemRefs, entriesItemRefs.count > 0 else {
+					completion(.success([String]()))
+					return
+				}
+				let dateInfo = HTTPDateInfo(urlResponse: response)
+				let itemIDs = entriesItemRefs.compactMap { $0.itemId }
+				self.retrieveItemIDs(type: type, url: callURL, dateInfo: dateInfo, itemIDs: itemIDs, continuation: entries?.continuation, completion: completion)
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+	}
+
+	func retrieveItemIDs(type: ItemIDType, url: URL, dateInfo: HTTPDateInfo?, itemIDs: [String], continuation: String?, completion: @escaping ((Result<[String], Error>) -> Void)) {
+		guard let continuation = continuation else {
+			if type == .allForAccount {
+				self.delegate?.lastArticleFetchStartTime = dateInfo?.date
+				self.delegate?.lastArticleFetchEndTime = Date()
+			}
+			completion(.success(itemIDs))
+			return
+		}
+		
+		guard var urlComponents = URLComponents(url: url, resolvingAgainstBaseURL: false) else {
+			completion(.failure(ReaderAPIError.invalidParameter))
+			return
+		}
+		
+		var queryItems = urlComponents.queryItems!.filter({ $0.name != "c" })
+		queryItems.append(URLQueryItem(name: "c", value: continuation))
+		urlComponents.queryItems = queryItems
+		
+		guard let callURL = urlComponents.url else {
+			completion(.failure(TransportError.noURL))
+			return
+		}
+		guard let delegate else {
+			completion(.failure(missingDelegateError))
+			return
+		}
+		var request = delegate.createURLRequest(url: callURL, credentials: credentials)
+		addVariantHeaders(&request)
+
+		self.transport.send(request: request, resultType: ReaderAPIReferenceWrapper.self) { result in
+			switch result {
+			case .success(let (_, entries)):
+				guard let entriesItemRefs = entries?.itemRefs, entriesItemRefs.count > 0 else {
+					self.retrieveItemIDs(type: type, url: callURL, dateInfo: dateInfo, itemIDs: itemIDs, continuation: entries?.continuation, completion: completion)
+					return
+				}
+				var totalItemIDs = itemIDs
+				totalItemIDs.append(contentsOf: entriesItemRefs.compactMap { $0.itemId })
+				self.retrieveItemIDs(type: type, url: callURL, dateInfo: dateInfo, itemIDs: totalItemIDs, continuation: entries?.continuation, completion: completion)
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+	}
+	
+	public func createUnreadEntries(entries: [String], completion: @escaping (Result<Void, Error>) -> Void) {
+		updateStateToEntries(entries: entries, state: .read, add: false, completion: completion)
+	}
+	
+	public func deleteUnreadEntries(entries: [String], completion: @escaping (Result<Void, Error>) -> Void) {
+		updateStateToEntries(entries: entries, state: .read, add: true, completion: completion)
+	}
+	
+	public func createStarredEntries(entries: [String], completion: @escaping (Result<Void, Error>) -> Void) {
+		updateStateToEntries(entries: entries, state: .starred, add: true, completion: completion)
+	}
+	
+	public func deleteStarredEntries(entries: [String], completion: @escaping (Result<Void, Error>) -> Void) {
+		updateStateToEntries(entries: entries, state: .starred, add: false, completion: completion)
+	}
+		
+}
+
+// MARK: Private
+
+private extension ReaderAPICaller {
+	
+	func encodeForURLPath(_ pathComponent: String?) -> String? {
+		guard let pathComponent = pathComponent else { return nil }
+		return pathComponent.addingPercentEncoding(withAllowedCharacters: uriComponentAllowed)
+	}
+	
+	static func addVariantHeaders(_ request: inout URLRequest, _ variant: ReaderAPIVariant) {
+		if variant == .inoreader {
+			request.addValue(SecretsManager.provider.inoreaderAppId, forHTTPHeaderField: "AppId")
+			request.addValue(SecretsManager.provider.inoreaderAppKey, forHTTPHeaderField: "AppKey")
+		}
+	}
+
+	func addVariantHeaders(_ request: inout URLRequest) {
+		Self.addVariantHeaders(&request, variant)
+	}
+
+	private func updateStateToEntries(entries: [String], state: ReaderState, add: Bool, completion: @escaping (Result<Void, Error>) -> Void) {
+		guard let baseURL = apiBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		self.requestAuthorizationToken(endpoint: baseURL) { (result) in
+			switch result {
+			case .success(let token):
+				// Do POST asking for data about all the new articles
+				guard let delegate = self.delegate else {
+					completion(.failure(self.missingDelegateError))
+					return
+				}
+				var request = delegate.createURLRequest(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.editTag.rawValue), credentials: self.credentials)
+				self.addVariantHeaders(&request)
+				request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+				request.httpMethod = "POST"
+				
+				// Get ids from above into hex representation of value
+				let idsToFetch = entries.compactMap({ idValue -> String? in
+					if self.variant == .theOldReader {
+						return "i=tag:google.com,2005:reader/item/\(idValue)"
+					} else {
+						guard let intValue = Int(idValue) else { return nil }
+						let idHexString = String(format: "%.16llx", intValue)
+						return "i=tag:google.com,2005:reader/item/\(idHexString)"
+					}
+				}).joined(separator:"&")
+				
+				let actionIndicator = add ? "a" : "r"
+				
+				let postData = "T=\(token)&\(idsToFetch)&\(actionIndicator)=\(state.rawValue)".data(using: String.Encoding.utf8)
+				
+				self.transport.send(request: request, method: HTTPMethod.post, payload: postData!, completion: { (result) in
+					switch result {
+					case .success:
+						completion(.success(()))
+					case .failure(let error):
+						completion(.failure(error))
+					}
+				})
+				
+				
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+	}
+	
+
+}

SyncClients/ReaderAPI/Sources/ReaderAPI/ReaderAPIEntry.swift

@@ -0,0 +1,131 @@
+//
+//  ReaderAPIArticle.swift
+//  Account
+//
+//  Created by Jeremy Beker on 5/28/19.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+import RSParser
+import RSCore
+
+struct ReaderAPIEntryWrapper: Codable {
+	let id: String
+	let updated: Int
+	let entries: [ReaderAPIEntry]
+	
+	
+	enum CodingKeys: String, CodingKey {
+		case id = "id"
+		case updated = "updated"
+		case entries = "items"
+	}
+}
+
+/* {
+"id": "tag:google.com,2005:reader/item/00058a3b5197197b",
+"crawlTimeMsec": "1559362260113",
+"timestampUsec": "1559362260113787",
+"published": 1554845280,
+"title": "",
+"summary": {
+"content": "\n<p>Found an old screenshot of NetNewsWire 1.0 for iPhone!</p>\n\n<p><img src=\"https://nnw.ranchero.com/uploads/2019/c07c0574b1.jpg\" alt=\"Netnewswire 1.0 for iPhone screenshot showing the list of feeds.\" title=\"NewsGator got renamed to Sitrion, years later, and then renamed again as Limeade.\" border=\"0\" width=\"260\" height=\"320\"></p>\n"
+},
+"alternate": [
+{
+"href": "https://nnw.ranchero.com/2019/04/09/found-an-old.html"
+}
+],
+"categories": [
+"user/-/state/com.google/reading-list",
+"user/-/label/Uncategorized"
+],
+"origin": {
+"streamId": "feed/130",
+"title": "NetNewsWire"
+}
+}
+*/
+public struct ReaderAPIEntry: Codable {
+
+	let articleID: String
+	public let title: String?
+	public let author: String?
+
+	let publishedTimestamp: Double?
+	let crawledTimestamp: String?
+	let timestampUsec: String?
+	
+	public let summary: ReaderAPIArticleSummary
+	public let alternates: [ReaderAPIAlternateLocation]?
+	let categories: [String]
+	public let origin: ReaderAPIEntryOrigin
+
+	enum CodingKeys: String, CodingKey {
+		case articleID = "id"
+		case title = "title"
+		case author = "author"
+		case summary = "summary"
+		case alternates = "alternate"
+		case categories = "categories"
+		case publishedTimestamp = "published"
+		case crawledTimestamp = "crawlTimeMsec"
+		case origin = "origin"
+		case timestampUsec = "timestampUsec"
+	}
+	
+	public func parseDatePublished() -> Date? {
+		guard let unixTime = publishedTimestamp else {
+			return nil
+		}
+		return Date(timeIntervalSince1970: unixTime)
+	}
+	
+	public func uniqueID(variant: ReaderAPIVariant) -> String {
+		// Should look something like "tag:google.com,2005:reader/item/00058b10ce338909"
+		// REGEX feels heavy, I should be able to just split on / and take the last element
+		
+		guard let idPart =  articleID.components(separatedBy: "/").last else {
+			return articleID
+		}
+		
+		guard variant != .theOldReader else {
+			return idPart
+		}
+
+		// Convert hex representation back to integer and then a string representation
+		guard let idNumber = Int(idPart, radix: 16) else {
+			return articleID
+		}
+		
+		return String(idNumber, radix: 10, uppercase: false)
+	}
+	
+}
+
+public struct ReaderAPIArticleSummary: Codable {
+	public let content: String?
+	
+	enum CodingKeys: String, CodingKey {
+		case content = "content"
+	}
+}
+
+public struct ReaderAPIAlternateLocation: Codable {
+	public let url: String?
+	
+	enum CodingKeys: String, CodingKey {
+		case url = "href"
+	}
+}
+
+public struct ReaderAPIEntryOrigin: Codable {
+	public let streamId: String?
+	let title: String?
+
+	enum CodingKeys: String, CodingKey {
+		case streamId = "streamId"
+		case title = "title"
+	}
+}

SyncClients/ReaderAPI/Sources/ReaderAPI/ReaderAPIError.swift

@@ -0,0 +1,28 @@
+//
+//  ReaderAPIError.swift
+//  
+//
+//  Created by Jeremy Beker on 5/28/19.
+//
+
+import Foundation
+
+public enum ReaderAPIError: LocalizedError {
+	case unknown
+	case invalidParameter
+	case invalidResponse
+	case urlNotFound
+
+	public var errorDescription: String? {
+		switch self {
+		case .unknown:
+			return NSLocalizedString("An unexpected error occurred.", comment: "An unexpected error occurred.")
+		case .invalidParameter:
+			return NSLocalizedString("An invalid parameter was passed.", comment: "An invalid parameter was passed.")
+		case .invalidResponse:
+			return NSLocalizedString("There was an invalid response from the server.", comment: "There was an invalid response from the server.")
+		case .urlNotFound:
+			return NSLocalizedString("The API URL wasn't found.", comment: "The API URL wasn't found.")
+		}
+	}
+}

SyncClients/ReaderAPI/Sources/ReaderAPI/ReaderAPISubscription.swift

@@ -0,0 +1,111 @@
+//
+//  ReaderAPISubscription.swift
+//  Account
+//
+//  Created by Jeremy Beker on 5/28/19.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+import RSCore
+import RSParser
+
+/*
+
+	{
+		"numResults":0,
+		"error": "Already subscribed! https://inessential.com/xml/rss.xml
+	}
+
+*/
+
+struct ReaderAPIQuickAddResult: Codable {
+	let numResults: Int
+	let error: String?
+	let streamId: String?
+	
+	enum CodingKeys: String, CodingKey {
+		case numResults = "numResults"
+		case error = "error"
+		case streamId = "streamId"
+	}
+}
+
+struct ReaderAPISubscriptionContainer: Codable {
+	let subscriptions: [ReaderAPISubscription]
+	
+	enum CodingKeys: String, CodingKey {
+		case subscriptions = "subscriptions"
+	}
+}
+
+/*
+{
+	"id": "feed/1",
+	"title": "Questionable Content",
+	"categories": [
+	{
+		"id": "user/-/label/Comics",
+		"label": "Comics"
+	}
+	],
+	"url": "http://www.questionablecontent.net/QCRSS.xml",
+	"htmlUrl": "http://www.questionablecontent.net",
+	"iconUrl": "https://rss.confusticate.com/f.php?24decabc"
+}
+
+*/
+public struct ReaderAPISubscription: Codable {
+	public let feedID: String
+	public let name: String?
+	public let categories: [ReaderAPICategory]
+	let feedURL: String?
+	public let homePageURL: String?
+	let iconURL: String?
+
+	enum CodingKeys: String, CodingKey {
+		case feedID = "id"
+		case name = "title"
+		case categories = "categories"
+		case feedURL = "url"
+		case homePageURL = "htmlUrl"
+		case iconURL = "iconUrl"
+	}
+
+	public var url: String {
+		if let feedURL = feedURL {
+			return feedURL
+		} else {
+			return feedID.stripping(prefix: "feed/")
+		}
+	}
+}
+
+public struct ReaderAPICategory: Codable {
+	public let categoryId: String
+	let categoryLabel: String
+	
+	enum CodingKeys: String, CodingKey {
+		case categoryId = "id"
+		case categoryLabel = "label"
+	}
+}
+
+struct ReaderAPICreateSubscription: Codable {
+	let feedURL: String
+	enum CodingKeys: String, CodingKey {
+		case feedURL = "feed_url"
+	}
+}
+
+struct ReaderAPISubscriptionChoice: Codable {
+	
+	let name: String?
+	let url: String
+	
+	enum CodingKeys: String, CodingKey {
+		case name = "title"
+		case url = "feed_url"
+	}
+	
+}

SyncClients/ReaderAPI/Sources/ReaderAPI/ReaderAPITag.swift

@@ -0,0 +1,36 @@
+//
+//  ReaderAPICompatibleTag.swift
+//  Account
+//
+//  Created by Jeremy Beker on 5/28/19.
+//  Copyright © 2019 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+
+struct ReaderAPITagContainer: Codable {
+	let tags: [ReaderAPITag]
+	
+	enum CodingKeys: String, CodingKey {
+		case tags = "tags"
+	}
+}
+
+public struct ReaderAPITag: Codable {
+	
+	public let tagID: String
+	public let type: String?
+	
+	enum CodingKeys: String, CodingKey {
+		case tagID = "id"
+		case type = "type"
+	}
+	
+	public var folderName: String? {
+		guard let range = tagID.range(of: "/label/") else {
+			return nil
+		}
+		return String(tagID.suffix(from: range.upperBound))
+	}
+	
+}

SyncClients/ReaderAPI/Sources/ReaderAPI/ReaderAPITagging.swift

@@ -0,0 +1,35 @@
+//
+//  ReaderAPICompatibleTagging.swift
+//  Account
+//
+//  Created by Jeremy Beker on 5/28/19.
+//  Copyright © 2018 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+
+struct ReaderAPITagging: Codable {
+
+	let taggingID: Int
+	let feedID: Int
+	let name: String
+
+	enum CodingKeys: String, CodingKey {
+		case taggingID = "id"
+		case feedID = "feed_id"
+		case name = "name"
+	}
+
+}
+
+struct ReaderAPICreateTagging: Codable {
+	
+	let feedID: Int
+	let name: String
+	
+	enum CodingKeys: String, CodingKey {
+		case feedID = "feed_id"
+		case name = "name"
+	}
+	
+}

SyncClients/ReaderAPI/Sources/ReaderAPI/ReaderAPIUnreadEntry.swift

@@ -0,0 +1,27 @@
+//
+//  ReaderAPIUnreadEntry.swift
+//  Account
+//
+//  Created by Jeremy Beker on 5/28/19.
+//  Copyright © 2019 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+
+struct ReaderAPIReferenceWrapper: Codable {
+	let itemRefs: [ReaderAPIReference]?
+	let continuation: String?
+	
+	enum CodingKeys: String, CodingKey {
+		case itemRefs = "itemRefs"
+		case continuation = "continuation"
+	}
+}
+
+struct ReaderAPIReference: Codable {
+	let itemId: String?
+	
+	enum CodingKeys: String, CodingKey {
+		case itemId = "id"
+	}
+}

SyncClients/ReaderAPI/Sources/ReaderAPI/ReaderAPIVariant.swift

@@ -0,0 +1,30 @@
+//
+//  ReaderAPIVariant.swift
+//  
+//
+//  Created by Maurice Parker on 10/23/20.
+//
+
+import Foundation
+
+public enum ReaderAPIVariant {
+	case generic
+	case freshRSS
+	case inoreader
+	case bazQux
+	case theOldReader
+	
+	public var host: String {
+		switch self {
+		case .inoreader:
+			return "https://www.inoreader.com"
+		case .bazQux:
+			return "https://bazqux.com"
+		case .theOldReader:
+			return "https://theoldreader.com"
+		default:
+			return ""
+		}
+	}
+	
+}