@pylonsync/create-pylon 0.19.0 → 0.20.0

package/templates/ios/consumer/apps/ios/Sources/__APP_NAME_PASCAL__/Media.swift

@@ -0,0 +1,271 @@
+import SwiftUI
+import UIKit
+import PylonClient
+
+/// Image URLs and photo uploads against the Pylon server.
+///
+/// Post and avatar URLs are server paths: `/images/...` for the demo photos
+/// in apps/api/public, `/api/files/<id>` for uploads.
+struct MediaService: Sendable {
+	let baseURL: URL
+	let client: PylonClient
+
+	/// The absolute URL for a stored image path.
+	func url(for path: String?) -> URL? {
+		guard let path, !path.isEmpty else { return nil }
+		if path.hasPrefix("http://") || path.hasPrefix("https://") { return URL(string: path) }
+		return URL(string: path, relativeTo: baseURL)?.absoluteURL
+	}
+
+	/// A resized copy for grids and avatars. The server's image optimizer
+	/// resizes files under public/. Uploads load at full size.
+	func thumbnailURL(for path: String?, width: Int) -> URL? {
+		guard let path, path.hasPrefix("/images/") else { return url(for: path) }
+		var components = URLComponents(url: baseURL.appendingPathComponent("_pylon/image"), resolvingAgainstBaseURL: false)
+		components?.queryItems = [
+			URLQueryItem(name: "src", value: path),
+			URLQueryItem(name: "w", value: String(width)),
+			URLQueryItem(name: "q", value: "75"),
+			URLQueryItem(name: "format", value: "jpeg"),
+		]
+		return components?.url
+	}
+
+	/// Upload a JPEG as a public file and return its `/api/files/<id>` path.
+	///
+	/// Pylon's upload is three requests: `POST /api/files/init` reserves a
+	/// slot, the bytes go to the returned `uploadUrl` with `PUT`, and
+	/// `POST /api/files/confirm` finishes it. `visibility: "public"` lets
+	/// every viewer load the photo without a session.
+	func uploadPublicJPEG(_ data: Data) async throws -> String {
+		struct InitBody: Encodable {
+			let filename: String
+			let mimeType: String
+			let size: Int
+			let visibility: String
+		}
+		struct InitResponse: Decodable {
+			let uploadUrl: String
+			let assetId: String
+		}
+		struct ConfirmBody: Encodable { let assetId: String }
+		struct ConfirmResponse: Decodable { let id: String }
+
+		let token = await client.currentToken()
+		let slot: InitResponse = try await send(
+			"POST",
+			to: baseURL.appendingPathComponent("api/files/init"),
+			json: InitBody(filename: "photo.jpg", mimeType: "image/jpeg", size: data.count, visibility: "public"),
+			token: token
+		)
+
+		guard let target = URL(string: slot.uploadUrl, relativeTo: baseURL)?.absoluteURL else {
+			throw MediaError.badResponse
+		}
+		var put = URLRequest(url: target)
+		put.httpMethod = "PUT"
+		put.setValue("image/jpeg", forHTTPHeaderField: "Content-Type")
+		// Only this server gets the session token. A storage provider's
+		// presigned URL carries its own authorization.
+		if target.host == baseURL.host, target.port == baseURL.port, let token {
+			put.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+		}
+		let (_, putResponse) = try await URLSession.shared.upload(for: put, from: data)
+		guard let http = putResponse as? HTTPURLResponse, (200..<300).contains(http.statusCode) else {
+			throw MediaError.uploadFailed
+		}
+
+		let confirmed: ConfirmResponse = try await send(
+			"POST",
+			to: baseURL.appendingPathComponent("api/files/confirm"),
+			json: ConfirmBody(assetId: slot.assetId),
+			token: token
+		)
+		// Store the server path. With S3 or Stack0 storage the confirm
+		// response's `url` is a CDN address; `/api/files/<id>` works for every
+		// backend and redirects to the CDN when there is one.
+		return "/api/files/\(confirmed.id)"
+	}
+
+	private func send<Body: Encodable, Response: Decodable>(
+		_ method: String,
+		to url: URL,
+		json body: Body,
+		token: String?
+	) async throws -> Response {
+		var request = URLRequest(url: url)
+		request.httpMethod = method
+		request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+		if let token { request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization") }
+		request.httpBody = try JSONEncoder().encode(body)
+		let (data, response) = try await URLSession.shared.data(for: request)
+		guard let http = response as? HTTPURLResponse else { throw MediaError.uploadFailed }
+		guard (200..<300).contains(http.statusCode) else {
+			let inner = (try? JSONDecoder().decode(ServerErrorBody.self, from: data))?.error
+			throw PylonError.http(status: http.statusCode, code: inner?.code, message: inner?.message)
+		}
+		return try JSONDecoder().decode(Response.self, from: data)
+	}
+}
+
+/// Pylon's error body: `{"error": {"code", "message"}}`.
+private struct ServerErrorBody: Decodable {
+	struct Inner: Decodable {
+		let code: String?
+		let message: String?
+	}
+	let error: Inner?
+}
+
+enum MediaError: LocalizedError {
+	case badResponse
+	case uploadFailed
+	case unreadableImage
+
+	var errorDescription: String? {
+		switch self {
+		case .badResponse, .uploadFailed: "The photo did not upload. Try again."
+		case .unreadableImage: "This photo cannot be read. Choose another one."
+		}
+	}
+}
+
+extension UIImage {
+	/// A JPEG no wider or taller than `maxPixels`, for upload.
+	func jpegForUpload(maxPixels: CGFloat = 1600, quality: CGFloat = 0.82) -> Data? {
+		let longest = max(size.width, size.height)
+		let scale = min(1, maxPixels / max(longest, 1))
+		let target = CGSize(width: (size.width * scale).rounded(), height: (size.height * scale).rounded())
+		let format = UIGraphicsImageRendererFormat()
+		format.scale = 1
+		let resized = UIGraphicsImageRenderer(size: target, format: format).image { _ in
+			draw(in: CGRect(origin: .zero, size: target))
+		}
+		return resized.jpegData(compressionQuality: quality)
+	}
+}
+
+// MARK: - Image loading
+
+/// Loads and caches decoded images. Rows scrolled off and back on screen
+/// draw from memory; the URL cache keeps the bytes on disk between launches.
+actor ImagePipeline {
+	static let shared = ImagePipeline()
+
+	nonisolated let memory = MemoryCache()
+	private let session: URLSession = {
+		let config = URLSessionConfiguration.default
+		config.urlCache = URLCache(memoryCapacity: 32 * 1024 * 1024, diskCapacity: 300 * 1024 * 1024)
+		config.requestCachePolicy = .returnCacheDataElseLoad
+		return URLSession(configuration: config)
+	}()
+	private var inFlight: [URL: Task<UIImage?, Never>] = [:]
+
+	nonisolated func cached(_ url: URL) -> UIImage? {
+		memory.image(for: url)
+	}
+
+	func image(for url: URL) async -> UIImage? {
+		if let hit = cached(url) { return hit }
+		if let running = inFlight[url] { return await running.value }
+		let session = self.session
+		let task = Task<UIImage?, Never> {
+			guard let (data, _) = try? await session.data(from: url),
+			      let image = UIImage(data: data) else { return nil }
+			return await image.byPreparingForDisplay() ?? image
+		}
+		inFlight[url] = task
+		let image = await task.value
+		inFlight[url] = nil
+		if let image {
+			let cost = Int(image.size.width * image.size.height * image.scale * image.scale * 4)
+			memory.store(image, for: url, cost: cost)
+		}
+		return image
+	}
+}
+
+/// Decoded images kept in memory. NSCache is safe to use from any thread.
+final class MemoryCache: @unchecked Sendable {
+	private let cache: NSCache<NSURL, UIImage> = {
+		let cache = NSCache<NSURL, UIImage>()
+		cache.totalCostLimit = 150 * 1024 * 1024
+		return cache
+	}()
+
+	func image(for url: URL) -> UIImage? { cache.object(forKey: url as NSURL) }
+
+	func store(_ image: UIImage, for url: URL, cost: Int) {
+		cache.setObject(image, forKey: url as NSURL, cost: cost)
+	}
+}
+
+/// A remote photo that fills its frame. Shows a neutral placeholder while it loads.
+struct RemoteImage: View {
+	let url: URL?
+	var placeholder: Color = Color(uiColor: .secondarySystemBackground)
+	@State private var image: UIImage?
+
+	init(url: URL?, placeholder: Color = Color(uiColor: .secondarySystemBackground)) {
+		self.url = url
+		self.placeholder = placeholder
+		_image = State(initialValue: url.flatMap { ImagePipeline.shared.cached($0) })
+	}
+
+	var body: some View {
+		Rectangle()
+			.fill(placeholder)
+			.overlay {
+				if let image {
+					Image(uiImage: image)
+						.resizable()
+						.scaledToFill()
+						.transition(.opacity)
+				}
+			}
+			.clipped()
+			.task(id: url) {
+				guard let url else { image = nil; return }
+				if let hit = ImagePipeline.shared.cached(url) {
+					image = hit
+					return
+				}
+				let loaded = await ImagePipeline.shared.image(for: url)
+				withAnimation(.easeOut(duration: 0.2)) { image = loaded }
+			}
+	}
+}
+
+/// A round profile photo over the first letter of the name on a tinted
+/// circle. The letter shows while the photo loads, or when there is none.
+struct AvatarView: View {
+	@EnvironmentObject private var social: SocialStore
+	let profile: Profile?
+	var size: CGFloat = 32
+
+	var body: some View {
+		ZStack {
+			Circle().fill(tint.gradient)
+			Text(initial)
+				.font(.system(size: size * 0.42, weight: .semibold, design: .rounded))
+				.foregroundStyle(.white)
+			if let path = profile?.avatarUrl, !path.isEmpty {
+				RemoteImage(url: social.media.thumbnailURL(for: path, width: size > 64 ? 256 : 128), placeholder: .clear)
+			}
+		}
+		.frame(width: size, height: size)
+		.clipShape(Circle())
+		.accessibilityHidden(true)
+	}
+
+	private var initial: String {
+		String((profile?.displayName ?? profile?.handle ?? "?").prefix(1)).uppercased()
+	}
+
+	private var tint: Color {
+		let palette: [Color] = [.orange, .pink, .purple, .indigo, .teal, .green, .blue, .red]
+		let key = profile?.handle ?? ""
+		let index = key.unicodeScalars.reduce(0) { ($0 &* 31 &+ Int($1.value)) & 0xFFFF } % palette.count
+		return palette[index]
+	}
+}

package/templates/ios/consumer/apps/ios/Sources/__APP_NAME_PASCAL__/Models.swift

@@ -1,19 +1,26 @@
 import Foundation
 
+// Row shapes for the entities in apps/api/app.ts. The sync engine hands
+// every row over as JSON, so optional fields must be optional here too.
+
 struct Profile: Codable, Identifiable, Hashable {
 	let id: String
 	let userId: String
 	let handle: String
 	let displayName: String
 	let bio: String?
+	let avatarUrl: String?
 	let createdAt: String
 }
 
 struct Post: Codable, Identifiable, Hashable {
 	let id: String
 	let authorId: String
-	let body: String
+	let imageUrl: String
+	let caption: String?
 	let createdAt: String
+
+	var date: Date { Timestamp.parse(createdAt) }
 }
 
 struct Like: Codable, Identifiable, Hashable {
@@ -23,12 +30,102 @@ struct Like: Codable, Identifiable, Hashable {
 	let createdAt: String
 }
 
+struct Comment: Codable, Identifiable, Hashable {
+	let id: String
+	let postId: String
+	let profileId: String
+	let text: String
+	let createdAt: String
+
+	var date: Date { Timestamp.parse(createdAt) }
+}
+
+struct Follow: Codable, Identifiable, Hashable {
+	let id: String
+	let followerId: String
+	let followingId: String
+	let createdAt: String
+}
+
+// MARK: - Function arguments and results
+
+struct EmptyArgs: Encodable {}
+struct SeedResult: Decodable { let seeded: Bool }
+struct IdResult: Decodable { let id: String }
 struct UpsertProfileArgs: Encodable {
 	let handle: String
 	let displayName: String
 	let bio: String
+	let avatarUrl: String?
+}
+struct CreatePostArgs: Encodable {
+	let imageUrl: String
+	let caption: String
+}
+struct SetLikeArgs: Encodable {
+	let postId: String
+	let liked: Bool
 }
-struct CreatePostArgs: Encodable { let body: String }
 struct DeletePostArgs: Encodable { let id: String }
-struct ToggleLikeArgs: Encodable { let postId: String }
-struct EmptyArgs: Encodable {}
+struct AddCommentArgs: Encodable {
+	let postId: String
+	let text: String
+}
+struct SetFollowArgs: Encodable {
+	let profileId: String
+	let following: Bool
+}
+struct SetLikeResult: Decodable {
+	let liked: Bool
+	let likeCount: Int
+}
+struct SetFollowResult: Decodable { let following: Bool }
+
+// MARK: - Timestamps
+
+enum Timestamp {
+	private static let withFraction: ISO8601DateFormatter = {
+		let f = ISO8601DateFormatter()
+		f.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+		return f
+	}()
+	private static let plain = ISO8601DateFormatter()
+
+	static func parse(_ iso: String) -> Date {
+		withFraction.date(from: iso) ?? plain.date(from: iso) ?? .distantPast
+	}
+
+	/// "now", "5m", "2h", "3d", "2w", then "Sep 3".
+	static func short(_ date: Date, now: Date = .now) -> String {
+		let seconds = max(0, now.timeIntervalSince(date))
+		switch seconds {
+		case ..<60: return "now"
+		case ..<3_600: return "\(Int(seconds / 60))m"
+		case ..<86_400: return "\(Int(seconds / 3_600))h"
+		case ..<604_800: return "\(Int(seconds / 86_400))d"
+		case ..<2_419_200: return "\(Int(seconds / 604_800))w"
+		default: return date.formatted(.dateTime.month(.abbreviated).day())
+		}
+	}
+
+	/// "Just now", "5 minutes ago", "2 hours ago", "3 days ago", then "September 3".
+	static func long(_ date: Date, now: Date = .now) -> String {
+		let seconds = max(0, now.timeIntervalSince(date))
+		func unit(_ n: Int, _ name: String) -> String { "\(n) \(name)\(n == 1 ? "" : "s") ago" }
+		switch seconds {
+		case ..<60: return "Just now"
+		case ..<3_600: return unit(Int(seconds / 60), "minute")
+		case ..<86_400: return unit(Int(seconds / 3_600), "hour")
+		case ..<604_800: return unit(Int(seconds / 86_400), "day")
+		default: return date.formatted(.dateTime.month(.wide).day())
+		}
+	}
+}
+
+extension Int {
+	/// 950 → "950", 1_204 → "1,204", 12_400 → "12.4K".
+	var compactCount: String {
+		if self < 10_000 { return formatted(.number) }
+		return formatted(.number.notation(.compactName).precision(.fractionLength(0...1)))
+	}
+}

package/templates/ios/consumer/apps/ios/Sources/__APP_NAME_PASCAL__/PostCard.swift

@@ -0,0 +1,245 @@
+import SwiftUI
+
+/// Pushed screens, shared by every tab's NavigationStack.
+enum Route: Hashable {
+	case profile(String)
+	case post(String)
+	case profilePosts(profileId: String, startAt: String)
+}
+
+extension View {
+	/// Registers the destinations for `Route` values on a NavigationStack.
+	func appRoutes() -> some View {
+		navigationDestination(for: Route.self) { route in
+			switch route {
+			case .profile(let id): ProfileView(profileId: id, isRoot: false)
+			case .post(let id): PostDetailView(postId: id)
+			case .profilePosts(let profileId, let startAt): ProfilePostsView(profileId: profileId, startAt: startAt)
+			}
+		}
+	}
+}
+
+/// One post in a feed: author, photo, actions, likes, caption, comments.
+struct PostCard: View {
+	@EnvironmentObject private var social: SocialStore
+	let post: Post
+
+	@State private var showBurst = false
+	@State private var burstTrigger = 0
+	@State private var showComments = false
+	@State private var confirmDelete = false
+
+	private var author: Profile? { social.profile(post.authorId) }
+	private var liked: Bool { social.isLiked(post.id) }
+	private var likeCount: Int { social.likeCount(post.id) }
+	private var comments: [Comment] { social.comments(post.id) }
+
+	var body: some View {
+		VStack(alignment: .leading, spacing: 0) {
+			header
+			photo
+			actions
+			details
+		}
+		.padding(.bottom, 14)
+		.sheet(isPresented: $showComments) {
+			CommentsView(postId: post.id)
+				.environmentObject(social)
+				.presentationDetents([.medium, .large])
+				.presentationDragIndicator(.visible)
+		}
+		.confirmationDialog("Delete this post?", isPresented: $confirmDelete, titleVisibility: .visible) {
+			Button("Delete", role: .destructive) {
+				Task { try? await social.deletePost(post.id) }
+			}
+		} message: {
+			Text("The photo, its likes, and its comments are removed for everyone.")
+		}
+	}
+
+	private var header: some View {
+		HStack(spacing: 10) {
+			NavigationLink(value: Route.profile(post.authorId)) {
+				HStack(spacing: 10) {
+					StoryAvatar(profile: author, size: 34, ringed: social.hasRecentPost(post.authorId))
+					HStack(spacing: 5) {
+						Text(author?.handle ?? "")
+							.font(.subheadline.weight(.semibold))
+						Text(Timestamp.short(post.date))
+							.font(.subheadline)
+							.foregroundStyle(.secondary)
+					}
+				}
+			}
+			.buttonStyle(.plain)
+			Spacer()
+			Menu {
+				if let url = social.media.url(for: post.imageUrl) {
+					ShareLink(item: url) { Label("Share", systemImage: "square.and.arrow.up") }
+				}
+				if post.authorId == social.myProfileId {
+					Button(role: .destructive) { confirmDelete = true } label: {
+						Label("Delete", systemImage: "trash")
+					}
+				}
+			} label: {
+				Image(systemName: "ellipsis")
+					.font(.system(size: 16, weight: .semibold))
+					.frame(width: 36, height: 36)
+					.contentShape(Rectangle())
+			}
+			.foregroundStyle(.primary)
+			.accessibilityLabel("More")
+		}
+		.padding(.leading, 12)
+		.padding(.trailing, 4)
+		.padding(.vertical, 8)
+	}
+
+	private var photo: some View {
+		Color.clear
+			.aspectRatio(4 / 5, contentMode: .fit)
+			.overlay { RemoteImage(url: social.media.url(for: post.imageUrl)) }
+			.clipped()
+			.overlay {
+				Image(systemName: "heart.fill")
+					.font(.system(size: 100))
+					.foregroundStyle(.white)
+					.shadow(color: .black.opacity(0.25), radius: 12, y: 4)
+					.scaleEffect(showBurst ? 1 : 0.3)
+					.opacity(showBurst ? 1 : 0)
+					.allowsHitTesting(false)
+			}
+			.contentShape(Rectangle())
+			.onTapGesture(count: 2) {
+				social.like(post.id)
+				burstTrigger += 1
+				withAnimation(.spring(response: 0.28, dampingFraction: 0.5)) { showBurst = true }
+				Task {
+					try? await Task.sleep(for: .milliseconds(650))
+					withAnimation(.easeIn(duration: 0.2)) { showBurst = false }
+				}
+			}
+			.sensoryFeedback(.impact(weight: .light), trigger: burstTrigger)
+			.accessibilityLabel(post.caption ?? "Photo")
+			.accessibilityAddTraits(.isImage)
+	}
+
+	private var actions: some View {
+		HStack(spacing: 18) {
+			Button {
+				social.toggleLike(post.id)
+			} label: {
+				Image(systemName: liked ? "heart.fill" : "heart")
+					.foregroundStyle(liked ? Theme.heart : .primary)
+					.symbolEffect(.bounce, value: liked)
+			}
+			.accessibilityLabel(liked ? "Unlike" : "Like")
+			.sensoryFeedback(.selection, trigger: liked)
+
+			Button { showComments = true } label: {
+				Image(systemName: "bubble.right")
+			}
+			.accessibilityLabel("Comment")
+
+			if let url = social.media.url(for: post.imageUrl) {
+				ShareLink(item: url) {
+					Image(systemName: "paperplane")
+				}
+				.accessibilityLabel("Share")
+			}
+			Spacer()
+		}
+		.font(.system(size: 23))
+		.foregroundStyle(.primary)
+		.buttonStyle(.plain)
+		.padding(.horizontal, 14)
+		.padding(.top, 12)
+		.padding(.bottom, 8)
+	}
+
+	private var details: some View {
+		VStack(alignment: .leading, spacing: 5) {
+			likesLine
+			if let caption = post.caption, !caption.isEmpty {
+				(Text(author?.handle ?? "").fontWeight(.semibold) + Text(" ") + Text(caption))
+					.font(.subheadline)
+					.lineLimit(3)
+			}
+			if !comments.isEmpty {
+				Button {
+					showComments = true
+				} label: {
+					Text(comments.count == 1 ? "View 1 comment" : "View all \(comments.count) comments")
+						.font(.subheadline)
+						.foregroundStyle(.secondary)
+				}
+				.buttonStyle(.plain)
+			}
+		}
+		.padding(.horizontal, 14)
+	}
+
+	@ViewBuilder
+	private var likesLine: some View {
+		if likeCount > 0 {
+			if let liker = social.featuredLiker(post.id), likeCount > 1 {
+				HStack(spacing: 6) {
+					AvatarView(profile: liker, size: 18)
+					(Text("Liked by ") + Text(liker.handle).fontWeight(.semibold)
+						+ Text(" and ") + Text(likeCount - 1 == 1 ? "1 other" : "\((likeCount - 1).compactCount) others").fontWeight(.semibold))
+						.font(.subheadline)
+						.lineLimit(1)
+				}
+				.contentTransition(.numericText())
+			} else {
+				Text(likeCount == 1 ? "1 like" : "\(likeCount.compactCount) likes")
+					.font(.subheadline.weight(.semibold))
+					.contentTransition(.numericText())
+			}
+		}
+	}
+}
+
+/// An avatar with the gradient ring for someone who posted in the last 24 hours.
+struct StoryAvatar: View {
+	let profile: Profile?
+	var size: CGFloat
+	var ringed: Bool
+
+	var body: some View {
+		let ring = max(2, size * 0.045)
+		let gap = max(2, size * 0.05)
+		AvatarView(profile: profile, size: size)
+			.padding(gap)
+			.background(Circle().fill(Color(uiColor: .systemBackground)))
+			.padding(ring)
+			.background {
+				if ringed {
+					Circle().fill(Theme.storyRing)
+				} else {
+					Circle().stroke(Theme.hairline, lineWidth: 0.5).padding(ring)
+				}
+			}
+	}
+}
+
+/// A single post on its own screen, reached from grids and activity.
+struct PostDetailView: View {
+	@EnvironmentObject private var social: SocialStore
+	let postId: String
+
+	var body: some View {
+		ScrollView {
+			if let post = social.post(postId) {
+				PostCard(post: post)
+			} else {
+				ContentUnavailableView("Post removed", systemImage: "photo", description: Text("This post is no longer available."))
+					.padding(.top, 80)
+			}
+		}
+		.navigationTitle("Post")
+		.navigationBarTitleDisplayMode(.inline)
+	}
+}