@pylonsync/create-pylon 0.19.1 → 0.20.0

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

@@ -0,0 +1,171 @@
+import Foundation
+import PylonClient
+import PylonSync
+
+/// The signed-in state of the app. Owns the Pylon client and, while a user
+/// is signed in, the sync engine and the live social data built on it.
+@MainActor
+final class AppModel: ObservableObject {
+	enum Phase: Equatable {
+		case launching
+		case signedOut
+		case needsProfile
+		case ready
+	}
+
+	@Published private(set) var phase: Phase = .launching
+	@Published private(set) var social: SocialStore?
+
+	let client: PylonClient
+	let media: MediaService
+	let baseURL: URL
+	private var engine: SyncEngine?
+	private var engineStart: Task<Void, Never>?
+
+	init() {
+		// The simulator reaches the Mac's localhost. On a device, set
+		// PYLON_BASE_URL in the scheme to the Mac's LAN address or to your
+		// deployed API.
+		let raw = ProcessInfo.processInfo.environment["PYLON_BASE_URL"] ?? "http://localhost:4321"
+		guard let baseURL = URL(string: raw) else {
+			fatalError("Invalid PYLON_BASE_URL: \(raw)")
+		}
+		self.baseURL = baseURL
+		client = PylonClient(baseURL: baseURL, appName: "__APP_NAME_SNAKE__")
+		media = MediaService(baseURL: baseURL, client: client)
+	}
+
+	func boot() async {
+		guard phase == .launching else { return }
+		// Demo content for a new install. The server writes it once and
+		// returns at once after that. Delete this call with functions/seedDemo.ts.
+		_ = try? await client.callFn("seedDemo", args: EmptyArgs(), as: SeedResult.self)
+
+		guard await client.currentToken() != nil else {
+			phase = .signedOut
+			return
+		}
+		do {
+			let session = try await client.me()
+			guard let userId = session.userId else {
+				await clearLocalState()
+				return
+			}
+			await startSession(userId: userId)
+		} catch let error as PylonError where error.httpStatus == 401 {
+			await clearLocalState()
+		} catch {
+			// Offline launch: keep the stored session and show cached rows.
+			if let userId = UserDefaults.standard.string(forKey: Self.lastUserIdKey) {
+				await startSession(userId: userId)
+			} else {
+				phase = .signedOut
+			}
+		}
+	}
+
+	func signIn(email: String, password: String) async throws {
+		let session = try await client.signInWithPassword(email: email, password: password)
+		await startSession(userId: session.user_id)
+	}
+
+	func register(email: String, password: String) async throws {
+		let session = try await client.registerWithPassword(email: email, password: password)
+		await startSession(userId: session.user_id)
+	}
+
+	func signOut() async {
+		try? await client.logout()
+		await clearLocalState()
+	}
+
+	/// Called by the profile setup screen once the Profile row exists.
+	func profileCreated(_ profile: Profile) {
+		social?.myProfileId = profile.id
+		UserDefaults.standard.set(profile.id, forKey: Self.profileIdKey(profile.userId))
+		phase = .ready
+	}
+
+	/// Forgets the session and everything cached for it: the token, the
+	/// sync engine, the on-disk replica, and the remembered profile id.
+	private func clearLocalState() async {
+		await client.clearSession()
+		engineStart?.cancel()
+		await engineStart?.value
+		engineStart = nil
+		if let engine {
+			await engine.stop()
+			await engine.resetReplica(wipeMutations: true)
+		}
+		engine = nil
+		social = nil
+		Self.deleteReplicaFiles()
+		if let userId = UserDefaults.standard.string(forKey: Self.lastUserIdKey) {
+			UserDefaults.standard.removeObject(forKey: Self.profileIdKey(userId))
+		}
+		UserDefaults.standard.removeObject(forKey: Self.lastUserIdKey)
+		phase = .signedOut
+	}
+
+	private func startSession(userId: String?) async {
+		if let previous = UserDefaults.standard.string(forKey: Self.lastUserIdKey), previous != userId {
+			// A different account on this device: drop the last one's replica.
+			Self.deleteReplicaFiles()
+		}
+		if let userId { UserDefaults.standard.set(userId, forKey: Self.lastUserIdKey) }
+
+		var config = SyncEngineConfig(baseURL: baseURL, appName: "__APP_NAME_SNAKE__")
+		config.transport = .websocket
+		let engine = await SyncEngine(
+			config: config,
+			client: client,
+			persistence: Self.makePersistence()
+		)
+		self.engine = engine
+		// start() pulls the first snapshot, then keeps a WebSocket open so
+		// rows written by any other client arrive here without a refresh.
+		engineStart = Task { await engine.start() }
+
+		let social = SocialStore(engine: engine, client: client, media: media)
+		do {
+			let me = try await client.callFn("myProfile", args: EmptyArgs(), as: Profile?.self)
+			social.myProfileId = me?.id
+			if let userId {
+				if let id = me?.id {
+					UserDefaults.standard.set(id, forKey: Self.profileIdKey(userId))
+				} else {
+					UserDefaults.standard.removeObject(forKey: Self.profileIdKey(userId))
+				}
+			}
+		} catch {
+			// Offline: use this user's profile id from the last online launch.
+			social.myProfileId = userId.flatMap { UserDefaults.standard.string(forKey: Self.profileIdKey($0)) }
+		}
+		self.social = social
+		phase = social.myProfileId == nil ? .needsProfile : .ready
+	}
+
+	private static let lastUserIdKey = "lastUserId"
+
+	private static func profileIdKey(_ userId: String) -> String { "profileId.\(userId)" }
+
+	private static var replicaURL: URL {
+		FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0]
+			.appendingPathComponent("pylon-sync.sqlite")
+	}
+
+	/// An on-disk replica, so a relaunch shows the feed before the network answers.
+	private static func makePersistence() -> SQLitePersistence? {
+		try? FileManager.default.createDirectory(
+			at: replicaURL.deletingLastPathComponent(),
+			withIntermediateDirectories: true
+		)
+		return try? SQLitePersistence(path: replicaURL.path)
+	}
+
+	private static func deleteReplicaFiles() {
+		for suffix in ["", "-wal", "-shm"] {
+			try? FileManager.default.removeItem(atPath: replicaURL.path + suffix)
+		}
+	}
+}

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

@@ -0,0 +1,182 @@
+import SwiftUI
+
+/// Email and password sign-in and sign-up against Pylon auth.
+struct AuthView: View {
+	@EnvironmentObject private var app: AppModel
+
+	enum Mode { case signIn, signUp }
+	enum Field { case email, password }
+
+	@State private var mode: Mode = .signIn
+	@State private var email = ""
+	@State private var password = ""
+	@State private var busy = false
+	@State private var errorMessage: String?
+	@State private var photos: [URL] = []
+	@FocusState private var focus: Field?
+
+	var body: some View {
+		ZStack(alignment: .bottom) {
+			PhotoMosaic(photos: photos)
+				.ignoresSafeArea()
+			// A fade that follows the form, so the form stays readable when
+			// the keyboard pushes it up over the photos.
+			form
+				.padding(.horizontal, 24)
+				.padding(.bottom, 12)
+				.background(alignment: .top) {
+					let base = Color(uiColor: .systemBackground)
+					LinearGradient(
+						stops: [
+							.init(color: base.opacity(0), location: 0),
+							.init(color: base.opacity(0.9), location: 0.22),
+							.init(color: base, location: 0.3),
+						],
+						startPoint: .top,
+						endPoint: .bottom
+					)
+					.padding(.top, -200)
+					.ignoresSafeArea()
+				}
+		}
+		.task { await loadPhotos() }
+	}
+
+	private var form: some View {
+		VStack(spacing: 14) {
+			VStack(spacing: 6) {
+				Wordmark(size: 48)
+				Text(mode == .signIn ? "Sign in to see photos from people you follow." : "Create an account to share your photos.")
+					.font(.subheadline)
+					.foregroundStyle(.secondary)
+					.multilineTextAlignment(.center)
+			}
+			.padding(.bottom, 10)
+
+			TextField("Email", text: $email)
+				.textContentType(.emailAddress)
+				.keyboardType(.emailAddress)
+				.textInputAutocapitalization(.never)
+				.autocorrectionDisabled()
+				.submitLabel(.next)
+				.focused($focus, equals: .email)
+				.onSubmit { focus = .password }
+				.fieldStyle()
+
+			SecureField("Password", text: $password)
+				.textContentType(mode == .signIn ? .password : .newPassword)
+				.submitLabel(.go)
+				.focused($focus, equals: .password)
+				.onSubmit(submit)
+				.fieldStyle()
+
+			if let errorMessage {
+				Text(errorMessage)
+					.font(.footnote)
+					.foregroundStyle(.red)
+					.frame(maxWidth: .infinity, alignment: .leading)
+					.transition(.opacity)
+			}
+
+			Button(mode == .signIn ? "Log in" : "Create account", action: submit)
+				.buttonStyle(PrimaryButtonStyle(isLoading: busy))
+				.disabled(busy || !canSubmit)
+				.opacity(canSubmit ? 1 : 0.6)
+
+			HStack(spacing: 4) {
+				Text(mode == .signIn ? "No account yet?" : "Already have an account?")
+					.foregroundStyle(.secondary)
+				Button(mode == .signIn ? "Sign up" : "Log in") {
+					withAnimation(.snappy) {
+						mode = mode == .signIn ? .signUp : .signIn
+						errorMessage = nil
+					}
+				}
+				.fontWeight(.semibold)
+			}
+			.font(.footnote)
+			.padding(.top, 6)
+		}
+		.animation(.snappy, value: errorMessage)
+	}
+
+	private var canSubmit: Bool {
+		email.contains("@") && (mode == .signIn ? !password.isEmpty : password.count >= 8)
+	}
+
+	private func submit() {
+		guard !busy else { return }
+		guard canSubmit else {
+			if mode == .signUp, password.count < 8 {
+				errorMessage = "Use a password with at least 8 characters."
+			}
+			return
+		}
+		focus = nil
+		busy = true
+		errorMessage = nil
+		let email = email.trimmingCharacters(in: .whitespaces).lowercased()
+		Task {
+			defer { busy = false }
+			do {
+				if mode == .signIn {
+					try await app.signIn(email: email, password: password)
+				} else {
+					try await app.register(email: email, password: password)
+				}
+			} catch {
+				errorMessage = friendlyMessage(error)
+			}
+		}
+	}
+
+	/// The newest public photos, for the background.
+	private func loadPhotos() async {
+		guard let posts = try? await app.client.list("Post", as: Post.self) else { return }
+		photos = posts
+			.sorted { $0.createdAt > $1.createdAt }
+			.prefix(18)
+			.compactMap { app.media.thumbnailURL(for: $0.imageUrl, width: 384) }
+	}
+}
+
+/// Three columns of photos drifting upward at different speeds.
+private struct PhotoMosaic: View {
+	let photos: [URL]
+
+	var body: some View {
+		GeometryReader { geo in
+			let spacing: CGFloat = 8
+			let width = (geo.size.width - spacing * 4) / 3
+			TimelineView(.animation) { timeline in
+				let t = timeline.date.timeIntervalSinceReferenceDate
+				HStack(alignment: .top, spacing: spacing) {
+					ForEach(0..<3, id: \.self) { column in
+						let items = columnPhotos(column)
+						let tile = width * 1.25 + spacing
+						let loop = tile * CGFloat(max(items.count, 1))
+						let speed = [14.0, 20.0, 11.0][column]
+						let offset = CGFloat((t * speed).truncatingRemainder(dividingBy: Double(max(loop, 1))))
+						VStack(spacing: spacing) {
+							ForEach(Array((items + items).enumerated()), id: \.offset) { _, url in
+								RemoteImage(url: url)
+									.frame(width: width, height: width * 1.25)
+									.clipShape(RoundedRectangle(cornerRadius: 14, style: .continuous))
+							}
+						}
+						.offset(y: -offset - (column == 1 ? width * 0.5 : 0))
+					}
+				}
+				.padding(.horizontal, spacing)
+			}
+		}
+		.opacity(photos.isEmpty ? 0 : 1)
+		.animation(.easeIn(duration: 0.6), value: photos.isEmpty)
+		.allowsHitTesting(false)
+		.accessibilityHidden(true)
+	}
+
+	private func columnPhotos(_ column: Int) -> [URL] {
+		photos.enumerated().filter { $0.offset % 3 == column }.map(\.element)
+	}
+}

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

@@ -0,0 +1,136 @@
+import SwiftUI
+
+/// The comments on one post. New comments from anyone appear live.
+struct CommentsView: View {
+	@EnvironmentObject private var social: SocialStore
+	let postId: String
+
+	@State private var draft = ""
+	@State private var sending = false
+	@State private var errorMessage: String?
+	@FocusState private var inputFocused: Bool
+
+	private var post: Post? { social.post(postId) }
+	private var comments: [Comment] { social.comments(postId) }
+
+	var body: some View {
+		NavigationStack {
+			ScrollViewReader { proxy in
+				ScrollView {
+					LazyVStack(alignment: .leading, spacing: 18) {
+						if let post, let caption = post.caption, !caption.isEmpty {
+							CommentRow(profile: social.profile(post.authorId), text: caption, date: post.date)
+							Divider()
+						}
+						if comments.isEmpty {
+							Text("No comments yet. Start the conversation.")
+								.font(.subheadline)
+								.foregroundStyle(.secondary)
+								.frame(maxWidth: .infinity)
+								.padding(.top, 24)
+						}
+						ForEach(comments) { comment in
+							CommentRow(profile: social.profile(comment.profileId), text: comment.text, date: comment.date)
+								.id(comment.id)
+								.transition(.opacity.combined(with: .move(edge: .bottom)))
+						}
+					}
+					.padding(16)
+					.animation(.snappy, value: comments.map(\.id))
+				}
+				.onChange(of: comments.last?.id) { _, id in
+					guard let id else { return }
+					withAnimation { proxy.scrollTo(id, anchor: .bottom) }
+				}
+			}
+			.safeAreaInset(edge: .bottom) { inputBar }
+			.navigationTitle("Comments")
+			.navigationBarTitleDisplayMode(.inline)
+			.appRoutes()
+		}
+	}
+
+	private var inputBar: some View {
+		VStack(spacing: 6) {
+			if let errorMessage {
+				Text(errorMessage)
+					.font(.footnote)
+					.foregroundStyle(.red)
+					.frame(maxWidth: .infinity, alignment: .leading)
+			}
+			HStack(spacing: 10) {
+				AvatarView(profile: social.me, size: 34)
+				HStack {
+					TextField(placeholder, text: $draft, axis: .vertical)
+						.lineLimit(1...4)
+						.focused($inputFocused)
+						.submitLabel(.send)
+						.onSubmit(send)
+					if !draft.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+						Button(action: send) {
+							if sending { ProgressView() } else { Text("Post").fontWeight(.semibold) }
+						}
+						.disabled(sending)
+					}
+				}
+				.padding(.horizontal, 14)
+				.padding(.vertical, 10)
+				.background(Capsule().stroke(Theme.hairline))
+			}
+		}
+		.padding(.horizontal, 12)
+		.padding(.vertical, 8)
+		.background(.bar)
+	}
+
+	private var placeholder: String {
+		guard let post, let author = social.profile(post.authorId) else { return "Add a comment" }
+		return "Add a comment for \(author.handle)"
+	}
+
+	private func send() {
+		let text = draft.trimmingCharacters(in: .whitespacesAndNewlines)
+		guard !text.isEmpty, !sending else { return }
+		sending = true
+		errorMessage = nil
+		Task {
+			defer { sending = false }
+			do {
+				try await social.addComment(postId, text: text)
+				draft = ""
+			} catch {
+				errorMessage = friendlyMessage(error)
+			}
+		}
+	}
+}
+
+private struct CommentRow: View {
+	let profile: Profile?
+	let text: String
+	let date: Date
+
+	var body: some View {
+		HStack(alignment: .top, spacing: 12) {
+			if let profile {
+				NavigationLink(value: Route.profile(profile.id)) {
+					AvatarView(profile: profile, size: 34)
+				}
+				.buttonStyle(.plain)
+			}
+			VStack(alignment: .leading, spacing: 3) {
+				HStack(spacing: 6) {
+					Text(profile?.handle ?? "")
+						.font(.footnote.weight(.semibold))
+					Text(Timestamp.short(date))
+						.font(.footnote)
+						.foregroundStyle(.secondary)
+				}
+				Text(text)
+					.font(.subheadline)
+					.fixedSize(horizontal: false, vertical: true)
+			}
+			Spacer(minLength: 0)
+		}
+	}
+}

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

@@ -0,0 +1,152 @@
+import PhotosUI
+import SwiftUI
+
+/// New post: pick a photo from the library, write a caption, share.
+struct ComposeView: View {
+	@EnvironmentObject private var social: SocialStore
+	@Environment(\.dismiss) private var dismiss
+	let onPosted: () -> Void
+
+	@State private var pickerShown = false
+	@State private var pickedItem: PhotosPickerItem?
+	@State private var image: UIImage?
+	@State private var caption = ""
+	@State private var posting = false
+	@State private var errorMessage: String?
+	@FocusState private var captionFocused: Bool
+
+	private let captionLimit = 2200
+
+	var body: some View {
+		NavigationStack {
+			ScrollView {
+				VStack(alignment: .leading, spacing: 16) {
+					photoArea
+					if image != nil {
+						HStack(alignment: .top, spacing: 12) {
+							AvatarView(profile: social.me, size: 36)
+							TextField("Write a caption", text: $caption, axis: .vertical)
+								.lineLimit(3...8)
+								.focused($captionFocused)
+						}
+						.padding(.horizontal, 16)
+						if caption.count > captionLimit - 200 {
+							Text("\(caption.count)/\(captionLimit)")
+								.font(.caption.monospacedDigit())
+								.foregroundStyle(caption.count > captionLimit ? .red : .secondary)
+								.padding(.horizontal, 16)
+						}
+					}
+					if let errorMessage {
+						Text(errorMessage)
+							.font(.footnote)
+							.foregroundStyle(.red)
+							.padding(.horizontal, 16)
+					}
+				}
+			}
+			.scrollDismissesKeyboard(.interactively)
+			.navigationTitle("New post")
+			.navigationBarTitleDisplayMode(.inline)
+			.toolbar {
+				ToolbarItem(placement: .cancellationAction) {
+					Button("Cancel") { dismiss() }
+						.disabled(posting)
+				}
+				ToolbarItem(placement: .confirmationAction) {
+					if posting {
+						ProgressView()
+					} else {
+						Button("Share", action: share)
+							.fontWeight(.semibold)
+							.disabled(image == nil || caption.count > captionLimit)
+					}
+				}
+			}
+			.photosPicker(isPresented: $pickerShown, selection: $pickedItem, matching: .images)
+			.onChange(of: pickedItem) { _, item in
+				Task { await load(item) }
+			}
+			.onAppear { if image == nil { pickerShown = true } }
+			.interactiveDismissDisabled(posting)
+		}
+	}
+
+	@ViewBuilder
+	private var photoArea: some View {
+		if let image {
+			Color.clear
+				.aspectRatio(4 / 5, contentMode: .fit)
+				.overlay {
+					Image(uiImage: image)
+						.resizable()
+						.scaledToFill()
+				}
+				.clipped()
+				.overlay(alignment: .bottomTrailing) {
+					Button { pickerShown = true } label: {
+						Label("Change", systemImage: "photo.on.rectangle")
+							.font(.footnote.weight(.semibold))
+							.padding(.horizontal, 12)
+							.padding(.vertical, 8)
+							.background(.ultraThinMaterial, in: Capsule())
+					}
+					.buttonStyle(.plain)
+					.padding(12)
+				}
+		} else {
+			Button { pickerShown = true } label: {
+				VStack(spacing: 12) {
+					Image(systemName: "photo.on.rectangle.angled")
+						.font(.system(size: 44, weight: .light))
+					Text("Choose a photo")
+						.font(.headline)
+					Text("Pick one from your library to share.")
+						.font(.subheadline)
+						.foregroundStyle(.secondary)
+				}
+				.frame(maxWidth: .infinity)
+				.aspectRatio(4 / 5, contentMode: .fit)
+				.background(Theme.fieldFill)
+			}
+			.buttonStyle(.plain)
+		}
+	}
+
+	private func load(_ item: PhotosPickerItem?) async {
+		guard let item else { return }
+		do {
+			guard let data = try await item.loadTransferable(type: Data.self),
+			      let picked = UIImage(data: data) else {
+				errorMessage = MediaError.unreadableImage.errorDescription
+				return
+			}
+			image = picked
+			errorMessage = nil
+			captionFocused = true
+		} catch {
+			errorMessage = MediaError.unreadableImage.errorDescription
+		}
+	}
+
+	private func share() {
+		guard let image, !posting else { return }
+		guard let jpeg = image.jpegForUpload() else {
+			errorMessage = MediaError.unreadableImage.errorDescription
+			return
+		}
+		posting = true
+		errorMessage = nil
+		captionFocused = false
+		Task {
+			do {
+				try await social.createPost(jpeg: jpeg, caption: caption.trimmingCharacters(in: .whitespacesAndNewlines))
+				onPosted()
+				dismiss()
+			} catch {
+				errorMessage = friendlyMessage(error)
+				posting = false
+			}
+		}
+	}
+}